Java Web学习总结之数据库连接池

一、应用程序直接获取数据库连接的缺点

  用户每次请求都需要向数据库获得链接,而数据库创建连接通常需要消耗相对较大的资源,创建时间也较长。假设网站一天10万访问量,数据库服务器就需要创建10万次连接,极大的浪费数据库的资源,并且极易造成数据库服务器内存溢出、拓机。如下图所示:

二、使用数据库连接池优化程序性能

2.1、数据库连接池的基本概念

  数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正式针对这个问题提出来的.数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。如下图所示:

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中, 这些数据库连接的数量是由最小数据库连接数来设定的.无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中.

数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:

  1. 最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费.
  2. 最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作
  3. 如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.

2.2、编写数据库连接池

编写连接池需实现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

 1 proxyConn = (Connection) Proxy.newProxyInstance(this.getClass() 2             .getClassLoader(), conn.getClass().getInterfaces(), 3             new InvocationHandler() { 4         //此处为内部类,当close方法被调用时将conn还回池中,其它方法直接执行 5             public Object invoke(Object proxy, Method method, 6                       Object[] args) throws Throwable { 7                 if (method.getName().equals("close")) { 8                     pool.addLast(conn); 9                     return null;10             }11             return method.invoke(conn, args);12         }13     });

数据库连接池编写范例:

  1 package me.gacl.demo;  2   3 import java.io.InputStream;  4 import java.io.PrintWriter;  5 import java.lang.reflect.InvocationHandler;  6 import java.lang.reflect.Method;  7 import java.lang.reflect.Proxy;  8 import java.sql.Connection;  9 import java.sql.DriverManager; 10 import java.sql.SQLException; 11 import java.util.LinkedList; 12 import java.util.Properties; 13 import javax.sql.DataSource; 14  15 /** 16 * @ClassName: JdbcPool 17 * @Description:编写数据库连接池 18 * @author 19 * @date 20 * 21 */  22 public class JdbcPool implements DataSource{ 23  24     /** 25     * @Field: listConnections 26     *         使用LinkedList集合来存放数据库链接, 27     *        由于要频繁读写List集合,所以这里使用LinkedList存储数据库连接比较合适 28     */  29     private static LinkedList<Connection> listConnections = new LinkedList<Connection>(); 30      31     static{ 32         //在静态代码块中加载db.properties数据库配置文件 33         InputStream in = JdbcPool.class.getClassLoader().getResourceAsStream("db.properties"); 34         Properties prop = new Properties(); 35         try { 36             prop.load(in); 37             String driver = prop.getProperty("driver"); 38             String url = prop.getProperty("url"); 39             String username = prop.getProperty("username"); 40             String password = prop.getProperty("password"); 41             //数据库连接池的初始化连接数大小 42             int jdbcPoolInitSize =Integer.parseInt(prop.getProperty("jdbcPoolInitSize")); 43             //加载数据库驱动 44             Class.forName(driver); 45             for (int i = 0; i < jdbcPoolInitSize; i++) { 46                 Connection conn = DriverManager.getConnection(url, username, password); 47                 System.out.println("获取到了链接" + conn); 48                 //将获取到的数据库连接加入到listConnections集合中,listConnections集合此时就是一个存放了数据库连接的连接池 49                 listConnections.add(conn); 50             } 51              52         } catch (Exception e) { 53             throw new ExceptionInInitializerError(e); 54         } 55     } 56      57     @Override 58     public PrintWriter getLogWriter() throws SQLException { 59         // TODO Auto-generated method stub 60         return null; 61     } 62  63     @Override 64     public void setLogWriter(PrintWriter out) throws SQLException { 65         // TODO Auto-generated method stub 66          67     } 68  69     @Override 70     public void setLoginTimeout(int seconds) throws SQLException { 71         // TODO Auto-generated method stub 72          73     } 74  75     @Override 76     public int getLoginTimeout() throws SQLException { 77         // TODO Auto-generated method stub 78         return 0; 79     } 80  81     @Override 82     public <T> T unwrap(Class<T> iface) throws SQLException { 83         // TODO Auto-generated method stub 84         return null; 85     } 86  87     @Override 88     public boolean isWrapperFor(Class<?> iface) throws SQLException { 89         // TODO Auto-generated method stub 90         return false; 91     } 92  93     /* 获取数据库连接 94      * @see javax.sql.DataSource#getConnection() 95      */ 96     @Override 97     public Connection getConnection() throws SQLException { 98         //如果数据库连接池中的连接对象的个数大于0 99         if (listConnections.size()>0) {100             //从listConnections集合中获取一个数据库连接101             final Connection conn = listConnections.removeFirst();102             System.out.println("listConnections数据库连接池大小是" + listConnections.size());103             //返回Connection对象的代理对象104             return (Connection) Proxy.newProxyInstance(JdbcPool.class.getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler(){105                 @Override106                 public Object invoke(Object proxy, Method method, Object[] args)107                         throws Throwable {108                     if(!method.getName().equals("close")){109                         return method.invoke(conn, args);110                     }else{111                         //如果调用的是Connection对象的close方法,就把conn还给数据库连接池112                         listConnections.add(conn);113                         System.out.println(conn + "被还给listConnections数据库连接池了!!");114                         System.out.println("listConnections数据库连接池大小为" + listConnections.size());115                         return null;116                     }117                 }118             });119         }else {120             throw new RuntimeException("对不起,数据库忙");121         }122     }123 124     @Override125     public Connection getConnection(String username, String password)126             throws SQLException {127         return null;128     }129 }

db.properties配置文件如下:

1 driver=com.mysql.jdbc.Driver2 url=jdbc:mysql://localhost:3306/jdbcStudy3 username=root4 password=XDP5 6 jdbcPoolInitSize=10

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

 1 package me.gacl.utils; 2  3 import java.sql.Connection; 4 import java.sql.ResultSet; 5 import java.sql.SQLException; 6 import java.sql.Statement; 7 import me.gacl.demo.JdbcPool; 8  9 public class JdbcUtil {10     11     /**12     * @Field: pool13     *          数据库连接池14     */ 15     private static JdbcPool pool = new JdbcPool();16     17     /**18     * @Method: getConnection19     * @Description: 从数据库连接池中获取数据库连接对象20     * @Anthor21     * @return Connection数据库连接对象22     * @throws SQLException23     */ 24     public static Connection getConnection() throws SQLException{25         return pool.getConnection();26     }27     28     /**29     * @Method: release30     * @Description: 释放资源,31     * 释放的资源包括Connection数据库连接对象,负责执行SQL命令的Statement对象,存储查询结果的ResultSet对象32     * @Anthor33     *34     * @param conn35     * @param st36     * @param rs37     */ 38     public static void release(Connection conn,Statement st,ResultSet rs){39         if(rs!=null){40             try{41                 //关闭存储查询结果的ResultSet对象42                 rs.close();43             }catch (Exception e) {44                 e.printStackTrace();45             }46             rs = null;47         }48         if(st!=null){49             try{50                 //关闭负责执行SQL命令的Statement对象51                 st.close();52             }catch (Exception e) {53                 e.printStackTrace();54             }55         }56         57         if(conn!=null){58             try{59                 //关闭Connection数据库连接对象60                 conn.close();61             }catch (Exception e) {62                 e.printStackTrace();63             }64         }65     }66 }

三、开源数据库连接池

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

  • DBCP 数据库连接池
  • C3P0 数据库连接池

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

3.1、DBCP数据源

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

  • Commons-dbcp.jar:连接池的实现
  • Commons-pool.jar:连接池实现的依赖库

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

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

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

    dbcpconfig.properties的配置信息如下:

 1 #连接设置 2 driverClassName=com.mysql.jdbc.Driver 3 url=jdbc:mysql://localhost:3306/jdbcstudy 4 username=root 5 password=XDP 6  7 #<!-- 初始化连接 --> 8 initialSize=10 9 10 #最大连接数量11 maxActive=5012 13 #<!-- 最大空闲连接 -->14 maxIdle=2015 16 #<!-- 最小空闲连接 -->17 minIdle=518 19 #<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->20 maxWait=6000021 22 23 #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样:[属性名=property;] 24 #注意:"user" 与 "password" 两个属性会被明确地传递,因此这里不需要包含他们。25 connectionProperties=useUnicode=true;characterEncoding=UTF826 27 #指定由连接池所创建的连接的自动提交(auto-commit)状态。28 defaultAutoCommit=true29 30 #driver default 指定由连接池所创建的连接的只读(read-only)状态。31 #如果没有设置该值,则“setReadOnly”方法将不被调用。(某些驱动并不支持只读模式,如:Informix)32 defaultReadOnly=33 34 #driver default 指定由连接池所创建的连接的事务级别(TransactionIsolation)。35 #可用值为下列之一:(详情可见javadoc。)NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE36 defaultTransactionIsolation=READ_UNCOMMITTED

  如下图所示:

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

 1 package me.gacl.util; 2  3 import java.io.InputStream; 4 import java.sql.Connection; 5 import java.sql.ResultSet; 6 import java.sql.SQLException; 7 import java.sql.Statement; 8 import java.util.Properties; 9 import javax.sql.DataSource;10 import org.apache.commons.dbcp.BasicDataSourceFactory;11 12 /**13 * @ClassName: JdbcUtils_DBCP14 * @Description: 数据库连接工具类15 * @author16 * @date17 *18 */ 19 public class JdbcUtils_DBCP {20     /**21      * 在java中,编写数据库连接池需实现java.sql.DataSource接口,每一种数据库连接池都是DataSource接口的实现22      * DBCP连接池就是java.sql.DataSource接口的一个具体实现23      */24     private static DataSource ds = null;25     //在静态代码块中创建数据库连接池26     static{27         try{28             //加载dbcpconfig.properties配置文件29             InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");30             Properties prop = new Properties();31             prop.load(in);32             //创建数据源33             ds = BasicDataSourceFactory.createDataSource(prop);34         }catch (Exception e) {35             throw new ExceptionInInitializerError(e);36         }37     }38     39     /**40     * @Method: getConnection41     * @Description: 从数据源中获取数据库连接42     * @Anthor43     * @return Connection44     * @throws SQLException45     */ 46     public static Connection getConnection() throws SQLException{47         //从数据源中获取数据库连接48         return ds.getConnection();49     }50     51     /**52     * @Method: release53     * @Description: 释放资源,54     * 释放的资源包括Connection数据库连接对象,负责执行SQL命令的Statement对象,存储查询结果的ResultSet对象55     * @Anthor56     *57     * @param conn58     * @param st59     * @param rs60     */ 61     public static void release(Connection conn,Statement st,ResultSet rs){62         if(rs!=null){63             try{64                 //关闭存储查询结果的ResultSet对象65                 rs.close();66             }catch (Exception e) {67                 e.printStackTrace();68             }69             rs = null;70         }71         if(st!=null){72             try{73                 //关闭负责执行SQL命令的Statement对象74                 st.close();75             }catch (Exception e) {76                 e.printStackTrace();77             }78         }79         80         if(conn!=null){81             try{82                 //将Connection连接对象还给数据库连接池83                 conn.close();84             }catch (Exception e) {85                 e.printStackTrace();86             }87         }88     }89 }

  测试DBCP数据源

 1 package me.gacl.test; 2  3 import java.sql.Connection; 4 import java.sql.PreparedStatement; 5 import java.sql.ResultSet; 6 import org.junit.Test; 7 import me.gacl.util.JdbcUtils_DBCP; 8  9 public class DataSourceTest {10     11     @Test12     public void dbcpDataSourceTest() {13         Connection conn = null;14         PreparedStatement st = null;15         ResultSet rs = null;16         try{17             //获取数据库连接18             conn = JdbcUtils_DBCP.getConnection();19             String sql = "insert into test1(name) values(?)";20             st = conn.prepareStatement(sql);21             st.setString(1, "gacl");22             st.executeUpdate();23             //获取数据库自动生成的主键24             rs = st.getGeneratedKeys();25             if(rs.next()){26                 System.out.println(rs.getInt(1));27             }28         }catch (Exception e) {29             e.printStackTrace();30         }finally{31             //释放资源32             JdbcUtils_DBCP.release(conn, st, rs);33         }34     }35 }

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的配置信息如下:

 1 <?xml version="1.0" encoding="UTF-8"?> 2 <!-- 3 c3p0-config.xml必须位于类路径下面 4 private static ComboPooledDataSource ds; 5 static{ 6     try { 7         ds = new ComboPooledDataSource("MySQL"); 8     } catch (Exception e) { 9         throw new ExceptionInInitializerError(e);10     }11 }12 -->13 14 <c3p0-config>15     <!--16     C3P0的缺省(默认)配置,17     如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写就表示使用的是C3P0的缺省(默认)配置信息来创建数据源18     -->19     <default-config>20         <property name="driverClass">com.mysql.jdbc.Driver</property>21         <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy</property>22         <property name="user">root</property>23         <property name="password">XDP</property>24         25         <property name="acquireIncrement">5</property>26         <property name="initialPoolSize">10</property>27         <property name="minPoolSize">5</property>28         <property name="maxPoolSize">20</property>29     </default-config>30 31     <!--32     C3P0的命名配置,33     如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”这样写就表示使用的是name是MySQL的配置信息来创建数据源34     -->35     <named-config name="MySQL">36         <property name="driverClass">com.mysql.jdbc.Driver</property>37         <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy</property>38         <property name="user">root</property>39         <property name="password">XDP</property>40         41         <property name="acquireIncrement">5</property>42         <property name="initialPoolSize">10</property>43         <property name="minPoolSize">5</property>44         <property name="maxPoolSize">20</property>45     </named-config>46 47 </c3p0-config>

  如下图所示:

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

 1 package me.gacl.util; 2  3 import java.sql.Connection; 4 import java.sql.ResultSet; 5 import java.sql.SQLException; 6 import java.sql.Statement; 7 import com.mchange.v2.c3p0.ComboPooledDataSource; 8  9 /**10 * @ClassName: JdbcUtils_C3P011 * @Description: 数据库连接工具类12 * @author13 * @date14 *15 */ 16 public class JdbcUtils_C3P0 {17     18     private static ComboPooledDataSource ds = null;19     //在静态代码块中创建数据库连接池20     static{21         try{22             //通过代码创建C3P0数据库连接池23             /*ds = new ComboPooledDataSource();24             ds.setDriverClass("com.mysql.jdbc.Driver");25             ds.setJdbcUrl("jdbc:mysql://localhost:3306/jdbcstudy");26             ds.setUser("root");27             ds.setPassword("XDP");28             ds.setInitialPoolSize(10);29             ds.setMinPoolSize(5);30             ds.setMaxPoolSize(20);*/31             32             //通过读取C3P0的xml配置文件创建数据源,C3P0的xml配置文件c3p0-config.xml必须放在src目录下33             //ds = new ComboPooledDataSource();//使用C3P0的默认配置来创建数据源34             ds = new ComboPooledDataSource("MySQL");//使用C3P0的命名配置来创建数据源35             36         }catch (Exception e) {37             throw new ExceptionInInitializerError(e);38         }39     }40     41     /**42     * @Method: getConnection43     * @Description: 从数据源中获取数据库连接44     * @Anthor45     * @return Connection46     * @throws SQLException47     */ 48     public static Connection getConnection() throws SQLException{49         //从数据源中获取数据库连接50         return ds.getConnection();51     }52     53     /**54     * @Method: release55     * @Description: 释放资源,56     * 释放的资源包括Connection数据库连接对象,负责执行SQL命令的Statement对象,存储查询结果的ResultSet对象57     * @Anthor58     *59     * @param conn60     * @param st61     * @param rs62     */ 63     public static void release(Connection conn,Statement st,ResultSet rs){64         if(rs!=null){65             try{66                 //关闭存储查询结果的ResultSet对象67                 rs.close();68             }catch (Exception e) {69                 e.printStackTrace();70             }71             rs = null;72         }73         if(st!=null){74             try{75                 //关闭负责执行SQL命令的Statement对象76                 st.close();77             }catch (Exception e) {78                 e.printStackTrace();79             }80         }81         82         if(conn!=null){83             try{84                 //将Connection连接对象还给数据库连接池85                 conn.close();86             }catch (Exception e) {87                 e.printStackTrace();88             }89         }90     }91 }

  测试C3P0数据源

 1 package me.gacl.test; 2  3 import java.sql.Connection; 4 import java.sql.PreparedStatement; 5 import java.sql.ResultSet; 6 import org.junit.Test; 7 import me.gacl.util.JdbcUtils_C3P0; 8 import me.gacl.util.JdbcUtils_DBCP; 9 10 public class DataSourceTest {11     12     @Test13     public void c3p0DataSourceTest() {14         Connection conn = null;15         PreparedStatement st = null;16         ResultSet rs = null;17         try{18             //获取数据库连接19             conn = JdbcUtils_C3P0.getConnection();20             String sql = "insert into test1(name) values(?)";21             st = conn.prepareStatement(sql);22             st.setString(1, "gacl");23             st.executeUpdate();24             //获取数据库自动生成的主键25             rs = st.getGeneratedKeys();26             if(rs.next()){27                 System.out.println(rs.getInt(1));28             }29         }catch (Exception e) {30             e.printStackTrace();31         }finally{32             //释放资源33             JdbcUtils_C3P0.release(conn, st, rs);34         }35     }36 }

四、配置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服务器的数据源:

1 <Context>2   <Resource name="jdbc/datasource" auth="Container"3             type="javax.sql.DataSource" username="root" password="XDP"4             driverClassName="com.mysql.jdbc.Driver" 5             url="jdbc:mysql://localhost:3306/jdbcstudy"6             maxActive="8" maxIdle="4"/>7 </Context>

  服务器创建好数据源之后,我们的应用程序又该怎么样得到这个数据源呢,Tomcat服务器创建好数据源之后是以JNDI的形式绑定到一个JNDI容器中的,我们可以把JNDI想象成一个大大的容器,我们可以往这个容器中存放一些对象,一些资源,JNDI容器中存放的对象和资源都会有一个独一无二的名称,应用程序想从JNDI容器中获取资源时,只需要告诉JNDI容器要获取的资源的名称,JNDI根据名称去找到对应的资源后返回给应用程序。我们平时做javaEE开发时,服务器会为我们的应用程序创建很多资源,比如request对象,response对象,服务器创建的这些资源有两种方式提供给我们的应用程序使用:第一种是通过方法参数的形式传递进来,比如我们在Servlet中写的doPost和doGet方法中使用到的request对象和response对象就是服务器以参数的形式传递给我们的。第二种就是JNDI的方式,服务器把创建好的资源绑定到JNDI容器中去,应用程序想要使用资源时,就直接从JNDI容器中获取相应的资源即可。

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

1 Context initCtx = new InitialContext();2 Context envCtx = (Context) initCtx.lookup("java:comp/env");3 dataSource = (DataSource)envCtx.lookup("jdbc/datasource");

此种配置下,数据库的驱动jar文件需放置在tomcat的lib下

4.2、配置Tomcat数据源

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

  如下图所示:

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

 1 <Context> 2    <Resource  3        name="jdbc/datasource"  4        auth="Container" 5        type="javax.sql.DataSource"  6        username="root"  7        password="XDP" 8        driverClassName="com.mysql.jdbc.Driver"  9        url="jdbc:mysql://localhost:3306/jdbcstudy"10        maxActive="8" 11        maxIdle="4"/>12 </Context>

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

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

 1 package me.gacl.util; 2  3 import java.sql.Connection; 4 import java.sql.ResultSet; 5 import java.sql.SQLException; 6 import java.sql.Statement; 7 import javax.naming.Context; 8 import javax.naming.InitialContext; 9 import javax.sql.DataSource;10 11 /**12 * @ClassName: JdbcUtils_DBCP13 * @Description: 数据库连接工具类14 * @author15 * @date16 *17 */ 18 public class JdbcUtils_JNDI {19     20     private static DataSource ds = null;21     //在静态代码块中创建数据库连接池22     static{23         try{24              //初始化JNDI25             Context initCtx = new InitialContext();26              //得到JNDI容器27             Context envCtx = (Context) initCtx.lookup("java:comp/env");28              //从JNDI容器中检索name为jdbc/datasource的数据源29             ds = (DataSource)envCtx.lookup("jdbc/datasource");30         }catch (Exception e) {31             throw new ExceptionInInitializerError(e);32         }33     }34     35     /**36     * @Method: getConnection37     * @Description: 从数据源中获取数据库连接38     * @Anthor39     * @return Connection40     * @throws SQLException41     */ 42     public static Connection getConnection() throws SQLException{43         //从数据源中获取数据库连接44         return ds.getConnection();45     }46     47     /**48     * @Method: release49     * @Description: 释放资源,50     * 释放的资源包括Connection数据库连接对象,负责执行SQL命令的Statement对象,存储查询结果的ResultSet对象51     * @Anthor52     *53     * @param conn54     * @param st55     * @param rs56     */ 57     public static void release(Connection conn,Statement st,ResultSet rs){58         if(rs!=null){59             try{60                 //关闭存储查询结果的ResultSet对象61                 rs.close();62             }catch (Exception e) {63                 e.printStackTrace();64             }65             rs = null;66         }67         if(st!=null){68             try{69                 //关闭负责执行SQL命令的Statement对象70                 st.close();71             }catch (Exception e) {72                 e.printStackTrace();73             }74         }75         76         if(conn!=null){77             try{78                 //将Connection连接对象还给数据库连接池79                 conn.close();80             }catch (Exception e) {81                 e.printStackTrace();82             }83         }84     }85 }

  写一个Servlet测试JNDI数据源

 1 package me.gacl.test; 2  3 import java.io.IOException; 4 import java.sql.Connection; 5 import java.sql.PreparedStatement; 6 import java.sql.ResultSet; 7 import javax.servlet.ServletException; 8 import javax.servlet.http.HttpServlet; 9 import javax.servlet.http.HttpServletRequest;10 import javax.servlet.http.HttpServletResponse;11 import me.gacl.util.JdbcUtils_JNDI;12 13 public class JNDITest extends HttpServlet {14 15     public void doGet(HttpServletRequest request, HttpServletResponse response)16             throws ServletException, IOException {17         Connection conn = null;18         PreparedStatement st = null;19         ResultSet rs = null;20         try{21             //获取数据库连接22             conn = JdbcUtils_JNDI.getConnection();23             String sql = "insert into test1(name) values(?)";24             st = conn.prepareStatement(sql);25             st.setString(1, "gacl");26             st.executeUpdate();27             //获取数据库自动生成的主键28             rs = st.getGeneratedKeys();29             if(rs.next()){30                 System.out.println(rs.getInt(1));31             }32         }catch (Exception e) {33             e.printStackTrace();34         }finally{35             //释放资源36             JdbcUtils_JNDI.release(conn, st, rs);37         }38     }39 40     public void doPost(HttpServletRequest request, HttpServletResponse response)41             throws ServletException, IOException {42         doGet(request, response);43     }44 45 }
  • 原文:http://www.cnblogs.com/xdp-gacl/p/4002804.html

原文发布于微信公众号 - Java团长(javatuanzhang)

原文发表时间:2018-01-06

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏JAVA高级架构

Java面试分享(题目+答案)

37530
来自专栏JAVA同学会

Zookeeper应用之——栅栏(barrier)

barrier的作用是所有的线程等待,知道某一时刻,锁释放,所有的线程同时执行。举一个生动的例子,比如跑步比赛,所有 运动员都要在起跑线上等待,直到枪声响后,所...

9510
来自专栏沃趣科技

MySQL中server_id一致带来的问题

简 介 我们都知道在MySQL搭建复制环境的时候,需要设置每个server的server_id不一致,如果主库与从库的server_id一致,那么复制会失败。...

44960
来自专栏JMCui

Netty 系列一(核心组件和实例).

    早期的 Java API 只支持由本地系统套接字库提供所谓的阻塞函数来支持网络编程。由于是阻塞 I/O ,要管理多个并发客户端,需要为每个新的客户端So...

11630
来自专栏java思维导图

mybatis-plus思维导图,让mybatis-plus不再难懂

 Mybatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果...

1.4K180
来自专栏java学习

关于Spring 和 Spring MVC的43个问题【问题汇总】

通过Spring提供的IoC容器,可以将对象之间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。

10910
来自专栏陈树义

Dubbo配置方式详解

Dubbo 是一个分布式服务框架,致力于提供高性能和透明化的 RPC 远程服务调用方案,是阿里巴巴 SOA 服务化治理方案的核心框架,每天为 2,000+ 个...

42850
来自专栏magicsoar

html5利用websocket完成的推送功能(tomcat)

利用websocket和java完成的消息推送功能,服务器用的是tomcat7.0.42,一些东西是自己琢磨的,也不知道恰不恰当,不恰当处,还请各位见谅,并指出...

54460
来自专栏一个会写诗的程序员的博客

Spring Boot 使用 Spring Session 集成 Redis 实现Session共享Spring Boot 使用 Spring Session 集成 Redis 实现Session共享

通常在web开发中,Session 会话管理是很重要的一部分,用于存储与用户相关的一些数据。在Java Web 系统中的 Session一般由 Tomcat 容...

1.4K50
来自专栏LanceToBigData

JDBC(三)数据库连接池(DBCP、C3P0)

前言   这段时间状态有一点浮躁,希望自己静下心来。还有特别多的东西还没有学懂。需要学习的东西非常的多,加油! 一、JDBC复习   Java Data Bas...

812100

扫码关注云+社区

领取腾讯云代金券