Hibernate内嵌了对C3P0,Proxool,JNDI数据源等数据库连接池的支持。但当我们需要使用除了这几个数据源外的其他数据源的时候就有问题了，例如我们需要用Apache的开源连接池项目DBCP，或者说我们想要使用多数JDBC驱动程序中自带的XxxxDataSource时，Hibernate就没有提供对这方面的支持。庆幸的是Hibernate做为一个强大的数据持久层组件，它在实现数据库连接方面的扩展性也是非常强大的。本文将介绍两种如何在Hibernate项目中使用自定义数据源的方法。

本文假设你已经有Hibernate的开发经验。

在开始之前应该先明确你的项目中的具体情况，也就是确认Hibernate内嵌的组件是否真的无法支持你的应用需要。例如C3P0或者Proxool已经可以满足大部分数据库的需要，又或者你的数据源是在应用服务器中配置的，那么你也没有必要进行扩展，你可以直接使用DatasourceConnectionProvider来让Hibernate使用你所定义的数据源。

那么什么时候你需要扩展Hibernate对数据源的支持呢？可能你永远也用不上，但我一直在用。我用的原因可能不能成为正当的理由，因为C3P0或者Proxool总有些小地方的不足让我不爽，个人更偏向于DBCP连接池。或许本文应该改名为《让Hibernate支持DBCP数据源》，其实DBCP只不过是我的一个具体的例子，本文具有更普遍的应用意义。下面我们具体介绍两种不同的扩展思路。

思路一：使用外部定义数据源

假设我们已经有了一个WEB项目，该项目采用了Struts框架，而且我们已经在Struts中配置了数据源，也有不少的代码是依赖这个数据源运行的。现在我们需要给项目中加入对Hibernate的支持，但又不想去修改旧的已经成功稳定运行的代码了。那我们该怎么办？如果同样在Hibernate配置一个数据源指到同一个数据库，相信你也不乐意这样干，因为一旦配置上有修改那么Struts和Hibernate的配置都需要修改，这个也只是麻烦一点而已，最要命的是没法让原有的代码和Hibernate共用一个数据库连接，因此事务处理也就无从谈起。

说那么多理由，无非就是为了让Hibernate可以使用Struts中配置的数据源，而我们暂且不去考虑这是否是最好的解决方法。

在Hibernate中有一个UserSuppliedConnectionProvider类，其实这个类什么也不干，你一旦让它干点啥吧，它还净出异常，搞得你很是恼火。在Hibernate中，这个类的含义是要求用户自己来提供数据库连接的获取方法，同时当然也要自己负责关闭连接。

为了使用Struts中配置的数据源，我们就不能直接调用SessionFactory.openSession()方法来获取Session实例，因为你如果没有在Hibernate中配置任何的数据库连接，那Hibernate会默认让UserSuppliedConnectionProvider类来跟你捣乱，你会收到很多异常信息，反复提醒我们必须自己提供数据库连接！我们要做还是调用openSession方法，不同的是需要先从Struts的数据源中获取数据库连接，然后传递该连接给openSession方法（参照 SessionFactory.openSession(Connection) 方法）。

下面是我写的一个代码片断

														
																//获取Session实例
public Session getSession(){
	ServletContext contxt = ....
	SessionFactory sessions = ....

	DataSource ds = (DataSource)context.getAttribute(Globals.DATA_SOURCE_KEY);
	final Connection conn = ds.getConnection();
	return sessions.openSession(conn);
}

//释放Session
public void closeSession(Session ssn){
	ssn.connection().close();
	ssn.close();
}

														
												

需要提醒大家注意的是closeSession方法，在该方法中我们必须手工去关闭session对应的数据库连接，我们前面已经提到了，UserSuppliedConnectionProvider类就是要求用户自己提供数据库连接已经连接的关闭。如果没有调用ssn.connection().close()方法，这会导致Struts的数据源的连接没有被释放。

同理，上面提到的Struts只是一个应用普遍的例子，实际中你可以使用任何的外部连接池，你只需要将获取到的数据库连接传递给openSession方法，并自行负责释放数据库连接即可。应该说这是一种最简单的思路，好处是对系统的变动最小，兼容原来的代码。

