1 package com.haifei.datasource.druid;
 2 
 3 import com.alibaba.druid.pool.DruidDataSourceFactory;
 4 
 5 import javax.sql.DataSource;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.sql.Connection;
 9 import java.util.Properties;
10 
11 /*
12 数据库连接池
13 
14 5 Druid：数据库连接池技术，由阿里巴巴提供
15 
16     1. 步骤：
17         1. 导入jar包 druid-1.0.9.jar
18             不要忘记还需要数据库驱动jar包mysql-connector-java-5.1.37-bin.jar
19         2. 定义配置文件：
20             * 是properties形式的
21             * 可以叫任意名称，可以放在任意目录下
22         3. 利用Properties集合类加载配置文件
23         4. 获取数据库连接池对象：通过工厂来来获取  DruidDataSourceFactory
24         5. 获取连接：getConnection
25 
26     2. 定义工具类
27         1. 定义一个类 JDBCUtils
28         2. 提供静态代码块加载配置文件，初始化连接池对象
29         3. 提供方法
30             1. 获取连接方法：通过数据库连接池获取连接
31             2. 释放资源
32             3. 获取连接池的方法
33  */
34 public class DruidDemo1 {
35     public static void main(String[] args) throws Exception {
36         //3 加载配置文件
37         Properties prop = new Properties();
38         InputStream is = DruidDemo1.class.getClassLoader().getResourceAsStream("druid.properties");
39         prop.load(is);
40 
41         //4 利用工厂来获取连接池对象
42         DataSource ds = DruidDataSourceFactory.createDataSource(prop);
43 
44         //5 获取连接对象
45         Connection conn = ds.getConnection();
46         System.out.println(conn); //com.mysql.jdbc.JDBC4Connection@13b6aecc
47     }
48 }

  1 package com.haifei.utils;
  2 
  3 import com.alibaba.druid.pool.DruidDataSourceFactory;
  4 
  5 import javax.sql.DataSource;
  6 import javax.xml.crypto.Data;
  7 import java.io.IOException;
  8 import java.sql.Connection;
  9 import java.sql.ResultSet;
 10 import java.sql.SQLException;
 11 import java.sql.Statement;
 12 import java.util.Properties;
 13 
 14 /**
 15  * Druid连接池工具类
 16  *  后期开发主用
 17  */
 18 public class JDBCUtils {
 19 
 20 
 21     //定义成员变量
 22     private static DataSource ds;
 23 
 24     //静态代码块
 25     static {
 26         try {
 27             //1 加载配置文件
 28             Properties prop = new Properties();
 29             prop.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
 30 
 31             //2 获取DataSource对象
 32             ds = DruidDataSourceFactory.createDataSource(prop);
 33         } catch (IOException e) {
 34             e.printStackTrace();
 35         } catch (Exception e) {
 36             e.printStackTrace();
 37         }
 38     }
 39 
 40 
 41     /**
 42      * 获取连接对象
 43      * @return
 44      * @throws SQLException
 45      */
 46     public static Connection getConnection() throws SQLException {
 47         return ds.getConnection();
 48     }
 49 
 50 
 51     /**
 52      * 释放资源
 53      * @param stmt
 54      * @param conn
 55      */
 56     public static void close(Statement stmt, Connection conn){
 57         /*if (stmt != null){
 58             try {
 59                 stmt.close();
 60             } catch (SQLException e) {
 61                 e.printStackTrace();
 62             }
 63         }
 64 
 65         if (conn != null){
 66             try {
 67                 conn.close(); //此处实质不是释放资源，而是将连接对象归还给连接池
 68             } catch (SQLException e) {
 69                 e.printStackTrace();
 70             }
 71         }*/
 72 
 73         close(null, stmt, conn);
 74     }
 75 
 76 
 77     /**
 78      * 释放资源
 79      * @param rs
 80      * @param stmt
 81      * @param conn
 82      */
 83     public static void close(ResultSet rs, Statement stmt, Connection conn){ //重载
 84         if (rs != null){
 85             try {
 86                 rs.close();
 87             } catch (SQLException e) {
 88                 e.printStackTrace();
 89             }
 90         }
 91 
 92         if (stmt != null){
 93             try {
 94                 stmt.close();
 95             } catch (SQLException e) {
 96                 e.printStackTrace();
 97             }
 98         }
 99 
100         if (conn != null){
101             try {
102                 conn.close(); //此处实质不是释放资源，而是将连接对象归还给连接池
103             } catch (SQLException e) {
104                 e.printStackTrace();
105             }
106         }
107     }
108 
109 
110     /**
111      * 获取连接池对象
112      * @return DataSource ds
113      */
114     public static DataSource getDataSource(){
115         return ds;
116     }
117 }

 1 package com.haifei.datasource.druid;
 2 
 3 import com.haifei.utils.JDBCUtils;
 4 
 5 import java.sql.Connection;
 6 import java.sql.PreparedStatement;
 7 import java.sql.SQLException;
 8 
 9 /*
10 测试新的JDBCUtils：Druid连接池工具类
11 
12     需求：给account表添加一条记录
13  */
14 public class DruidDemo2 {
15     public static void main(String[] args) {
16 
17         Connection conn = null;
18         PreparedStatement pstmt = null;
19 
20         try {
21             //1 获取连接conn对象
22             conn = JDBCUtils.getConnection();
23 
24             //2 定义sql
25             String sql = "insert into account values(null, ?, ?)";
26 
27             //3 获取执行sql的pstmt对象
28             pstmt = conn.prepareStatement(sql);
29 
30             //4 给sql中的?赋值
31             pstmt.setString(1, "wangwu");
32             pstmt.setDouble(2, 3000);
33 
34             //5 执行sql
35             int count = pstmt.executeUpdate();
36             System.out.println(count); //1
37 
38         } catch (SQLException e) {
39             e.printStackTrace();
40         } finally {
41             JDBCUtils.close(pstmt, conn);
42         }
43 
44     }
45 }