**
 * <pre>
 * Title:         HttpRequestProxy.java
 * Project:     HP-Common
 * Type:        com.hengpeng.common.web.HttpRequestProxy
 * Author:        benl
 * Create:         2007-7-3 上午03:07:07
 * Copyright:     Copyright (c) 2007
 * Company:
 * <pre>
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.log4j.Logger;

/**
 * <pre>
 * HTTP请求代理类
 * </pre>
 *
 * @author benl
 * @version 1.0, 2007-7-3
 */
public class HttpRequestProxy
{
    /**
     * 连接超时
     */
    private static int connectTimeOut = 5000;

    /**
     * 读取数据超时
     */
    private static int readTimeOut = 10000;

    /**
     * 请求编码
     */
    private static String requestEncoding = "GBK";

    private static Logger logger = Logger.getLogger(HttpRequestProxy.class);

    /**
     * <pre>
     * 发送带参数的GET的HTTP请求
     * </pre>
     *
     * @param reqUrl HTTP请求URL
     * @param parameters 参数映射表
     * @return HTTP响应的字符串
     */
    public static String doGet(String reqUrl, Map parameters,
            String recvEncoding)
    {
        HttpURLConnection url_con = null;
        String responseContent = null;
        try
        {
            StringBuffer params = new StringBuffer();
            for (Iterator iter = parameters.entrySet().iterator(); iter
                    .hasNext();)
            {
                Entry element = (Entry) iter.next();
                params.append(element.getKey().toString());
                params.append("=");
                params.append(URLEncoder.encode(element.getValue().toString(),
                        HttpRequestProxy.requestEncoding));
                params.append("&");
            }

            if (params.length() > 0)
            {
                params = params.deleteCharAt(params.length() - 1);
            }

            URL url = new URL(reqUrl);
            url_con = (HttpURLConnection) url.openConnection();
            url_con.setRequestMethod("GET");
            System.setProperty("sun.net.client.defaultConnectTimeout", String
                    .valueOf(HttpRequestProxy.connectTimeOut));// （单位：毫秒）jdk1.4换成这个,连接超时
            System.setProperty("sun.net.client.defaultReadTimeout", String
                    .valueOf(HttpRequestProxy.readTimeOut)); // （单位：毫秒）jdk1.4换成这个,读操作超时
            // url_con.setConnectTimeout(5000);//（单位：毫秒）jdk
            // 1.5换成这个,连接超时
            // url_con.setReadTimeout(5000);//（单位：毫秒）jdk 1.5换成这个,读操作超时
            url_con.setDoOutput(true);
            byte[] b = params.toString().getBytes();
            url_con.getOutputStream().write(b, 0, b.length);
            url_con.getOutputStream().flush();
            url_con.getOutputStream().close();

            InputStream in = url_con.getInputStream();
            BufferedReader rd = new BufferedReader(new InputStreamReader(in,
                    recvEncoding));
            String tempLine = rd.readLine();
            StringBuffer temp = new StringBuffer();
            String crlf=System.getProperty("line.separator");
            while (tempLine != null)
            {
                temp.append(tempLine);
                temp.append(crlf);
                tempLine = rd.readLine();
            }
            responseContent = temp.toString();
            rd.close();
            in.close();
        }
        catch (IOException e)
        {
            logger.error("网络故障", e);
        }
        finally
        {
            if (url_con != null)
            {
                url_con.disconnect();
            }
        }

        return responseContent;
    }

