数据库连接池的TOMCAT配置方法

数据库连接池的TOMCAT配置方法

一：新手方法
1．将数据库驱动程序的JAR文件放在Tomcat的 common/lib 中；

2．在server.xml中设置数据源，以MySQL数据库为例，如下：
在<GlobalNamingResources> </GlobalNamingResources>节点中加入，
      <Resource
      name="jdbc/DBPool"
      type="javax.sql.DataSource"
      password="root"
      driverClassName="com.mysql.jdbc.Driver"
      maxIdle="2"
      maxWait="5000"
      username="root"
      url="jdbc:mysql://127.0.0.1:3306/test"
      maxActive="4"/>
   属性说明：name，数据源名称，通常取”jdbc/XXX”的格式；
            type，”javax.sql.DataSource”;
            password，数据库用户密码；
            driveClassName，数据库驱动；
            maxIdle，最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连
                     接将被标记为不可用，然后被释放。设为0表示无限制。
            MaxActive，连接池的最大数据库连接数。设为0表示无限制。
            maxWait ，最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示
                     无限制。

3．在你的web应用程序的web.xml中设置数据源参考，如下：
  在<web-app></web-app>节点中加入，
  <resource-ref>
    <description>MySQL DB Connection Pool</description>
    <res-ref-name>jdbc/DBPool</res-ref-name>
    <res-type>javax.sql.DataSource</res-type>
    <res-auth>Container</res-auth>
    <res-sharing-scope>Shareable</res-sharing-scope>
</resource-ref>
  子节点说明： description，描述信息；
               res-ref-name，参考数据源名字，同上一步的属性name；
               res-type，资源类型，”javax.sql.DataSource”；
               res-auth，”Container”；
               res-sharing-scope，”Shareable”；

4．在web应用程序的context.xml中设置数据源链接，如下：
  在<Context></Context>节点中加入，
  <ResourceLink
   name="jdbc/DBPool"
   type="javax.sql.DataSource"
   global="jdbc/DBPool"/>
   属性说明：name，同第2步和第3步的属性name值，和子节点res-ref-name值；
             type，同样取”javax.sql.DataSource”；
             global，同name值。

至此，设置完成，下面是如何使用数据库连接池。
1．建立一个连接池类，DBPool.java，用来创建连接池，代码如下：
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

public class DBPool {
    private static DataSource pool;
    static {
         Context env = null;
          try {
              env = (Context) new InitialContext().lookup("java:comp/env");
              pool = (DataSource)env.lookup("jdbc/DBPool");
              if(pool==null)
                  System.err.println("'DBPool' is an unknown DataSource");
               } catch(NamingException ne) {
                  ne.printStackTrace();
          }
      }
    public static DataSource getPool() {
        return pool;
    }
}

2．在要用到数据库操作的类或jsp页面中，用DBPool.getPool().getConnection()，获得一个Connection对象，就可以进行数据库操作，最后别忘了对Connection对象调用close()方法，注意：这里不会关闭这个Connection，而是将这个Connection放回数据库连接池。

二：此部分转载来自http://www.iteye.com/topic/245596
以前就听说过数据库连接池这个概念，加入数据库连接池。设置基本上主要有两种方法我们以MySQL+TOMCAT为例
1.把DataSource设置到我们的WEB项目中，下面详细的介绍下：
第一步：在我们的WEB项目中的META-INF文件夹下建立一个context.xml
Xml代码 
<?xml version='1.0' encoding='utf-8'?> 
 
<Context> 
 
    <Resource name="jdbc/mysql"     
       auth="Container"     
       type="javax.sql.DataSource"     
       driverClassName="com.mysql.jdbc.Driver"     
       url="jdbc:mysql://localhost/bbs"     
       username="root"     
       password="root"     
       maxActive="50"     
       maxIdle="20"     
       maxWait="10000" />     
 
</Context> 

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

<Context>

    <Resource name="jdbc/mysql"  
       auth="Container"  
       type="javax.sql.DataSource"  
       driverClassName="com.mysql.jdbc.Driver"  
       url="jdbc:mysql://localhost/bbs"  
       username="root"  
       password="root"  
       maxActive="50"  
       maxIdle="20"  
       maxWait="10000" />  

</Context>