回页首

思路二：扩展ConnectionProvider

Hibernate本身是通过ConnectionProvider接口来实现管理数据库连接的。例如其自带的C3P0ConnectionProvider，ProxoolConnectionProvider等。

在这个思路中，我们希望可以直接在Hibernate的配置文件中配置数据库连接，也就是让Hibernate独揽数据库的管理，真正做到各司其职。为了更了解该接口的使用，你不妨阅读一下Hibernate提供的上面几个类的源码。

接下来我们需要编写一个实现了ConnectionProvider接口的类，要求这个类能支持任何的符合DataSource接口规范的数据源，同时在Hibernate的配置文件中进行参数的设定。首先我们假定我们的类名是DataSourceConnProvider，那我们的配置信息在hibernate.cfg.xml中看起来应该像下面一样

														
																        	<!-- Connection Pool settings -->
<property name="connection.provider_class">
com.liusoft.dlog4j.db.DataSourceConnProvider</property>
        <property name="dscp.datasource">org.apache.commons.dbcp.BasicDataSource</property>
        <property name="dscp.driverClassName">sun.jdbc.odbc.JdbcOdbcDriver</property>
        <property name="dscp.url">jdbc:odbc:dlog4j</property>
        <property name="dscp.username">admin</property>
        <property name="dscp.password"></property>
        <property name="dscp.initialSize">1</property>
        <property name="dscp.maxActive">200</property>
        <property name="dscp.maxWait">2000</property>
        <property name="dscp.defaultAutoCommit">false</property>
        <property name="dscp.defaultReadOnly">false</property>
        <property name="dscp.removeAbandoned">true</property>
        <property name="dscp.removeAbandonedTimeout">120</property>
	<!--
        <property name="dscp.defaultTransactionIsolation">1</property>
	-->
        <property name="dscp.poolPreparedStatements">true</property>
        <property name="dscp.maxOpenPreparedStatements">1000</property> 
        
														
												

在上面的配置信息中，connection.provider_class是Hibernate本身用来指定不同ConnectionProvider实现类。接下来我们规定了我们的扩展所使用的配置键值都是以dscp.开头，同时我们使用dscp.datasource来指定具体实现了DataSource接口的类名，例如如果使用DBCP这个连接池，那么这个类名应该是org.apache.commons.dbcp.BasicDataSource。对于其他以dscp.开头的且不是dscp.datasource的配置信息都会直接赋值给DataSource的实现类。例如上面的配置中，driverClassName、url、username、password等配置信息都是BasicDataSource类的属性。

下面是我们所实现的DataSourceConnProvider类的源码。

														
																package com.liusoft.dlog4j.db;

import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.beanutils.BeanUtils;
import org.hibernate.HibernateException;
import org.hibernate.connection.ConnectionProvider;

import com.liusoft.dlog4j.Globals;
import com.liusoft.dlog4j.util.StringUtils;

/**
 * 让Hibernate支持各种数据源
 * @author Winter Lau
 */
public class DataSourceConnProvider implements ConnectionProvider {
	
	private final static String BASE_KEY = "dscp.";
	private final static String ENCODING_KEY = "dscp.encoding";
	private final static String DATASOURCE_KEY = "dscp.datasource";
	
	protected DataSource dataSource;
	
	/* (non-Javadoc)
	 * @see org.hibernate.connection.ConnectionProvider#configure(java.util.Properties)
	 */
	public void configure(Properties props) throws HibernateException {
		String dataSourceClass = null;
		Properties new_props = new Properties();
		Iterator keys = props.keySet().iterator();
		while(keys.hasNext()){
			String key = (String)keys.next();
			if(DATASOURCE_KEY.equalsIgnoreCase(key)){
				dataSourceClass = props.getProperty(key);
			}
			else if(key.startsWith(BASE_KEY)){
				String value = props.getProperty(key);
				value = StringUtils.replace(value, "{DLOG4J}", Globals.WEBAPP_PATH);
				new_props.setProperty(key.substring(BASE_KEY.length()), value);
			}
		}
		if(dataSourceClass == null)
			throw new HibernateException("Property 'dscp.datasource' no defined.");
		try {
			dataSource = (DataSource)Class.forName(dataSourceClass).newInstance();
			BeanUtils.populate(dataSource, new_props);
		} catch (Exception e) {
			throw new HibernateException(e);
		}
	}