    /**
     * <pre>
     * 发送不带参数的GET的HTTP请求
     * </pre>
     *
     * @param reqUrl HTTP请求URL
     * @return HTTP响应的字符串
     */
    public static String doGet(String reqUrl, String recvEncoding)
    {
        HttpURLConnection url_con = null;
        String responseContent = null;
        try
        {
            StringBuffer params = new StringBuffer();
            String queryUrl = reqUrl;
            int paramIndex = reqUrl.indexOf("?");

            if (paramIndex > 0)
            {
                queryUrl = reqUrl.substring(0, paramIndex);
                String parameters = reqUrl.substring(paramIndex + 1, reqUrl
                        .length());
                String[] paramArray = parameters.split("&");
                for (int i = 0; i < paramArray.length; i++)
                {
                    String string = paramArray[i];
                    int index = string.indexOf("=");
                    if (index > 0)
                    {
                        String parameter = string.substring(0, index);
                        String value = string.substring(index + 1, string
                                .length());
                        params.append(parameter);
                        params.append("=");
                        params.append(URLEncoder.encode(value,
                                HttpRequestProxy.requestEncoding));
                        params.append("&");
                    }
                }

                params = params.deleteCharAt(params.length() - 1);
            }

            URL url = new URL(queryUrl);
            url_con = (HttpURLConnection) url.openConnection();
            url_con.setRequestMethod("GET");
            System.setProperty("sun.net.client.defaultConnectTimeout", String
                    .valueOf(HttpRequestProxy.connectTimeOut));// （单位：毫秒）jdk1.4换成这个,连接超时
            System.setProperty("sun.net.client.defaultReadTimeout", String
                    .valueOf(HttpRequestProxy.readTimeOut)); // （单位：毫秒）jdk1.4换成这个,读操作超时
            // url_con.setConnectTimeout(5000);//（单位：毫秒）jdk
            // 1.5换成这个,连接超时
            // url_con.setReadTimeout(5000);//（单位：毫秒）jdk 1.5换成这个,读操作超时
            url_con.setDoOutput(true);
            byte[] b = params.toString().getBytes();
            url_con.getOutputStream().write(b, 0, b.length);
            url_con.getOutputStream().flush();
            url_con.getOutputStream().close();
            InputStream in = url_con.getInputStream();
            BufferedReader rd = new BufferedReader(new InputStreamReader(in,
                    recvEncoding));
            String tempLine = rd.readLine();
            StringBuffer temp = new StringBuffer();
            String crlf=System.getProperty("line.separator");
            while (tempLine != null)
            {
                temp.append(tempLine);
                temp.append(crlf);
                tempLine = rd.readLine();
            }
            responseContent = temp.toString();
            rd.close();
            in.close();
        }
        catch (IOException e)
        {
            logger.error("网络故障", e);
        }
        finally
        {
            if (url_con != null)
            {
                url_con.disconnect();
            }
        }

        return responseContent;
    }

    /**
     * <pre>
     * 发送带参数的POST的HTTP请求
     * </pre>
     *
     * @param reqUrl HTTP请求URL
     * @param parameters 参数映射表
     * @return HTTP响应的字符串
     */
    public static String doPost(String reqUrl, Map parameters,
            String recvEncoding)
    {
        HttpURLConnection url_con = null;
        String responseContent = null;
        try
        {
            StringBuffer params = new StringBuffer();
            for (Iterator iter = parameters.entrySet().iterator(); iter
                    .hasNext();)
            {
                Entry element = (Entry) iter.next();
                params.append(element.getKey().toString());
                params.append("=");
                params.append(URLEncoder.encode(element.getValue().toString(),
                        HttpRequestProxy.requestEncoding));
                params.append("&");
            }

            if (params.length() > 0)
            {
                params = params.deleteCharAt(params.length() - 1);
            }

            URL url = new URL(reqUrl);
            url_con = (HttpURLConnection) url.openConnection();
            url_con.setRequestMethod("POST");
            System.setProperty("sun.net.client.defaultConnectTimeout", String
                    .valueOf(HttpRequestProxy.connectTimeOut));// （单位：毫秒）jdk1.4换成这个,连接超时
            System.setProperty("sun.net.client.defaultReadTimeout", String
                    .valueOf(HttpRequestProxy.readTimeOut)); // （单位：毫秒）jdk1.4换成这个,读操作超时
            // url_con.setConnectTimeout(5000);//（单位：毫秒）jdk
            // 1.5换成这个,连接超时
            // url_con.setReadTimeout(5000);//（单位：毫秒）jdk 1.5换成这个,读操作超时
            url_con.setDoOutput(true);
            byte[] b = params.toString().getBytes();
            url_con.getOutputStream().write(b, 0, b.length);
            url_con.getOutputStream().flush();
            url_con.getOutputStream().close();

            InputStream in = url_con.getInputStream();
            BufferedReader rd = new BufferedReader(new InputStreamReader(in,
                    recvEncoding));
            String tempLine = rd.readLine();
            StringBuffer tempStr = new StringBuffer();
            String crlf=System.getProperty("line.separator");
            while (tempLine != null)
            {
                tempStr.append(tempLine);
                tempStr.append(crlf);
                tempLine = rd.readLine();
            }
            responseContent = tempStr.toString();
            rd.close();
            in.close();
        }
        catch (IOException e)
        {
            logger.error("网络故障", e);
        }
        finally
        {
            if (url_con != null)
            {
                url_con.disconnect();
            }
        }
        return responseContent;
    }