第二步：在我们的WEB项目下的WEB-INF文件夹下建立一个web.xml(如果存在了就不用了，直接修改就行了)
(这几天测试了一下，不做这步也可以，O(∩_∩)O哈哈~省事了)
Xml代码 
<resource-ref> 
    <description>DB Connection</description> 
    <res-ref-name>jdbc/mysql</res-ref-name> 
    <res-type>javax.sql.DataSource</res-type> 
    <res-auth>Container</res-auth> 
</resource-ref> 

  <resource-ref>
      <description>DB Connection</description>
      <res-ref-name>jdbc/mysql</res-ref-name>
      <res-type>javax.sql.DataSource</res-type>
      <res-auth>Container</res-auth>
  </resource-ref>

第三步：我们就可以用代码来获取Connection对象了
Java代码 
package xushun.util;  
 
import java.sql.*;  
import javax.sql.*;  
import javax.naming.*;  
 
public class DBHelper {  
      
    public static Connection getConnection() throws SQLException,NamingException  
    {  
        // 初始化查找命名空间  
        Context initContext = new InitialContext();  
        Context envContext = (Context)initContext.lookup("java:/comp/env");  
        // 找到DataSource  
        DataSource ds = (DataSource)envContext.lookup("jdbc/mysql");  
        return ds.getConnection();  
    }  
} 

package xushun.util;

import java.sql.*;
import javax.sql.*;
import javax.naming.*;

public class DBHelper {
   
    public static Connection getConnection() throws SQLException,NamingException
    {
        // 初始化查找命名空间
        Context initContext = new InitialContext();
        Context envContext = (Context)initContext.lookup("java:/comp/env");
        // 找到DataSource
        DataSource ds = (DataSource)envContext.lookup("jdbc/mysql");
        return ds.getConnection();
    }
}

2.把DataSource设置到我们的Tomcat中，下面详细的介绍下（测试用的JAVA代码和上面的一样就不帖出了）：
这里我查到的设置方法就有了一点区别了。有的人把DataSource设置在Tomcat的server.xml文件的GlobalNamingResources下面，然后在context.xml中去映射。有的直接就写在context.xml中了
先说下在server.xml添加DataSource
第一步：在Tomcat的conf中的server.xml文件中找到Xml代码 
<GlobalNamingResources> 
  <!-- Editable user database that can also be used by  
       UserDatabaseRealm to authenticate users  
  --> 
  <Resource name="UserDatabase" auth="Container" 
            type="org.apache.catalina.UserDatabase" 
            description="User database that can be updated and saved" 
            factory="org.apache.catalina.users.MemoryUserDatabaseFactory" 
            pathname="conf/tomcat-users.xml" /> 
</GlobalNamingResources> 

  <GlobalNamingResources>
    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users
    -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>修改为Xml代码 
<GlobalNamingResources> 
  <!-- Editable user database that can also be used by  
       UserDatabaseRealm to authenticate users  
  --> 
  <Resource name="UserDatabase" auth="Container" 
            type="org.apache.catalina.UserDatabase" 
            description="User database that can be updated and saved" 
            factory="org.apache.catalina.users.MemoryUserDatabaseFactory" 
            pathname="conf/tomcat-users.xml" /> 
  <Resource name="jdbc/bbs"       
         auth="Container" type="javax.sql.DataSource" 
         driverClassName="com.mysql.jdbc.Driver" 
         maxIdle="20" 
         maxWait="5000" 
         username="root" 
         password="admin" 
         url="jdbc:mysql://localhost:3306/bbs"       
         maxActive="100"   
         removeAbandoned="true" 
         removeAbandonedTimeout="60" 
         logAbandoned="true"/> 
</GlobalNamingResources> 

  <GlobalNamingResources>
    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users
    -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
    <Resource name="jdbc/bbs"    
          auth="Container" type="javax.sql.DataSource"
          driverClassName="com.mysql.jdbc.Driver"
          maxIdle="20"
          maxWait="5000"
          username="root"
          password="admin"
          url="jdbc:mysql://localhost:3306/bbs"    
          maxActive="100"
          removeAbandoned="true"
          removeAbandonedTimeout="60"
          logAbandoned="true"/>
  </GlobalNamingResources>
第二步：在Tomcat的conf文件夹下的context.xml中加入
Xml代码 
<ResourceLink name="jdbc/bbs" global="jdbc/bbs" type="javax.sql.DataSource"/> 

