什么是JDBC编程？

全称Java Database Connectivity。简单来说就是使用Java里面提供的一些类和方法，利用程序链接数据库，进行增删改查操作。这个过程就叫做JDBC编程。

MySQL数据库操作

传送门

连接数据库步骤

前置准备

  1. 安装MySQL Connector J 8.0。

  2. 导入mysql-connector-java-8.0.20.jar包（通过驱动里面的API访问MySQL数据库）。

    程序中使用步骤

  3. 注册驱动（指明使用什么驱动来连接数据库）。

  4. 建立连接。
  5. 发起请求。
  6. 处理数据。
  7. 关闭连接

基本使用：

  1. package com.desiki.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.Statement;
  8. public class JDBCDemo {
  9.     public static void main(String[] args) {
  10.         try {
  11.             //1、注册驱动（使用什么驱动来连接数据库）
  12.             Class.forName("com.mysql.cj.jdbc.Driver");
  14.             //2、建立连接
  15.             String url = "jdbc:mysql://localhost:3306/mygamedb?useUnicode=true&characterEncoding=UTF8&useSSL=true&&serverTimezone=GMT";
  16.             String user = "root";
  17.             String password = "root";
  18.             Connection con = DriverManager.getConnection(url, user, password);
  20.             //3、发起请求
  21.             Statement stmt = con.createStatement();
  22.             ResultSet rs = stmt.executeQuery("select * from users");
  24.             //4、处理数据
  25.             while(rs.next())
  26.             {
  27.                 System.out.println(rs.getInt(1)+","+rs.getString(2)+","+rs.getString(3)+","+rs.getDate(4));
  28.             }
  29.         } catch (Exception e) {
  30.             e.printStackTrace();
  31.         } finally {
  32.             //5、关闭连接
  33.             try {
  34.                 if (rs != null)
  35.                     rs.close();
  36.             } catch (SQLException e) {
  37.                 e.printStackTrace();
  38.             }
  39.             try {
  40.                 if (stmt != null)
  41.                     stmt.close();
  42.             } catch (SQLException e) {
  43.                 e.printStackTrace();
  44.             }
  45.             try {
  46.                 if (con != null)
  47.                     con.close();
  48.             } catch (SQLException e) {
  49.                 e.printStackTrace();
  50.             }//Connection，Statement，ResultSet不能放在一起，需要把每个单独try catch
  51.         }
  52.     }
  53. }

注意：JDBC中The server time zone value ‘?й???????’ is unrecognized …… 的错误

  1. java.sql.SQLException: The server time zone value '?й???????' is unrecognized or represents more than one time zone.
  2. You must configure either the server or JDBC driver (via the 'serverTimezone' configuration property) to use a more specifc time zone value
  3. if you want to utilize time zone support.

出现这个的原因是因为 mysql返回的时间总是有问题，比实际时间要早8小时。

解决办法：
在jdbc连接的url后面加上serverTimezone=GMT即可解决问题，如果需要使用gmt+8时区，需要写成GMT%2B8。
例如：
将
String url=”jdbc:mysql://localhost:3306/student?useSSL=true”;
改为
String uri=”jdbc:mysql://localhost:3306/student?useSSL=true&serverTimezone=GMT”;

提取工具类JDBCUtils

由于每次进行数据库操作时都需要上述几部操作，而且像注册驱动，建立连接，关闭连接这些代码都是重复的，故提取出一个工具类JDBCUtils.java来优化程序。

  1. package com.desiki.jdbc;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  9. public class JDBCUtils {
  11.     private static final String connectionURL="jdbc:mysql://localhost:3306/mygamedb?useUnicode=true&characterEncoding=UTF8&useSSL=true&&serverTimezone=GMT";
  12.     private static final String username = "root";
  13.     private static final String password = "root";
  15.     public static Connection getConnection() {
  16.         try {
  17.             Class.forName("com.mysql.cj.jdbc.Driver");
  18.             return DriverManager.getConnection(connectionURL, username, password);
  19.         } catch (Exception e) {
  20.             // TODO Auto-generated catch block
  21.             e.printStackTrace();
  22.         }
  23.         return null;
  24.     }
  25.     public static void close(ResultSet rs,Statement stmt,Connection con) {
  26.         closeResultSet(rs);
  27.         closeStatement(stmt);
  28.         closeConnection(con);
  29.     }
  30.     public static void close(Statement stmt1,Statement stmt2,Connection con) {
  31.         closeStatement(stmt1);
  32.         closeStatement(stmt2);
  33.         closeConnection(con);
  34.     }
  35.     private static void closeResultSet(ResultSet rs ) {
  36.         try {
  37.             if(rs!=null)rs.close();
  38.         } catch (SQLException e) {
  39.             // TODO Auto-generated catch block
  40.             e.printStackTrace();
  41.         }
  42.     }
  43.     private static void closeStatement(Statement stmt) {
  44.         try {
  45.             if(stmt!=null)
  46.                 stmt.close();
  47.         } catch (SQLException e) {
  48.             // TODO Auto-generated catch block
  49.             e.printStackTrace();
  50.         }
  51.     }
  52.     private static void closeConnection(Connection con) {
  53.         try {
  54.             if(con!=null)con.close();
  55.         } catch (SQLException e) {
  56.             // TODO Auto-generated catch block
  57.             e.printStackTrace();
  58.         }
  59.     }
  60. }