	/* (non-Javadoc)
	 * @see org.hibernate.connection.ConnectionProvider#getConnection()
	 */
	public Connection getConnection() throws SQLException {		
		final Connection conn = dataSource.getConnection();
		if(useProxy && conn!=null){
			return (new _Connection(conn,encoding)).getConnection();
		}
		return conn;
	}

	/* (non-Javadoc)
	 * @see org.hibernate.connection.ConnectionProvider#closeConnection(java.sql.Connection)
	 */
	public void closeConnection(Connection conn) throws SQLException {
		if(conn!=null && !conn.isClosed())
			conn.close();
	}

	/* (non-Javadoc)
	 * @see org.hibernate.connection.ConnectionProvider#close()
	 */
	public void close() throws HibernateException {
		if(dataSource != null)
		try {
			Method mClose = dataSource.getClass().getMethod("close",null);
			mClose.invoke(dataSource, null);
		} catch (Exception e) {
			throw new HibernateException(e);
		}
		dataSource = null;
	}

	/* (non-Javadoc)
	 * @see org.hibernate.connection.ConnectionProvider#supportsAggressiveRelease()
	 */
	public boolean supportsAggressiveRelease() {
		return false;
	}

}

														
												

在DataSourceConnProvider类中，configure方法会在Hibernate进行初始化的过程中被调用，我们根据配置的DataSource类名创建数据源实例，并将配置参数赋值给该实例后即完成了数据源的初始化。接下来就是实现了getConnection和closeConnection方法分别是获取数据库连接和关闭连接的方法。方法close用来关闭整个数据源，该方法会在Hibernate释放时被调用。

你也可以使用其他一些不同的数据源而不一定非是DBCP数据源。配置完毕后接下来的事情就简单了，直接调用SessionFactory.openSession()方法获取Session实例，直接调用session.close()释放该实例，无需再手工去关闭session所封装的connection接口。

相比较上面两种思路而言，各有千秋。如果你真的有必要扩展Hibernate对数据源的支持，如果你没有兼容旧代码这个问题需要考虑的话，那我更倾向于第二种思路。因为它使得整个项目的各个层次分工非常清晰，而且除了ConnectionProvider 类以外应用的代码也相对简单。

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;

import com.zte.hibernate.domain.Dept;
import com.zte.hibernate.domain.Emp;

/**
 * Configures and provides access to Hibernate sessions, tied to the
 * current thread of execution.  Follows the Thread Local Session
 * pattern, see {@linkhttp://hibernate.org/42.html}.
 */
public class HibernateSessionFactory {

    /**
     * Location of hibernate.cfg.xml file.
     * NOTICE: Location should be on the classpath as Hibernate uses
     * #resourceAsStream style lookup for its configuration file. That
     * is place the config file in a Java package - the default location
     * is the default Java package.<br><br>
     * Examples: <br>
     * <code>CONFIG_FILE_LOCATION = "/hibernate.conf.xml".
     * CONFIG_FILE_LOCATION = "/com/foo/bar/myhiberstuff.conf.xml".</code>
     */
    private static String CONFIG_FILE_LOCATION = "/com/zte/hibernate/dao/hibernate.cfg.xml";

    /** Holds a single instance of Session */
 private static final ThreadLocal threadLocal = new ThreadLocal();

    /** The single instance of hibernate configuration */
    private static final Configuration cfg = new Configuration();

    /** The single instance of hibernate SessionFactory */
    private static org.hibernate.SessionFactory sessionFactory;