<ResourceLink name="jdbc/bbs" global="jdbc/bbs" type="javax.sql.DataSource"/>
第三步：就是在WEB项目的WEB-INF中的web.xml添加Xml代码 
<resource-ref> 
    <description>DB Connection</description> 
    <res-ref-name>jdbc/mysql</res-ref-name> 
    <res-type>javax.sql.DataSource</res-type> 
    <res-auth>Container</res-auth> 
</resource-ref> 

  <resource-ref>
      <description>DB Connection</description>
      <res-ref-name>jdbc/mysql</res-ref-name>
      <res-type>javax.sql.DataSource</res-type>
      <res-auth>Container</res-auth>
  </resource-ref>

还有就是在Tomcat文档中提到的方法，直接修改context.xml文件了
在Tomcat的conf文件夹下的context.xml中加入Xml代码 
<Resource name="jdbc/bbs"       
              auth="Container" type="javax.sql.DataSource" 
              driverClassName="com.mysql.jdbc.Driver" 
              maxIdle="20" 
              maxWait="5000" 
              username="root" 
              password="admin" 
              url="jdbc:mysql://localhost:3306/bbs"       
              maxActive="100"   
              removeAbandoned="true" 
              removeAbandonedTimeout="60" 
              logAbandoned="true"/> 

<Resource name="jdbc/bbs"    
          auth="Container" type="javax.sql.DataSource"
          driverClassName="com.mysql.jdbc.Driver"
          maxIdle="20"
          maxWait="5000"
          username="root"
          password="admin"
          url="jdbc:mysql://localhost:3306/bbs"    
          maxActive="100"
          removeAbandoned="true"
          removeAbandonedTimeout="60"
          logAbandoned="true"/>然后就是在WEB项目的WEB-INF中的web.xml添加Xml代码 
<resource-ref> 
    <description>DB Connection</description> 
    <res-ref-name>jdbc/mysql</res-ref-name> 
    <res-type>javax.sql.DataSource</res-type> 
    <res-auth>Container</res-auth> 
</resource-ref> 

  <resource-ref>
      <description>DB Connection</description>
      <res-ref-name>jdbc/mysql</res-ref-name>
      <res-type>javax.sql.DataSource</res-type>
      <res-auth>Container</res-auth>
  </resource-ref>

就是这些了，如果有什么不太清楚的就留言，一起研究下。等以后我在搜集下资料整理出上面用到的XML文件中各个标签的属性及其代表的意思。有兴趣的也可以自己先查下。:-)

<td>JNDI 查找名称</td>       <td>关联的引用</td>

<td>java:comp/env</td>      <td>应用程序环境条目</td>

<td>java:comp/env/jdbc</td> <td>JDBC 数据源资源管理器连接工厂</td>

<td>java:comp/env/ejb</td>  <td>EJB 引用</td>

<td>java:comp/UserTransaction</td><td>UserTransaction 引用</td>

<td>java:comp/env/mail</td> <td>JavaMail 会话连接工厂</td>

<td>java:comp/env/url</td>  <td>URL 连接工厂</td>

<td>java:comp/env/jms</td>  <td>JMS 连接工厂和目标</td>

<td>java:comp/ORB</td>      <td>应用程序组件之间共享的 ORB 实例</td>

三：现在习惯用c3p0的连接池和配置文件。。或者spring里配置数据库那也集成c3p0