JDBC操作（增删改查）

查询

查询所有数据

  1.     public static void selectAll() {
  2.         Connection con = null;
  3.         Statement stmt = null;
  4.         ResultSet rs = null;
  5.         try {
  6.             con = JDBCUtils.getConnection();
  7.             stmt = con.createStatement();
  8.             rs = stmt.executeQuery("select * from users");//excuteXXX
  10.             //跟iterator遍历器类似
  11.             while(rs.next()) {
  12.                 // 通过列的索引来取数据，索引从1开始
  13.                 System.out.println(rs.getInt(1)+","+rs.getString(2)+","+rs.getString(3));
  14.                 // 通过列的列名来取数据
  15.                 System.out.println(rs.getInt("id")+","+rs.getString("username")+","+rs.getString("password"));
  16.             }
  17.         } catch (Exception e) {
  18.             e.printStackTrace();
  19.         } finally {
  20.             JDBCUtils.close(rs, stmt, con);
  21.         }
  22.     }

查询带参数的数据

错误用法：使用Statement，会导致SQL注入。

举例：用户名密码验证。

  1.     public static Boolean verticy(String username, String password) {
  2.         Connection con = null;
  3.         Statement stmt = null;
  4.         ResultSet rs = null;
  5.         try {
  6.             con = JDBCUtils.getConnection();
  7.             stmt = con.createStatement();
  8.             String sql = "select * from users where username='" + username + "' and password = '" + password + "'";
  9.             System.out.println(sql);
  10.             rs = stmt.executeQuery(sql);
  12.             if (rs.next()) {
  13.                 return true;
  14.             } else {
  15.                 return false;
  16.             }
  17.         } catch (Exception e) {
  18.             e.printStackTrace();
  19.         } finally {
  20.             JDBCUtils.close(rs, stmt, con);
  21.         }
  22.         return false;
  23.     }

正常情况，在main方法中测试成功：

  1.     public static void main(String[] args) {
  2.         System.out.println(verticy("azure", "123"));//用户名密码都存在且正确，输出true，合理
  3.     }

但是如果这么输入参数，用户名密码都不正确，同样也验证成功：

  1.     public static void main(String[] args) {
  2.         System.out.println(verticy("azure123", "1213' or '1' = '1"));//用户名密码不正确，也输出了true
  3.     }

这就是SQL注入。
SQL注入即是指web应用程序对用户输入数据的合法性没有判断或过滤不严，攻击者可以在web应用程序中事先定义好的查询语句的结尾上添加额外的SQL语句，在管理员不知情的情况下实现非法操作，以此来实现欺骗数据库服务器执行非授权的任意查询，从而进一步得到相应的数据信息。

上述代码中验证了两个用户名密码的登录。
第一条因为用户名密码都正确，输出true，验证成功，合情合理。
第二条用户名密码都不正确，居然也验证成功了，这是为什么呢？
原因在于我们组拼的sql语句是有漏洞的，比如上述第二条sql组拼后：
select * from users where username='azure123' and password = '1213' or '1' = '1'
条件1=1 恒为true，所以用户名和密码正不正确无所谓，这个条件一定会执行成功。

正确方法：使用PreparedStatement

语法格式：

  1. String sql = "select * from users where username = ? and password = ?";//?代表参数
  2. PreparedStatement pstmt = conn.prepareStatement(sql);
  3. //设置参数索引，从1开始
  4. pstmt.setString(1,xxx);
  5. pstmt.setString(2,xxx);
  6. ResultSet rs = pstmt.executeQuery();

