1  public class JdbcPool implements DataSource {
 2       private static LinkedList<Connection> list = new LinkedList<Connection>();
 3       private static Properties config = new Properties();
 4       static{
 5             try {
 6                   config.load(JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("db.properties"));
 7                   // 以配置文件方式 读取数据库配置信息。
 8                   Class.forName(config.getProperty("driver"));
 9                   for(int i=0;i<10;i++){
10                         Connection conn = DriverManager.getConnection(config.getProperty("url"), config.getProperty("username"), config.getProperty("password"));
11                         list.add(conn);
12                   }
13             } catch (Exception e) {
14                   throw new ExceptionInInitializerError(e);
15             }
16       }
17       //conn.close()    此方法会将连接返回给数据库，所以不可用，需要自定义增强其功能，将连接返回到List集合中。
18       /* 在实际开发，发现对象的方法满足不了开发需求时，有三种方式对其进行增强
19        * 1.写一个connecton子类，覆盖close方法，增强close方法
20        * 2.用包装设计模式
21        * 3.用动态代理    aop 面向切面编程
22        */
23       public Connection getConnection() throws SQLException {
24             if(list.size()<=0){
25                   throw new RuntimeException("数据库忙，请稍会再来！！");
26             }
27             Connection conn = list.removeFirst();   //mysqlconnection   C
28             MyConnection my = new MyConnection(conn);    调用自定义链接。
29              return my;      //my-------preparedStatement   commit   createStatement  close
30       }
31       // 内部类，当然也可以使用外部类
32       class MyConnection implements Connection{      //1.定义一个类，实现与被增强相同的接口
33                 private Connection conn;      //2.在类中定义一个变量，记住被增强对象
34                 public MyConnection(Connection conn){    //3.定义一个构造函数，接收被增强对象
35                        this.conn = conn;
36                 }
37                 public void close(){     //4.覆盖想增强的方法
38                       list.add(this.conn);
39                 }
40                //5.对于不想增强的方法，直接调用目标对象（被增强对象）的方法
41                public void clearWarnings() throws SQLException {
42                       this.conn.clearWarnings();
43                 }
44                 public void commit() throws SQLException {
45                       this.conn.commit();
46                 }
47                 public Statement createStatement() throws SQLException {
48                       return this.conn.createStatement();
49                 }
50                 以下省略其他32个 不想增强的方法。（装饰模式的缺点，会实现许多不需要增强的方法）
51
52                  ………………
53
54          ｝
55           public Connection getConnection(String username, String password)
56               throws SQLException {
57             // TODO Auto-generated method stub
58             return null;
59           }
60           public PrintWriter getLogWriter() throws SQLException {
61             // TODO Auto-generated method stub
62             return null;
63           }
64           public int getLoginTimeout() throws SQLException {
65             // TODO Auto-generated method stub
66             return 0;
67           }
68           public void setLogWriter(PrintWriter arg0) throws SQLException {
69             // TODO Auto-generated method stub
70           }
71           public void setLoginTimeout(int arg0) throws SQLException {
72             // TODO Auto-generated method stub
73           }
74     ｝ 

 1 public class JdbcUtils_DBCP {
 2           private static DataSource ds = null;
 3           static{
 4                 try{
 5                       InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("2013-06-10 11:26");
 6                       Properties prop = new Properties();
 7                       prop.load(in);
 8                       BasicDataSourceFactory factory = new BasicDataSourceFactory();
 9                       ds = factory.createDataSource(prop);
10                 }catch (Exception e) {
11                       throw new ExceptionInInitializerError(e);
12                 }
13           }
14           public static Connection getConnection() throws SQLException{
15             return ds.getConnection();
16           }
17           public static void release(Connection conn,Statement st,ResultSet rs){
18                 if(rs!=null){
19                       try{
20                             rs.close();   //throw new
21                       }catch (Exception e) {
22                             e.printStackTrace();
23                       }
24                       rs = null;
25                 }
26                 if(st!=null){
27                       try{
28                             st.close();
29                       }catch (Exception e) {
30                             e.printStackTrace();
31                       }
32                       st = null;
33                 }
34                 if(conn!=null){
35                       try{
36                             conn.close();
37                       }catch (Exception e) {
38                             e.printStackTrace();
39                       }
40                 }
41           }
42     } 

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

 1 public class JdbcUtils_Tomcat {
 2               private static DataSource ds;
 3               static {
 4                     try {
 5                           Context initCtx = new InitialContext();
 6                           Context envCtx = (Context) initCtx.lookup("java:comp/env");
 7                           ds = (DataSource) envCtx.lookup("jdbc/EmployeeDB");
 8                     } catch (Exception e) {
 9                           throw new RuntimeException(e);
10                     }
11               }
12               public static Connection getConnection() throws SQLException{
13                     return ds.getConnection();
14               }
15         }

 1 <?xml version="1.0" encoding="UTF-8"?>
 2     <c3p0-config>
 3      <default-config>        <!-- 默认数据库连接池配置信息-->
 4        <property name="driverClass">com.mysql.jdbc.Driver</property>
 5        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day16</property>
 6        <property name="user">root</property>
 7        <property name="password">root</property>
 8        <property name="acquireIncrement">5</property>
 9        <property name="initialPoolSize">10</property>
10        <property name="minPoolSize">5</property>
11        <property name="maxPoolSize">20</property>
12      </default-config>
13
14  <!-- 第二个数据库连接池配置信息-->
15      <named-config name="flx">  <!--自定义数据源连接信息，比如可以分别书写 mysql  和 oracle 两个连接信息，以方便 换数据库。 注：此处对应调用代码中的“连接信息名” -->
16        <property name="driverClass">com.mysql.jdbc.Driver</property>
17        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day16</property>
18        <property name="user">root</property>
19        <property name="password">root</property>
20        <property name="acquireIncrement">5</property>
21        <property name="initialPoolSize">10</property>
22        <property name="minPoolSize">5</property>
23        <property name="maxPoolSize">20</property>
24      </named-config>
25     </c3p0-config> 

 1   public class JdbcUtils_C3P0 {
 2           private static ComboPooledDataSource ds = null;
 3           static{
 4                 try{
 5                       ds = new ComboPooledDataSource();  //没指定数据源名称，则使用默认数据源
 6                 }catch (Exception e) {
 7                       throw new ExceptionInInitializerError(e);
 8                 }
 9           }
10           public static Connection getConnection() throws SQLException{
11                 return ds.getConnection();
12           }
13           public static void release(Connection conn,Statement st,ResultSet rs){
14                 if(rs!=null){
15                       try{
16                             rs.close();   //throw new
17                       }catch (Exception e) {
18                             e.printStackTrace
19                       }
20                       rs = null;
21                 }
22                 if(st!=null){
23                       try{
24                             st.close();
25                       }catch (Exception e) {
26                             e.printStackTrace();
27                       }
28                       st = null;
29                 }
30                 if(conn!=null){
31                       try{
32                             conn.close();
33                       }catch (Exception e) {
34                             e.printStackTrace();
35                       }
36                 }
37           }
38     }