Java数据库连接——JDBC调用存储过程,事务管理和高级应用

一、JDBC常用的API深入详解及存储过程的调用

相关链接：Jdbc调用存储过程

1、存储过程（Stored Procedure）的介绍

　　我们常用的操作数据库语言SQL语句在执行的时候需要先编译，然后执行，而存储过程（Stored Procedure）是在大型数据库系统中，一组为了完成特定功能的SQL 语句集，存储在数据库中，经过第一次编译后再次调用不需要再次编译，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。存储过程是数据库中的一个重要对象，任何一个设计良好的数据库应用程序都应该用到存储过程。

　　一个存储过程是一个可编程的函数，它在数据库中创建并保存。它可以有SQL语句和一些特殊的控制结构组成。当希望在不同的应用程序或平台上执行相同的函数，或者封装特定功能时，存储过程是非常有用的。数据库中的存储过程可以看做是对编程中面向对象方法的模拟。它允许控制数据的访问方式。


简单来说它的好处主要是：

1.由于数据库执行动作时，是先编译后执行的。然而存储过程是一个编译过的代码块，所以执行效率要比T-SQL语句高。
2.一个存储过程在程序在网络中交互时可以替代大堆的T-SQL语句，所以也能降低网络的通信量，提高通信速率。
3.通过存储过程能够使没有权限的用户在控制之下间接地存取数据库，从而确保数据的安全。

2、JDBC调用无参存储过程

在数据库新建存储过程：



注意：创建的存储过程名称不要加“()”,不然在调用存储过程时会提示如下错误：



代码示例：ProduceDao.java

package com.study.dao;

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.study.db.DBUtil;

/**
* @Description: 存储过程
* @author: Qian
* @date: 2016-4-3 下午4:15:24
*/
public class ProduceDao {
public static void select_nofilter() throws SQLException{
//1.获得连接
Connection conn = DBUtil.getConnection();
//2.获得CallableStatement
CallableStatement cs = conn.prepareCall("call sp_select_nofilter()");
//3.执行存储过程
cs.execute();
//4.处理返回的结果：结果集，出参
ResultSet rs = cs.getResultSet();
/*遍历结果集*/
while(rs.next()){
System.out.println(rs.getString("user_name")+":"+rs.getString("email"));
}
}
}

JDBCTestProduce.java

package com.study.test;

import java.sql.SQLException;

import com.study.dao.ProduceDao;

/**
* @Description: 测试存储过程
* @author: Qian
* @date: 2016-4-3 下午4:24:10
*/
public class JDBCTestProduce {
public static void main(String[] args) throws SQLException {
ProduceDao dao=new ProduceDao();
dao.select_nofilter();
}
}

运行结果：

3、JDBC调用含输入参数存储过程

调用存储过程：传个空字符



传个“小”

//JDBC 调用带输入参数的存储过程
public static List<Goddess> select_filter(String sp_name) throws SQLException{
List<Goddess> result=new ArrayList<Goddess>();
//1.获得连接
Connection conn = DBUtil.getConnection();
//2.获得CallableStatement
CallableStatement cs = conn.prepareCall("call sp_select_filter(?)");
cs.setString(1, sp_name);
//3.执行存储过程
cs.execute();
//4.处理返回的结果：结果集，出参
ResultSet rs = cs.getResultSet();
Goddess g=null;
while(rs.next()){//如果对象中有数据，就会循环打印出来
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUserName(rs.getString("user_name"));
g.setAge(rs.getInt("age"));
result.add(g);
}
return result;
}

测试：

public class JDBCTestProduce {
public static void main(String[] args) throws SQLException {
ProduceDao dao=new ProduceDao();
//        dao.select_nofilter();
String sp_name="";
List<Goddess> res=null;
res=dao.select_filter(sp_name);
for (int i = 0; i < res.size(); i++) {
System.out.println(res.get(i).getId()+":"+res.get(i).getUserName()+":"+res.get(i).getAge());

}
}
}

