Java 数据库连接池的实现

最新推荐文章于 2024-04-21 23:14:13 发布

huangshulang1234

最新推荐文章于 2024-04-21 23:14:13 发布

阅读量4.3k

点赞数 2

分类专栏：后台开发文章标签：数据库数据库连接池

后台开发专栏收录该内容

9 篇文章 1 订阅

订阅专栏

Java 数据库连接池的实现

转载：javaweb学习总结(三十九)——数据库连接池

一、连接池的定义

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

二、连接池的实现

一般来说，Java应用程序访问数据库的过程是：
①装载数据库驱动程序；
②通过jdbc建立数据库连接；
③访问数据库，执行sql语句；
④断开数据库连接。

编写连接池需实现java.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：

· Connection getConnection()

· Connection getConnection(String username, String password)

实现DataSource接口，并实现连接池功能的步骤：

1. 在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。

2. 实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。

3. 当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。Collection保证将自己返回到LinkedList中是此处编程的难点。

数据库连接池核心代码

使用动态代理技术构建连接池中的connection：

[java]view plain copy 
   
 proxyConn = (Connection) Proxy.newProxyInstance(this.getClass().getClassLoader(), conn.getClass().getInterfaces(),  
             new InvocationHandler() {  
             //此处为内部类，当close方法被调用时将conn还回池中,其它方法直接执行  
             public Object invoke(Object proxy, Method method,  
                       Object[] args) throws Throwable {  
                 if (method.getName().equals("close")) {  
                     pool.addLast(conn);  
                     return null;  
             }  
             return method.invoke(conn, args);  
         }  
     });  

数据库连接池编写范例：

[java]view plain copy 
   
 package me.gacl.demo;  
    
 import java.io.InputStream;  
 import java.io.PrintWriter;  
 import java.lang.reflect.InvocationHandler;  
 import java.lang.reflect.Method;  
 import java.lang.reflect.Proxy;  
 import java.sql.Connection;  
 import java.sql.DriverManager;  
 import java.sql.SQLException;  
 import java.util.Vector;  
 import java.util.Properties;  
 import javax.sql.DataSource;  
    
 /** 
 * @ClassName: JdbcPool 
 * @Description:编写数据库连接池 
 * @author: 孤傲苍狼 
 * @date: 2014-9-30 下午11:07:23 
 * 
 */  
 public class JdbcPool implements DataSource{  
    
     /** 
     * @Field: Connections 
     *         使用Vector来存放数据库链接， 
     *         Vector具备线程安全性 
     */  
     private static Vector Connections = new Vector();  
       
     static{  
         //在静态代码块中加载db.properties数据库配置文件  
         InputStream in = JdbcPool.class.getClassLoader().getResourceAsStream("db.properties");  
         Properties prop = new Properties();  
         try {  
             prop.load(in);  
             String driver = prop.getProperty("driver");  
             String url = prop.getProperty("url");  
             String username = prop.getProperty("username");  
             String password = prop.getProperty("password");  
             //数据库连接池的初始化连接数大小  
             int jdbcPoolInitSize =Integer.parseInt(prop.getProperty("jdbcPoolInitSize"));  
             //加载数据库驱动  
             Class.forName(driver);  
             for (int i = 0; i < jdbcPoolInitSize; i++) {  
                 Connection conn = DriverManager.getConnection(url, username, password);  
                 System.out.println("获取到了链接" + conn);  
                 //将获取到的数据库连接加入到Connections集合中，Connections此时就是一个存放了数据库连接的连接池  
                 Connections.addElement(conn);  
             }  
               
         } catch (SQLException e) {  
             System.out.println(" 创建数据库连接失败！ " + e.getMessage());  
             throw new SQLException();  
         }  
     }  
       
     @Override  
     public PrintWriter getLogWriter() throws SQLException {  
         // TODO Auto-generated method stub  
         return null;  
     }  
    
     @Override  
     public void setLogWriter(PrintWriter out) throws SQLException {  
         // TODO Auto-generated method stub  
           
     }  
    
     @Override  
     public void setLoginTimeout(int seconds) throws SQLException {  
         // TODO Auto-generated method stub  
           
     }  
    
     @Override  
     public int getLoginTimeout() throws SQLException {  
         // TODO Auto-generated method stub  
         return 0;  
     }  
    
     @Override  
     public <T> T unwrap(Class<T> iface) throws SQLException {  
         // TODO Auto-generated method stub  
         return null;  
     }  
    
     @Override  
     public boolean isWrapperFor(Class<?> iface) throws SQLException {  
         // TODO Auto-generated method stub  
         return false;  
     }  
    
     /* 获取数据库连接 
      * @see javax.sql.DataSource#getConnection() 
      */  
     @Override  
     public Connection getConnection() throws SQLException {  
         //如果数据库连接池中的连接对象的个数大于0  
         if (Connections.size()>0) {  
             //从Connections集合中获取一个数据库连接  
             final Connection conn = Connections.removeFirst;  
             System.out.println("Connections数据库连接池大小是" + Connections.size());  
             //返回Connection对象的代理对象  
             return (Connection) Proxy.newProxyInstance(JdbcPool.class.getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler(){  
                 @Override  
                 public Object invoke(Object proxy, Method method, Object[] args)  
                         throws Throwable {  
                     if(!method.getName().equals("close")){  
                         return method.invoke(conn, args);  
                     }else{  
                         //如果调用的是Connection对象的close方法，就把conn还给数据库连接池  
                         Connections.addElement(conn);  
                         System.out.println(conn + "被还给Connections数据库连接池了！！");  
                         System.out.println("Connections数据库连接池大小为" + Connections.size());  
                         return null;  
                     }  
                 }  
             });  
         }else {  
             throw new RuntimeException("对不起，数据库忙");  
         }  
     }  
    
     @Override  
     public Connection getConnection(String username, String password)  
             throws SQLException {  
         return null;  
     }  
 }  

