以下介绍proxool的部署和使用：

1、添加proxool-0.8.3.jar包。

2、把proxool-conf.xml放到src的根目录。
具体内容如下：
<?xml version="1.0" encoding="utf-8"?>
<!-- the proxool configuration can be embedded within your own application's.
Anything outside the "proxool" tag is ignored.
请不要随意改动配置!
-->

<something-else-entirely>
<proxool>
<alias>pro_pool</alias>
<!--proxool只能管理由自己产生的连接-->
<driver-class>oracle.jdbc.driver.OracleDriver</driver-class>
<driver-url>jdbc:oracle:thin:@IP地址:数据库实例名</driver-url>
<driver-properties>
    <property name="user" value="具体用户名" />
  <property name="password" value="具体密码" />
</driver-properties>
 

--><!-- proxool自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁-->
<house-keeping-sleep-time>60000</house-keeping-sleep-time>
<!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受-->
<maximum-new-connections>20</maximum-new-connections>
<!-- 线程最大寿命 -->
<maximum-connection-lifetime>1200000</maximum-connection-lifetime>
<!-- 最少保持的空闲连接数-->
<prototype-count>3</prototype-count>
<!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由maximum-new-connections决定-->
<maximum-connection-count>40</maximum-connection-count>
<!-- 最小连接数-->
<minimum-connection-count>3</minimum-connection-count>
<house-keeping-test-sql>select CURRENT_DATE from dual</house-keeping-test-sql>
</proxool>
</something-else-entirely>

3、在web.xml中添加以下代码，使得项目启动时，自动加载proxool。
 <servlet>
  <servlet-name>AdminP</servlet-name>
  <servlet-class>
   org.logicalcobwebs.proxool.admin.servlet.AdminServlet
  </servlet-class>
  <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>AdminP</servlet-name>
  <url-pattern>/AdminP</url-pattern>
 </servlet-mapping>

 <servlet>
  <servlet-name>proxoolServletConfigurator</servlet-name>
  <servlet-class>
   org.logicalcobwebs.proxool.configuration.ServletConfigurator
  </servlet-class>
  <init-param>
   <param-name>xmlFile</param-name>
   <param-value>WEB-INF/classes/proxool-conf.xml</param-value>
  </init-param>
  <load-on-startup>5</load-on-startup>
 </servlet>

4、程序调用（三种方式）

     根据自己项目情况，采用以下三种方式中的任何一种即可。
1）、Spring框架调用。
在applicationContext.xml文件中：

 <bean id="dataSource"
  class="org.springframework.jdbc.datasource.DriverManagerDataSource"
  destroy-method="close" singleton="true">
  <property name="driverClassName">
   <value>org.logicalcobwebs.proxool.ProxoolDriver</value>
  </property>
  <property name="url">
   <value>proxool.pro_pool</value>
  </property>
 </bean>

2）、纯JDBC调用

driver = (Driver)Class.forName("org.logicalcobwebs.proxool.ProxoolDriver").newInstance();
DriverManager.registerDriver(driver);
conn = DriverManager.getConnection("proxool.pro_pool");

3）、Hibernate调用

在hibernate.cfg.xml中增加：
<property name="hibernate.proxool.pool_alias">pro_pool</property>
<property name="hibernate.proxool.xml">proxool-conf.xml</property>
<property name="connection.provider_class">org.hibernate.connection.ProxoolConnectionProvider</property>

程序中使用

Connection con = DriverManager.getConnection("proxool.pro_pool");

CREATE DATABASE `interceptor`

CHARACTER SET 'utf8';

USE `interceptor`;

DROP TABLE IF EXISTS `users`;



create table users(

id int auto_increment primary key,

name varchar(10) not null,

passwd varchar(10) not null

)

ENGINE=InnoDB DEFAULT CHARSET=utf8;

