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链接步骤

链接数据库；
创建执行声明；
执行Sql语句；
处理结果；
释放资源；
以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

上面的示例有两个缺点：

使用DriverManager获得数据库连接。这种方式效率低，并且其性能、可靠性和稳定性随着用户访问量得增加逐渐下降，应该使用连接池取而代之(后文再讲);

应该使用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