正确的用户名密码验证示例：

  1.     public static boolean verticy(String username,String password) {
  2.         Connection con = null;
  3.         PreparedStatement pstmt = null;
  4.         ResultSet rs = null;
  5.         try {
  6.             con = JDBCUtils.getConnection();
  8.             String sql = "select * from users where username = ? and password = ?";
  9.             pstmt = con.prepareStatement(sql);
  10.             pstmt.setString(1, username);
  11.             pstmt.setString(2, password);
  12.             rs = pstmt.executeQuery();
  14.             if(rs.next())
  15.                 return true;
  16.             else 
  17.                 return false;
  18.         } catch (Exception e) {
  19.             // TODO Auto-generated catch block
  20.             e.printStackTrace();
  21.         }finally {
  22.             JDBCUtils.close(rs, pstmt, con);
  23.         }
  24.         return false;
  25.     }

这样可以防止SQL注入。一般来说，对于带参数的数据库操作，都是使用PreparedStatement而不是Statement。

分页查询

语法：
limit ?,?

  • 第一个问号：用于指定查询记录的起始行数（从哪一行开始，行数从0开始）。
  • 第二个问号：用于指定查询数据所返回的记录行数（指查询几行）。

公式：
如果要查询 第7页，每页8行：
0-7 第一页
8-15 第二页
16-23 第三页
…
起始行数：（页数-1）*8
查询行数：自定义，这里是8
所以最终的结果是limit 48,8。

  1.     // pageNumber是页数，第几页  pageCount是每页显示多少条数据
  2.     public static void selectUserByPage(int pageNumber,int pageCount) {
  3.         Connection con = null;
  4.         PreparedStatement pstmt = null;
  5.         ResultSet rs = null;
  6.         try {
  7.             con = JDBCUtils.getConnection();
  9.             String sql = "select * from users limit ?,?";
  10.             stmt = con.prepareStatement(sql);
  11.             stmt.setInt(1, (pageNumber-1)*pageCount );
  12.             stmt.setInt(2, pageCount);
  13.             rs = stmt.executeQuery();
  15.             //跟iterator遍历器
  16.             while(rs.next()) {
  17. //                System.out.println(rs.getInt(1)+","+rs.getString(2)+","+rs.getString(3));
  18.                 System.out.println(rs.getInt("id")+","+rs.getString("username")+","+rs.getString("password"));
  19.             }
  20.         } catch (Exception e) {
  21.             e.printStackTrace();
  22.         } finally {
  23.             JDBCUtils.close(rs, pstmt, con);
  24.         }
  25.     }

插入

  1.     public static void insert( String username,String password ) {
  2.         Connection con = null;
  3.         PreparedStatement stmt = null;
  4.         ResultSet rs = null;
  5.         try {
  6.             con = JDBCUtils.getConnection();
  8.             String sql = "insert into users(username,password) values(?,?)";
  9.             stmt = con.prepareStatement(sql);
  10.             stmt.setString(1, username);
  11.             stmt.setString(2, password);
  12.             int result =stmt.executeUpdate();// 返回值代表收到影响的行数
  13.         } catch (Exception e) {
  14.             e.printStackTrace();
  15.         } finally {
  16.             JDBCUtils.close(rs, stmt, con);
  17.         }
  18.     }

删除

  1.     //一般根据id来删除数据    
  2.     public static void delete(int id) {
  3.         Connection con = null;
  4.         PreparedStatement stmt = null;
  5.         ResultSet rs = null;
  6.         try {
  7.             con = JDBCUtils.getConnection();
  9.             String sql = "delete from user where id = ?";
  10.             stmt = con.prepareStatement(sql);
  11.             stmt.setInt(1, id);
  12.             int result =stmt.executeUpdate();// 返回值代表收到影响的行数
  13.             if(result>0) {
  14.                 System.out.println("删除成功");
  15.             }else {
  16.                 System.out.println("删除失败");
  17.             }
  18.         } catch (Exception e) {
  19.             e.printStackTrace();
  20.         } finally {
  21.             JDBCUtils.close(rs, stmt, con);
  22.         }
  23.     }

修改