public class Users implements java.io.Serializable {

private Integer id;

private String name;

private String passwd;

public Users() {

}

public Users(String name, String passwd) {

this.name = name;

this.passwd = passwd;

}

public Integer getId() {

return this.id;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return this.name;

}

public void setName(String name) {

this.name = name;

}

public String getPasswd() {

return this.passwd;

}

public void setPasswd(String passwd) {

this.passwd = passwd;

}

User.hbm.xml: 

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<class name="com.domain.Users" table="users" catalog="interceptor">

<id name="id" type="java.lang.Integer">

<column name="id" />

<generator class="native" />

</id>

<property name="name" type="java.lang.String">

<column name="name" length="10" not-null="true" />

</property>

<property name="passwd" type="java.lang.String">

<column name="passwd" length="10" not-null="true" />

</property>

</class>

</hibernate-mapping>

//直接from查询出来的是一个映射对象，即：查询整个映射对象所有字段



String hql = "from Users";

Query query = session.createQuery(hql);



List<Users> users = query.list();

for(Users user : users){

System.out.println(user.getName() + " : " + user.getPasswd() + " : " + user.getId());

}



输出结果为：

name1 : password1 : 1

name2 : password2 : 2

name3 : password3 : 3

//查询单个字段



String hql = " select name from Users";

Query query = session.createQuery(hql);

List<String> list = query.list();

for(String str : list){

System.out.println(str);

}

输出结果为：

name1

name2

name3

//查询其中几个字段



String hql = " select name,passwd from Users";

Query query = session.createQuery(hql);

//默认查询出来的list里存放的是一个Object数组

List<Object[]> list = query.list();

for(Object[] object : list){

String name = (String)object[0];

String passwd = (String)object[1];



System.out.println(name + " : " + passwd);

}



输出结果为：

name1 : password1

name2 : password2

name3 : password3

//查询其中几个字段,添加new list(),注意list里的l是小写的。也不需要导入包，这样通过query.list()出来的list里存放的不再是默认的Object数组了，而是List集合了

String hql = " select new list(name,passwd) from Users";

Query query = session.createQuery(hql);

//默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是List集合了

List<List> list = query.list();

for(List user : list){



String name = (String)user.get(0);

String passwd = (String)user.get(1);



System.out.println(name + " : " + passwd);

}



/**



输出结果为：

name1 : password1

name2 : password2

name3 : password3

*/

//查询其中几个字段,添加new map(),注意map里的m是小写的。也不需要导入包，这样通过query.list()出来的list里存放的不再是默认的Object数组了，而是map集合了

String hql = " select new map(name,passwd) from Users";

Query query = session.createQuery(hql);

//默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是Map集合了



List<Map> list = query.list();

for(Map user : list){

//一条记录里所有的字段值都是map里的一个元素,key是字符串0,1,2,3....，value是字段值

//如果将hql改为：String hql = " select new map(name as username,passwd as password) from Users";,那么key将不是字符串0,1,2...了，而是"username","password"了

String name = (String)user.get("0");//get("0");是get(key),注意:0,1,2...是字符串，而不是整形

String passwd = (String)user.get("1");

System.out.println(name + " : " + passwd);



}



/**

输出结果为：

name1 : password1

name2 : password2

name3 : password3

*/

6.修改默认查询结果(query.list())不以Object[]数组形式返回，以Set形式返回,但是因为Set里是不允许有重复的元素，所以:username和password的值不能相同。只需将hql改为：String
hql = " select new set(name,passwd) from Users";

public class MyUser {

private String username;

private String password;

//因为：String hql = " select new  com.domain.MyUser(name,passwd) from Users";所以必须要有接受2个参数的构造函数

public MyUser(String username,String password){

this.username = username;

this.password = password;

}



public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}



public String getPassword() {

return password;

}



public void setPassword(String password) {

this.password = password;

}

}

//通过query.list()出来的list里存放的不再是默认的Object数组了,而是自定义的类MyUser,必须加包名，String hql = "from Users";中的Users类也是必须加包名的，但是因为再Users.hbm.xml里<hibernate-mapping auto-import="true"> auto-import默认值为true（所以auto-import属性也可以不写）,自动导入了

String hql = " select new  com.domain.MyUser(name,passwd) from Users";

