连接池

连接池的作用就是为了提高性能。

       连接池的作用：连接池是将已经创建好的连接保存在池中，当有请求来时，直接使用已经创建好的连接对数据库进行访问。这样省略了创建连接和销毁连接的过程。这样性能上得到了提高。

基本原理是这样的：

（1）建立数据库连接池对象（服务器启动）。
（2）按照事先指定的参数创建初始数量的数据库连接（即：空闲连接数）。
（3）对于一个数据库访问请求，直接从连接池中得到一个连接。如果数据库连接池对象中没有空闲的连接，且连接数没有达到最大（即：最大活跃连接数），创建一个新的数据库连接。
（4）存取数据库。
（5）关闭数据库，释放所有数据库连接（此时的关闭数据库连接，并非真正关闭，而是将其放入空闲队列中。如实际空闲连接数大于初始空闲连接数则释放连接）。
（6）释放数据库连接池对象（服务器停止、维护期间，释放数据库连接池对象，并释放所有连接）。

1 .连接池的概念和为什么要使用连接池？
    连接池放了N个Connection对象，本质上放在内存当中，在内存中划出一块缓存对象，应用程序每次从池里获得Connection对象，而不是直接从数据里获得，这样不占用服务器的内存资源。

2 .如果不使用连接池会出现的情况：
a.占用服务器的内存资源
b.导致服务器的速度非常慢

3 .应用连接池的三种方式：
a.自定义连接池
b.使用第三方连接池
c.使用服务器自带的连接池

       连接池一般比直接连接更有优越性,因为它提高了性能的同时还保存了宝贵的资源。在整个应用程序的使用过程,当中重复的打开直接连接将导致性能的下降。而池连接只在服务器启动时打开一次，从而消除了这种性能问题。
        连接池主要考虑的是性能，每次获取连接和释放连接都有很大的工作量，会对性能有很大影响；而对资源来说起的是反作用，因为保存一定数量的连接是要消耗内存的。应用程序每次从池里获得Connection对象，而不是直接从数据里获得，这样不占用服务器的内存资源。所以一般要建立连接池，而连接的数量要适当，不能太大，太大会过多消耗资源。(所以，考虑2个方面，一个是内存，另一个是资源)。

       连接池就是为了避免重复多次的打开数据库连接而造成的性能的下降和系统资源的浪费。

接下来，我们来学习三种连接池的配置:dbcp、c3p0、druid

1、dbcp连接池

连接配置文件

[plain] view plaincopy

1. #数据库驱动  
2. driverClassName=com.mysql.jdbc.Driver  
3. #数据库连接地址  
4. url=jdbc:mysql://localhost/ctg  
5. #用户名  
6. username=root  
7. #密码  
8. password=123456  
9.   
10. #连接池的最大数据库连接数。设为0表示无限制  
11. maxActive=30  
12. #最大空闲数，数据库连接的最大空闲时间。超过空闲时间，数据库连  
13. #接将被标记为不可用，然后被释放。设为0表示无限制  
14. maxIdle=10  
15. #最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制  
16. maxWait=1000  
17.   
18. #超过removeAbandonedTimeout时间后，是否进 行没用连接（废弃）的回收（默认为false，调整为true)   
19. removeAbandoned=true  
20. #超过时间限制，回收没有用(废弃)的连接（默认为 300秒，调整为180）  
21. removeAbandonedTimeout=180  

连接池管理类

[java] view plaincopy