    /**
     * Returns the ThreadLocal Session instance.  Lazy initialize
     * the <code>SessionFactory</code> if needed.
     *
     *  @return Session
     *  @throws HibernateException
     */
    public static Session currentSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        Properties p = new Properties();
        InputStream in;
  try {
   in = new FileInputStream("src/hibernate.properties");
   p.load(in);
  } catch (FileNotFoundException e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
       
  if (session == null || !session.isOpen()) {
   if (sessionFactory == null) {
    try {
     cfg.setProperties(p);
     cfg.addClass(Dept.class);
     cfg.addClass(Emp.class);
     //cfg.configure(CONFIG_FILE_LOCATION);
     sessionFactory = cfg.buildSessionFactory();
    } catch (Exception e) {
     System.err
       .println("%%%% Error Creating SessionFactory %%%%");
     e.printStackTrace();
    }
   }
   session = (sessionFactory != null) ? sessionFactory.openSession()
     : null;
   threadLocal.set(session);
  }

        return session;
    }

    /**
     *  Close the single hibernate session instance.
     *
     *  @throws HibernateException
     */
    public static void closeSession() throws HibernateException {
        Session session = (Session) threadLocal.get();
        threadLocal.set(null);

        if (session != null) {
            session.close();
        }
    }

    /**
     * Default constructor.
     */
    private HibernateSessionFactory() {
    }

}

set hibernate.cglib.use_reflection_optimizer=false for more info

今天碰到

HibernateDBModel Error: exception setting property value with CGLIB

(set hibernate.cglib.use_reflection_optimizer=false for more info)

setter of com.belief.po.Good.setTuijian

解决办法

你的数据库里的某个字段的值为NULL，而事情本不该这样的。解决的办法就是把这个字段的NULL值改为非NULL值，就是查找数据库，看看是否又字段为null，改成非null即可。（i use sqlserver）

作者的其他文章

• 我为什么要学习Hibernate?
• Hibernate入门 - 基础配置
• Hibernate入门 - 包作用详解
• Hibernate获得成功的十大理由
• Hibernate的JNDI绑定分析
• Weblogic上配置Hibernate为JNDI
• Hibernate分页查询原理解读
• JDBC+Hibernate将Blob数据写入Oracle
• Struts+Hibernate数据表示
• Struts+Hibernate谈J2EE的数据表示

more..

其他相关文章

• JDBC+Hibernate将Blob数据写入Oracle

more...

MD5将任意长度的"字节串"变换成一个128bit的大整数，并且它是一个不可逆的字符串变换算法，换句话说就是，即使你看到源程序和算法描述，也无法将一个MD5的值变换回原始的字符串，从数学原理上说，是因为原始的字符串有无穷多个，这有点象不存在反函数的数学函数。

MD5的典型应用是对一段Message(字节串)产生fingerprint(指纹)，以防止被"篡改"。举个例子，你将一段话写在一个叫readme.txt文件中，并对这个readme.txt产生一个MD5的值并记录在案，然后你可以传播这个文件给别人，别人如果修改了文件中的任何内容，你对这个文件重新计算MD5时就会发现。如果再有一个第三方的认证机构，用MD5还可以防止文件作者的"抵赖"，这就是所谓的数字签名应用。

MD5还广泛用于加密和解密技术上，在很多操作系统中，用户的密码是以MD5值（或类似的其它算法）的方式保存的，用户Login的时候，系统是把用户输入的密码计算成MD5值，然后再去和系统中保存的MD5值进行比较，而系统并不"知道"用户的密码是什么。

一些黑客破获这种密码的方法是一种被称为"跑字典"的方法。有两种方法得到字典，一种是日常搜集的用做密码的字符串表，另一种是用排列组合方法生成的，先用MD5程序计算出这些字典项的MD5值，然后再用目标的MD5值在这个字典中检索。

即使假设密码的最大长度为8，同时密码只能是字母和数字，共26+26+10=62个字符，排列组合出的字典的项数则是P(62,1)+P(62,2)....+P(62,8)，那也已经是一个很天文的数字了，存储这个字典就需要TB级的磁盘组，而且这种方法还有一个前提，就是能获得目标账户的密码MD5值的情况下才可以。

在很多电子商务和社区应用中，管理用户的Account是一种最常用的基本功能，尽管很多Application Server提供了这些基本组件，但很多应用开发者为了管理的更大的灵活性还是喜欢采用关系数据库来管理用户，懒惰的做法是用户的密码往往使用明文或简单的变换后直接保存在数据库中，因此这些用户的密码对软件开发者或系统管理员来说可以说毫无保密可言，本文的目的是介绍MD5的Java Bean的实现，同时给出用MD5来处理用户的Account密码的例子，这种方法使得管理员和程序设计者都无法看到用户的密码，尽管他们可以初始化它们。但重要的一点是对于用户密码设置习惯的保护