Query query = session.createQuery(hql);

//默认查询出来的list里存放的是一个Object数组，但是在这里list里存放的不再是默认的Object数组了，而是MyUser对象了

List<MyUser> myUsers = query.list();

for(MyUser myUser : myUsers){

String name = myUser.getUsername();

String passwd = myUser.getPassword();

System.out.println(name + " : " + passwd);

}



/**



输出结果为：

name1 : password1

name2 : password2

name3 : password3

*/

//条件查询，参数索引值从0开始，索引位置。通过setString,setParameter设置参数

String hql = "from Users where name=? and passwd=?";

Query query = session.createQuery(hql);

//第1种方式

//		query.setString(0, "name1");

//		query.setString(1, "password1");

//第2种方式

query.setParameter(0, "name1",Hibernate.STRING);

query.setParameter(1, "password1",Hibernate.STRING);

List<Users> list = query.list();

for(Users users : list){

System.out.println(users.getId());

}

//条件查询，自定义索引名(参数名):username,:password.通过setString,setParameter设置参数

String hql = "from Users where name=:username and passwd=:password";

Query query = session.createQuery(hql);

//第1种方式

//		query.setString("username", "name1");

//		query.setString("password", "password1");

//第2种方式,第3个参数确定类型

query.setParameter("username", "name1",Hibernate.STRING);

query.setParameter("password", "password1",Hibernate.STRING);

List<Users> list = query.list();

for(Users users : list){

out.println(users.getId());

}

//条件查询,通过setProperties设置参数

String hql = "from Users where name=:username and passwd=:password";

Query query = session.createQuery(hql);

//MyUser类的2个属性必须和:username和:password对应

MyUser myUser = new MyUser("name1","password1");

query.setProperties(myUser);

List<Users> list = query.list();

for(Users users : list){

System.out.println(users.getId());

}

 public int getNextVal() {
  localVar.set(localVar.get() + 1);
  return localVar.get();
 }

 public static void main(String[] args) {
  Sequence seq = new Sequence();
  Client client1 = new Client(seq);
  Client client2 = new Client(seq);
  Client client3 = new Client(seq);

  client1.start();
  client2.start();
  client3.start();

 }

}

package hvp.spring.transaction.threadLocal;

public class Client extends Thread{
 private Sequence seq;
 public Client(Sequence seq){
  this.seq = seq;
 }
 public void run(){
  StringBuffer sb = new StringBuffer();
  for(int i=0;i<5;i++){
   sb.append("Thread[");
   sb.append(Thread.currentThread().getName());
   sb.append("] seq[");
   sb.append(seq.getNextVal());
   sb.append("]");
   System.out.println(sb.toString());
   sb.delete(0, sb.length());
  }
 }
}

主要介绍的是Hibernate使用到的.jar
Hibernate一共包括了23个jar包，令人眼花缭乱。本文将详细讲解Hibernate每个jar包的作用，便于你在应用中根据自己的需要进行取舍。
下载Hibernate，例如2.0.3稳定版本，解压缩，可以看到一个hibernate2.jar和lib目录下有22个jar包.

1.hibernate2: jar
    Hibernate的库，没有什么可说的，必须使用的jar包.

2.cglib-asm.jar
    CGLIB库，Hibernate用它来实现PO字节码的动态生成，非常核心的库，必须使用的jar包.

3.dom4j.jar
    dom4j是一个Java的XML API，类似于jdom，用来读写XML文件的。dom4j是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件，可以在SourceForge上找到它。在IBM developerWorks上面可以找到一篇文章，对主流的Java XML API进行的性能、功能和易用性的评测，dom4j无论在那个方面都是非常出色的。我早在将近两年之前就开始使用dom4j，直到现在。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML，特别值得一提的是连Sun的JAXM也在用dom4j。这是必须使用的jar包，Hibernate用它来读写配置文件。

4.odmg.jar
    ODMG是一个ORM的规范，Hibernate实现了ODMG规范，这是一个核心的库，必须使用的jar包。