正常修改一条或多条记录

  1.     //根据id修改密码    
  2.     public static void update(int id,String newPassword) {
  3.         Connection con = null;
  4.         PreparedStatement stmt = null;
  5.         ResultSet rs = null;
  6.         try {
  7.             con = JDBCUtils.getConnection();
  9.             String sql = "update usesr set password = ? where id = ?";
  10.             stmt = con.prepareStatement(sql);
  11.             stmt.setString(1, newPassword);
  12.             stmt.setInt(2, id);
  13.             int result =stmt.executeUpdate();// 返回值代表收到影响的行数
  14.             if(result>0) {
  15.                 System.out.println("修改成功");
  16.             }else {
  17.                 System.out.println("修改失败");
  18.             }
  19.         } catch (Exception e) {
  20.             e.printStackTrace();
  21.         } finally {
  22.             JDBCUtils.close(rs, stmt, con);
  23.         }
  24.     }

事务操作

理解事务之前，先讲一个日常生活中最常干的事：转账
从A账户中转1000块给B账户，转账这个过程必须是一个事务。否则，可能会由于各种原因而导致，A账户减少了1000块，但B账户没有相应的增加1000块，或者 B账户增加了1000块，但A账户没有减少1000块。一个步骤成功而另一个步骤失败，这样不是你用户损失就是银行损失。所以，为了保证转账前后的一致性，就必须确保转账操作是一个事务。这样，不管哪一个步骤失败了以后，就可以回滚到转账前的状态，就像这个事务从来没有执行过一样，对双方都有利。
事务就是用来解决类似问题的。事务是一系列的动作，它们综合在一起才是一个完整的工作单元，这些动作必须全部完成，如果有一个失败的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过一样。
当你需要一次执行多条SQL语句时，可以使用事务。通俗一点说，就是，如果这几条SQL语句全部执行成功，则才对数据库进行一次更新，如果有一条SQL语句执行失败，则这几条SQL语句全部不进行执行。这个时候需要用到事务。参考1

JDBC是Java数据库连接相关的API，所以Java的事务管理也是在通过该API进行的。JDBC的核心是Connection接口，JDBC的事务管理是基于Connection接口来实现的，通过Connection对象进行事务管理。
JDBC对事务的处理规则，必须是基于同一个Connection对象的。

JDBC提供了3个方法来进行事务管理：

  • setAutoCommit() 设置自动提交，方法中需要传入一个boolean类型的参数，true为自动提交，false为手动提交
  • commit() 提交事务
  • rollback() 回滚事务（回滚一般写在catch块中）

JDBC默认的事务处理行为是自动提交。所以JDBC在进行事务管理时，首先要通过Connection对象调用setAutoCommit(false) 方法, 将SQL语句的提交（commit）由驱动程序转交给应用程序负责。并且调用setAutoCommit(false) 方法后，程序必须调用commit或者rollback方法，否则SQL语句不会被提交或回滚。参考2

  1.     public static void transferAccounts(String username1,String username2,int money) {
  2.         Connection con = null;
  3.         PreparedStatement stmt1 = null;
  4.         PreparedStatement stmt2 = null;
  5.         ResultSet rs = null;
  6.         try {
  7.             con = JDBCUtils.getConnection();
  9.             con.setAutoCommit(false);//设置手动提交事务
  10.             //转出
  11.             String sql = "update user set balance = balance - ? where username = ?";
  12.             stmt1 = con.prepareStatement(sql);
  13.             stmt1.setInt(1, money);
  14.             stmt1.setString(2, username1);
  15.             stmt1.executeUpdate();// 返回值代表收到影响的行数
  16.             //转入
  17.             sql = "update user set balance = balance + ? where username = ?";
  18.             stmt2 = con.prepareStatement(sql);
  19.             stmt2.setInt(1, money);
  20.             stmt2.setString(2, username2);
  21.             stmt2.executeUpdate();// 返回值代表收到影响的行数
  23.             con.commit();//提交事务
  25.         } catch (Exception e) {
  26.             try {
  27.                 con.rollback();//只要出现异常。就回滚!
  28.             } catch (SQLException e1) {
  29.                 e1.printStackTrace();
  30.             }
  31.         } finally {
  32.             JDBCUtils.close(stmt2, stmt1, con);
  33.         }
  34.     }

连接池（数据源）

对于现在的JDBCUtils，其实还有些问题。每次数据库操作都需要建立一个新的连接，使用完后再关闭掉。假如有大量的用户使用，会造成性能内存的极大开销，对此，我们可以使用连接池（数据源）。
连接池的基本思想就是为数据库连接建立一个“缓冲池”。预先在缓冲池中放入一定数量的连接，当需要建立数据库连接时，只需从“缓冲池”中取出一个，使用完毕之后再放回去。
这篇文档连接池部分写的比较简单，具体可以看这篇JDBC连接池。

改良JDBCUtils