Spring C3P0 配置文件 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
        xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
   
    <!-- 定义数据源Bean,使用C3P0数据源实现-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <!-- 指定连接数据库的驱动-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <!-- 指定连接数据库的URL-->
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_hibernate"/>
        <!-- 指定连接数据库的用户名-->
        <property name="user" value="root"/>
        <!-- 指定连接数据库的密码-->
        <property name="password" value="root"/>
        <!-- 指定连接池中保留的最大连接数. Default:15-->
        <property name="maxPoolSize" value="15"/>
        <!-- 指定连接池中保留的最小连接数-->
        <property name="minPoolSize" value="10"/>
        <!-- 指定连接池的初始化连接数  取值应在minPoolSize 与 maxPoolSize 之间.Default:3-->
        <property name="initialPoolSize" value="5"/>
        <!-- 最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。 Default:0-->
        <property name="maxIdleTime" value="60"/>
        <!-- 当连接池中的连接耗尽的时候c3p0一次同时获取的连接数. Default:3-->
        <property name="acquireIncrement" value="5"/>
        <!-- JDBC的标准,用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements属于单个connection而不是整个连接池所以设置这个参数需要考虑到多方面的因数.如果maxStatements与maxStatementsPerConnection均为0,则缓存被关闭。Default:0-->
        <property name="maxStatements" value="0"/>
        <!-- 每60秒检查所有连接池中的空闲连接.Default:0 -->
        <property name="idleConnectionTestPeriod" value="60"/>
        <!-- 定义在从数据库获取新连接失败后重复尝试的次数。 Default:30 -->
        <property name="acquireRetryAttempts" value="30"/>
        <!-- 获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效保留,并在下次调用getConnection()的时候继续尝试获取连接。如果设为true,那么在尝试获取连接失败后该数据源将申明已断开并永久关闭。Default:false -->
        <property name="breakAfterAcquireFailure" value="true"/>
        <!-- 银性能消耗大请只在需要的时候是哟个它。如果设为true,那么在每个connection提交的时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable等提升连接测试的性能。 Default:false-->
        <property name="testConnectionOnCheckout" value="false"/>
    </bean>
   
    <!-- 配置SessionFactory-->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- 依赖注入 数据源-->
        <property name="dataSource" ref="dataSource"></property>
        <!-- 配置映射文件-->
        <property name="mappingResources">
            <list>
                <value>org/cric/model/NewMapping.hbm.xml</value>
            </list>
        </property>
        <!-- 配置hibernate属性-->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>
   
    <bean id="studentDao" class="org.cric.dao.impl.StudentDaoImpl">
        <!-- 依赖注入 -->
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
   
    <bean id="studentService" class="org.cric.service.impl.StudentServiceImpl">
        <!-- 依赖注入 -->
        <property name="studentDao" ref="studentDao"/>
    </bean>
   
</beans>


四：hibernate的配置文件及连接池
hibernate可以与任何一种Java应用的运行环境集成。Java应用的运行环境可分为两种：
1，受管理环境Managed environment，由容器负责管理各种共享资源，如线程池和数据库连接池，以及管理事务和安全。一些J2EE应用服务器，如JBoss,WebLogic和WebSphere提供了符合J2EE规范的受管理环境。
2，不受管理环境Non-managed environment，由应用本身负责管理数据库连接，定义事务边界以及管理安全。独立的桌面应用或命令行应用都运行在不受管理环境中，servlet容器会负责管理线程池，有些servlet容器，如tomcat，还会管理数据库连接池，但是servlet容器不会管理事务，因此它提供的仍然是不受管理的运行环境。
hibernate允许Java应用在不同的环境中移植。移植只需要修改hibernate的配置文件，而不需要修改或只需要修改少量的Java源代码。

所有的Java应用最终都必须通过JDBC API来访问数据库。
在不受管理的环境中，Java应用自身负责构造特定的连接池实例，然后访问这个连接池的API，从连接池中获得数据库连接。
在受管理的环境中，容器负责构造连接池的实例，Java应用直接访问容器提供的连接池实例。
JNDI技术可以简单的理解为一种将对象/服务和名字绑定的技术；它在受管理的环境中得到了广泛的运用。

hibernate把不同来源的连接池抽象为net.sf.hibernate.connection.ConnectionProvider接口，并提供了以下内置的ConnectionProvider实现类。、
DriverManagerConnectionProvider：代表hibernate提供的默认的数据库连接池。
DataSourceConnectionProvider：代表在受管理环境中由容器提供的数据源。
DBCPConnectionProvider：代表DBCP连接池。
C3P0ConnectionProvider：代表C3P0连接池。
ProxoolConnectionProvider：代表Proxool连接池。
连接池用户也可以扩展，写自己的连接池。这里不写了，可以用百度一下。