4、JDBC调用含输出参数存储过程

调用存储过程：

//JDBC 调用含输出参数存储过程
public static Integer select_count() throws SQLException{
Integer count=0;
//1.获得连接
Connection conn = DBUtil.getConnection();
//2.获得CallableStatement,prepareStatement,statement
CallableStatement cs = conn.prepareCall("call sp_select_count(?)");
cs.registerOutParameter(1, Types.INTEGER);//注册输出参数，第二个参数是告诉JDBC，输出参数的类型
//3.执行存储过程
cs.execute();
//4.处理返回的结果：这个不是结果集，是出参
count=cs.getInt(1);
return count;
}

测试：

package com.study.test;

import java.sql.SQLException;
import java.util.List;

import com.study.dao.ProduceDao;
import com.study.model.Goddess;

/**
* @Description: 测试存储过程
* @author: Qian
* @date: 2016-4-3 下午4:24:10
*/
public class JDBCTestProduce {
public static void main(String[] args) throws SQLException {
//        ProduceDao dao=new ProduceDao();
//        dao.select_nofilter();
/*String sp_name="";
List<Goddess> res=null;
res=dao.select_filter(sp_name);
for (int i = 0; i < res.size(); i++) {
System.out.println(res.get(i).getId()+":"+res.get(i).getUserName()+":"+res.get(i).getAge());

}*/
String sp_name="小";
List<Goddess> res=null;
Integer count=0;
//带输入参数的存储过程
/*res=select_filter(sp_name);
showResult(res);*/
count=select_count();
System.out.println(count);
}

public static List<Goddess> select_filter(String sp_name) throws SQLException{
ProduceDao dao=new ProduceDao();
return dao.select_filter(sp_name);
}
public static Integer select_count() throws SQLException{
ProduceDao dao=new ProduceDao();
return dao.select_count();
}

public static void showResult(List<Goddess> result){
for (int i = 0; i < result.size(); i++) {
System.out.println(result.get(i).getId()+":"+result.get(i).getUserName()+":"+result.get(i).getAge());

}
}
}

二、JDBC的事务管理

事务的概念：

事务（transaction）是作为单个逻辑工作单元执行的一系列操作。这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行。

事务的特点：

　　1、原子性（Atomicity）

　　　　事务是一个完整的操作。不能对它进行再分割，是最小的一个单元。

　　2、一致性（Consistency）

　　　　当事务完成时，数据必须处于一致状态。

（例如银行转账，张三要给李四转100元。则第一步张三的账户需要减去100元，第二步李四的账户需要加上100元。这是两个操作，但是应该在一个事务里面。如果没有在一个事务里面，张三减去100，李四并没有增加100，那这样数据就出现了不一致性，张三的钱跑哪去了呢 ）

　　3、隔离性（Isolation）

　　　　对数据进行修改的所有并发事务是彼此隔离的。

（比如业务A:张三减100，李四加100；同时业务B也是张三减100，李四加100进行操作。业务A和B是同时的，这时候就出现了并发，这个时候是怎么变化的呢？当业务员A进行操作的时候，业务员B就要等待……就是同一时间对数据库的操作要保持一个事务的锁定。也就是说我在做的时候，别人是不能做的。我做完了之后别人才能做，彼此之间是隔离的）

　　4、永久性（Durability）

　　　　事务完成后，它对数据库的修改被永久保持。

1、JDBC实现事务管理

①我们通过提交commit()或是回退rollback()来管理事务的操作。

　　当事务完成的时候，我们通过commit将事务提交到数据库之中，然后数据库会变成持久化的，我们的数据就会永久保存了。

　　如果采用rollback的话，事务回滚，比如说我们插入的数据、更新的数据都会变成原来没有更新、没有插入时的样子。

②事务操作默认是自动提交

　　当我们调用完insert语句，不用调用commit语句，自己就提交了。

③可以调用setAutoCommit(false) 来禁止自动提交。

2、通过代码实现事物的管理

