Java的JDBC原生态学习以及连接池的用法

转自：http://www.oseye.net/user/kevin/blog/269

JDBC是什么

JDBC(Java Data Base Connectivity)是Java访问数据库的桥梁，但它只是接口规范，具体实现是各数据库厂商提供的驱动程序(Driver)。

应用程序、JDBC、JDBC驱动、数据库之间的关系如上图：应用程序通过JDBC访问数据库，而JDBC驱动来具体实现JDBC访问数据库的动作。

JDBC版本

JDBC的版本和JDK版本是独立的，他们的对应关系：

JDK版本	DB版本
JDK 1.1	JDBC1
JDK 1.2, 1.3	JDBC2
JDK 1.4, 1.5	JDBC3
JDK 1.6	JDBC4
JDK 1.7	JDBC4.1

JDBC4.0新特性

JDBC 4.0中增加的主要特性包括：

• JDBC驱动类的自动加载；
  不必再使用Class.forName()方法明确加载JDBC驱动。当调用getConnection方法 时，DriverManager会尝试从初始化时已经加载的JDBC驱动程序库中选择合适的驱动，以及他在当前应用的同一个类加载器中明确加载使用过的驱动。
• 连接管理的增强
• 在JDBC 4.0之前，我们依靠JDBC URL来定义一个数据源连接。现在我们只需为标准连接工厂机制提供一组参数，就能获取与任何数据源的连接。
• 对RowId SQL类型的支持
  增加了RowID接口以支持ROWID数据类型。
• SQL的DataSet实现使用了Annotations；
  JDBC 4.0对标注（Java SE 5新增）作了进一步规范和补充，他允许开发人员不必再写大量代码就能达到联系SQL查询和Java类的目的。
• SQL异常处理的增强；
  JDBC 4.0在SQLException处理中有不少增强，在处理SQLException时提供了更好的开发体验，如新的SQLException子类、对因果关系的支持、对改进的for-each循环的支持。
• 对SQL XML的支持；

JDBC链接步骤

1. 链接数据库；
2. 创建执行声明；
3. 执行Sql语句；
4. 处理结果；
5. 释放资源；

以MySql为例，制作了一个DEMO(也可以了解下我早期入门的一个DEMO)。

pom.xml添加MySql驱动依赖：

  
  
  
  

   
   
   
   
<dependency>
   
   
   
   
 <groupId>mysql</groupId>
   
   
   
   
 <artifactId>mysql-connector-java</artifactId>
   
   
   
   
 <version>5.1.30</version>
   
   
   
   
</dependency>
  
  
  
  

完整的App.java代码

  
  
  
  

   
   
   
   
package net.oseye.DbDemo;
   
   
   
   
 
   
   
   
   
import java.sql.Connection;
   
   
   
   
import java.sql.DriverManager;
   
   
   
   
import java.sql.ResultSet;
   
   
   
   
import java.sql.Statement;
   
   
   
   
 
   
   
   
   