MD加密算法的JAVA描述为：

import java.security.*; 
import java.security.spec.*; 

class Md5{
public final static String MD5(String s){ 
char hexDigits[] = { 
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; 
try { 
byte[] strTemp = s.getBytes(); 
MessageDigest mdTemp = MessageDigest.getInstance("MD5"); 
mdTemp.update(strTemp); 
byte[] md = mdTemp.digest(); 
int j = md.length; 
char str[] = new char[j * 2]; 
int k = 0; 
for (int i = 0; i < j; i++) { 
byte byte0 = md[i]; 
str[k++] = hexDigits[byte0 >>> 4 & 0xf]; 
str[k++] = hexDigits[byte0 & 0xf]; 
} 
return new String(str); 
} 
catch (Exception e){ 
return null; 
} 
} 
public static void main(String[] args){ 
System.out.print(MD5.Md5("XX")); 
}

    private static final int PORT = 9999;

    private ByteBuffer buffer = ByteBuffer.allocate(10240);

    private ProxyUtil proxyUtil = new ProxyUtil();

    private static String remoteHost = "";

    private static int remotePort = 80;

    private Logger log = ZXLogger.getLogger(ProxyServer.class.getName());

    //private Log log = LogFactory.getLog(ProxyServer.class);

    public ProxyServer()
    {
        //PropertyConfigurator.configure("src/log4j.properties");
    }

    /**
     * 方法名称：start <p>
     * 方法功能：运行代理服务器 <p>
     * 参数说明：<p>
     * 返回：void <p>
     * 作者：李明 <p>
     * 日期：2006年3月23日 <p>
     */
    public void runServer()
    {

        ServerSocket sSocket = null;
        ServerSocketChannel ssc = null;

        // 代理服务器监听开启

        Selector selector = null;
        try
        {
            ssc = ServerSocketChannel.open();
            sSocket = ssc.socket();
            sSocket.bind(new InetSocketAddress(PORT));

            selector = Selector.open();

            System.err.println("Listening Port is " + PORT);

            ssc.configureBlocking(false);
            ssc.register(selector, SelectionKey.OP_ACCEPT);
        }
        catch(ClosedChannelException e1)
        {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        catch(IOException e1)
        {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }

        try
        {
            while(true)
            {

                int n = selector.select();

                if(n == 0)
                {
                    continue; // nothing to do
                }

                Set set = selector.selectedKeys();

                Iterator iter = set.iterator();

                while(iter.hasNext())
                {
                    SelectionKey key = (SelectionKey)iter.next();

                    if(key.isAcceptable())
                    {
                        ServerSocketChannel svrSocketChannel = (ServerSocketChannel)key.channel();
                        SocketChannel clientChannel = null;
                        try
                        {
                            clientChannel = svrSocketChannel.accept();
                        }
                        catch(IOException e)
                        {
                            // TODO Auto-generated catch block
                            if(clientChannel != null)
                            {

                                clientChannel.close();
                            }
                            if(key != null)
                            {
                                key.cancel();
                            }
                        }

                        send(clientChannel);

                    }
                    iter.remove();
                    log.info("************SEND  END*************");
                }
            }
        }
        catch(IOException e)
        {
            // TODO Auto-generated catch block
            log.info("ServerSocketChannel总体迭代发生核心异常\r\n" + e.getMessage());
            e.printStackTrace();
        }

    }

    /**
     * 方法名称：send <p>
     * 方法功能：发送给客户信息 <p>
     * 参数说明：SocketChannel, String <p>
     * 返回：void <p>
     * 作者：李明 <p>
     * 日期：2006年3月23日 <p>
     *
     * @param channel
     * @param key
     * @throws IOException
     */
    public void send(SocketChannel clientChannel)
    {

        SocketChannel remoteSvrChannel = null;

        buffer.clear();
        int count;

        log.info("************SEND START*************");

        try
        {
            while((count = clientChannel.read(buffer)) > 0)
            {
                buffer.flip();

                byte[] bytebuffer = new byte[count];
                buffer.get(bytebuffer, 0, count);

                ByteBuffer bufferWrite = ByteBuffer.wrap(bytebuffer);

                byte[] b = new byte[bufferWrite.limit()];
                bufferWrite.get(b);
                String context = new String(b);

                // 打印客户请求代理服务器信息
                log.info(context);

                // 解析客户信息，得到远程主机和端口。
                proxyUtil.setUrl(context);
                setRemoteHost(proxyUtil.getHost());
                setRemotePort(proxyUtil.getPort());

                log.info("Remote Host " + getRemoteHost());
                log.info("Remote Port " + getRemotePort());

                if(remoteSvrChannel == null)
                {
                    InetSocketAddress inet = new InetSocketAddress(getRemoteHost(), getRemotePort());
                    try
                    {
                        remoteSvrChannel = SocketChannel.open(inet);
                        // remoteSvrChannel.configureBlocking(false);
                        // Socket remoteSvr = remoteSvrChannel.socket();
                        // remoteSvr.setSoTimeout(1000);
                        bufferWrite.flip();
                        remoteSvrChannel.write(bufferWrite);
                        buffer.clear();
                        int n;
                        while((n = remoteSvrChannel.read(buffer)) > 0)
                        {
                            log.info("n=" + n);
                            buffer.flip();
                            log.info("buffer.limit=" + buffer.limit());
                            clientChannel.write(buffer);
                        }
                    }
                    catch(java.nio.channels.UnresolvedAddressException ex)
                    {
                        log.info("主机地址访问无效\r\n" + ex.getMessage());
                    }
                    catch(IOException e)
                    {
                        // TODO Auto-generated catch block
                        try
                        {
                            if(remoteSvrChannel != null)
                            {
                                remoteSvrChannel.close();
                            }
                        }
                        catch(IOException e1)
                        {
                            // TODO Auto-generated catch block
                            e1.printStackTrace();
                        }
                    }
                }
            }
        }
        catch(IOException e1)
        {
            // TODO Auto-generated catch block
            try
            {
                if(clientChannel != null)
                {
                    clientChannel.close();
                }
            }
            catch(IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        finally
        {
            try
            {
                if(remoteSvrChannel != null)
                {
                    remoteSvrChannel.close();
                }
                if(clientChannel != null)
                {
                    clientChannel.close();
                }
            }
            catch(IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        // 打印远程服务器返回给客户端信息
//        buffer.flip();
//        byte[] b2 = new byte[buffer.limit()];
//        buffer.get(b2);
//        log.info(new String(b2));

        // 关闭远程和客户的连接

    }

    public static String getRemoteHost()
    {
        return remoteHost;
    }

    public static void setRemoteHost(String remoteHost)
    {
        ProxyServer.remoteHost = remoteHost;
    }

    public static int getRemotePort()
    {
        return remotePort;
    }

    public static void setRemotePort(int remotePort)
    {
        ProxyServer.remotePort = remotePort;
    }

    public ByteBuffer getBuffer()
    {
        return buffer;
    }

    public void setBuffer(ByteBuffer buffer)
    {
        this.buffer = buffer;
    }

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        ProxyServer p = new ProxyServer();
        p.runServer();
    }
}

        while(true)
        {
            Socket client = null, server = null;
            try
            {
                // 等待客户连接
                client = ss.accept();
                log.info("*******Client logon*******");
                log.info(client);
                final InputStream streamFromClient = client.getInputStream();
                final OutputStream streamToClient = client.getOutputStream();

                // 连接真实的服务器,如果不能连接成功,将向客户发送错误信息,断开本次连接
                // 并且继续等待连接.
                try
                {
                    server = new Socket(host, remoteport);
                }
                catch(IOException e)
                {
                    PrintWriter out = new PrintWriter(streamToClient);
                    out.print("Proxy server cannot connect to " + host + ":" + remoteport + ":\n" + e + "\n");
                    out.flush();
                    client.close();
                    continue;
                }

                // 得到连接服务器的输入输出流.
                final InputStream streamFromServer = server.getInputStream();
                final OutputStream streamToServer = server.getOutputStream();

                // 构建一个单独线程读客户请求并传给服务器,此线程为异步.
                Thread t = new Thread()
                {
                    public void run()
                    {
                        int bytesRead;
                        String context = null;
                        try
                        {
                            while((bytesRead = streamFromClient.read(request)) != -1)
                            {
                                streamToServer.write(request, 0, bytesRead);
                                context = new String(request).trim();
                                streamToServer.flush();
                            }
                            // 打印客户浏览器发来的信息
                            log.info("#################S##############");
                            log.info(context);
                            log.info("#################E##############");
                            // 解析发来的信息,获取请求的主机地址和端口.
                            proxyUtil.setUrl(context);
                            host = proxyUtil.getHost();
                            remoteport = proxyUtil.getPort();
                            log.info("host : '" + host + "'" + " port : '" + remoteport + "'");

                        }
                        catch(IOException e)
                        {
                            // e.printStackTrace();
                        }

                        // 关闭请求服务器连接,屏蔽无意义的异常,减少代理服务器负担.
                        try
                        {
                            streamToServer.close();
                        }
                        catch(IOException e)
                        {
                            // e.printStackTrace();
                        }
                    }
                };

                // 开启客户端到服务器请求线程
                t.start();

                // 读服务器的请求,成功后返回信息给客户端.
                int bytesRead;
                try
                {
                    while((bytesRead = streamFromServer.read(reply)) != -1)
                    {
                        streamToClient.write(reply, 0, bytesRead);
                        streamToClient.flush();
                    }
                }
                catch(IOException e)
                {
                    // e.printStackTrace();
                }

                // 关闭客户连接.
                streamToClient.close();
            }
            catch(IOException e)
            {
                System.err.println(e);
            }
            finally
            {
                try
                {
                    if(server != null)
                    {
                        server.close();
                    }
                    if(client != null)
                    {
                        client.close();
                    }
                }
                catch(IOException e)
                {
                    e.printStackTrace();
                }
            }
        }
    }

            System.out.println(redirect.lastIndexOf("></HEAD>"));
            System.out.println(redirect.substring(redirect.indexOf("URL") + 4, redirect.lastIndexOf("></HEAD>") - 1));
            redirect = redirect.substring(redirect.indexOf("URL") + 4, redirect.lastIndexOf("></HEAD>") - 1);
            GetMethod getMethod = new GetMethod("http://reg.163.com/" + redirect);
            httpClient.executeMethod(getMethod);
            buff = getMethod.getResponseBodyAsString();
        }
        catch(HttpException e)
        {
            // 发生致命的异常，可能是协议不对或者返回的内容有问题
            System.out.println("Please check your provided http address!");
            e.printStackTrace();
        }
        catch(IOException e)
        {
            // 发生网络异常
            e.printStackTrace();
        }
        finally
        {
            // 释放连接
            postMethod.releaseConnection();
        }
        return buff;

    }

import javax.ejb.MessageDrivenBean;
import javax.ejb.MessageDrivenContext;
import javax.ejb.EJBException;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.TextMessage;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class TextMDBBean
    implements MessageDrivenBean, MessageListener {
  private MessageDrivenContext ctx = null;
  private QueueConnection conn;
  private QueueSession session;

  public TextMDBBean() {
    System.out.println("TextMDB.ctor, this=" + hashCode());
  }

  public void setMessageDrivenContext(MessageDrivenContext ctx) {
    this.ctx = ctx;
    System.out.println("TextMDB.setMessageDrivenContext, this=" +
                       hashCode());
  }

  public void ejbCreate() {
    System.out.println("TextMDB.ejbCreate, this=" + hashCode());
    try {
      setupPTP();
    }
    catch (Exception e) {
      throw new EJBException("Failed to init TextMDB", e);
    }
  }

  public void ejbRemove() {
    System.out.println("TextMDB.ejbRemove, this=" + hashCode());
    ctx = null;
    try {
      if (session != null) {
        session.close();
      }
      if (conn != null) {
        conn.close();
      }
    }
    catch (JMSException e) {
      e.printStackTrace();
    }
  }

  public void onMessage(Message msg) {
    System.out.println("TextMDB.onMessage, this=" + hashCode());
    try {
      TextMessage tm = (TextMessage) msg;
      String text = tm.getText() + "processed by: " + hashCode();
      Queue dest = (Queue) msg.getJMSReplyTo();
      sendReply(text, dest);
    }
    catch (Throwable t) {
      t.printStackTrace();
    }
  }

  private void setupPTP() throws JMSException, NamingException {
    InitialContext iniCtx = new InitialContext();
    Object tmp = iniCtx.lookup("java:comp/env/jms/QCF");
    QueueConnectionFactory qcf = (QueueConnectionFactory) tmp;
    conn = qcf.createQueueConnection();
    session = conn.createQueueSession(false,
                                      QueueSession.AUTO_ACKNOWLEDGE);
    conn.start();
  }

  private void sendReply(String text, Queue dest) throws JMSException {
    System.out.println("TextMDB.sendReply, this=" +
                       hashCode() + ", dest=" + dest);
    QueueSender sender = session.createSender(dest);
    TextMessage tm = session.createTextMessage(text);
    sender.send(tm);
    sender.close();
  }

}

<jboss>
  <enterprise-beans>
    <message-driven>
      <ejb-name>TextMDB</ejb-name>
      <destination-jndi-name>queue/B</destination-jndi-name>
      <resource-ref>
        <res-ref-name>jms/QCF</res-ref-name>
        <jndi-name>ConnectionFactory</jndi-name>
      </resource-ref>
    </message-driven>
  </enterprise-beans>
</jboss>

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.Queue;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSender;
import javax.jms.QueueSession;
import javax.jms.TextMessage;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import EDU.oswego.cs.dl.util.concurrent.CountDown;

/**
 * A complete JMS client example program that sends N TextMessages to a Queue B
 * and asynchronously receives the messages as modified by TextMDB from Queue A.
 *
 * @author Scott.Stark@jboss.org
 * @version $Revision: 1.9 $
 */
public class SendRecvClient {
 static final int N = 10;

 static CountDown done = new CountDown(N);

 QueueConnection conn;

 QueueSession session;

 Queue queA;

 Queue queB;

 public static class ExListener implements MessageListener {
  public void onMessage(Message msg) {
   done.release();
   TextMessage tm = (TextMessage) msg;
   try {
    System.out.println("onMessage, recv text=" + tm.getText());
   } catch (Throwable t) {
    t.printStackTrace();
   }
  }
 }

 public void setupPTP() throws JMSException, NamingException {
  InitialContext iniCtx = InitContext.getInitContext();
  Object tmp = iniCtx.lookup("ConnectionFactory");
  QueueConnectionFactory qcf = (QueueConnectionFactory) tmp;
  conn = qcf.createQueueConnection();
  queA = (Queue) iniCtx.lookup("queue/A");
  queB = (Queue) iniCtx.lookup("queue/B");
  session = conn.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
  conn.start();
 }

 public void sendRecvAsync(String textBase) throws JMSException,
   NamingException, InterruptedException {
  System.out.println("Begin sendRecvAsync");

  // Setup the PTP connection, session
  setupPTP();

  // Set the async listener for queA
  QueueReceiver recv = session.createReceiver(queA);
  recv.setMessageListener(new ExListener());

  // Send a few text msgs to queB
  QueueSender send = session.createSender(queB);

  for (int m = 0; m < 10; m++) {
   TextMessage tm = session.createTextMessage(textBase + "#" + m);
   tm.setJMSReplyTo(queA);
   send.send(tm);
   System.out.println("sendRecvAsync, sent text=" + tm.getText());
  }
  System.out.println("End sendRecvAsync");
 }

 public void stop() throws JMSException {
  conn.stop();
  session.close();
  conn.close();
 }

 public static void main(String args[]) throws Exception {
  System.out.println("Begin SendRecvClient,now="
    + System.currentTimeMillis());
  SendRecvClient client = new SendRecvClient();
  client.sendRecvAsync("A text msg");
  client.done.acquire();
  client.stop();
  System.exit(0);
  System.out.println("End SendRecvClient");
 }

}