5.commons-collections.jar
    Apache Commons包中的一个，包含了一些Apache开发的集合类，功能比java.util.*强大。必须使用的jar包。

6.commons-beanutils.jar
    Apache Commons包中的一个，包含了一些Bean工具类类。必须使用的jar包。

7.commons-lang.jar
    Apache Commons包中的一个，包含了一些数据类型工具类，是java.lang.*的扩展。必须使用的jar包。

8.commons-logging.jar:
    Apache Commons包中的一个，包含了日志功能，必须使用的jar包。这个包本身包含了一个Simple Logger，但是功能很弱。在运行的时候它会先在CLASSPATH找log4j，如果有，就使用log4j，如果没有，就找JDK1.4带的java.util.logging，如果也找不到就用Simple Logger。commons-logging.jar的出现是一个历史的的遗留的遗憾，当初Apache极力游说Sun把log4j加入JDK1.4，然而JDK1.4项目小组已经接近发布JDK1.4产品的时间了，因此拒绝了Apache的要求，使用自己的java.util.logging，这个包的功能比log4j差的很远，性能也一般。后来Apache就开发出来了commons-logging.jar用来兼容两个logger。因此用commons-logging.jar写的log程序，底层的Logger是可以切换的，你可以选择log4j，java.util.logging或者它自带的Simple Logger。不过我仍然强烈建议使用log4j，因为log4j性能很高，log输出信息时间几乎等于System.out，而处理一条log平均只需要5us。你可以在Hibernate的src目录下找到Hibernate已经为你准备好了的log4j的配置文件，你只需要到Apache 网站去下载log4j就可以了。commons-logging.jar也是必须的jar包。

-----------------------------------------------------------------------------------------
使用Hibernate必须的jar包就是以上的这几个，剩下的都是可选的。
-----------------------------------------------------------------------------------------

9.ant.jar
    Ant编译工具的jar包，用来编译Hibernate源代码的。如果你不准备修改和编译Hibernate源代码，那么就没有什么用，可选的jar包

10.optional.jar
    Ant的一个辅助包。

11.c3p0.jar
    C3PO是一个数据库连接池，Hibernate可以配置为使用C3PO连接池。如果你准备用这个连接池，就需要这个jar包。

12.proxool.jar
    也是一个连接池，同上。

13.commons-pool.jar,commons-dbcp.jar
    DBCP数据库连接池，Apache的Jakarta组织开发的，Tomcat4的连接池也是DBCP。

    实际上Hibernate自己也实现了一个非常非常简单的数据库连接池，加上上面3个，你实际上可以在Hibernate上选择4种不同的数据库连接池，选择哪一个看个人的偏好，不过DBCP可能更通用一些。另外强调一点，如果在EJB中使用Hibernate，一定要用App Server的连接池，不要用以上4种连接池，否则容器管理事务不起作用。

14.connector.jar
    JCA 规范，如果你在App Server上把Hibernate配置为Connector的话，就需要这个jar。不过实际上一般App Server肯定会带上这个包，所以实际上是多余的包。

15.jaas.jar
    JAAS是用来进行权限验证的，已经包含在JDK1.4里面了。所以实际上是多余的包。

16.jcs.jar
    如果你准备在Hibernate中使用JCS的话，那么必须包括它，否则就不用。

17.jdbc2_0-stdext.jar
    JDBC2.0的扩展包，一般来说数据库连接池会用上它。不过App Server都会带上，所以也是多余的。

18.jta.jar
    JTA规范，当Hibernate使用JTA的时候需要，不过App Server都会带上，所以也是多余的。

19.junit.jar
    Junit包，当你运行Hibernate自带的测试代码的时候需要，否则就不用。

20.xalan.jar, xerces.jar, xml-apis.jar
    Xerces是XML解析器，Xalan是格式化器，xml-apis实际上是JAXP。一般App Server都会带上，JDK1.4也包含了解析器，不过不是Xerces，是Crimson，效率比较差，不过Hibernate用XML只不过是读取配置文件，性能没什么紧要的，所以也是多余的。