hibernate提供了默认的连接池实现，它的实现类为DriverManagerConnectionProvider，如果在hibernate的配置文件中没有明确配置任何连接池，hibernate就会使用这个默认的连接池。在生产环境中不要使用这个连接池，因为它缺乏响应大批量并发请求以及容错的能力。
不管是在受管理环境中，还是在不受管理环境中，都可以在配置文件中显式配置特定数据库连接池。hibernate会负责构造这种连接池的实例，然后通过它获得数据库连接。
hibernate目前支持的第三方连接池产品包括：C3P0,Proxool,DBCP，hibernate开发组织优先推荐的是C3P0和Proxool。C3P0配置的例子如下：
hibernate.c3p0.min_size=5//在连接池中可用的数据库连接的最少数目
hibernate.c3p0.max_size=20//在连接池中可用的数据库连接的最多数目
hibernate.c3p0.timeout=300//设定数据库连接的过期时间，以秒为单位。如果连接池中的某个数据库连接处于空闲状态的时间超过了指定的时间，就会从连接池中清除。
hibernate.c3p0.max_statements=50//可以被缓存的PreparedStatement实例的最大数目。缓存适量的PreparedStatement实例，能够大大提高hibernate的性能。
hibernate.c3p0.idle_test_period=3000//在使数据库连接自动生效之前处于空闲状态的时间，以秒为单位。

不同的连接池有不同的配置选项。

在受管理环境中，容器负责构造数据源，即javax.sql.DataSource实例，然后把它发布为JNDI资源，hibernate的DataSourceConnectionProvider类充当这个数据源的代理。
在不受管理环境中，有些Servlet容器，如tomcat，也能负责构造数据源，并能把它发布为JNDI资源。

以tomcat为例，为了使hibernate从容器中获得数据源，需要分别配置tomcat容器和hibernate：
1，在tomcat容器中配置数据源；2，在hibernate的配置文件中指定使用容器中的数据源。

tomcat的配置文件server.xml中，<Resource>元素用来配置JNDI资源，它允许把数据源也发布为JNDI资源，如：
<Resource name="jdbc/SAMPLEDB" auth="Container" type="javax.sql.DataSource"/>
<ResourceParams name="jdbc/SAMPLEDB">
<parameter>
   <name>factory</name>
   <value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
</parameter>
<parameter>
   <name>maxActive</name>
   <value>100</value>
</parameter>
<parameter>
   <name>maxIdle</name>
   <value>30</value>
</parameter>
<parameter>
   <name>maxWait</name>
   <value>10000</value>
</parameter>
<parameter>
   <name>username</name>
   <value>root</value>
</parameter>
<parameter>
   <name>password</name>
   <value>1234</value>
</parameter>
<parameter>
   <name>driverClassName</name>
   <value>com.mysql.jdbc.Driver</value>
</parameter>
<parameter>
   <name>url</name>
   <value>jdbc:mysql://loaclhost:3306/SAMPLEDB?autoReconnection=true</value>
</parameter>
</ResourceParams>
以上代码设置了<Resource>和<ResourceParams>元素。
<Resource>的属性值描述如下：
name：指定resource的JNDI名字。
auth：指定管理resource的manager，它有两个可选的值：Container和Application；分别表示由容器和由WEB应用程序来创建和管理resource。
type：指定resource所属的Java类名。
在<ResourceParams>元素中指定了配置数据源的各种参数：
factory：生成DataSource的factory类名。
maxActive：数据库连接池中处于活动状态的数据库连接的最大数目，取值为0，表示不受限制。
maxIdle：数据库连接池中处于空闲状态的数据库连接的最大数目，取值为0，表示不受限制。
maxWait：数据库连接池中的数据库连接处于空闲状态的时长时间，以毫秒为单位，超过这一时间，将会抛出异常，取值为-1，表示可以无限制等待。
username：数据库用户名
password：数据库密码
driverClassName：JDBC驱动程序
url：数据库连接URL。

hibernate的配置文件中配置如下：
hibernate.connection.datasource=java:comp/env/jdbc/SAMPLEDB
指定数据源时，必须提供完整的JNDI名字。因为使用了数据源，所以在hibernate配置文件中无须再指定以下参数：hibernate.connection.url,hibernate.connection.username,hibernate.connection.password。

Java应用本身提供数据库连接这里不介绍了，如果session使用的是java应用提供的Connection实例，那么hibernate的二级缓存就会失效。