1. package cn.songxinqiang.samples.commonsdbcp.util;  
2.   
3. import java.sql.Connection;  
4. import java.sql.DatabaseMetaData;  
5. import java.sql.SQLException;  
6. import java.util.Properties;  
7.   
8. import javax.sql.DataSource;  
9.   
10. import org.apache.commons.logging.Log;  
11. import org.apache.commons.logging.LogFactory;  
12. import org.apache.tomcat.dbcp.dbcp.BasicDataSourceFactory;  
13.   
14. /** 
15.  * tomcat数据库连接池管理类<br> 
16.  * 使用为tomcat部署环境<br> 
17.  * 需要在类路径下准备数据库连接配置文件dbcp.properties 
18.  *  
19.  * @author 宋信强 
20.  * @mail [e-mail] 
21.  *  
22.  * @time 2013-12-27 
23.  *  
24.  */  
25. public class DBManager {  
26.  private static final Log log = LogFactory.getLog(DBManager.class);  
27.  private static final String configFile = "dbcp.properties";  
28.   
29.  private static DataSource dataSource;  
30.   
31.  static {  
32.   Properties dbProperties = new Properties();  
33.   try {  
34.    dbProperties.load(DBManager.class.getClassLoader()  
35.      .getResourceAsStream(configFile));  
36.    dataSource = BasicDataSourceFactory.createDataSource(dbProperties);  
37.   
38.    Connection conn = getConn();  
39.    DatabaseMetaData mdm = conn.getMetaData();  
40.    log.info("Connected to " + mdm.getDatabaseProductName() + " "  
41.      + mdm.getDatabaseProductVersion());  
42.    if (conn != null) {  
43.     conn.close();  
44.    }  
45.   } catch (Exception e) {  
46.    log.error("初始化连接池失败：" + e);  
47.   }  
48.  }  
49.   
50.  private DBManager() {  
51.  }  
52.   
53.  /** 
54.   * 获取链接，用完后记得关闭 
55.   *  
56.   * @see {@link DBManager#closeConn(Connection)} 
57.   * @return 
58.   */  
59.  public static final Connection getConn() {  
60.   Connection conn = null;  
61.   try {  
62.    conn = dataSource.getConnection();  
63.   } catch (SQLException e) {  
64.    log.error("获取数据库连接失败：" + e);  
65.   }  
66.   return conn;  
67.  }  
68.   
69.  /** 
70.   * 关闭连接 
71.   *  
72.   * @param conn 
73.   *            需要关闭的连接 
74.   */  
75.  public static void closeConn(Connection conn) {  
76.   try {  
77.    if (conn != null && !conn.isClosed()) {  
78.     conn.setAutoCommit(true);  
79.     conn.close();  
80.    }  
81.   } catch (SQLException e) {  
82.    log.error("关闭数据库连接失败：" + e);  
83.   }  
84.  }  
85.   
86. }  

 

 

以上是dbcp连接池的配置和使用方式，以上的方式仅供参考。

 

2、c3p0连接池

 

数据库连接配置

[html] view plaincopy

1. <p>c3p0.jdbcUrl=jdbc:oracle:thin:@127.0.0.1:1521:orcl  
2. c3p0.driverClass=oracle.jdbc.driver.OracleDriver  
3. c3p0.user=test  
4. c3p0.password=test</p><p>c3p0.acquireIncrement=3   
5. c3p0.idleConnectionTestPeriod=60   
6. c3p0.initialPoolSize=10   
7. c3p0.maxIdleTime=60   
8. c3p0.maxPoolSize=20   
9. c3p0.maxStatements=100   
10. c3p0.minPoolSize=5 </p>  

C3P0获取连接公共类

[java] view plaincopy

1. public class MyC3P0Utils{  
2.     private static DataSource ds;  
3.   
4.     private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();  
5.     static {  
6.         ds = new ComboPooledDataSource();//直接使用即可，不用显示的配置，其会自动识别配置文件  
7.     }  
8.   
9.     public static DataSource getDataSource() {  
10.         return ds;  
11.     }  
12.   
13.     public static Connection getConnection() {  
14.         try {  
15. //           得到当前线程上绑定的连接  
16.             Connection conn = tl.get();  
17.             if (conn == null) { // 代表线程上没有绑定连接  
18.                 conn = ds.getConnection();  
19.                 tl.set(conn);  
20.             }  
21.             return conn;  
22.         } catch (Exception e) {  
23.             throw new RuntimeException(e);  
24.         }  
25.     }  
26.   
27.     public static void startTransaction() {  
28.         try {  
29.             // 得到当前线程上绑定连接开启事务  
30.             Connection conn=getConnection();  
31.             conn.setAutoCommit(false);  
32.         } catch (Exception e) {  
33.             throw new RuntimeException(e);  
34.         }  
35.     }  
36.   
37.     public static void commitTransaction() {  
38.         try {  
39.             Connection conn = tl.get();  
40.             if (conn != null) {  
41.                 conn.commit();  
42.             }  
43.         } catch (Exception e) {  
44.             throw new RuntimeException(e);  
45.         }  
46.     }  
47.   
48.     public static void closeConnection() {  
49.         try {  
50.             Connection conn = tl.get();  
51.             if (conn != null) {  
52.                 conn.close();  
53.             }  
54.         } catch (Exception e) {  
55.             throw new RuntimeException(e);  
56.         } finally {  
57.             tl.remove(); // 千万注意，解除当前线程上绑定的链接（从threadlocal容器中移除对应当前线程的链接）  
58.         }  
59.     }  
60. }  

 