    /**
     * @return 连接超时(毫秒)
     * @see com.hengpeng.common.web.HttpRequestProxy#connectTimeOut
     */
    public static int getConnectTimeOut()
    {
        return HttpRequestProxy.connectTimeOut;
    }

    /**
     * @return 读取数据超时(毫秒)
     * @see com.hengpeng.common.web.HttpRequestProxy#readTimeOut
     */
    public static int getReadTimeOut()
    {
        return HttpRequestProxy.readTimeOut;
    }

    /**
     * @return 请求编码
     * @see com.hengpeng.common.web.HttpRequestProxy#requestEncoding
     */
    public static String getRequestEncoding()
    {
        return requestEncoding;
    }

    /**
     * @param connectTimeOut 连接超时(毫秒)
     * @see com.hengpeng.common.web.HttpRequestProxy#connectTimeOut
     */
    public static void setConnectTimeOut(int connectTimeOut)
    {
        HttpRequestProxy.connectTimeOut = connectTimeOut;
    }

    /**
     * @param readTimeOut 读取数据超时(毫秒)
     * @see com.hengpeng.common.web.HttpRequestProxy#readTimeOut
     */
    public static void setReadTimeOut(int readTimeOut)
    {
        HttpRequestProxy.readTimeOut = readTimeOut;
    }

    /**
     * @param requestEncoding 请求编码
     * @see com.hengpeng.common.web.HttpRequestProxy#requestEncoding
     */
    public static void setRequestEncoding(String requestEncoding)
    {
        HttpRequestProxy.requestEncoding = requestEncoding;
    }
   
    public static void main(String[] args)
    {
        Map map = new HashMap();
        map.put("actionType", "1");
//        map.put("issueId", "33");
        String temp = HttpRequestProxy.doPost("http://192.168.0.99/AgentPortal/autoHandler", map, "GBK");
        System.out.println("返回的消息是:"+temp);
       
    }
}

Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想
用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。
transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

ant手册中的ant配置classpath采用classpath标签，可是我发现这样配置总是不好用，还是直接用path可以使用
  设置classpath的方法有多种
<path id="project.classpath">
    1<pathelement path="${basedir}/lib/aa.jar"/>
   2<pathelement location="aa.jar"/>与1的区别在于location可以去当前路径，当然可以使用绝对路径
    3<filelist id="file" dir="${basedir}/lin">
          <file name="a.jar"/>
          <file name="d:lib/b.jar"/>
     </filelist>
   4<fileset dir="d:/lib">
       <include name="**/*.jar"/>
    </fileset>
   5手册上说了dirset也好用，但是我测试了还是不要用的
</path>   
  下面说classpath的使用
   样例如下
     <javac scdir="./src" destdir="./classes">
           <classpath refid="project.classpath"/> 
   </javac>


下面是比较四种方式的优缺点
   第一种调用的需要设置绝对路径适合第三方jar包
    第二种则适合jar包和build.xml文件在同一目录下的情况，但是我觉得两个文件放在一起本身就不合理，估计是用的情况不多。
  前两个都是设置单个jar包
   第三种是一个文件集合适合引入不同路径的jar包，但是需要输入每个jar包的名字，比较繁琐，适合于jar包属于不同位置，比较分散但是不多的情况
  第四种是一个文件夹，可以采用匹配模式来引入，这个适合在同一个文件夹下，文件名字比较多的情况下

ant的构建文件中，有很多核心类型，这些核心类型都是XXXSet的形式，主要有以下几个：PatternSet、DirSet、FileSet、PropertySet、ZipFileSet等。说下前三个的功能就应该可以举一反三了。
          1.PatternSet  即模式集合。顾名思义，就是定义一个模式，他可以用来指定一个文件集合。常常可以被外部的target引用，复用性很强。有includes、 includesfile、excludes、excludesfile属性。每个属性里面还可以嵌套name、if、unless等类型。
          2.DirSet  即目录集合。用来定义目录的集合。有dir、casesensitive、followsymlinks和PatternSet也有的那4个属性。上面说过PatternSet可以很好的复用。下面就是一个例子：

<dirset dir="${build.dir}">
               <patternset id="non.test.classes">
                      <include name="apps/**/classes"/>
                       <exclude name="apps/**/*Test*"/>
                </patternset>
 </dirset>

 

        这是用patternset来定义DirSet的模式，这个模式还可以在外部引用。如：

  <dirset dir="{build.dir}">
                  <patternset refid="non.test.classes"/>
  </dirset>

 

          上面定义了一个名为non.test.classes的PatternSet，现在就可以引用他了。refid即reference ID.
          3.FileSet即文件集合，他的内部属性与DirSet几乎一样，只是多了一个file和defaultexcludes。和dirset一样，经常 嵌入patternset来定义文件集合；但是也有另外一个很常用的类型，叫selector，它并不是一个真正的类型或元素，只是一种、一类类型的统 称。如contains、date、depend、depth、different、filename、present、containsregexp、 size、type等。