在Java应用中，按照声明事务边界的接口划分，事务可分为两类：
1，JDBC事务，通过JDBC API来声明事务边界，适用于任何Java运行环境。
2，JTA事务，通过JTA来声明事务边界，适用于基于J2EE的受管理环境。
JTA(Java Transaction API)是SUN公司为基于J2EE的受管理环境制定的标准事务API，JTA支持分布式的事务以及跨数据库平台的事务，JTA中的两个核心接口如下：
1，TransactionManager：在CMT环境中，容器通过这个接口来声明事务边界。CMT(Container-managered Transaction)是指由容器来负责管理事务，在Java应用中不必编写声明事务边界的程序代码。
2，UserTransaction：Java应用通过这个接口来声明事务边界。
对于使用了hibernate的Java应用，Java应用不必直接访问JDBC API或JTA，而是由hibernate来声明JDBC事务或JTA事务。不管hibernate使用的是哪种事务，对Java应用是透明的。在hibernate的配置文件中，hibernate.transaction.factory_class属性用来指定事务工厂类，它的默认值为net.sf.hibernate.transaction.JDBCTransactionFactory。下面配置了JTA事务如：
hibernate.transaction.factory_class=net.sf.hibernate.transaction.JTATransactionFactory
hibernate.transaction.manager_lookup_class=net.sf.hibernate.transaction.JBossTransactionManagerLookup

hibernate.transaction.manager_lookup_class这个属性用于指定TransactionManagerLookup接口的实现类，这个接口负责定位容器中的JTA TransactionManager。hibernate为许多J2EE应用服务器提供了实现类，如JBoss的实现类为JBossTransactionManagerLookup。只有当需要使用二级缓存并且由容器管理事务时，才必须设置manager_lookup_class属性，其它情况下可以不必设置。
当使用JTA事务时，还可以显式指定JTA UserTransaction的JNDI名字，UserTransaction在容器中被发布为JNDI资源，下面是例子：
hibernate.transaction.factory_class=net.sf.hibernate.transaction.JTATransactionFactory
hibernate.jta.UserTransaction=java:comp/UserTransaction

应用程序中的SessionFactory的存取方案：
1，创建一个实用类HibernateUtil，在这个类中定义static类型的SessionFactory变量，以及public static类型的getSessionFactory()方法。
2，在Servlet容器中，把SessionFactory实例存放在ServletContext中。
3，在基于J2EE的受管理环境中，把SessionFactory发布为JNDI资源。在hibernate配置文件中，hibernate.session_factory_name属性指定SessionFactory的JNDI名字，如果在受管理环境中设置了这个属性，hibernate就会把SessionFactory发布为JNDI资源。如：
配置文件中设置：hibernate.session_factory_name=java:hibernate/HibernateFactory
Java应用通过JNDI来访问：
Context context = new InitialContext();
String jndiName = "java:hibernate/HibernateFactory"
SessionFactory sessionFactory = (SessionFactory)context.lookup(jndiName);
Session session = sessionFactory.openSession();
以上程序代码只能在J2EE应用服务器内运行，不能在J2EE应用服务器外运行，因为SessionFactory不支持RMI(remote method invoke远程方法调用)。