　　首先我们要注意，在JDBC中，事务操作默认是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作。操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回退。

　　其次，在JDBC中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成 后调用commit()来进行整体提交。倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常。此时就可以在异常捕获时调用 rollback()进行回退。这样做可以保持多次更新操作后，相关数据的一致性。

try {
conn = DriverManager.getConnection("jdbc:microsoft:sqlserver://localhost:1433;User=JavaDB;Password=javadb;DatabaseName=northwind);
//点禁止自动提交，设置回退
conn.setAutoCommit(false);
stmt = conn.createStatement();
//数据库更新操作1
stmt.executeUpdate(“update firsttable Set Name='testTransaction' Where ID = 1”);
//数据库更新操作2
stmt.executeUpdate(“insert into firsttable ID = 12，Name = 'testTransaction2'”);
//事务提交
conn.commit();
}catch(Exception ex) {
ex.printStackTrace();
try {
//操作不成功则回退
conn.rollback();
}catch(Exception e){
e.printStackTrace();
}
}

这样上面这段程序的执行，或者两个操作都成功，或者两个都不成功，读者可以自己修改第二个操作，使其失败，以此来检查事务处理的效果。

我们在前面还提到了JDBC对事务所支持的隔离级别，下面将更详细进行讨论。

JDBC API支持事务对数据库的加锁，并且提供了5种操作支持，2种加锁密度。

5种加锁支持为：

static int TRANSACTION_NONE = 0;

static int TRANSACTION_READ_UNCOMMITTED = 1;

static int TRANSACTION_READ_COMMITTED = 2;

static int TRANSACTION_REPEATABLE_READ = 4;

static int TRANSACTION_SERIALIZABLE = 8;

具体的说明见表4-2。

2种加锁密度：

最后一项为表加锁，其余3～4项为行加锁。

“脏”数据读写(Dirty Reads)：当一个事务修改了某一数据行的值而未提交时，另一事务读取了此行值。倘若前一事务发生了回退，则后一事务将得到一个无效的值(“脏”数据)。

重复读写(Repeatable Reads)：当一个事务在读取某一数据行时，另一事务同时在修改此数据行。则前一事务在重复读取此行时将得到一个不一致的值。

错 误(映像)读写(Phantom Reads)：当一个事务在某一表中进行数据查询时，另一事务恰好插入了满足了查询条件的数据行。则前一事务在重复读取满足条件的值时，将得到一个额外的 “影像”值。JDBC根据数据库提供的默认值来设置事务支持及其加锁，当然，也可以手工设置：

setTransactionIsolation(TRANSACTION_READ_UNCOMMITTED);

可以查看数据库的当前设置：

getTransactionIsolation ()

需要注意的是，在进行手动设置时，数据库及其驱动程序必须得支持相应的事务操作操作才行。

上 述设置随着值的增加，其事务的独立性增加，更能有效地防止事务操作之间的冲突，同时也增加了加锁的开销，降低了用户之间访问数据库的并发性，程序的运行效 率也会随之降低。因此得平衡程序运行效率和数据一致性之间的冲突。一般来说，对于只涉及到数据库的查询操作时，可以采用 TRANSACTION_READ_UNCOMMITTED方式；对于数据查询远多于更新的操作，可以采用 TRANSACTION_READ_COMMITTED方式；对于更新操作较多的，可以采用TRANSACTION_REPEATABLE_READ；在 数据一致性要求更高的场合再考虑最后一项，由于涉及到表加锁，因此会对程序运行效率产生较大的影响。

另外，在Oracle中数据库驱动对事务处理的默认值是TRANSACTION_NONE，即不支持事务操作，所以需要在程序中手动进行设置。总之，JDBC提供的对数据库事务操作的支持是比较完整的，通过事务操作可以提高程序的运行效率，保持数据的一致性。

三、数据库连接池（dbcp、c3p0）

连接池产生的背景：

　　数据库连接是一种重要资源。大部分很重要的数据都存在数据库里，那么在产生连接池之前，我们连接数据库的方式：直连。（获取连接->使用->关闭连接）程序小的话可以采用这种方式，但是如果程序很大，比如大型网站，它可能每分钟或者每秒变化量在100万次，就是说同时访问数据库有100万个用户，这时候如果我们不用连接池的话，我们就需要创建100万个连接这样的话就会对数据库造成很大的压力，如果数据库承受不了的话就崩溃了，服务器也崩溃了，网站就瘫痪了。

即：

①数据库连接是一种重要资源；

②频繁的连接数据库会增加数据库的压力；

③为解决以上问题出现连接池技术。

（池子里保持一定数量的连接，当使用时就从池子中拿一个连接出来，当使用完连接后就把它释放到池子里。当你同时访问数据库人很多的时候，这个时候连接不够用，就需要等待，减少数据库的压力）

常用的开源数据库连接池：

dbcp

c3p0

1、dbcp使用步骤

　　1、首先，导入相关jar包：



　　2、在项目根目录增加配置文件：dbcp.properties

这个属性文件的内容如下：



　　3、配置并测试dbcp连接

DBCPUtil.java

package com.study.db;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.commons.dbcp2.BasicDataSource;
import org.apache.commons.dbcp2.BasicDataSourceFactory;
/**
* @Description: DBCP配置类
* @author: Qian
* @date: 2016-4-4 上午8:57:49
*/
public class DBCPUtil {
/**数据源，static*/
private static DataSource DS;
private static final String configFile="/dbcp.properties";//配置文件

/**从数据源获得一个连接*/
/**
* @Description: TODO
* @param @return 设定文件
* @return Connection 返回类型
* @author Qian
* @date 2016-4-4 上午9:11:07
*/
public Connection getConn(){
Connection conn=null;
if(DS !=null){
try {
conn=DS.getConnection();//从数据源里面拿到连接
} catch (Exception e) {
e.printStackTrace(System.err);
}
try {
conn.setAutoCommit(false);//关闭连接的自动提交
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}
return conn;
}

/**默认的构造函数*/
/**
* @Description: TODO
* @param
* @return
* @author Qian
* @date 2016-4-4 上午9:17:02
*/
public DBCPUtil(){
initDbcp();
}

private static void initDbcp(){
Properties pops=new Properties();
try {
pops.load(Object.class.getResourceAsStream(configFile));//读取配置文件
DS=BasicDataSourceFactory.createDataSource(pops);//通过BasicDataSourceFactory提供的工厂类，拿到DataSource数据源
} catch (Exception e) {
e.printStackTrace();
}
}
/*构造函数，初始化了DS，指定数据库*/
public DBCPUtil(String connectURI){
initDS(connectURI);
}

/*构造函数，初始化了DS，指定所有参数*/
public DBCPUtil(String connectURI,String userName,String passWord,String driverClass,int initialSize,int maxIdle,int minIdle,int maxWait){
initDS(connectURI,userName,passWord,driverClass,initialSize,maxIdle,minIdle,maxWait);
}

/**
* @Description: 创建数据源，除了数据外，都是用硬编码默认参数
* @param @param connectURI 数据库
* @return
* @author Qian
* @date 2016-4-4 上午9:47:18
*/
public static void initDS(String connectURI){
initDS(connectURI, "root", "root",     "com.mysql.jdbc.Driver", 10, 20, 5, 1000);
}

/**
* @Description:
* @param @param connectURI 数据库
* @param @param userName 用户名
* @param @param passWord 密码
* @param @param driverClass 驱动
* @param @param initialSize 初始化连接数
* @param @param maxIdle 最大连接数
* @param @param minIdle 最小连接数
* @param @param maxWait 超时等待时间（获得连接的最大等待毫秒数）
* @return
* @author Qian
* @date 2016-4-4 上午9:45:18
*/
public static void initDS(String connectURI,String userName,String passWord,String driverClass,
int initialSize,int maxIdle,int minIdle,int maxWait){
BasicDataSource ds=new BasicDataSource();//new 一个数据源
ds.setDriverClassName(driverClass);
ds.setUsername(userName);
ds.setPassword(passWord);
ds.setUrl(connectURI);
ds.setInitialSize(initialSize);//初始的连接数
ds.setMaxIdle(maxIdle);
ds.setMaxWaitMillis(maxWait);
ds.setMinIdle(minIdle);
DS = ds;
}
}

GoddessDao.java

//查询单个女神(根据id去查询)
public Goddess get(Integer id) throws SQLException{
Goddess g=null;
Connection con=DBUtil.getConnection();//首先拿到数据库的连接
String sql="" +
"select * from imooc_goddess "+
"where id=?";//参数用?表示，相当于占位符;用mysql的日期函数current_date()来获取当前日期
//预编译sql语句
PreparedStatement psmt = con.prepareStatement(sql);
//先对应SQL语句，给SQL语句传递参数
psmt.setInt(1, id);
//执行SQL语句
/*psmt.execute();*///execute()方法是执行更改数据库操作（包括新增、修改、删除）;executeQuery()是执行查询操作
ResultSet rs = psmt.executeQuery();//返回一个结果集
//遍历结果集
while(rs.next()){
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUserName(rs.getString("user_name"));
g.setAge(rs.getInt("age"));
g.setSex(rs.getInt("sex"));
//rs.getDate("birthday")获得的是java.sql.Date类型。注意：java.sql.Date类型是java.util.Date类型的子集，所以这里不需要进行转换了。
g.setBirthday(rs.getDate("birthday"));
g.setEmail(rs.getString("email"));
g.setMobile(rs.getString("mobile"));
g.setCreateUser(rs.getString("create_user"));
g.setCreateDate(rs.getDate("create_date"));
g.setUpdateUser(rs.getString("update_user"));
g.setUpdateDate(rs.getDate("update_date"));
g.setIsDel(rs.getInt("isdel"));
}
return g;
}

//查询单个女神(根据id去查询)
public Goddess getByDbcp(Integer id) throws SQLException{
DBCPUtil db=new DBCPUtil();
Goddess g=null;
Connection con=db.getConn();//首先拿到数据库的连接
String sql="" +
"select * from imooc_goddess "+
"where id=?";//参数用?表示，相当于占位符;用mysql的日期函数current_date()来获取当前日期
//预编译sql语句
PreparedStatement psmt = con.prepareStatement(sql);
//先对应SQL语句，给SQL语句传递参数
psmt.setInt(1, id);
//执行SQL语句
/*psmt.execute();*///execute()方法是执行更改数据库操作（包括新增、修改、删除）;executeQuery()是执行查询操作
ResultSet rs = psmt.executeQuery();//返回一个结果集
//遍历结果集
while(rs.next()){
g=new Goddess();
g.setId(rs.getInt("id"));
g.setUserName(rs.getString("user_name"));
g.setAge(rs.getInt("age"));
g.setSex(rs.getInt("sex"));
//rs.getDate("birthday")获得的是java.sql.Date类型。注意：java.sql.Date类型是java.util.Date类型的子集，所以这里不需要进行转换了。
g.setBirthday(rs.getDate("birthday"));
g.setEmail(rs.getString("email"));
g.setMobile(rs.getString("mobile"));
g.setCreateUser(rs.getString("create_user"));
g.setCreateDate(rs.getDate("create_date"));
g.setUpdateUser(rs.getString("update_user"));
g.setUpdateDate(rs.getDate("update_date"));
g.setIsDel(rs.getInt("isdel"));
}
return g;
}

测试：

package com.study.test;

import java.util.Date;

import com.study.dao.GoddessDao;
import com.study.model.Goddess;

/**@Description: 测试用DBCP连接数据库
* @author: Qian
* @date: 2016-4-4 上午9:53:53
*/
public class TestDbcp {

/**@Description: TODO
* @param @param args
* @return
* @author Qian
* @throws Exception
* @date 2016-4-4 上午9:53:53
*/
public static void main(String[] args) throws Exception {
//1.通过普通方式操作数据库
Date a=new Date();
get();
Date b=new Date();
System.out.println(b.getTime()-a.getTime());

//2.通过DBCP连接池的方式操作数据库
Date c=new Date();
get();
Date d=new Date();
System.out.println(d.getTime()-c.getTime());

/**
* 通过运行，发现第二种方式明显要比第一种用时少
*/
}

public static void get() throws Exception{
GoddessDao dao=new GoddessDao();
Goddess g=dao.get(1);
System.out.println(g.toString());
}

public static void getByDbcp() throws Exception{
GoddessDao dao=new GoddessDao();
Goddess g=dao.getByDbcp(1);
System.out.println(g.toString());
}
}

2、c3p0使用步骤

　　c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。

默认情况下（即没有配置连接池的情况下），Hibernate会采用内建的连接池。但这个连接池性能不佳，因此官方也只是建议仅在开发环境下使用。Hibernate支持第三方的连接池，官方推荐的连接池是C3P0,Proxool。

　　1、导入相关jar包：



注：在tomcat或者项目中引入最新版的C3P0的JAR包（我是用的是c3p0-0.9.2.1.jar）

如果启动时报类没有找到：Caused by: java.lang.NoClassDefFoundError: com/mchange/v2/ser/Indirector，

则需要加入mchange-commons-java-0.2.3.4.jar。

　　2、在项目根目录增加配置文件：c3p0.properties

c3p0.driverClass=com.mysql.jdbc.Driver
c3p0.jdbcUrl=jdbc:mysql://localhost:3306/demo_jdbc
c3p0.user=root
c3p0.password=root

　　3、编写类文件，创建连接池

C3P0Util.java

package com.study.db;

import java.sql.Connection;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;

/**@Description: c3p0数据源配置类
* @author: Qian
* @date: 2016-4-4 上午10:40:01
*/
public class C3P0Util {
//创建一个数据源
private static ComboPooledDataSource ds=new ComboPooledDataSource();

public static Connection getConn(){
try {
return ds.getConnection();
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}

TestC3p0.java

package com.study.test;

import java.sql.Connection;
import java.sql.SQLException;

import com.study.db.C3P0Util;

/**@Description: 测试C3P0
* @author: Qian
* @date: 2016-4-4 上午10:43:11
*/
public class TestC3p0 {

/**@Description: TODO
* @param @param args
* @return
* @author Qian
* @throws SQLException
* @date 2016-4-4 上午10:43:11
*/
public static void main(String[] args) throws SQLException {
Connection con=C3P0Util.getConn();
System.out.println(con.getCatalog());

}

}

可以仿照上面dbcp来测试c3p0连接池。

3、连接池总结

DBCP和C3P0的相同点：



DBCP和C3P0的不同点：

四、JDBC的替代产品（Hibernate、Mybatis）

上面介绍的都是手工的连接数据库，写SQL语句。这部分的替代产品会替代我们的这些工作。

替代工具：

Commons-dbutils;

Hibernate;

Mybatis;

1、Commons-dbutils　

从字面意思可以理解为：通用的数据库工具类。

Apache组织提供的一个开源JDBC工具类库，对传统操作数据库的类进行二次封装，可以把结果集转化成List。

特点：



核心接口：



示例：

2、Hibernate简介

　　是一种Java语言下的对象关系映射解决方案。它是一种自由、开源的软件。

优点：



缺点：

如果对大量的数据进行频繁的操作，性能效率比较低，不如直接使用JDBC。（因为Hibernate做了完整的封装，所以效率可能会低。）

核心接口：





示例：



*.hbm.xml



插入：

3、Mybatis简介

　　Mybatis是支持普通SQL查询，存储过程和高级映射的优秀持久层框架。

特点：



示例：



userMapper.xml示例