给现有的JDBCUtils加入连接池。

  1. package com.desiki.jdbc01;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  8. import java.util.ArrayList;
  10. public class JDBCUtils {
  12.     private static final String connectionURL="jdbc:mysql://localhost:3306/mygamedb?useUnicode=true&characterEncoding=UTF8&useSSL=true&&serverTimezone=GMT";
  13.     private static final String username = "root";
  14.     private static final String password = "root";
  16.     private static ArrayList<Connection> conList = new ArrayList<Connection>();
  18.     static {
  19.         //设置5个初始连接
  20.         for(int i =0;i<5;i++) {
  21.             Connection con = createConnection();
  22.             conList.add(con);
  23.         }
  24.     }
  26.     public static Connection getConnection() {
  27.         if(conList.isEmpty()==false) {
  28.             Connection con = conList.get(0);
  29.             conList.remove(con);
  30.             return con;
  31.         }else {
  32.             return createConnection();
  33.         }
  34.     }
  35.     private static Connection createConnection() {
  36.         try {
  37.             Class.forName("com.mysql.cj.jdbc.Driver");
  39.             return DriverManager.getConnection(connectionURL, username, password);
  40.         } catch (Exception e) {
  41.             // TODO Auto-generated catch block
  42.             e.printStackTrace();
  43.         }
  44.         return null;
  45.     }
  46.     public static void close(ResultSet rs,Statement stmt,Connection con) {
  47.         closeResultSet(rs);
  48.         closeStatement(stmt);
  49.         closeConnection(con);
  50.     }
  51.     public static void close(Statement stmt1,Statement stmt2,Connection con) {
  52.         closeStatement(stmt1);
  53.         closeStatement(stmt2);
  54.         closeConnection(con);
  55.     }
  56.     private static void closeResultSet(ResultSet rs ) {
  57.         try {
  58.             if(rs!=null)rs.close();
  59.         } catch (SQLException e) {
  60.             // TODO Auto-generated catch block
  61.             e.printStackTrace();
  62.         }
  63.     }
  64.     private static void closeStatement(Statement stmt) {
  65.         try {
  66.             if(stmt!=null)
  67.                 stmt.close();
  68.         } catch (SQLException e) {
  69.             // TODO Auto-generated catch block
  70.             e.printStackTrace();
  71.         }
  72.     }
  73.     private static void closeConnection(Connection con) {
  74. //        try {
  75. //            if(con!=null)con.close();
  76. //        } catch (SQLException e) {
  77. //            // TODO Auto-generated catch block
  78. //            e.printStackTrace();
  79. //        }
  80.         conList.add(con);
  81.     }
  82. }

使用方式和之前完全一样。
对于我们自己写的连接池，不是很完善，比较简陋，很多东西没考虑到，一般可以用第三方的数据源。这里介绍两种：DBCB，C3P0。

DBCP

DBCP（DataBase Connection Pool）是Java数据库连接池的一种，由Apache开发，通过数据库连接池，可以让程序自动管理数据库连接的释放和断开。