public class App 
   
   
   
   
{
   
   
   
   
 public static void main( String[] args ) throws Exception
   
   
   
   
 {
   
   
   
   
 //链接数据库
   
   
   
   
 Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root","root");
   
   
   
   
 //创建执行声明
   
   
   
   
 Statement stmt=conn.createStatement();
   
   
   
   
 //执行Sql语句
   
   
   
   
 ResultSet rs=stmt.executeQuery("select user_id,user_name from user");
   
   
   
   
 //处理结果集
   
   
   
   
 while(rs.next()){
   
   
   
   
 System.out.println("用户ID"+rs.getInt(1)+"\t用户名："+rs.getString(2));
   
   
   
   
 }
   
   
   
   
 //释放资源
   
   
   
   
 rs.close();
   
   
   
   
 stmt.close();
   
   
   
   
 conn.close();
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

相关API在此不做详细介绍，请查看JDK API文档。

JDBC预处理PreparedStatement

上面的示例有两个缺点：

1. 使用DriverManager获得数据库连接。这种方式效率低，并且其性能、可靠性和稳定性随着用户访问量得增加逐渐下降，应该使用连接池取而代之(后文再讲);
2. 应该使用PreparedStatement取代Statement，因为Statement的缺点也非常明显：
   • 执行时发送sql，影响效率.
   • 同样的sql，每次都要发送，不能进行有效的缓存，是一种资源的浪费.
   • 示例代码中演示可以看出，为了防止恶意数据我们还需要编写附加的程序（过滤器）带来不必要的开支.
   • 拼接sql字符串很容易出现错误.

PreparedStatement是Statement的子接口，它在执行sql之前首先准备好sql语句，将其中的条件通过？进行占位，还有一个好处就是，同样的sql会被PreparedStatement有效的缓存，也就是说，数据库会减少校验的过程，减少消耗，这就是我们常说的预处理命令方式。

  
  
  
  

   
   
   
   
package net.oseye.DbDemo;
   
   
   
   
 
   
   
   
   
import java.sql.Connection;
   
   
   
   
import java.sql.DriverManager;
   
   
   
   
import java.sql.PreparedStatement;
   
   
   
   
import java.sql.ResultSet;
   
   
   
   
 
   
   
   
   
public class App 
   
   
   
   
{
   
   
   
   
 public static void main( String[] args ) throws Exception
   
   
   
   
 {
   
   
   
   
 //链接数据库
   
   
   
   
 Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root","root");
   
   
   
   
 //创建执行声明
   
   
   
   
 PreparedStatement pstmt=conn.prepareStatement("select user_id,user_name from user where user_id < ?");
   
   
   
   
 //填充占位符?
   
   
   
   
 pstmt.setInt(1, 3);
   
   
   
   
 //执行Sql语句
   
   
   
   
 ResultSet rs=pstmt.executeQuery();
   
   
   
   
 //处理结果集
   
   
   
   
 while(rs.next()){
   
   
   
   
 System.out.println("用户ID"+rs.getInt(1)+"\t用户名："+rs.getString(2));
   
   
   
   
 }
   
   
   
   
 //释放资源
   
   
   
   
 rs.close();
   
   
   
   
 pstmt.close();
   
   
   
   
 conn.close();
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

JDBC调用存储过程请使用“CallableStatement”接口。

JDBC事务

数据库的事务是保证数据完整性的一种机制，简而言之，就是怎样确保数据的执行过程要么都成功，要么都失败

• 原子性(atomicity)：组成事务处理的语句形成了一个逻辑单元，不能只执行其中的一部分。 
• 一致性(consistency)：在事务处理执行前后，数据库是一致的(两个账户要么都变，或者都不变)。 
• 隔离性(isolcation)：一个事务处理对另一个事务处理没有影响。 
• 持续性(durability)：事务处理的效果能够被永久保存下来 。

Jdbc的事务默认是打开的，也就是说执行每一步操作的话，事务都会隐式的进行提交，可以取消默认事务：

  
  
  
  

   
   
   
   
connection.setAutoCommit(false);
  
  
  
  

示例代码( 也可以了解下我早期的一个DEMO)

  
  
  
  

   
   
   
   
package net.oseye.DbDemo;
   
   
   
   
 
   
   
   
   
import java.sql.Connection;
   
   
   
   
import java.sql.DriverManager;
   
   
   
   
import java.sql.PreparedStatement;
   
   
   
   
import java.sql.ResultSet;
   
   
   
   
 
   
   
   
   
public class App 
   
   
   
   
{
   
   
   
   
 public static void main( String[] args ) throws Exception
   
   
   
   
 {
   
   
   
   
 Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root","root");
   
   
   
   
 
   
   
   
   
 //取消默认事务
   
   
   
   
 conn.setAutoCommit(false);
   
   
   
   
 PreparedStatement pstmt=conn.prepareStatement("update user set user_name=? where user_id = ?");
   
   
   
   
 pstmt.setString(1, "kevin");
   
   
   
   
 pstmt.setInt(2, 1);
   
   
   
   
 pstmt.execute();
   
   
   
   
 
   
   
   
   
 pstmt=conn.prepareStatement("select user_name from user where user_id=?");
   
   
   
   
 pstmt.setInt(1,1);
   
   
   
   
 ResultSet rs=pstmt.executeQuery();
   
   
   
   
 //提交事务
   
   
   
   
 conn.commit();
   
   
   
   
 
   
   
   
   
 if(rs.next()){
   
   
   
   
 System.out.println("用户名："+rs.getString(1));
   
   
   
   
 } 
   
   
   
   
 rs.close();
   
   
   
   
 pstmt.close();
   
   
   
   
 conn.close();
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

这里没有对事务做深入讨论，看到这儿容易让你产生误会，以为事务如此简单，请正式生产前一定找相关专业书籍学习，切记切记。

JDBC的DataSource

前文提到使用DriverManager获取数据库连接的低效，是因为数据库连接是一种关键的有限而昂贵的资源。所以JDK为我们提供了一个DataSource接口。DataSource作为 DriverManager 工具的替代项，DataSource 对象是获取连接的首选方法。DataSource接口：

  
  
  
  

   
   
   
   
//尝试建立与此 DataSource 对象所表示的数据源的连接。 
   
   
   
   
Connection getConnection() 
   
   
   
   
 
   
   
   
   
//尝试建立与此 DataSource 对象所表示的数据源的连接。
   
   
   
   
Connection getConnection(String username, String password) 
  
  
  
  

有很多容器如Tomcat都实现DataSource接口而提供了连接池功能，现在我们来简单实现一个连接池：

  
  
  
  

   
   
   
   
/**
   
   
   
   
 * 实现DataSource接口的简单连接池
   
   
   
   
 */
   
   
   
   
public class ConnectPool implements DataSource {
   
   
   
   
 private static final String url = "jdbc:mysql://127.0.0.1:3306/test";
   
   
   
   
 private static final String user = "root";
   
   
   
   
 private static final String pswd = "root";
   
   
   
   
 
   
   
   
   
 // 连接池队列
   
   
   
   
 private static LinkedList<Connection> pool = new LinkedList<Connection>();
   
   
   
   
 private static ConnectPool instance = new ConnectPool();
   
   
   
   
 
   
   
   
   
 /**
   
   
   
   
 * 获取数据源单例
   
   
   
   
 */
   
   
   
   
 public static ConnectPool instance() {
   
   
   
   
 if (instance == null)
   
   
   
   
 instance = new ConnectPool();
   
   
   
   
 return instance;
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 /**
   
   
   
   
 * 获取一个数据库连接
   
   
   
   
 */
   
   
   
   
 public Connection getConnection() throws SQLException {
   
   
   
   
 synchronized (pool) {
   
   
   
   
 if (pool.size() > 0) {
   
   
   
   
 return pool.removeFirst();
   
   
   
   
 } else {
   
   
   
   
 return DriverManager.getConnection(url, user, pswd);
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 /**
   
   
   
   
 * 连接归池，这里的实现思想是使用过的线程入池以备下次使用
   
   
   
   
 */
   
   
   
   
 public static void freeConnection(Connection conn) {
   
   
   
   
 pool.addLast(conn);
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 public Connection getConnection(String username, String password)
   
   
   
   
 throws SQLException {
   
   
   
   
 // TODO Auto-generated method stub
   
   
   
   
 return null;
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 public PrintWriter getLogWriter() throws SQLException {
   
   
   
   
 // TODO Auto-generated method stub
   
   
   
   
 return null;
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 public void setLogWriter(PrintWriter out) throws SQLException {
   
   
   
   
 // TODO Auto-generated method stub
   
   
   
   
 
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 public void setLoginTimeout(int seconds) throws SQLException {
   
   
   
   
 // TODO Auto-generated method stub
   
   
   
   
 
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 public int getLoginTimeout() throws SQLException {
   
   
   
   
 // TODO Auto-generated method stub
   
   
   
   
 return 0;
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 public Logger getParentLogger() throws SQLFeatureNotSupportedException {
   
   
   
   
 // TODO Auto-generated method stub
   
   
   
   
 return null;
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 public <T> T unwrap(Class<T> iface) throws SQLException {
   
   
   
   
 // TODO Auto-generated method stub
   
   
   
   
 return null;
   
   
   
   
 }
   
   
   
   
 
   
   
   
   
 public boolean isWrapperFor(Class<?> iface) throws SQLException {
   
   
   
   
 // TODO Auto-generated method stub
   
   
   
   
 return false;
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

使用连接池

  
  
  
  

   
   
   
   
public class App {
   
   
   
   
 public static void main(String[] args) throws Exception {
   
   
   
   
 //没有使用连接池
   
   
   
   
 long start=System.currentTimeMillis();
   
   
   
   
 for (int i = 0; i < 100; i++) {
   
   
   
   
 Connection conn = DriverManager.getConnection(
   
   
   
   
 "jdbc:mysql://127.0.0.1:3306/test",
   
   
   
   
 "root", "root");
   
   
   
   
 
   
   
   
   
 PreparedStatement pstmt = conn
   
   
   
   
 .prepareStatement("insert into user(user_name) values(?)");
   
   
   
   
 pstmt.setString(1, String.valueOf(System.currentTimeMillis()));
   
   
   
   
 pstmt.execute();
   
   
   
   
 
   
   
   
   
 pstmt.close();
   
   
   
   
 conn.close();
   
   
   
   
 }
   
   
   
   
 System.out.println("没有使用连接池花费时间："+(System.currentTimeMillis()-start));
   
   
   
   
 //使用连接池
   
   
   
   
 start=System.currentTimeMillis();
   
   
   
   
 for (int i = 0; i < 100; i++) {
   
   
   
   
 Connection conn=ConnectPool.instance().getConnection();
   
   
   
   
 
   
   
   
   
 PreparedStatement pstmt = conn
   
   
   
   
 .prepareStatement("insert into user(user_name) values(?)");
   
   
   
   
 pstmt.setString(1, String.valueOf(System.currentTimeMillis()));
   
   
   
   
 pstmt.execute();
   
   
   
   
 
   
   
   
   
 pstmt.close();
   
   
   
   
 ConnectPool.freeConnection(conn);
   
   
   
   
 }
   
   
   
   
 System.out.println("使用连接池花费时间："+(System.currentTimeMillis()-start));
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

输出

没有使用连接池花费时间：4625
使用连接池花费时间：2782

示例是使用的单线程就能足以展现出差距了，如果使用多线程会更明显，但多线程就要对连接池进行同步操作，实现起来会更复杂。实例中的连接池实现虽然使用了同步(synchronized )，但是向当地弱，此实现只是简单展示连接池的实现以及使用，禁止把如此简单实现投入生产，切记切记。

开源连接池

有很多产品都实现了自己的连接池，如Jboss、Tomcat等容器，业界也有很多著名的开源连接池供大家使用，如：C3P0、BoneCP、DBCP 、Proxool等。我们以BoneCP连接池为例来展示。

pom.xml增加BoneCP的依赖配置(BoneCP使用了SLF4J，这里暂时没做配置)

  
  
  
  

   
   
   
   
<dependency>
   
   
   
   
 <groupId>com.jolbox</groupId>
   
   
   
   
 <artifactId>bonecp</artifactId>
   
   
   
   
 <version>0.8.0.RELEASE</version>
   
   
   
   
</dependency>
  
  
  
  

App.java代码

  
  
  
  

   
   
   
   
package net.oseye.DbDemo;
   
   
   
   
 
   
   
   
   
import java.sql.Connection;
   
   
   
   
import java.sql.PreparedStatement;
   
   
   
   
import java.sql.SQLException;
   
   
   
   
 
   
   
   
   
import com.jolbox.bonecp.BoneCP;
   
   
   
   
import com.jolbox.bonecp.BoneCPConfig;
   
   
   
   
 
   
   
   
   
public class App {
   
   
   
   
 public static void main(String[] args) {
   
   
   
   
 long start=System.currentTimeMillis();
   
   
   
   
 BoneCP connectionPool = null;
   
   
   
   
 Connection connection = null;
   
   
   
   
 try {
   
   
   
   
 //连接池配置
   
   
   
   
 BoneCPConfig config = new BoneCPConfig();
   
   
   
   
 config.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/test");
   
   
   
   
 config.setUsername("root");
   
   
   
   
 config.setPassword("root");
   
   
   
   
 config.setMinConnectionsPerPartition(5);
   
   
   
   
 config.setMaxConnectionsPerPartition(10);
   
   
   
   
 config.setPartitionCount(1);
   
   
   
   
 
   
   
   
   
 connectionPool = new BoneCP(config);
   
   
   
   
 for (int i = 0; i < 100; i++) {
   
   
   
   
 //获取链接
   
   
   
   
 connection = connectionPool.getConnection();
   
   
   
   
 if (connection != null) {
   
   
   
   
 PreparedStatement pstmt = connection
   
   
   
   
 .prepareStatement("insert into user(user_name) values(?)");
   
   
   
   
 pstmt.setString(1,
   
   
   
   
 String.valueOf(System.currentTimeMillis()));
   
   
   
   
 pstmt.execute();
   
   
   
   
 pstmt.close();
   
   
   
   
 connection.close();
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
 connectionPool.shutdown();
   
   
   
   
 System.out.println("使用BoneCP连接池花费时间："+(System.currentTimeMillis()-start));
   
   
   
   
 } catch (SQLException e) {
   
   
   
   
 e.printStackTrace();
   
   
   
   
 }
   
   
   
   
 }
   
   
   
   
}
  
  
  
  

输出

使用BoneCP连接池花费时间：3531