第一种方法：
mysql> GRANT SELECT,INSERT,UPDATE,DELETE,CREATE,DROP
-> ON <dbname>.*
-> TO <username>@<host name>
-> IDENTIFIED BY '<password>';

where <dbname> is the name of the database you are tyring to connect to, <username> is the username of the user trying to connect to the database, <host name> the name of the host (in your case the XXX host) and <password> the password of the user.
第二种方法：
通过客户端软件设置用户的主机以及权限，

工具：grub4dos0.4.2(想要的给我发信，我发给你，loveitdoit@163.com)

文件：fedora7.0映像文件，可在网上下载。

过程：

1．解压缩grub4dos0.4.2，把里面的 grldr和menu.lst，文件复制到c盘根目录下。

2．fedora7.0映像文件不必解压，必须放在fat32的分区里。把里面的isolinux目录下

的VMLINUZ、INITRD.IMG解压到c盘根目录下。

3．在c:\下找到menu.lst，用记事本打开并修改，删除其他命令，添加以下命令！


title Linux System Install

kernel (hd0,0)/vmlinuz

initrd (hd0,0)/initrd.img


4．修改c:\boot.ini文件，在最后面添加c:\grldr="Start GRUB"并保存即可。

5．重起系统，选择Start GRUB，开始安装。

花了半天时间研究了下下MYSQL的备份实现，发现其是在MY.CNF（MY.INI）配置文件中作的设置，直接设置服务器唯一性ID号加上其它的附加设 置，则可作为一台MASTER，而在 SLAVE机上，也只需要在配置文件中设置一下连接MASTER所需的参数即可，如果在MASTER里也加上连到SLAVE机的参数，则就是双向备份 了～～不过，这些连接参数中用到的账号需要注意权限的设置，否则会搞半天没反就急死你迪。。。
我在WIN上和LINUX上各装了MYSQL5，下面是它们的配置：
WIN(172.22.33.33)下的MASTER(由于我改了端口3327所以下面多加了个端口方面的特殊处理了)的配置（my.ini）：(**一定要在mysqld配置段中配置，不象PHP，APACHE可以随便找个方便的地方配的，注意哈！！)

[mysqld]
#master 设置
server-id=1
log-bin=c:/masterlog
binlog-do-db=db5

#实现双机备份段，给MASTER同时加上SLAVE段,可选哈，如果不选，那就是WIN到LIN的主从备份

master-host=172.22.1.37
master-user=backup2
master-password=backup2
master-port=3306
master-connect-retry=60
replicate-do-db=db5

数据库中加一个账号:

GRANT FILE,REPLICATION SLAVE,REPLICATION CLIENT,SUPER ON *.*
TO [email=backup@]backup@'172.22.1.37'[/email] IDENTIFIED by 'backup';
这个权限表示，这个backup账号只能由从备份机172.22.1.37访问只能用来进行备份操作
LINUX(172.22.1.37)下的SLAVE机的配置(把安装目录里找到的任意一个*.cnf拷到/etc/my.cnf下进行修改)：

server-id=2
#如果不需要双向备份下面两行可以不要
#否则还要加一个数据库用户账号
/*
GRANT FILE,REPLICATION SLAVE,REPLICATION CLIENT,SUPER ON *.*
TO [email=backup2@]backup2@'172.22.33.33'[/email] IDENTIFIED by 'backup2';
*/
log-bin=./masterlog
binlog-do-db=db5
#---------------------------------------
master-host=172.22.33.33
master-user=backup
master-password=backup
master-port=3327
master-connect-retry=60
replicate-do-db=db5
由于只是大概的弄了一下，特别是在数据库用户方面没有作仔细试验：），可能会有所不太准确的地方，还有就是，上面测试用到的数据库一定要是已经建立好并且 结构相同的，两台机子都重启后会进行检查，如果出现找不到或者检查到结构不同，会报错，最好就是在创建空数据库时或初始时安装两个一样的数据库后就建立好 关系，对于不同版本的MYSQL，官方说明也可以同步，但想一想，把MYSQL5 的数据备份到4中去丢失5的特性也没什么意义吧。。