javaweb数据库连接池
一、应用程序直接获取数据库连接的缺点
用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。
二、使用数据库连接池优化程序性能
2.1、数据库连接池的基本概念
数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正式针对这个问题提出来的.数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中,这些数据库连接的数量是由最小数据库连接数来设定的.无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中.
数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:
最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费.
最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作
如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.
2.2、编写数据库连接池
编写连接池需实现java.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：
ConnectiongetConnection()
ConnectiongetConnection(Stringusername,Stringpassword)
实现DataSource接口，并实现连接池功能的步骤：
在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。
实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。
当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。Collection保证将自己返回到LinkedList中是此处编程的难点。
数据库连接池核心代码
使用动态代理技术构建连接池中的connection
复制代码
1proxyConn=(Connection)Proxy.newProxyInstance(this.getClass()
2.getClassLoader(),conn.getClass().getInterfaces(),
3newInvocationHandler(){
4//此处为内部类，当close方法被调用时将conn还回池中,其它方法直接执行
5publicObjectinvoke(Objectproxy,Methodmethod,
6Object[]args)throwsThrowable{
7if(method.getName().equals("close")){
8pool.addLast(conn);
9returnnull;
10}
11returnmethod.invoke(conn,args);
12}
13});
复制代码
数据库连接池编写范例：
复制代码
1packageme.gacl.demo;
2
3importjava.io.InputStream;
4importjava.io.PrintWriter;
5importjava.lang.reflect.InvocationHandler;
6importjava.lang.reflect.Method;
7importjava.lang.reflect.Proxy;
8importjava.sql.Connection;
9importjava.sql.DriverManager;
10importjava.sql.SQLException;
11importjava.util.LinkedList;
12importjava.util.Properties;
13importjavax.sql.DataSource;
14
15/
16@ClassName:JdbcPool
17@Description:编写数据库连接池
18@author:孤傲苍狼
19@date:2014-9-30下午11:07:23
20
21/
22publicclassJdbcPoolimplementsDataSource{
23
24/
25@Field:listConnections
26使用LinkedList集合来存放数据库链接，
27由于要频繁读写List集合，所以这里使用LinkedList存储数据库连接比较合适
28/
29privatestaticLinkedListlistConnections=newLinkedList();
30
31static{
32//在静态代码块中加载db.properties数据库配置文件
33InputStreamin=JdbcPool.class.getClassLoader().getResourceAsStream("db.properties");
34Propertiesprop=newProperties();
35try{
36prop.load(in);
37Stringdriver=prop.getProperty("driver");
38Stringurl=prop.getProperty("url");
39Stringusername=prop.getProperty("username");
40Stringpassword=prop.getProperty("password");
41//数据库连接池的初始化连接数大小
42intjdbcPoolInitSize=Integer.parseInt(prop.getProperty("jdbcPoolInitSize"));
43//加载数据库驱动
44Class.forName(driver);
45for(inti=0;i
46Connectionconn=DriverManager.getConnection(url,username,password);
47System.out.println("获取到了链接"+conn);
48//将获取到的数据库连接加入到listConnections集合中，listConnections集合此时就是一个存放了数据库连接的连接池
49listConnections.add(conn);
50}
51
52}catch(Exceptione){
53thrownewExceptionInInitializerError(e);
54}
55}
56
57@Override
58publicPrintWritergetLogWriter()throwsSQLException{
59//TODOAuto-generatedmethodstub
60returnnull;
61}
62
63@Override
64publicvoidsetLogWriter(PrintWriterout)throwsSQLException{
65//TODOAuto-generatedmethodstub
66
67}
68
69@Override
70publicvoidsetLoginTimeout(intseconds)throwsSQLException{
71//TODOAuto-generatedmethodstub
72
73}
74
75@Override
76publicintgetLoginTimeout()throwsSQLException{
77//TODOAuto-generatedmethodstub
78return0;
79}
80
81@Override
82publicTunwrap(Classiface)throwsSQLException{
83//TODOAuto-generatedmethodstub
84returnnull;
85}
86
87@Override
88publicbooleanisWrapperFor(Classiface)throwsSQLException{
89//TODOAuto-generatedmethodstub
90returnfalse;
91}
92
93/获取数据库连接
94@seejavax.sql.DataSource#getConnection()
95/
96@Override
97publicConnectiongetConnection()throwsSQLException{
98//如果数据库连接池中的连接对象的个数大于0
99if(listConnections.size()>0){
100//从listConnections集合中获取一个数据库连接
101finalConnectionconn=listConnections.removeFirst();
102System.out.println("listConnections数据库连接池大小是"+listConnections.size());
103//返回Connection对象的代理对象
104return(Connection)Proxy.newProxyInstance(JdbcPool.class.getClassLoader(),conn.getClass().getInterfaces(),newInvocationHandler(){
105@Override
106publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)
107throwsThrowable{
108if(!method.getName().equals("close")){
109returnmethod.invoke(conn,args);
110}else{
111//如果调用的是Connection对象的close方法，就把conn还给数据库连接池
112listConnections.add(conn);
113System.out.println(conn+"被还给listConnections数据库连接池了！！");
114System.out.println("listConnections数据库连接池大小为"+listConnections.size());
115returnnull;
116}
117}
118});
119}else{
120thrownewRuntimeException("对不起，数据库忙");
121}
122}
123
124@Override
125publicConnectiongetConnection(Stringusername,Stringpassword)
126throwsSQLException{
127returnnull;
128}
129}
复制代码
db.properties配置文件如下：
1driver=com.mysql.jdbc.Driver
2url=jdbc:mysql://localhost:3306/jdbcStudy
3username=root
4password=XDP
5
6jdbcPoolInitSize=10
写一个JdbcUtil测试数据库连接池
复制代码
1packageme.gacl.utils;
2
3importjava.sql.Connection;
4importjava.sql.ResultSet;
5importjava.sql.SQLException;
6importjava.sql.Statement;
7importme.gacl.demo.JdbcPool;
8
9publicclassJdbcUtil{
10
11/
12@Field:pool
13数据库连接池
14/
15privatestaticJdbcPoolpool=newJdbcPool();
16
17/
18@Method:getConnection
19@Description:从数据库连接池中获取数据库连接对象
20@Anthor:孤傲苍狼
21@returnConnection数据库连接对象
22@throwsSQLException
23/
24publicstaticConnectiongetConnection()throwsSQLException{
25returnpool.getConnection();
26}
27
28/
29@Method:release
30@Description:释放资源，
31释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
32@Anthor:孤傲苍狼
33
34@paramconn
35@paramst
36@paramrs
37/
38publicstaticvoidrelease(Connectionconn,Statementst,ResultSetrs){
39if(rs!=null){
40try{
41//关闭存储查询结果的ResultSet对象
42rs.close();
43}catch(Exceptione){
44e.printStackTrace();
45}
46rs=null;
47}
48if(st!=null){
49try{
50//关闭负责执行SQL命令的Statement对象
51st.close();
52}catch(Exceptione){
53e.printStackTrace();
54}
55}
56
57if(conn!=null){
58try{
59//关闭Connection数据库连接对象
60conn.close();
61}catch(Exceptione){
62e.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#连接设置
2driverClassName=com.mysql.jdbc.Driver
3url=jdbc:mysql://localhost:3306/jdbcstudy
4username=root
5password=XDP
6
7#
8initialSize=10
9
10#最大连接数量
11maxActive=50
12
13#
14maxIdle=20
15
16#
17minIdle=5
18
19#
20maxWait=60000
21
22
23#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;]
24#注意："user"与"password"两个属性会被明确地传递，因此这里不需要包含他们。
25connectionProperties=useUnicode=true;characterEncoding=UTF8
26
27#指定由连接池所创建的连接的自动提交（auto-commit）状态。
28defaultAutoCommit=true
29
30#driverdefault指定由连接池所创建的连接的只读（read-only）状态。
31#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
32defaultReadOnly=
33
34#driverdefault指定由连接池所创建的连接的事务级别（TransactionIsolation）。
35#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED,READ_COMMITTED,REPEATABLE_READ,SERIALIZABLE
36defaultTransactionIsolation=READ_UNCOMMITTED
复制代码
如下图所示：
3、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中创建池
复制代码
1packageme.gacl.util;
2
3importjava.io.InputStream;
4importjava.sql.Connection;
5importjava.sql.ResultSet;
6importjava.sql.SQLException;
7importjava.sql.Statement;
8importjava.util.Properties;
9importjavax.sql.DataSource;
10importorg.apache.commons.dbcp.BasicDataSourceFactory;
11
12/
13@ClassName:JdbcUtils_DBCP
14@Description:数据库连接工具类
15@author:孤傲苍狼
16@date:2014-10-4下午6:04:36
17
18/
19publicclassJdbcUtils_DBCP{
20/
21在java中，编写数据库连接池需实现java.sql.DataSource接口，每一种数据库连接池都是DataSource接口的实现
22DBCP连接池就是java.sql.DataSource接口的一个具体实现
23/
24privatestaticDataSourceds=null;
25//在静态代码块中创建数据库连接池
26static{
27try{
28//加载dbcpconfig.properties配置文件
29InputStreamin=JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
30Propertiesprop=newProperties();
31prop.load(in);
32//创建数据源
33ds=BasicDataSourceFactory.createDataSource(prop);
34}catch(Exceptione){
35thrownewExceptionInInitializerError(e);
36}
37}
38
39/
40@Method:getConnection
41@Description:从数据源中获取数据库连接
42@Anthor:孤傲苍狼
43@returnConnection
44@throwsSQLException
45/
46publicstaticConnectiongetConnection()throwsSQLException{
47//从数据源中获取数据库连接
48returnds.getConnection();
49}
50
51/
52@Method:release
53@Description:释放资源，
54释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
55@Anthor:孤傲苍狼
56
57@paramconn
58@paramst
59@paramrs
60/
61publicstaticvoidrelease(Connectionconn,Statementst,ResultSetrs){
62if(rs!=null){
63try{
64//关闭存储查询结果的ResultSet对象
65rs.close();
66}catch(Exceptione){
67e.printStackTrace();
68}
69rs=null;
70}
71if(st!=null){
72try{
73//关闭负责执行SQL命令的Statement对象
74st.close();
75}catch(Exceptione){
76e.printStackTrace();
77}
78}
79
80if(conn!=null){
81try{
82//将Connection连接对象还给数据库连接池
83conn.close();
84}catch(Exceptione){
85e.printStackTrace();
86}
87}
88}
89}
复制代码
测试DBCP数据源
复制代码
1packageme.gacl.test;
2
3importjava.sql.Connection;
4importjava.sql.PreparedStatement;
5importjava.sql.ResultSet;
6importorg.junit.Test;
7importme.gacl.util.JdbcUtils_DBCP;
8
9publicclassDataSourceTest{
10
11@Test
12publicvoiddbcpDataSourceTest(){
13Connectionconn=null;
14PreparedStatementst=null;
15ResultSetrs=null;
16try{
17//获取数据库连接
18conn=JdbcUtils_DBCP.getConnection();
19Stringsql="insertintotest1(name)values(?)";
20st=conn.prepareStatement(sql);
21st.setString(1,"gacl");
22st.executeUpdate();
23//获取数据库自动生成的主键
24rs=st.getGeneratedKeys();
25if(rs.next()){
26System.out.println(rs.getInt(1));
27}
28}catch(Exceptione){
29e.printStackTrace();
30}finally{
31//释放资源
32JdbcUtils_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
2
13
14
15
19
20com.mysql.jdbc.Driver
21jdbc:mysql://localhost:3306/jdbcstudy
22www.wang027.comroot
23XDP
24
255
2610
275
2820
29
30
31
35
36com.mysql.jdbc.Driver
37jdbc:mysql://localhost:3306/jdbcstudy
38root
39XDP
40
415
4210
435
4420
45
46
47
复制代码
如下图所示：
3、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中创建池
复制代码
1packageme.gacl.util;
2
3importjava.sql.Connection;
4importjava.sql.ResultSet;
5importjava.sql.SQLException;
6importjava.sql.Statement;
7importcom.mchange.v2.c3p0.ComboPooledDataSource;
8
9/
10@ClassName:JdbcUtils_C3P0
11@Description:数据库连接工具类
12@author:孤傲苍狼
13@date:2014-10-4下午6:04:36
14
15/
16publicclassJdbcUtils_C3P0{
17
18privatestaticComboPooledDataSourceds=null;
19//在静态代码块中创建数据库连接池
20static{
21try{
22//通过代码创建C3P0数据库连接池
23/ds=newComboPooledDataSource();
24ds.setDriverClass("com.mysql.jdbc.Driver");
25ds.setJdbcUrl("jdbc:mysql://localhost:3306/jdbcstudy");
26ds.setUser("root");
27ds.setPassword("XDP");
28ds.setInitialPoolSize(10);
29ds.setMinPoolSize(5);
30ds.setMaxPoolSize(20);/
31
32//通过读取C3P0的xml配置文件创建数据源，C3P0的xml配置文件c3p0-config.xml必须放在src目录下
33//ds=newComboPooledDataSource();//使用C3P0的默认配置来创建数据源
34ds=newComboPooledDataSource("MySQL");//使用C3P0的命名配置来创建数据源
35
36}catch(Exceptione){
37thrownewExceptionInInitializerError(e);
38}
39}
40
41/
42@Method:getConnection
43@Description:从数据源中获取数据库连接
44@Anthor:孤傲苍狼
45@returnConnection
46@throwsSQLException
47/
48publicstaticConnectiongetConnection()throwsSQLException{
49//从数据源中获取数据库连接
50returnds.getConnection();
51}
52
53/
54@Method:release
55@Description:释放资源，
56释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
57@Anthor:孤傲苍狼
58
59@paramconn
60@paramst
61@paramrs
62/
63publicstaticvoidrelease(Connectionconn,Statementst,ResultSetrs){
64if(rs!=null){
65try{
66//关闭存储查询结果的ResultSet对象
67rs.close();
68}catch(Exceptione){
69e.printStackTrace();
70}
71rs=null;
72}
73if(st!=null){
74try{
75//关闭负责执行SQL命令的Statement对象
76st.close();
77}catch(Exceptione){
78e.printStackTrace();
79}
80}
81
82if(conn!=null){
83try{
84//将Connection连接对象还给数据库连接池
85conn.close();
86}catch(Exceptione){
87e.printStackTrace();
88}
89}
90}
91}
复制代码
测试C3P0数据源
复制代码
1packageme.gacl.test;
2
3importjava.sql.Connection;
4importjava.sql.PreparedStatement;
5importjava.sql.ResultSet;
6importorg.junit.Test;
7importme.gacl.util.JdbcUtils_C3P0;
8importme.gacl.util.JdbcUtils_DBCP;
9
10publicclassDataSourceTest{
11
12@Test
13publicvoidc3p0DataSourceTest(){
14Connectionconn=null;
15PreparedStatementst=null;
16ResultSetrs=null;
17try{
18//获取数据库连接
19conn=JdbcUtils_C3P0.getConnection();
20Stringsql="insertintotest1(name)values(?)";
21st=conn.prepareStatement(sql);
22st.setString(1,"gacl");
23st.executeUpdate();
24//获取数据库自动生成的主键
25rs=st.getGeneratedKeys();
26if(rs.next()){
27System.out.println(rs.getInt(1));
28}
29}catch(Exceptione){
30e.printStackTrace();
31}finally{
32//释放资源
33JdbcUtils_C3P0.release(conn,st,rs);
34}
35}
36}
复制代码
四、配置Tomcat数据源
在实际开发中，我们有时候还会使用服务器提供给我们的数据库连接池，比如我们希望Tomcat服务器在启动的时候可以帮我们创建一个数据库连接池，那么我们在应用程序中就不需要手动去创建数据库连接池，直接使用Tomcat服务器创建好的数据库连接池即可。要想让Tomcat服务器在启动的时候帮我们创建一个数据库连接池，那么需要简单配置一下Tomcat服务器。
4.1、JNDI技术简介
JNDI(JavaNamingandDirectoryInterface)，Java命名和目录接口，它对应于J2SE中的javax.naming包，
这套API的主要作用在于：它可以把Java对象放在一个容器中（JNDI容器），并为容器中的java对象取一个名称，以后程序想获得Java对象，只需通过名称检索即可。其核心API为Context，它代表JNDI容器，其lookup方法为检索容器中对应名称的对象。
Tomcat服务器创建的数据源是以JNDI资源的形式发布的，所以说在Tomat服务器中配置一个数据源实际上就是在配置一个JNDI资源，通过查看Tomcat文档，我们知道使用如下的方式配置tomcat服务器的数据源：
复制代码
1
2
3type="javax.sql.DataSource"username="root"password="XDP"
4driverClassName="com.mysql.jdbc.Driver"
5url="jdbc:mysql://localhost:3306/jdbcstudy"
6maxActive="8"maxIdle="4"/>
7
复制代码
服务器创建好数据源之后，我们的应用程序又该怎么样得到这个数据源呢，Tomcat服务器创建好数据源之后是以JNDI的形式绑定到一个JNDI容器中的，我们可以把JNDI想象成一个大大的容器，我们可以往这个容器中存放一些对象，一些资源，JNDI容器中存放的对象和资源都会有一个独一无二的名称，应用程序想从JNDI容器中获取资源时，只需要告诉JNDI容器要获取的资源的名称，JNDI根据名称去找到对应的资源后返回给应用程序。我们平时做javaEE开发时，服务器会为我们的应用程序创建很多资源，比如request对象，response对象，服务器创建的这些资源有两种方式提供给我们的应用程序使用：第一种是通过方法参数的形式传递进来，比如我们在Servlet中写的doPost和doGet方法中使用到的request对象和response对象就是服务器以参数的形式传递给我们的。第二种就是JNDI的方式，服务器把创建好的资源绑定到JNDI容器中去，应用程序想要使用资源时，就直接从JNDI容器中获取相应的资源即可。
对于上面的name="jdbc/datasource"数据源资源，在应用程序中可以用如下的代码去获取
1ContextinitCtx=newInitialContext();
2ContextenvCtx=(Context)initCtx.lookup("java:comp/env");
3dataSource=(DataSource)envCtx.lookup("jdbc/datasource");
此种配置下，数据库的驱动jar文件需放置在tomcat的lib下
4.2、配置Tomcat数据源
1、在Web项目的WebRoot目录下的META-INF目录创建一个context.xml文件
如下图所示：
2、在context.xml文件配置tomcat服务器的数据源
复制代码
1
2
3name="jdbc/datasource"
4auth="Container"
5type="javax.sql.DataSource"
6username="root"
7password="XDP"
8driverClassName="com.mysql.jdbc.Driver"
9url="jdbc:mysql://localhost:3306/jdbcstudy"
10maxActive="8"
11maxIdle="4"/>
12
复制代码
3、将数据库的驱动jar文件需放置在tomcat的lib下
4、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中获取JNDI容器中的数据源
复制代码
1packageme.gacl.util;
2
3importjava.sql.Connection;
4importjava.sql.ResultSet;
5importjava.sql.SQLException;
6importjava.sql.Statement;
7importjavax.naming.Context;
8importjavax.naming.InitialContext;
9importjavax.sql.DataSource;
10
11/
12@ClassName:JdbcUtils_DBCP
13@Description:数据库连接工具类
14@author:孤傲苍狼
15@date:2014-10-4下午6:04:36
16
17/
18publicclassJdbcUtils_JNDI{
19
20privatestaticDataSourceds=null;
21//在静态代码块中创建数据库连接池
22static{
23try{
24//初始化JNDI
25ContextinitCtx=newInitialContext();
26//得到JNDI容器
27ContextenvCtx=(Context)initCtx.lookup("java:comp/env");
28//从JNDI容器中检索name为jdbc/datasource的数据源
29ds=(DataSource)envCtx.lookup("jdbc/datasource");
30}catch(Exceptione){
31thrownewExceptionInInitializerError(e);
32}
33}
34
35/
36@Method:getConnection
37@Description:从数据源中获取数据库连接
38@Anthor:孤傲苍狼
39@returnConnection
40@throwsSQLException
41/
42publicstaticConnectiongetConnection()throwsSQLException{
43//从数据源中获取数据库连接
44returnds.getConnection();
45}
46
47/
48@Method:release
49@Description:释放资源，
50释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
51@Anthor:孤傲苍狼
52
53@paramconn
54@paramst
55@paramrs
56/
57publicstaticvoidrelease(Connectionconn,Statementst,ResultSetrs){
58if(rs!=null){
59try{
60//关闭存储查询结果的ResultSet对象
61rs.close();
62}catch(Exceptione){
63e.printStackTrace();
64}
65rs=null;
66}
67if(st!=null){
68try{
69//关闭负责执行SQL命令的Statement对象
70st.close();
71}catch(Exceptione){
72e.printStackTrace();
73}
74}
75
76if(conn!=null){
77try{
78//将Connection连接对象还给数据库连接池
79conn.close();
80}catch(Exceptione){
81e.printStackTrace();
82}
83}
84}
85}
复制代码
写一个Servlet测试JNDI数据源
复制代码
1packageme.gacl.test;
2
3importjava.io.IOException;
4importjava.sql.Connection;
5importjava.sql.PreparedStatement;
6importjava.sql.ResultSet;
7importjavax.servlet.ServletException;
8importjavax.servlet.http.HttpServlet;
9importjavax.servlet.http.HttpServletRequest;
10importjavax.servlet.http.HttpServletResponse;
11importme.gacl.util.JdbcUtils_JNDI;
12
13publicclassJNDITestextendsHttpServlet{
14
15publicvoiddoGet(HttpServletRequestrequest,HttpServletResponseresponse)
16throwsServletException,IOException{
17Connectionconn=null;
18PreparedStatementst=null;
19ResultSetrs=null;
20try{
21//获取数据库连接
22conn=JdbcUtils_JNDI.getConnection();
23Stringsql="insertintotest1(name)values(?)";
24st=conn.prepareStatement(sql);
25st.setString(1,"gacl");
26st.executeUpdate();
27//获取数据库自动生成的主键
28rs=st.getGeneratedKeys();
29if(rs.next()){
30System.out.println(rs.getInt(1));
31}
32}catch(Exceptione){
33e.printStackTrace();
34}finally{
35//释放资源
36JdbcUtils_JNDI.release(conn,st,rs);
37}
38}
39
40publicvoiddoPost(HttpServletRequestrequest,HttpServletResponseresponse)
41throwsServletException,IOException{
42doGet(request,response);
43}
44
45}
|
|
