以下介紹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只不過是讀取配置文件，性能沒什么緊要的，所以也是多余的。