如果hibernate配置文件格式为.properties，那么必须以编程方式声明需要加载的映射文件：
SessionFactory sessionFactory = new Configuration().addClass(mypack.Customer.class).addClass(mypack.Order.class).buildSessionFactory();
如果使用xml配置文件，可以在配置文件中声明映射文件。
当通过Configuration的默认构造方法Configuration()来创建Configuration实例时，hibernate会到classpath中查找默认的hibernate.properties文件，如果找到，就把它的配置信息加载到内存中。在默认情况下，hibernate不会加载hibernate.cfg.xml文件，必须通过Configuration的configure()方法来显式加载hibernate.cfg.xml文件：SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
Configuration的configure()方法会到classpath中查找hibernate.cfg.xml文件，如果找到，就把它的配置信息加载到内存中，如果同时存在hibernate.properties文件和hibernate.cfg.xml文件，那么hibernate.cfg.xml文件的内容会覆盖hibernate.properties文件的内容。在实际应用中，可以在hibernate.properties文件中设定默认的配置，然后在hibernate.cfg.xml文件中把与特定环境相关的配置放在里面。
如果希望hibernate从指定的XML文件中读取配置信息，可以调用Configuration.configure(String resource)方法：SessionFactory sessionFactory = new Configuration().configure(/netstore.cfg.xml").buildSessionFactory();这里的目录不能是相对目录，只能是相对于classpath的绝对目录。


五：

C3P0.xml  连接池配置文件：
<!--
author：Gavin.lee
date：2009-12-10 20:46:50
c3p0连接池配置文件，这里目前配置了2个MSSQ库的连接池，设置了主要的参数
c3p0 api 手册  http://www.mchange.com/projects/c3p0/apidocs/index.html
-->
<root>
    <cp-sqlserver>
        <user>wap</user>
        <password>esunxyz500wan!^wap</password>
        <url>jdbc:jtds:sqlserver://serverIP:port/wubai_wapcp</url>
        <driver>net.sourceforge.jtds.jdbc.Driver</driver>
        <maxPoolSize>100</maxPoolSize>
        <minPoolSize>5</minPoolSize>
        <initialPoolSize>20</initialPoolSize>
        <maxStatements>100</maxStatements>
        <maxIdleTime>600</maxIdleTime>
    </cp-sqlserver>
   
    <new-sqlserver>
        <user>wap</user>
        <password>esunxyz500wan!^wap</password>
        <url>jdbc:jtds:sqlserver://serverIP:port/wubai_wapnew</url>
        <driver>net.sourceforge.jtds.jdbc.Driver</driver>
        <maxPoolSize>100</maxPoolSize>
        <minPoolSize>5</minPoolSize>
        <initialPoolSize>20</initialPoolSize>
        <maxStatements>100</maxStatements>
        <maxIdleTime>600</maxIdleTime>
    </new-sqlserver>
   
    <cp-mysql></cp-mysql>
</root>

##配置除user,password,minpoolsize,maxpoolsize的参数
##[注意] 整数值不能有空格

#初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3
c3p0.initialPoolSize=10

#当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3
c3p0.acquireIncrement=3

#最大空闲时间,60秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0
#maxIdleTime应该小于MySQL的wait_timeout的值
c3p0.maxIdleTime=600

#定义在从数据库获取新连接失败后重复尝试的次数。Default: 30
c3p0.acquireRetryAttempts=5

#两次连接中间隔时间，单位毫秒。Default: 1000
c3p0.acquireRetryDelay=1000

#连接关闭时默认将所有未提交的操作回滚。Default: false
c3p0.autoCommitOnClose=false

#c3p0将建一张名为Test的空表，并使用其自带的查询语句进行测试。如果定义了这个参数那么
#属性preferredTestQuery将被忽略。你不能在这张Test表上进行任何操作，它将只供c3p0测试
#使用。Default: null
#c3p0.automaticTestTable=

#获取连接失败将会引起所有等待连接池来获取连接的线程抛出异常。但是数据源仍有效
#保留，并在下次调用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试
#获取连接失败后该数据源将申明已断开并永久关闭。Default: false
#c3p0.breakAfterAcquireFailure=false

#当连接池用完时客户端调用getConnection()后等待获取新连接的时间，超时后将抛出
#SQLException,如设为0则无限期等待。单位毫秒。Default: 0
c3p0.checkoutTimeout=10000

#每60秒检查所有连接池中的空闲连接。Default: 0
c3p0.idleConnectionTestPeriod=600

#JDBC的标准参数，用以控制数据源内加载的PreparedStatements数量。但由于预缓存的statements
#属于单个connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素。
#如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 0
c3p0.maxStatements=100

#maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0
c3p0.maxStatementsPerConnection=0

#c3p0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能
#通过多线程实现多个操作同时被执行。Default: 3
c3p0.numHelperThreads=3

#通过实现ConnectionTester或QueryConnectionTester的类来测试连接。类名需制定全路径。
#Default: com.mchange.v2.c3p0.impl.DefaultConnectionTester
#c3p0.connectionTesterClassName=

#指定c3p0 libraries的路径，如果（通常都是这样）在本地即可获得那么无需设置，默认null即可
#Default: null
#c3p0.factoryClassLocation=

#当用户调用getConnection()时使root用户成为去获取连接的用户。主要用于连接池连接非c3p0
#的数据源时。Default: nul
#c3p0.overrideDefaultUser=root

#与overrideDefaultUser参数对应使用的一个参数。Default: null
#c3p0.overrideDefaultPassword=

#定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个一显著提高测试速度。注意：
#测试的表必须在初始数据源的时候就存在。Default: null
#c3p0.preferredTestQuery=

#因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的
#时候都将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
#等方法来提升连接测试的性能。Default: false
#c3p0.testConnectionOnCheckout=false

#如果设为true那么在取得连接的同时将校验连接的有效性。Default: false
#c3p0.testConnectionOnCheckin=false