db.properties配置文件如下：

[java]view plain copy 
   
 driver=com.mysql.jdbc.Driver  
 url=jdbc:mysql://localhost:3306/jdbcStudy  
 username=root  
 password=XDP  
 jdbcPoolInitSize=10  

写一个JdbcUtil测试数据库连接池：

[java]view plain copy 
   
 package me.gacl.utils;  
    
 import java.sql.Connection;  
 import java.sql.ResultSet;  
 import java.sql.SQLException;  
 import java.sql.Statement;  
 import me.gacl.demo.JdbcPool;  
    
 public class JdbcUtil {  
       
     /** 
     * @Field: pool 
     *          数据库连接池 
     */  
     private static JdbcPool pool = new JdbcPool();  
       
     /** 
     * @Method: getConnection 
     * @Description: 从数据库连接池中获取数据库连接对象 
     * @Anthor:孤傲苍狼 
     * @return Connection数据库连接对象 
     * @throws SQLException 
     */  
     public static Connection getConnection() throws SQLException{  
         return pool.getConnection();  
     }  
       
     /** 
     * @Method: release 
     * @Description: 释放资源， 
     * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象 
     * @Anthor:孤傲苍狼 
     * 
     * @param conn 
     * @param st 
     * @param rs 
     */  
     public static void release(Connection conn,Statement st,ResultSet rs){  
         if(rs!=null){  
             try{  
                 //关闭存储查询结果的ResultSet对象  
                 rs.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
             rs = null;  
         }  
         if(st!=null){  
             try{  
                 //关闭负责执行SQL命令的Statement对象  
                 st.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
         }  
           
         if(conn!=null){  
             try{  
                 //关闭Connection数据库连接对象  
                 conn.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
         }  
     }  
 }  

三、开源数据库连接池

现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实现。
　　也有一些开源组织提供了数据源的独立实现：

· DBCP 数据库连接池

· C3P0 数据库连接池

　　在使用了数据库连接池之后，在项目的实际开发中就不需要编写连接数据库的代码了，直接从数据源获得数据库的连接。

3.1、DBCP数据源

DBCP 是 Apache 软件基金组织下的开源连接池实现，要使用DBCP数据源，需要应用程序应在系统中增加如下两个 jar 文件：

1. Commons-dbcp.jar：连接池的实现

2. Commons-pool.jar：连接池实现的依赖库

Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

3.2、在应用程序中加入dbcp连接池

1.导入相关jar包
　　 commons-dbcp-1.2.2.jar、commons-pool.jar
2、在类目录下加入dbcp的配置文件：dbcpconfig.properties
dbcpconfig.properties的配置信息如下：

[html]view plain copy 
   
 #连接设置  
 driverClassName=com.mysql.jdbc.Driver  
 url=jdbc:mysql://localhost:3306/jdbcstudy  
 username=root  
 password=XDP  
    
 #<!-- 初始化连接 -->  
 initialSize=10  
    
 #最大连接数量  
 maxActive=50  
    
 #<!-- 最大空闲连接 -->  
 maxIdle=20  
    
 #<!-- 最小空闲连接 -->  
 minIdle=5  
    
 #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->  
 maxWait=60000  
    
    
 #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]  
 #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。  
 connectionProperties=useUnicode=true;characterEncoding=UTF8  
    
 #指定由连接池所创建的连接的自动提交（auto-commit）状态。  
 defaultAutoCommit=true  
    
 #driver default 指定由连接池所创建的连接的只读（read-only）状态。  
 #如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）  
 defaultReadOnly=  
    
 #driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。  
 #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE  
 defaultTransactionIsolation=READ_UNCOMMITTED  

3、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中创建池

[java]view plain copy 
   
 package me.gacl.util;  
    
 import java.io.InputStream;  
 import java.sql.Connection;  
 import java.sql.ResultSet;  
 import java.sql.SQLException;  
 import java.sql.Statement;  
 import java.util.Properties;  
 import javax.sql.DataSource;  
 import org.apache.commons.dbcp.BasicDataSourceFactory;  
    
 /** 
 * @ClassName: JdbcUtils_DBCP 
 * @Description: 数据库连接工具类 
 * @author: 孤傲苍狼 
 * @date: 2014-10-4 下午6:04:36 
 * 
 */  
 public class JdbcUtils_DBCP {  
     /** 
      * 在java中，编写数据库连接池需实现java.sql.DataSource接口，每一种数据库连接池都是DataSource接口的实现 
      * DBCP连接池就是java.sql.DataSource接口的一个具体实现 
      */  
     private static DataSource ds = null;  
     //在静态代码块中创建数据库连接池  
     static{  
         try{  
             //加载dbcpconfig.properties配置文件  
             InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");  
             Properties prop = new Properties();  
             prop.load(in);  
             //创建数据源  
             ds = BasicDataSourceFactory.createDataSource(prop);  
         }catch (Exception e) {  
             throw new ExceptionInInitializerError(e);  
         }  
     }  
       
     /** 
     * @Method: getConnection 
     * @Description: 从数据源中获取数据库连接 
     * @Anthor:孤傲苍狼 
     * @return Connection 
     * @throws SQLException 
     */  
     public static Connection getConnection() throws SQLException{  
         //从数据源中获取数据库连接  
         return ds.getConnection();  
     }  
       
     /** 
     * @Method: release 
     * @Description: 释放资源， 
     * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象 
     * @Anthor:孤傲苍狼 
     * 
     * @param conn 
     * @param st 
     * @param rs 
     */  
     public static void release(Connection conn,Statement st,ResultSet rs){  
         if(rs!=null){  
             try{  
                 //关闭存储查询结果的ResultSet对象  
                 rs.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
             rs = null;  
         }  
         if(st!=null){  
             try{  
                 //关闭负责执行SQL命令的Statement对象  
                 st.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
         }  
           
         if(conn!=null){  
             try{  
                 //将Connection连接对象还给数据库连接池  
                 conn.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
         }  
     }  
 }  

测试DBCP数据源：

[java]view plain copy 
   
 package me.gacl.test;  
    
 import java.sql.Connection;  
 import java.sql.PreparedStatement;  
 import java.sql.ResultSet;  
 import org.junit.Test;  
 import me.gacl.util.JdbcUtils_DBCP;  
    
 public class DataSourceTest {  
       
     @Test  
     public void dbcpDataSourceTest() {  
         Connection conn = null;  
         PreparedStatement st = null;  
         ResultSet rs = null;  
         try{  
             //获取数据库连接  
             conn = JdbcUtils_DBCP.getConnection();  
             String sql = "insert into test1(name) values(?)";  
             st = conn.prepareStatement(sql);  
             st.setString(1, "gacl");  
             st.executeUpdate();  
             //获取数据库自动生成的主键  
             rs = st.getGeneratedKeys();  
             if(rs.next()){  
                 System.out.println(rs.getInt(1));  
             }  
         }catch (Exception e) {  
             e.printStackTrace();  
         }finally{  
             //释放资源  
             JdbcUtils_DBCP.release(conn, st, rs);  
         }  
     }  
 }  

3.3、C3P0数据源

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。C3P0数据源在项目开发中使用得比较多。
c3p0与dbcp区别

1. dbcp没有自动回收空闲连接的功能

2. c3p0有自动回收空闲连接功能

3.4、在应用程序中加入C3P0连接池

1.导入相关jar包
　c3p0-0.9.2-pre1.jar、mchange-commons-0.2.jar，如果操作的是Oracle数据库，那么还需要导入c3p0-oracle-thin-extras-0.9.2-pre1.jar
2、在类目录下加入C3P0的配置文件：c3p0-config.xml
c3p0-config.xml的配置信息如下：

[html]view plain copy 
   
 <?xml version="1.0" encoding="UTF-8"?>  
 <!--  
 c3p0-config.xml必须位于类路径下面  
 private static ComboPooledDataSource ds;  
 static{  
     try {  
         ds = new ComboPooledDataSource("MySQL");  
     } catch (Exception e) {  
         throw new ExceptionInInitializerError(e);  
     }  
 }  
 -->  
    
 <c3p0-config>  
     <!--  
     C3P0的缺省(默认)配置，  
     如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写就表示使用的是C3P0的缺省(默认)配置信息来创建数据源  
     -->  
     <default-config>  
         <property name="driverClass">com.mysql.jdbc.Driver</property>  
         <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy</property>  
         <property name="user">root</property>  
         <property name="password">XDP</property>  
           
         <property name="acquireIncrement">5</property>  
         <property name="initialPoolSize">10</property>  
         <property name="minPoolSize">5</property>  
         <property name="maxPoolSize">20</property>  
     </default-config>  
    
     <!--  
     C3P0的命名配置，  
     如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”这样写就表示使用的是name是MySQL的配置信息来创建数据源  
     -->  
     <named-config name="MySQL">  
         <property name="driverClass">com.mysql.jdbc.Driver</property>  
         <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy</property>  
         <property name="user">root</property>  
         <property name="password">XDP</property>  
           
         <property name="acquireIncrement">5</property>  
         <property name="initialPoolSize">10</property>  
         <property name="minPoolSize">5</property>  
         <property name="maxPoolSize">20</property>  
     </named-config>  
    
 </c3p0-config>  

3、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中创建池：

[java]view plain copy 
   
 package me.gacl.util;  
    
 import java.sql.Connection;  
 import java.sql.ResultSet;  
 import java.sql.SQLException;  
 import java.sql.Statement;  
 import com.mchange.v2.c3p0.ComboPooledDataSource;  
    
 /** 
 * @ClassName: JdbcUtils_C3P0 
 * @Description: 数据库连接工具类 
 * @author: 孤傲苍狼 
 * @date: 2014-10-4 下午6:04:36 
 * 
 */  
 public class JdbcUtils_C3P0 {  
       
     private static ComboPooledDataSource ds = null;  
     //在静态代码块中创建数据库连接池  
     static{  
         try{  
             //通过代码创建C3P0数据库连接池  
             /*ds = new ComboPooledDataSource(); 
             ds.setDriverClass("com.mysql.jdbc.Driver"); 
             ds.setJdbcUrl("jdbc:mysql://localhost:3306/jdbcstudy"); 
             ds.setUser("root"); 
             ds.setPassword("XDP"); 
             ds.setInitialPoolSize(10); 
             ds.setMinPoolSize(5); 
             ds.setMaxPoolSize(20);*/  
               
             //通过读取C3P0的xml配置文件创建数据源，C3P0的xml配置文件c3p0-config.xml必须放在src目录下  
             //ds = new ComboPooledDataSource();//使用C3P0的默认配置来创建数据源  
             ds = new ComboPooledDataSource("MySQL");//使用C3P0的命名配置来创建数据源  
               
         }catch (Exception e) {  
             throw new ExceptionInInitializerError(e);  
         }  
     }  
       
     /** 
     * @Method: getConnection 
     * @Description: 从数据源中获取数据库连接 
     * @Anthor:孤傲苍狼 
     * @return Connection 
     * @throws SQLException 
     */  
     public static Connection getConnection() throws SQLException{  
         //从数据源中获取数据库连接  
         return ds.getConnection();  
     }  
       
     /** 
     * @Method: release 
     * @Description: 释放资源， 
     * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象 
     * @Anthor:孤傲苍狼 
     * 
     * @param conn 
     * @param st 
     * @param rs 
     */  
     public static void release(Connection conn,Statement st,ResultSet rs){  
         if(rs!=null){  
             try{  
                 //关闭存储查询结果的ResultSet对象  
                 rs.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
             rs = null;  
         }  
         if(st!=null){  
             try{  
                 //关闭负责执行SQL命令的Statement对象  
                 st.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
         }  
           
         if(conn!=null){  
             try{  
                 //将Connection连接对象还给数据库连接池  
                 conn.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
         }  
     }  
 }  

测试C3P0数据源：

[java]view plain copy 
   
 package me.gacl.test;  
    
 import java.sql.Connection;  
 import java.sql.PreparedStatement;  
 import java.sql.ResultSet;  
 import org.junit.Test;  
 import me.gacl.util.JdbcUtils_C3P0;  
 import me.gacl.util.JdbcUtils_DBCP;  
    
 public class DataSourceTest {  
       
     @Test  
     public void c3p0DataSourceTest() {  
         Connection conn = null;  
         PreparedStatement st = null;  
         ResultSet rs = null;  
         try{  
             //获取数据库连接  
             conn = JdbcUtils_C3P0.getConnection();  
             String sql = "insert into test1(name) values(?)";  
             st = conn.prepareStatement(sql);  
             st.setString(1, "gacl");  
             st.executeUpdate();  
             //获取数据库自动生成的主键  
             rs = st.getGeneratedKeys();  
             if(rs.next()){  
                 System.out.println(rs.getInt(1));  
             }  
         }catch (Exception e) {  
             e.printStackTrace();  
         }finally{  
             //释放资源  
             JdbcUtils_C3P0.release(conn, st, rs);  
         }  
     }  
 }  

四、使用Tomcat配置的数据库连接池

在实际开发中，我们有时候还会使用服务器提供给我们的数据库连接池，比如我们希望Tomcat服务器在启动的时候可以帮我们创建一个数据库连接池，那么我们在应用程序中就不需要手动去创建数据库连接池，直接使用Tomcat服务器创建好的数据库连接池即可。要想让Tomcat服务器在启动的时候帮我们创建一个数据库连接池，那么需要简单配置一下Tomcat服务器。

4.1、JNDI技术简介

JNDI(Java Naming and Directory Interface)，Java命名和目录接口，它对应于J2SE中的javax.naming包，
　　这套API的主要作用在于：它可以把Java对象放在一个容器中（JNDI容器），并为容器中的java对象取一个名称，以后程序想获得Java对象，只需通过名称检索即可。其核心API为Context，它代表JNDI容器，其lookup方法为检索容器中对应名称的对象。

Tomcat服务器创建的数据源是以JNDI资源的形式发布的，所以说在Tomat服务器中配置一个数据源实际上就是在配置一个JNDI资源，通过查看Tomcat文档，我们知道使用如下的方式配置tomcat服务器的数据源：

[html]view plain copy 
   
 <Context>  
   <Resource name="jdbc/datasource" auth="Container"  
             type="javax.sql.DataSource" username="root" password="XDP"  
             driverClassName="com.mysql.jdbc.Driver"  
             url="jdbc:mysql://localhost:3306/jdbcstudy"  
             maxActive="8" maxIdle="4"/>  
 </Context>  

服务器创建好数据源之后，我们的应用程序又该怎么样得到这个数据源呢，Tomcat服务器创建好数据源之后是以JNDI的形式绑定到一个JNDI容器中的，我们可以把JNDI想象成一个大大的容器，我们可以往这个容器中存放一些对象，一些资源，JNDI容器中存放的对象和资源都会有一个独一无二的名称，应用程序想从JNDI容器中获取资源时，只需要告诉JNDI容器要获取的资源的名称，JNDI根据名称去找到对应的资源后返回给应用程序。

我们平时做javaEE开发时，服务器会为我们的应用程序创建很多资源，比如request对象，response对象，服务器创建的这些资源有两种方式提供给我们的应用程序使用：

第一种是通过方法参数的形式传递进来，比如我们在Servlet中写的doPost和doGet方法中使用到的request对象和response对象就是服务器以参数的形式传递给我们的。

第二种就是JNDI的方式，服务器把创建好的资源绑定到JNDI容器中去，应用程序想要使用资源时，就直接从JNDI容器中获取相应的资源即可。

对于上面的name="jdbc/datasource"数据源资源，在应用程序中可以用如下的代码去获取

[java]view plain copy 
   
 Context initCtx = new InitialContext();  
 Context envCtx = (Context) initCtx.lookup("java:comp/env");  
 dataSource = (DataSource)envCtx.lookup("jdbc/datasource");  

4.2、配置Tomcat数据源

1、在Web项目的WebRoot目录下的META-INF目录创建一个context.xml文件
　　如下图所示：

2、在context.xml文件配置tomcat服务器的数据源

[html]view plain copy 
   
 <Context>  
    <Resource  
        name="jdbc/datasource"  
        auth="Container"  
        type="javax.sql.DataSource"  
        username="root"  
        password="XDP"  
        driverClassName="com.mysql.jdbc.Driver"  
        url="jdbc:mysql://localhost:3306/jdbcstudy"  
        maxActive="8"  
        maxIdle="4"/>  
 </Context>  

3、将数据库的驱动jar文件需放置在tomcat的lib下

4、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中获取JNDI容器中的数据源

[java]view plain copy 
   
 package me.gacl.util;  
    
 import java.sql.Connection;  
 import java.sql.ResultSet;  
 import java.sql.SQLException;  
 import java.sql.Statement;  
 import javax.naming.Context;  
 import javax.naming.InitialContext;  
 import javax.sql.DataSource;  
    
 /** 
 * @ClassName: JdbcUtils_DBCP 
 * @Description: 数据库连接工具类 
 * @author: 孤傲苍狼 
 * @date: 2014-10-4 下午6:04:36 
 * 
 */  
 public class JdbcUtils_JNDI {  
       
     private static DataSource ds = null;  
     //在静态代码块中创建数据库连接池  
     static{  
         try{  
              //初始化JNDI  
             Context initCtx = new InitialContext();  
              //得到JNDI容器  
             Context envCtx = (Context) initCtx.lookup("java:comp/env");  
              //从JNDI容器中检索name为jdbc/datasource的数据源  
             ds = (DataSource)envCtx.lookup("jdbc/datasource");  
         }catch (Exception e) {  
             throw new ExceptionInInitializerError(e);  
         }  
     }  
       
     /** 
     * @Method: getConnection 
     * @Description: 从数据源中获取数据库连接 
     * @Anthor:孤傲苍狼 
     * @return Connection 
     * @throws SQLException 
     */  
     public static Connection getConnection() throws SQLException{  
         //从数据源中获取数据库连接  
         return ds.getConnection();  
     }  
       
     /** 
     * @Method: release 
     * @Description: 释放资源， 
     * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象 
     * @Anthor:孤傲苍狼 
     * 
     * @param conn 
     * @param st 
     * @param rs 
     */  
     public static void release(Connection conn,Statement st,ResultSet rs){  
         if(rs!=null){  
             try{  
                 //关闭存储查询结果的ResultSet对象  
                 rs.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
             rs = null;  
         }  
         if(st!=null){  
             try{  
                 //关闭负责执行SQL命令的Statement对象  
                 st.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
         }  
           
         if(conn!=null){  
             try{  
                 //将Connection连接对象还给数据库连接池  
                 conn.close();  
             }catch (Exception e) {  
                 e.printStackTrace();  
             }  
         }  
     }  
 }  

写一个Servlet测试JNDI数据源

[java]view plain copy 
   
 package me.gacl.test;  
    
 import java.io.IOException;  
 import java.sql.Connection;  
 import java.sql.PreparedStatement;  
 import java.sql.ResultSet;  
 import javax.servlet.ServletException;  
 import javax.servlet.http.HttpServlet;  
 import javax.servlet.http.HttpServletRequest;  
 import javax.servlet.http.HttpServletResponse;  
 import me.gacl.util.JdbcUtils_JNDI;  
    
 public class JNDITest extends HttpServlet {  
    
     public void doGet(HttpServletRequest request, HttpServletResponse response)  
             throws ServletException, IOException {  
         Connection conn = null;  
         PreparedStatement st = null;  
         ResultSet rs = null;  
         try{  
             //获取数据库连接  
             conn = JdbcUtils_JNDI.getConnection();  
             String sql = "insert into test1(name) values(?)";  
             st = conn.prepareStatement(sql);  
             st.setString(1, "gacl");  
             st.executeUpdate();  
             //获取数据库自动生成的主键  
             rs = st.getGeneratedKeys();  
             if(rs.next()){  
                 System.out.println(rs.getInt(1));  
             }  
         }catch (Exception e) {  
             e.printStackTrace();  
         }finally{  
             //释放资源  
             JdbcUtils_JNDI.release(conn, st, rs);  
         }  
     }  
    
     public void doPost(HttpServletRequest request, HttpServletResponse response)  
             throws ServletException, IOException {  
         doGet(request, response);  
     }  
    
 }  