javaweb学习总结(三十九)——数据库连接池
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了javaweb学习总结(三十九)——数据库连接池，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含20848字，纯文字阅读大概需要30分钟。
内容图文
一、应用程序直接获取数据库连接的缺点
用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。如下图所示：
二、使用数据库连接池优化程序性能
2.1、数据库连接池的基本概念
数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正式针对这个问题提出来的.数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。如下图所示：
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中, 这些数据库连接的数量是由最小数据库连接数来设定的.无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中.
数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:
- 最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费.
- 最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作
- 如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.
2.2、编写数据库连接池
编写连接池需实现java.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：
- Connection getConnection()
- Connection getConnection(String username, String password)
实现DataSource接口，并实现连接池功能的步骤：
- 在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。
- 实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。
- 当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。Collection保证将自己返回到LinkedList中是此处编程的难点。
数据库连接池核心代码
使用动态代理技术构建连接池中的connection
1 proxyConn = (Connection) Proxy.newProxyInstance(this.getClass()
2 .getClassLoader(), conn.getClass().getInterfaces(),
3new InvocationHandler() {
4//此处为内部类，当close方法被调用时将conn还回池中,其它方法直接执行 5public Object invoke(Object proxy, Method method,
6 Object[] args) throws Throwable {
7if (method.getName().equals("close")) {
8 pool.addLast(conn);
9returnnull;
10 }
11return 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: 2014-9-30 下午11:07:23
20
*
21
*/
22
public
class JdbcPool implements DataSource{
23 24/** 25 * @Field: listConnections
26 * 使用LinkedList集合来存放数据库链接，
27 * 由于要频繁读写List集合，所以这里使用LinkedList存储数据库连接比较合适
28*/ 29privatestatic LinkedList<Connection> listConnections = new LinkedList<Connection>();
30 31static{
32//在静态代码块中加载db.properties数据库配置文件 33 InputStream in = JdbcPool.class.getClassLoader().getResourceAsStream("db.properties");
34 Properties prop = new Properties();
35try {
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//数据库连接池的初始化连接数大小 42int jdbcPoolInitSize =Integer.parseInt(prop.getProperty("jdbcPoolInitSize"));
43//加载数据库驱动 44 Class.forName(driver);
45for (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) {
53thrownew ExceptionInInitializerError(e);
54 }
55 }
56 57 @Override
58public PrintWriter getLogWriter() throws SQLException {
59// TODO Auto-generated method stub 60returnnull;
61 }
62 63 @Override
64publicvoid setLogWriter(PrintWriter out) throws SQLException {
65// TODO Auto-generated method stub 66 67 }
68 69 @Override
70publicvoid setLoginTimeout(int seconds) throws SQLException {
71// TODO Auto-generated method stub 72 73 }
74 75 @Override
76publicint getLoginTimeout() throws SQLException {
77// TODO Auto-generated method stub 78return 0;
79 }
80 81 @Override
82public <T> T unwrap(Class<T> iface) throws SQLException {
83// TODO Auto-generated method stub 84returnnull;
85 }
86 87 @Override
88publicboolean isWrapperFor(Class<?> iface) throws SQLException {
89// TODO Auto-generated method stub 90returnfalse;
91 }
92 93/* 获取数据库连接
94 * @see javax.sql.DataSource#getConnection()
95*/ 96 @Override
97public Connection getConnection() throws SQLException {
98//如果数据库连接池中的连接对象的个数大于0 99if (listConnections.size()>0) {
100//从listConnections集合中获取一个数据库连接101final Connection conn = listConnections.removeFirst();
102 System.out.println("listConnections数据库连接池大小是" + listConnections.size());
103//返回Connection对象的代理对象104return (Connection) Proxy.newProxyInstance(JdbcPool.class.getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler(){
105 @Override
106public Object invoke(Object proxy, Method method, Object[] args)
107throws Throwable {
108if(!method.getName().equals("close")){
109return 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());
115returnnull;
116 }
117 }
118 });
119 }else {
120thrownew RuntimeException("对不起，数据库忙");
121 }
122 }
123124 @Override
125public Connection getConnection(String username, String password)
126throws SQLException {
127returnnull;
128 }
129 }
db.properties配置文件如下：
1 driver=com.mysql.jdbc.Driver
2 url=jdbc:mysql://localhost:3306/jdbcStudy
3 username=root
4 password=XDP
56 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: pool
13
* 数据库连接池
14
*/
15
private
static JdbcPool pool = new JdbcPool();
1617/**18 * @Method: getConnection
19 * @Description: 从数据库连接池中获取数据库连接对象
20 * @Anthor:孤傲苍狼
21 * @return Connection数据库连接对象
22 * @throws SQLException
23*/24publicstatic Connection getConnection() throws SQLException{
25return pool.getConnection();
26 }
2728/**29 * @Method: release
30 * @Description: 释放资源，
31 * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
32 * @Anthor:孤傲苍狼
33 *
34 * @param conn
35 * @param st
36 * @param rs
37*/38publicstaticvoid release(Connection conn,Statement st,ResultSet rs){
39if(rs!=null){
40try{
41//关闭存储查询结果的ResultSet对象42 rs.close();
43 }catch (Exception e) {
44 e.printStackTrace();
45 }
46 rs = null;
47 }
48if(st!=null){
49try{
50//关闭负责执行SQL命令的Statement对象51 st.close();
52 }catch (Exception e) {
53 e.printStackTrace();
54 }
55 }
5657if(conn!=null){
58try{
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
910#最大连接数量
11 maxActive=50
1213#<!-- 最大空闲连接 -->
14 maxIdle=20
1516#<!-- 最小空闲连接 -->
17 minIdle=5
1819#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
20 maxWait=60000
212223 #JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]24 #注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
25 connectionProperties=useUnicode=true;characterEncoding=UTF82627#指定由连接池所创建的连接的自动提交（auto-commit）状态。
28 defaultAutoCommit=true
2930#driver default 指定由连接池所创建的连接的只读（read-only）状态。
31#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
32 defaultReadOnly=
3334#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
35 #可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
36 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_DBCP
14
* @Description: 数据库连接工具类
15
*
@author
: 孤傲苍狼
16
* @date: 2014-10-4 下午6:04:36
17
*
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//在静态代码块中创建数据库连接池26static{
27try{
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) {
35thrownew ExceptionInInitializerError(e);
36 }
37 }
3839/**40 * @Method: getConnection
41 * @Description: 从数据源中获取数据库连接
42 * @Anthor:孤傲苍狼
43 * @return Connection
44 * @throws SQLException
45*/46publicstatic Connection getConnection() throws SQLException{
47//从数据源中获取数据库连接48return ds.getConnection();
49 }
5051/**52 * @Method: release
53 * @Description: 释放资源，
54 * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
55 * @Anthor:孤傲苍狼
56 *
57 * @param conn
58 * @param st
59 * @param rs
60*/61publicstaticvoid release(Connection conn,Statement st,ResultSet rs){
62if(rs!=null){
63try{
64//关闭存储查询结果的ResultSet对象65 rs.close();
66 }catch (Exception e) {
67 e.printStackTrace();
68 }
69 rs = null;
70 }
71if(st!=null){
72try{
73//关闭负责执行SQL命令的Statement对象74 st.close();
75 }catch (Exception e) {
76 e.printStackTrace();
77 }
78 }
7980if(conn!=null){
81try{
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
@Test
12
public
void
dbcpDataSourceTest() {
13 Connection conn = null;
14 PreparedStatement st = null;
15 ResultSet rs = null;
16try{
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();
25if(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区别
- dbcp没有自动回收空闲连接的功能
- 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>2425<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>3031<!--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>4041<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>4647</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_C3P0
11
* @Description: 数据库连接工具类
12
*
@author
: 孤傲苍狼
13
* @date: 2014-10-4 下午6:04:36
14
*
15
*/
16
public
class
JdbcUtils_C3P0 {
17
18
private
static ComboPooledDataSource ds = null;
19//在静态代码块中创建数据库连接池20static{
21try{
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);*/3132//通过读取C3P0的xml配置文件创建数据源，C3P0的xml配置文件c3p0-config.xml必须放在src目录下
33//ds = new ComboPooledDataSource();//使用C3P0的默认配置来创建数据源34 ds = new ComboPooledDataSource("MySQL");//使用C3P0的命名配置来创建数据源3536 }catch (Exception e) {
37thrownew ExceptionInInitializerError(e);
38 }
39 }
4041/**42 * @Method: getConnection
43 * @Description: 从数据源中获取数据库连接
44 * @Anthor:孤傲苍狼
45 * @return Connection
46 * @throws SQLException
47*/48publicstatic Connection getConnection() throws SQLException{
49//从数据源中获取数据库连接50return ds.getConnection();
51 }
5253/**54 * @Method: release
55 * @Description: 释放资源，
56 * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
57 * @Anthor:孤傲苍狼
58 *
59 * @param conn
60 * @param st
61 * @param rs
62*/63publicstaticvoid release(Connection conn,Statement st,ResultSet rs){
64if(rs!=null){
65try{
66//关闭存储查询结果的ResultSet对象67 rs.close();
68 }catch (Exception e) {
69 e.printStackTrace();
70 }
71 rs = null;
72 }
73if(st!=null){
74try{
75//关闭负责执行SQL命令的Statement对象76 st.close();
77 }catch (Exception e) {
78 e.printStackTrace();
79 }
80 }
8182if(conn!=null){
83try{
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
@Test
13
public
void
c3p0DataSourceTest() {
14 Connection conn = null;
15 PreparedStatement st = null;
16 ResultSet rs = null;
17try{
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();
26if(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_DBCP
13
* @Description: 数据库连接工具类
14
*
@author
: 孤傲苍狼
15
* @date: 2014-10-4 下午6:04:36
16
*
17
*/
18
public
class
JdbcUtils_JNDI {
19
20
private
static DataSource ds = null;
21//在静态代码块中创建数据库连接池22static{
23try{
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) {
31thrownew ExceptionInInitializerError(e);
32 }
33 }
3435/**36 * @Method: getConnection
37 * @Description: 从数据源中获取数据库连接
38 * @Anthor:孤傲苍狼
39 * @return Connection
40 * @throws SQLException
41*/42publicstatic Connection getConnection() throws SQLException{
43//从数据源中获取数据库连接44return ds.getConnection();
45 }
4647/**48 * @Method: release
49 * @Description: 释放资源，
50 * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
51 * @Anthor:孤傲苍狼
52 *
53 * @param conn
54 * @param st
55 * @param rs
56*/57publicstaticvoid release(Connection conn,Statement st,ResultSet rs){
58if(rs!=null){
59try{
60//关闭存储查询结果的ResultSet对象61 rs.close();
62 }catch (Exception e) {
63 e.printStackTrace();
64 }
65 rs = null;
66 }
67if(st!=null){
68try{
69//关闭负责执行SQL命令的Statement对象70 st.close();
71 }catch (Exception e) {
72 e.printStackTrace();
73 }
74 }
7576if(conn!=null){
77try{
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 {
1415publicvoid doGet(HttpServletRequest request, HttpServletResponse response)
16throws ServletException, IOException {
17 Connection conn = null;
18 PreparedStatement st = null;
19 ResultSet rs = null;
20try{
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();
29if(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 }
3940publicvoid doPost(HttpServletRequest request, HttpServletResponse response)
41throws ServletException, IOException {
42 doGet(request, response);
43 }
4445 }
原文：http://www.cnblogs.com/xdp-gacl/p/4002804.html
内容总结
以上是互联网集市为您收集整理的javaweb学习总结(三十九)——数据库连接池全部内容，希望文章能够帮你解决javaweb学习总结(三十九)——数据库连接池所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】