使用步骤：
下载本体commons-dbcp2-2.7.0-bin.jar包。下载地址： http://commons.apache.org/proper/commons-dbcp/download_dbcp.cgi
依赖包commons-pool2-2.8.0-bin.jar包。下载地址：http://commons.apache.org/proper/commons-pool/download_pool.cgi
依赖包commons-logging-1.2-bin.jar包。下载地址：http://commons.apache.org/proper/commons-logging/download_logging.cgi

  1. package com.desiki.jdbc01;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. import org.apache.commons.dbcp2.BasicDataSource;
  10. public class DBCPDataSource {
  11.     private static final String connectionURL="jdbc:mysql://localhost:3306/mygamedb?useUnicode=true&characterEncoding=UTF8&useSSL=true&&serverTimezone=GMT" ;
  12.     private static final String username = "root";
  13.     private static final String password = "root";
  15.     private static BasicDataSource ds;
  17.     static {
  18.         //初始化dbcp数据源
  19.         ds = new BasicDataSource();
  20.         ds.setDriverClassName("com.mysql.cj.jdbc.Driver");
  21.         ds.setUrl(connectionURL);
  22.         ds.setUsername(username);
  23.         ds.setPassword(password);
  25.         ds.setInitialSize(5);//初始化连接的个数
  26.         ds.setMaxTotal(20);//连接的最大个数
  27.         ds.setMinIdle(3);//保证连接池中最少有几个空闲的备用连接
  28.     }
  30.     public static Connection getConnection() {
  31.         try {
  32.             return ds.getConnection();//通过dbcp得到的链接，不需要归还，直接close就可以,
  33.         } catch (SQLException e) {
  34.             // TODO Auto-generated catch block
  35.             e.printStackTrace();
  36.         }
  37.         return null;
  38.     }
  39.     public static void close(ResultSet rs,Statement stmt,Connection con) {
  40.         closeResultSet(rs);
  41.         closeStatement(stmt);
  42.         closeConnection(con);
  43.     }
  44.     public static void close(Statement stmt1,Statement stmt2,Connection con) {
  45.         closeStatement(stmt1);
  46.         closeStatement(stmt2);
  47.         closeConnection(con);
  48.     }
  50.     private static void closeResultSet(ResultSet rs ) {
  51.         try {
  52.             if(rs!=null)rs.close();
  53.         } catch (SQLException e) {
  54.             // TODO Auto-generated catch block
  55.             e.printStackTrace();
  56.         }
  57.     }
  58.     private static void closeStatement(Statement stmt) {
  59.         try {
  60.             if(stmt!=null)
  61.                 stmt.close();
  62.         } catch (SQLException e) {
  63.             // TODO Auto-generated catch block
  64.             e.printStackTrace();
  65.         }
  66.     }
  67.     private static void closeConnection(Connection con) {
  68.         try {
  69.             if(con!=null)con.close();//这里会把链接归还给dbcp连接池，并不是真正的断开链接
  70.         } catch (SQLException e) {
  71.             // TODO Auto-generated catch block
  72.             e.printStackTrace();
  73.         }
  74.     }
  75. }

C3P0

快速入门：https://www.mchange.com/projects/c3p0/
下载地址：https://sourceforge.net/projects/c3p0/

注意：除去导入本体jar包外还需要导入mchange-commons-java-0.2.19.jar包

  1. package com.desiki.jdbc01;
  3. import java.beans.PropertyVetoException;
  4. import java.sql.Connection;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  9. import com.mchange.v2.c3p0.ComboPooledDataSource;
  11. public class C3P0DataSource {
  12.     private static final String connectionURL="jdbc:mysql://localhost:3306/mygamedb?useUnicode=true&characterEncoding=UTF8&useSSL=true&&serverTimezone=GMT" ;
  13.     private static final String username = "root";
  14.     private static final String password = "root";
  16.     private static ComboPooledDataSource ds ;
  18.     static {
  19.         try {
  20.             ds = new ComboPooledDataSource();
  21.             ds.setDriverClass("com.mysql.cj.jdbc.Driver");
  22.             ds.setJdbcUrl(connectionURL);
  23.             ds.setUser(username);
  24.             ds.setPassword(password);
  26.             ds.setInitialPoolSize(5);
  27.             ds.setMaxPoolSize(20);
  28.         } catch (PropertyVetoException e) {
  29.             // TODO Auto-generated catch block
  30.             e.printStackTrace();
  31.         }
  33.     }
  35.     public static Connection getConnection() {
  36.         try {
  37.             return ds.getConnection();
  38.         } catch (SQLException e) {
  39.             // TODO Auto-generated catch block
  40.             e.printStackTrace();
  41.         }
  42.         return null;
  43.     }
  45.     public static void close(ResultSet rs,Statement stmt,Connection con) {
  46.         closeResultSet(rs);
  47.         closeStatement(stmt);
  48.         closeConnection(con);
  49.     }
  50.     public static void close(Statement stmt1,Statement stmt2,Connection con) {
  51.         closeStatement(stmt1);
  52.         closeStatement(stmt2);
  53.         closeConnection(con);
  54.     }
  55.     private static void closeResultSet(ResultSet rs ) {
  56.         try {
  57.             if(rs!=null)rs.close();
  58.         } catch (SQLException e) {
  59.             // TODO Auto-generated catch block
  60.             e.printStackTrace();
  61.         }
  62.     }
  63.     private static void closeStatement(Statement stmt) {
  64.         try {
  65.             if(stmt!=null)
  66.                 stmt.close();
  67.         } catch (SQLException e) {
  68.             // TODO Auto-generated catch block
  69.             e.printStackTrace();
  70.         }
  71.     }
  72.     private static void closeConnection(Connection con) {
  73.         try {
  74.             if(con!=null)con.close();//这里会把链接归还给c3p0连接池，并不是真正的断开链接
  75.         } catch (SQLException e) {
  76.             // TODO Auto-generated catch block
  77.             e.printStackTrace();
  78.         }
  79.     }
  80. }