另外提醒一下：不要忘记导入jar包

导入C3P0相关jar包

 

上面就是c3p0连接池的配置方式，仅供参考哦！

当然连接池的配置方式是不同的，上面配置的方式都是将配置放入到property的文件中，还有一种就是使用XML文件的方式，这里不介绍了。

 

下面来讲解到druid连接池的配置方法

 

配置文件

[plain] view plaincopy

1. driverClassName=oracle.jdbc.driver.OracleDriver  
2. url=jdbc:oracle:thin:@192.168.97.51:1521:lc8  
3. username=admin8  
4. password=adminpwd8  
5. filters=stat  
6. initialSize=2  
7. maxActive=300  
8. maxWait=60000  
9. timeBetweenEvictionRunsMillis=60000  
10. minEvictableIdleTimeMillis=300000  
11. validationQuery=SELECT 1  
12. testWhileIdle=true  
13. testOnBorrow=false  
14. testOnReturn=false  
15. poolPreparedStatements=false  
16. maxPoolPreparedStatementPerConnectionSize=200  

测试连接：

 

[java] view plaincopy

1. <p>package taobao_druid;</p><p>import java.io.BufferedInputStream;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.IOException;  
5. import java.io.InputStream;  
6. import java.util.Properties;</p><p>import javax.sql.DataSource;</p><p>import com.alibaba.druid.pool.DruidDataSourceFactory;</p><p>/** 
7.  * The Class DataSourceUtil. 
8.  */  
9. public class DataSourceUtil {</p><p>    /** 使用配置文件构建Druid数据源. */  
10.     public static final int DRUID_MYSQL_SOURCE = 0;</p><p>    /** 使用配置文件构建Druid数据源. */  
11.     public static final int DRUID_MYSQL_SOURCE2 = 1;</p><p>    /** 使用配置文件构建Dbcp数据源. */  
12.     public static final int DBCP_SOURCE = 4;  
13.     public static String confile = "druid.properties";  
14.     public static Properties p = null;</p><p>    static {  
15.         p = new Properties();  
16.         InputStream inputStream = null;  
17.         try {  
18.             //java应用  
19.             confile = DataSourceUtil.class.getClassLoader().getResource("").getPath()  
20.                     + confile;  
21.             System.out.println(confile);  
22.             File file = new File(confile);  
23.             inputStream = new BufferedInputStream(new FileInputStream(file));  
24.             p.load(inputStream);  
25.         } catch (Exception e) {  
26.             e.printStackTrace();  
27.         } finally {  
28.             try {  
29.                 if (inputStream != null) {  
30.                     inputStream.close();  
31.                 }  
32.             } catch (IOException e) {  
33.                 e.printStackTrace();  
34.             }  
35.         }  
36.     }</p><p>    /** 
37.      * 根据类型获取数据源 
38.      *  
39.      * @param sourceType 
40.      *            数据源类型 
41.      * @return druid或者dbcp数据源 
42.      * @throws Exception 
43.      *             the exception 
44.      */  
45.     public static final DataSource getDataSource(int sourceType) throws Exception {  
46.         DataSource dataSource = null;  
47.         switch (sourceType) {  
48.         case DRUID_MYSQL_SOURCE:  
49.             dataSource = DruidDataSourceFactory.createDataSource(p);  
50.             break;  
51.         case DRUID_MYSQL_SOURCE2:  
52.             dataSource = DruidDataSourceFactory.createDataSource(p);  
53.             break;  
54.         case DBCP_SOURCE:  
55.             // dataSource = BasicDataSourceFactory.createDataSource(  
56.             // MySqlConfigProperty.getInstance().getProperties());  
57.             break;  
58.         }  
59.         return dataSource;  
60.     }  
61. }  
62. </p>