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

---