一、JDBC相关概念介绍
数据库驱动
这里的驱动的概念和平时听到的那种驱动的概念是一样的，比如平时购买的声卡，网卡直接插到计算机上面是不能用的，必须要安装相应的驱动程序之后才能够使用声卡和网卡，同样道理，我们安装好数据库之后，我们的应用程序也是不能直接使用数据库的，必须要通过相应的数据库驱动程序，通过驱动程序去和数据库打交道，如下所示：
JDBC介绍
SUN公司为了简化、统一对数据库的操作，定义了一套Java操作数据库的规范（接口），称之为JDBC。这套接口由数据库厂商去实现，这样，开发人员只需要学习jdbc接口，并通过jdbc加载具体的驱动，就可以操作数据库。如下图所示：
JDBC全称为：Java Data Base Connectivity（java数据库连接），它主要由接口组成。
组成JDBC的２个包：
- java.sql
- javax.sql
开发JDBC应用需要以上2个包的支持外，还需要导入相应JDBC的数据库实现(即数据库驱动)。
二、编写JDBC程序
搭建实验环境
安装数据库，在mysql中创建一个库，并创建user表和插入表的数据。
create database jdbcStudy character set utf8 collate utf8_general_ci;
use jdbcStudy;
create table users(
id int primary key,
name varchar(40),
password varchar(40),
email varchar(60),
birthday date
);
insert into users(id,name,password,email,birthday) values(1,'zhansan','123456','zs@sina.com','1980-12-04');
insert into users(id,name,password,email,birthday) values(2,'lisi','123456','lisi@sina.com','1981-12-04');
insert into users(id,name,password,email,birthday) values(3,'wangwu','123456','wangwu@sina.com','1979-12-04');2、导入mysql驱动
<!-- mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.49</version>
</dependency>3、编写程序从user表中读取数据，并打印在控制台中。
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
public class JdbcFirstDemo {
public static void main(String[] args) throws Exception {
//要连接的数据库URL
String url = "jdbc:mysql://localhost:3306/jdbcStudy";
//连接的数据库时使用的用户名
String username = "root";
//连接的数据库时使用的密码
String password = "XDP";
//1.加载驱动
//DriverManager.registerDriver(new com.mysql.jdbc.Driver());不推荐使用这种方式来加载驱动
Class.forName("com.mysql.jdbc.Driver");//推荐使用这种方式来加载驱动
//2.获取与数据库的链接
Connection conn = DriverManager.getConnection(url, username, password);
//3.获取用于向数据库发送sql语句的statement
Statement st = conn.createStatement();
String sql = "select id,name,password,email,birthday from users";
//4.向数据库发sql,并获取代表结果集的resultset
ResultSet rs = st.executeQuery(sql);
//5.取出结果集的数据
while(rs.next()){
System.out.println("id=" + rs.getObject("id"));
System.out.println("name=" + rs.getObject("name"));
System.out.println("password=" + rs.getObject("password"));
System.out.println("email=" + rs.getObject("email"));
System.out.println("birthday=" + rs.getObject("birthday"));
}
//6.关闭链接，释放资源
rs.close();
st.close();
conn.close();
}
}DriverManager类
Jdbc程序中的DriverManager用于加载驱动，并创建与数据库的链接，这个API的常用方法：
- DriverManager.registerDriver(new Driver())
- DriverManager.getConnection(url, user, password)
在实际开发中并不推荐采用registerDriver方法注册驱动。原因有二：
- 查看Driver的源代码可以看到，如果采用此种方式，会导致驱动程序注册两次，也就是在内存中会有两个Driver对象。
- 程序依赖mysql的api，脱离mysql的jar包，程序将无法编译，将来程序切换底层数据库将会非常麻烦。
推荐方式：Class.forName("com.mysql.jdbc.Driver");
采用此种方式不会导致驱动对象在内存中重复出现，并且采用此种方式，程序仅仅只需要一个字符串，不需要依赖具体的驱动，使程序的灵活性更高。
数据库URL讲解
URL用于标识数据库的位置，通过URL地址告诉JDBC程序连接哪个数据库，URL的写法为：
常用数据库URL地址的写法：
- Oracle写法：jdbc:oracle:thin:@localhost:1521:sid
- SqlServer写法：jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=sid
- MySql写法：jdbc:mysql://localhost:3306/sid
如果连接的是本地的Mysql数据库，并且连接使用的端口是3306，那么的url地址可以简写为： jdbc:mysql:///数据库
Connection类
Jdbc程序中的Connection，它用于代表数据库的链接，Collection是数据库编程中最重要的一个对象，客户端与数据库所有交互都是通过connection对象完成的，这个对象的常用方法：
- createStatement()：创建向数据库发送sql的statement对象。
- prepareStatement(sql) ：创建向数据库发送预编译sql的PrepareSatement对象。
- prepareCall(sql)：创建执行存储过程的callableStatement对象。
- setAutoCommit(boolean autoCommit)：设置事务是否自动提交。
- commit() ：在链接上提交事务。
- rollback() ：在此链接上回滚事务。
Statement类
Jdbc程序中的Statement对象用于向数据库发送SQL语句， Statement对象常用方法：
- executeQuery(String sql) ：用于向数据发送查询语句。
- executeUpdate(String sql)：用于向数据库发送insert、update或delete语句
- execute(String sql)：用于向数据库发送任意sql语句
- addBatch(String sql) ：把多条sql语句放到一个批处理中。
- executeBatch()：向数据库发送一批sql语句执行。
PreparedStatement类
PreperedStatement是Statement的子类，它的实例对象可以通过调用Connection.preparedStatement()方法获得，相对于Statement对象而言：PreperedStatement可以避免SQL注入的问题。
Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。PreparedStatement可对SQL进行预编译，从而提高数据库的执行效率。并且PreperedStatement对于sql中的参数，允许使用占位符的形式进行替换，简化sql语句的编写。
PreperedStatement对象设置参数的下标是从1开始的。
ResultSet类
Jdbc程序中的ResultSet用于代表Sql语句的执行结果。Resultset封装执行结果时，采用的类似于表格的方式。ResultSet 对象维护了一个指向表格数据行的游标，初始的时候，游标在第一行之前，调用ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法获取该行的数据。
ResultSet既然用于封装执行结果的，所以该对象提供的都是用于获取数据的get方法：
(1) 获取任意类型的数据
- getObject(int index)：index从1开始
- getObject(string columnName)
(2) 获取指定类型的数据
- getString(int index)：index从1开始
- getString(String columnName)
ResultSet还提供了对结果集进行滚动的方法：
- next()：移动到下一行
- Previous()：移动到前一行
- absolute(int row)：移动到指定行
- beforeFirst()：移动resultSet的最前面。
- afterLast() ：移动到resultSet的最后面。
释放资源
Jdbc程序运行完后，切记要释放程序在运行过程中，创建的那些与数据库进行交互的对象，这些对象通常是ResultSet, Statement和Connection对象，特别是Connection对象，它是非常稀有的资源，用完后必须马上释放，如果Connection不能及时、正确的关闭，极易导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。
为确保资源释放代码能运行，资源释放代码也一定要放在finally语句中。
JdbcUtils工具类
在db.properties中编写MySQL数据库的连接信息：
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/os_app
username=root
password=XDP编写一个JdbcUtils工具类，用于连接数据库，获取数据库连接和释放数据库连接。
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JdbcUtils {
private static String driver = null;
private static String url = null;
private static String username = null;
private static String password = null;
static{
try{
//读取db.properties文件中的数据库连接信息
InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
Properties prop = new Properties();
prop.load(in);
//获取数据库连接驱动
driver = prop.getProperty("driver");
//获取数据库连接URL地址
url = prop.getProperty("url");
//获取数据库连接用户名
username = prop.getProperty("username");
//获取数据库连接密码
password = prop.getProperty("password");
//加载数据库驱动
Class.forName(driver);
}catch (Exception e) {
throw new ExceptionInInitializerError(e);
}
}
/**
* @Method: getConnection
* @Description: 获取数据库连接对象
*
* @return Connection数据库连接对象
* @throws SQLException
*/
public static Connection getConnection() throws SQLException{
return DriverManager.getConnection(url, username,password);
}
/**
* @Method: release
* @Description: 释放资源，
* 要释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
* @param conn
* @param st
* @param rs
*/
public static void release(Connection conn,Statement st,ResultSet rs){
if(rs!=null){
try{
//关闭存储查询结果的ResultSet对象
rs.close();
}catch (Exception e) {
e.printStackTrace();
}
rs = null;
}
if(st!=null){
try{
//关闭负责执行SQL命令的Statement对象
st.close();
}catch (Exception e) {
e.printStackTrace();
}
}
if(conn!=null){
try{
//关闭Connection数据库连接对象
conn.close();
}catch (Exception e) {
e.printStackTrace();
}
}
}
}三、处理MySQL大数据字段
大数据也称之为LOB(Large Objects)，LOB又分为：clob和blob，clob用于存储大文本，blob用于存储二进制数据，例如图像、声音、二进制文等。
在实际开发中，有时是需要用程序把大文本或二进制数据直接保存到数据库中进行储存的。
对MySQL而言只有blob，而没有clob，mysql存储大文本采用的是Text，Text和blob分别又分为：
- TINYTEXT、TEXT、MEDIUMTEXT和LONGTEXT
- TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB
处理大文本数据
对于MySQL中的Text类型，可调用如下方法设置：
PreparedStatement.setCharacterStream(index, reader, length);//注意length长度须设置，并且设置为int型对MySQL中的Text类型，可调用如下方法获取：
reader = resultSet. getCharacterStream(String columnLabel);2 string s = resultSet.getString(String columnLabel);处理二进制数据
对于MySQL中的BLOB类型，可调用如下方法设置：
PreparedStatement.setBinaryStream(i, inputStream, length);对MySQL中的BLOB类型，可调用如下方法获取：
InputStream in = resultSet.getBinaryStream(String columnLabel);
InputStream in = resultSet.getBlob(String columnLabel).getBinaryStream(); 四、使用JDBC进行批处理
在实际的项目开发中，有时候需要向数据库发送一批SQL语句执行，这时应避免向数据库一条条的发送执行，而应采用JDBC的批处理机制，以提升执行效率。
JDBC实现批处理有两种方式：statement和preparedstatement
使用Statement完成批处理
使用Statement对象添加要批量执行SQL语句，如下：
Statement.addBatch(sql1);
Statement.addBatch(sql2);
Statement.addBatch(sql3);执行批处理SQL语句：Statement.executeBatch();
清除批处理命令：Statement.clearBatch();
使用Statement完成批处理范例
1、编写测试的SQL脚本创建表
create table testbatch
(
id int primary key,
name varchar(20)
);2、编写测试代码，如下所示：
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import me.gacl.utils.JdbcUtils;
import org.junit.Test;
/**
* @ClassName: JdbcBatchHandleByStatement
* @Description: 使用Statement实现JDBC批处理操作
*
*/
public class JdbcBatchHandleByStatement {
@Test
public void testJdbcBatchHandleByStatement(){
Connection conn = null;
Statement st = null;
ResultSet rs = null;
try{
conn = JdbcUtils.getConnection();
String sql1 = "insert into testbatch(id,name) values(1,'aaa')";
String sql2 = "insert into testbatch(id,name) values(2,'bbb')";
String sql3 = "insert into testbatch(id,name) values(3,'CCC')";
String sql4 = "insert into testbatch(id,name) values(4,'DDD')";
String sql5 = "update testbatch set name='gacl' where id=1";
String sql6 = "insert into testbatch(id,name) values(5,'FFF')";
String sql7 = "delete from testbatch where id=2";
st = conn.createStatement();
//添加要批量执行的SQL
st.addBatch(sql1);
st.addBatch(sql2);
st.addBatch(sql3);
st.addBatch(sql4);
st.addBatch(sql5);
st.addBatch(sql6);
st.addBatch(sql7);
//执行批处理SQL语句
st.executeBatch();
//清除批处理命令
st.clearBatch();
}catch (Exception e) {
e.printStackTrace();
}finally{
JdbcUtils.release(conn, st, rs);
}
}
}采用Statement.addBatch(sql)方式实现批处理的优缺点
优点：可以向数据库发送多条不同的SQL语句。
缺点：① SQL语句没有预编译。② 当向数据库发送多条语句相同，但仅参数不同的SQL语句时，需重复写上很多条SQL语句。
insert into user(name,password) values('aa','111');
insert into user(name,password) values('bb','222');
insert into user(name,password) values('cc','333');
insert into user(name,password) values('dd','444');使用PreparedStatement完成批处理
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import me.gacl.utils.JdbcUtils;
import org.junit.Test;
/**
* @ClassName: JdbcBatchHandleByStatement
* @Description: 使用prepareStatement实现JDBC批处理操作
*
*/
public class JdbcBatchHandleByPrepareStatement {
@Test
public void testJdbcBatchHandleByPrepareStatement(){
long starttime = System.currentTimeMillis();
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try{
conn = JdbcUtils.getConnection();
String sql = "insert into testbatch(id,name) values(?,?)";
st = conn.prepareStatement(sql);
for(int i=1;i<1000008;i++){ //i=1000 2000
st.setInt(1, i);
st.setString(2, "aa" + i);
st.addBatch();
if(i%1000==0){
st.executeBatch();
st.clearBatch();
}
}
st.executeBatch();
}catch (Exception e) {
e.printStackTrace();
}finally{
JdbcUtils.release(conn, st, rs);
}
long endtime = System.currentTimeMillis();
System.out.println("程序花费时间：" + (endtime-starttime)/1000 + "秒！！");
}
}优点：发送的是预编译后的SQL语句，执行效率高。
缺点：只能应用在SQL语句相同，但参数不同的批处理中。因此此种形式的批处理经常用于在同一个表中批量插入数据，或批量更新表的数据。
五、获得MySQL数据库自动生成的主键
SQL脚本：
create table test1
(
id int primary key auto_increment,
name varchar(20)
);import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import me.gacl.utils.JdbcUtils;
public class Test {
public static void main(String[] args) {
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try{
conn = JdbcUtils.getConnection();
String sql = "insert into test1(name) values(?)";
st = conn.prepareStatement(sql);
st.setString(1, "aaa");
st.executeUpdate();
//获取数据库自动生成的主键
rs = st.getGeneratedKeys();
if(rs.next()){
System.out.println(rs.getInt(1));
}
}catch (Exception e) {
e.printStackTrace();
}finally{
JdbcUtils.release(conn, st, rs);
}
}
}六、事务
事务指逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功。
例如：A——B转帐，对应于如下两条sql语句
update from account set money=money+100 where name='B';
update from account set money=money-100 where name='A';MySQL数据库中操作事务命令
编写测试SQL脚本
/*创建账户表*/
create table account(
id int primary key auto_increment,
name varchar(40),
money float
);
/*插入测试数据*/
insert into account(name,money) values('A',1000);
insert into account(name,money) values('B',1000);
insert into account(name,money) values('C',1000);下面我们在MySQL数据库中模拟A——B转帐这个业务场景。
1、开启事务(start transaction)
使用"start transaction"开启MySQL数据库的事务。
我们首先在数据库中模拟转账失败的场景，首先执行update语句让A用户的money减少100块钱，如下图所示：
然后我们关闭当前操作的dos命令行窗口，这样就导致了刚才执行的update语句的数据库的事务没有被提交，那么我们对A用户的修改就不算是是真正的修改了，下次在查询A用户的money时，依然还是之前的1000，如下图所示：
2、提交事务(commit)
下面我们在数据库模拟A——B转账成功的场景
我们手动提交(commit)数据库事务之后，A——B转账100块钱的这个业务操作算是真正成功了，A账户中少了100，B账户中多了100。
3、回滚事务(rollback)
通过手动回滚事务，让所有的操作都失效，这样数据就会回到最初的初始状态！
JDBC中使用事务
当Jdbc程序向数据库获得一个Connection对象时，默认情况下这个Connection对象会自动向数据库提交在它上面发送的SQL语句。若想关闭这种默认提交方式，让多条SQL在一个事务中执行，可使用下列的JDBC控制事务语句：
- Connection.setAutoCommit(false);//开启事务(start transaction)
- Connection.rollback();//回滚事务(rollback)
- Connection.commit();//提交事务(commit)
JDBC中使用事务范例
在JDBC代码中演示银行转帐案例，使如下转帐操作在同一事务中执行：
update account set money=money-100 where name='A'
update account set money=money+100 where name='B'代码如下：
public class TransactionDemo1 {
/**
* @Method: testTransaction1
* @Description: 模拟转账成功时的业务场景
*/
@Test
public void testTransaction1(){
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try{
conn = JdbcUtils.getConnection();
conn.setAutoCommit(false);//通知数据库开启事务(start transaction)
String sql1 = "update account set money=money-100 where name='A'";
st = conn.prepareStatement(sql1);
st.executeUpdate();
String sql2 = "update account set money=money+100 where name='B'";
st = conn.prepareStatement(sql2);
st.executeUpdate();
conn.commit();//上面的两条SQL执行Update语句成功之后就通知数据库提交事务(commit)
System.out.println("成功！！！"); //log4j
}catch (Exception e) {
e.printStackTrace();
}finally{
JdbcUtils.release(conn, st, rs);
}
}
/**
* @Method: testTransaction1
* @Description: 模拟转账过程中出现异常导致有一部分SQL执行失败后让数据库自动回滚事务
*/
@Test
public void testTransaction2(){
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try{
conn = JdbcUtils.getConnection();
conn.setAutoCommit(false);//通知数据库开启事务(start transaction)
String sql1 = "update account set money=money-100 where name='A'";
st = conn.prepareStatement(sql1);
st.executeUpdate();
//用这句代码模拟执行完SQL1之后程序出现了异常而导致后面的SQL无法正常执行，事务也无法正常提交，此时数据库会自动执行回滚操作
int x = 1/0;
String sql2 = "update account set money=money+100 where name='B'";
st = conn.prepareStatement(sql2);
st.executeUpdate();
conn.commit();//上面的两条SQL执行Update语句成功之后就通知数据库提交事务(commit)
System.out.println("成功！！！");
}catch (Exception e) {
e.printStackTrace();
}finally{
JdbcUtils.release(conn, st, rs);
}
}
/**
* @Method: testTransaction1
* @Description: 模拟转账过程中出现异常导致有一部分SQL执行失败时手动通知数据库回滚事务
*/
@Test
public void testTransaction3(){
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try{
conn = JdbcUtils.getConnection();
conn.setAutoCommit(false);//通知数据库开启事务(start transaction)
String sql1 = "update account set money=money-100 where name='A'";
st = conn.prepareStatement(sql1);
st.executeUpdate();
//用这句代码模拟执行完SQL1之后程序出现了异常而导致后面的SQL无法正常执行，事务也无法正常提交
int x = 1/0;
String sql2 = "update account set money=money+100 where name='B'";
st = conn.prepareStatement(sql2);
st.executeUpdate();
conn.commit();//上面的两条SQL执行Update语句成功之后就通知数据库提交事务(commit)
System.out.println("成功！！！");
}catch (Exception e) {
try {
//捕获到异常之后手动通知数据库执行回滚事务的操作
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally{
JdbcUtils.release(conn, st, rs);
}
}
}设置事务回滚点
在开发中，有时候可能需要手动设置事务的回滚点，在JDBC中使用如下的语句设置事务回滚点：
- Savepoint sp = conn.setSavepoint();
- Conn.rollback(sp);
- Conn.commit();//回滚后必须通知数据库提交事务
设置事务回滚点范例：
public class TransactionDemo2 {
/**
* @Method: testTransaction1
* @Description: 模拟转账成功时的业务场景
*/
@Test
public void testTransaction1(){
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
Savepoint sp = null;
try{
conn = JdbcUtils.getConnection();
conn.setAutoCommit(false);//通知数据库开启事务(start transaction)
String sql1 = "update account set money=money-100 where name='A'";
st = conn.prepareStatement(sql1);
st.executeUpdate();
//设置事务回滚点
sp = conn.setSavepoint();
String sql2 = "update account set money=money+100 where name='B'";
st = conn.prepareStatement(sql2);
st.executeUpdate();
//程序执行到这里出现异常，后面的sql3语句执行将会中断
int x = 1/0;
String sql3 = "update account set money=money+100 where name='C'";
st = conn.prepareStatement(sql3);
st.executeUpdate();
conn.commit();
}catch (Exception e) {
try {
/**
* 我们在上面向数据库发送了3条update语句，
* sql3语句由于程序出现异常导致无法正常执行，数据库事务而已无法正常提交，
* 由于设置的事务回滚点是在sql1语句正常执行完成之后，sql2语句正常执行之前,
* 那么通知数据库回滚事务时，不会回滚sql1执行的update操作
* 只会回滚到sql2执行的update操作，也就是说，上面的三条update语句中，sql1这条语句的修改操作起作用了
* sql2的修改操作由于事务回滚没有起作用，sql3由于程序异常没有机会执行
*/
conn.rollback(sp);//回滚到设置的事务回滚点
//回滚了要记得通知数据库提交事务
conn.commit();
} catch (SQLException e1) {
e1.printStackTrace();
}
e.printStackTrace();
}finally{
JdbcUtils.release(conn, st, rs);
}
}
}事务的四大特性（ACID）
原子性（Atomicity）
原子性是指事务是一个不可分割的工作单位，事务中的操作要么全部成功，要么全部失败。比如在同一个事务中的SQL语句，要么全部执行成功，要么全部执行失败。
一致性（Consistency）
官网上事务一致性的概念是：事务必须使数据库从一个一致性状态变换到另外一个一致性状态。以转账为例子，A向B转账，假设转账之前这两个用户的钱加起来总共是2000，那么A向B转账之后，不管这两个账户怎么转，A用户的钱和B用户的钱加起来的总额还是2000，这个就是事务的一致性。
隔离性（Isolation）
事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。
提示：事务的四大特性中最麻烦的是隔离性。
事务的隔离级别
多个线程开启各自事务操作数据库中数据时，数据库系统要负责隔离操作，以保证各个线程在获取数据时的准确性。
事务不考虑隔离性可能会引发的问题
1、脏读
脏读指一个事务读取了另外一个事务未提交的数据。
这是非常危险的，假设Ａ向Ｂ转帐100元，对应sql语句如下所示：
① update account set money=money+100 where name='B';
② update account set money=money-100 where name='A';
当第①条sql执行完，第②条还没执行(A未提交时)，如果此时Ｂ查询自己的帐户，就会发现自己多了100元钱。如果A等B走后再回滚，B就会损失100元。
2、不可重复读
不可重复读指在一个事务内读取表中的某一行数据，多次读取结果不同。
例如银行想查询A帐户余额，第一次查询A帐户为200元，此时A向帐户内存了100元并提交了，银行接着又进行了一次查询，此时A帐户为300元了。银行两次查询不一致，可能就会很困惑，不知道哪次查询是准的。
不可重复读和脏读的区别是，脏读是读取前一事务未提交的脏数据，不可重复读是重新读取了前一事务已提交的数据。
很多人认为这种情况就对了，无须困惑，当然是后面的为准。我们可以考虑这样一种情况，比如银行程序需要将查询结果分别输出到电脑屏幕和写到文件中，结果在一个事务中针对输出的目的地，进行的两次查询不一致，导致文件和屏幕中的结果不一致，银行工作人员就不知道以哪个为准了。
3、虚读(幻读)
虚读(幻读)是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。
如丙存款100元未提交，这时银行做报表统计account表中所有用户的总额为500元，然后丙提交了，这时银行再统计发现帐户为600元了，造成虚读同样会使银行不知所措，到底以哪个为准。
事务隔离性的设置语句
MySQL数据库共定义了四种隔离级别：
- Serializable(串行化)：可避免脏读、不可重复读、虚读情况的发生。
- Repeatable read(可重复读)：可避免脏读、不可重复读情况的发生。
- Read committed(读已提交)：可避免脏读情况发生。
- Read uncommitted(读未提交)：最低级别，以上情况均无法保证。
mysql数据库查询当前事务隔离级别：select @@tx_isolation
mysql数据库默认的事务隔离级别是：Repeatable read(可重复读)
mysql数据库设置事务隔离级别：set transaction isolation level 隔离级别名
使用MySQL数据库演示不同隔离级别下的并发问题
同时打开两个窗口模拟2个用户并发访问数据库。
① 当把事务的隔离级别设置为read uncommitted时，会引发脏读、不可重复读和虚读
A窗口
set transaction isolation level read uncommitted;--设置A用户的数据库隔离级别为Read uncommitted(读未提交)
start transaction;--开启事务
select * from account;--查询A账户中现有的钱，转到B窗口进行操作
select * from account--发现a多了100元，这时候A读到了B未提交的数据（脏读）B窗口
start transaction;--开启事务
update account set money=money+100 where name='A';--不要提交，转到A窗口查询② 当把事务的隔离级别设置为read committed时，会引发不可重复读和虚读，但避免了脏读
A窗口
set transaction isolation level read committed;
start transaction;
select * from account;--发现a帐户是1000元，转到b窗口
select * from account;--发现a帐户多了100,这时候，a读到了别的事务提交的数据，两次读取a帐户读到的是不同的结果（不可重复读）B窗口
start transaction;
update account set money=money+100 where name='aaa';
commit;--转到a窗口③ 当把事务的隔离级别设置为repeatable read(mysql默认级别)时，会引发虚读，但避免了脏读、不可重复读
A窗口
set transaction isolation level repeatable read;
start transaction;
select * from account;--发现表有4个记录，转到b窗口
select * from account;--可能发现表有5条记录，这时候发生了a读取到另外一个事务插入的数据（虚读）B窗口
start transaction;
insert into account(name,money) values('ggg',1000);
commit;--转到a窗口④ 当把事务的隔离级别设置为Serializable时，会避免所有问题
A窗口
set transaction isolation level Serializable;
start transaction;
select * from account;--转到b窗口
B窗口
start transaction;
insert into account(name,money) values('ggg',1000);--发现不能插入，只能等待a结束事务才能插入七、数据库连接池
应用程序直接获取数据库连接的缺点
用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、宕机。
数据库连接池的基本概念
数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现的尤为突出.对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标.数据库连接池正式针对这个问题提出来的.数据库连接池负责分配,管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。如下图所示：
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中，这些数据库连接的数量是由最小数据库连接数来设定的。无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量。接池的最大数据库连接数量限定了这个连接池能占有的最大连接数，当应用程序向连接池请求的连接数超过最大连接数量时，这些请求将被加入到等待队列中。
数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素：
- 最小连接数：是连接池一直保持的数据库连接，所以如果应用程序对数据库连接的使用量不大，将会有大量的数据库连接资源被浪。
- 最大连接数：是连接池能申请的最大连接数，如果数据库连接请求超过次数，后面的数据库连接请求将被加入到等待队列中，这会影响以后的数据库操作。
- 如果最小连接数与最大连接数相差很大：那么最先连接请求将会获利，之后超过最小连接数量的连接请求等价于建立一个新的数据库连接。不过，这些大于最小连接数的数据库连接在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放。
自己写数据库连接池
编写连接池需实现java.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：
- Connection getConnection()
- Connection getConnection(String username, String password)
实现DataSource接口，并实现连接池功能的步骤：
① 在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。
② 实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。
③ 当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。Collection保证将自己返回到LinkedList中是此处编程的难点。
数据库连接池范例：
db.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/os_app
username=root
password=123456
jdbcPoolInitSize=10import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.Properties;
import javax.sql.DataSource;
/**
* @ClassName: JdbcPool
* @Description:编写数据库连接池
*
*/
public class JdbcPool implements DataSource{
/**
* @Field: listConnections
* 使用LinkedList集合来存放数据库链接，
* 由于要频繁读写List集合，所以这里使用LinkedList存储数据库连接比较合适
*/
private static LinkedList<Connection> listConnections = new LinkedList<Connection>();
static{
//在静态代码块中加载db.properties数据库配置文件
InputStream in = JdbcPool.class.getClassLoader().getResourceAsStream("db.properties");
Properties prop = new Properties();
try {
prop.load(in);
String driver = prop.getProperty("driver");
String url = prop.getProperty("url");
String username = prop.getProperty("username");
String password = prop.getProperty("password");
//数据库连接池的初始化连接数大小
int jdbcPoolInitSize =Integer.parseInt(prop.getProperty("jdbcPoolInitSize"));
//加载数据库驱动
Class.forName(driver);
for (int i = 0; i < jdbcPoolInitSize; i++) {
Connection conn = DriverManager.getConnection(url, username, password);
System.out.println("获取到了链接" + conn);
//将获取到的数据库连接加入到listConnections集合中，listConnections集合此时就是一个存放了数据库连接的连接池
listConnections.add(conn);
}
} catch (Exception e) {
throw new ExceptionInInitializerError(e);
}
}
@Override
public PrintWriter getLogWriter() throws SQLException {
// TODO Auto-generated method stub
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
// TODO Auto-generated method stub
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
// TODO Auto-generated method stub
}
@Override
public int getLoginTimeout() throws SQLException {
// TODO Auto-generated method stub
return 0;
}
@Override
public <T> T unwrap(Class<T> iface) throws SQLException {
// TODO Auto-generated method stub
return null;
}
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
// TODO Auto-generated method stub
return false;
}
/* 获取数据库连接
* @see javax.sql.DataSource#getConnection()
*/
@Override
public Connection getConnection() throws SQLException {
//如果数据库连接池中的连接对象的个数大于0
if (listConnections.size()>0) {
//从listConnections集合中获取一个数据库连接
final Connection conn = listConnections.removeFirst();
System.out.println("listConnections数据库连接池大小是" + listConnections.size());
//返回Connection对象的代理对象
return (Connection) Proxy.newProxyInstance(JdbcPool.class.getClassLoader(), conn.getClass().getInterfaces(), new InvocationHandler(){
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
if(!method.getName().equals("close")){
return method.invoke(conn, args);
}else{
//如果调用的是Connection对象的close方法，就把conn还给数据库连接池
listConnections.add(conn);
System.out.println(conn + "被还给listConnections数据库连接池了！！");
System.out.println("listConnections数据库连接池大小为" + listConnections.size());
return null;
}
}
});
}else {
throw new RuntimeException("对不起，数据库忙");
}
}
@Override
public Connection getConnection(String username, String password)
throws SQLException {
return null;
}
}写一个JdbcUtil测试数据库连接池：
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import me.gacl.demo.JdbcPool;
public class JdbcUtil {
/**
* @Field: pool
* 数据库连接池
*/
private static JdbcPool pool = new JdbcPool();
/**
* @Method: getConnection
* @Description: 从数据库连接池中获取数据库连接对象
* @return Connection数据库连接对象
* @throws SQLException
*/
public static Connection getConnection() throws SQLException{
return pool.getConnection();
}
/**
* @Method: release
* @Description: 释放资源，
* 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
* @param conn
* @param st
* @param rs
*/
public static void release(Connection conn,Statement st,ResultSet rs){
if(rs!=null){
try{
//关闭存储查询结果的ResultSet对象
rs.close();
}catch (Exception e) {
e.printStackTrace();
}
rs = null;
}
if(st!=null){
try{
//关闭负责执行SQL命令的Statement对象
st.close();
}catch (Exception e) {
e.printStackTrace();
}
}
if(conn!=null){
try{
//关闭Connection数据库连接对象
conn.close();
}catch (Exception e) {
e.printStackTrace();
}
}
}
}开源数据库连接池
现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实现。
也有一些开源组织提供了数据源的独立实现：
- DBCP 数据库连接池：DBCP 是 Apache 软件基金组织下的开源连接池实现，Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。DBCP没有自动回收空闲连接的功能。
- C3P0 数据库连接池：C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。C3P0数据源在项目开发中使用得比较多。C3P0有自动回收空闲连接功能
- Druid 数据库连接池：阿里巴巴开源的数据库连接池
配置Tomcat数据源
在实际开发中，我们有时候还会使用服务器提供给我们的数据库连接池，比如我们希望Tomcat服务器在启动的时候可以帮我们创建一个数据库连接池，那么我们在应用程序中就不需要手动去创建数据库连接池，直接使用Tomcat服务器创建好的数据库连接池即可。Tomcat服务器创建的数据源是以JNDI资源的形式发布的，所以说在Tomat服务器中配置一个数据源实际上就是在配置一个JNDI资源
JNDI技术
JNDI(Java Naming and Directory Interface)，Java命名和目录接口，它对应于J2SE中的javax.naming包，这 套API的主要作用在于：它可以把Java对象放在一个容器中（JNDI容器），并为容器中的java对象取一个名称，以后程序想获得Java对象，只需 通过名称检索即可。其核心API为Context，它代表JNDI容器，其lookup方法为检索容器中对应名称的对象。
八、元数据
元数据指的是"数据库"、"表"、"列"的定义信息。
DataBaseMetaData元数据
Connection.getDatabaseMetaData()获得代表DatabaseMetaData元数据的DatabaseMetaData对象。
DataBaseMetaData对象的常用方法：
- getURL()：返回一个String类对象，代表数据库的URL。
- getUserName()：返回连接当前数据库管理系统的用户名。
- getDatabaseProductName()：返回数据库的产品名称。
- getDatabaseProductVersion()：返回数据库的版本号。
- getDriverName()：返回驱动驱动程序的名称。
- getDriverVersion()：返回驱动程序的版本号。
- isReadOnly()：返回一个boolean值，指示数据库是否只允许读操作。
ParameterMetaData元数据
PreparedStatement.getParameterMetaData() 获得代表PreparedStatement元数据的ParameterMetaData对象。
Select * from user where name=? And password=?ParameterMetaData对象的常用方法：
- getParameterCount()： 获得指定参数的个数
- getParameterType(int param)：获得指定参数的sql类型，MySQL数据库驱动不支持
/**
* @Method: testParameterMetaData
* @Description: 获取参数元信息
* @throws SQLException
*/
@Test
public void testParameterMetaData() throws SQLException {
Connection conn = JdbcUtils.getConnection();
String sql = "select * from user wherer name=? and password=?";
//将SQL预编译一下
PreparedStatement st = conn.prepareStatement(sql);
ParameterMetaData pm = st.getParameterMetaData();
//getParameterCount() 获得指定参数的个数
System.out.println(pm.getParameterCount());
//getParameterType(int param)：获得指定参数的sql类型，MySQL数据库驱动不支持
System.out.println(pm.getParameterType(1));
JdbcUtils.release(conn, null, null);
}ResultSetMetaData元数据
ResultSet. getMetaData() 获得代表ResultSet对象元数据的ResultSetMetaData对象。
ResultSetMetaData对象的常用方法：
- getColumnCount() 返回resultset对象的列数
- getColumnName(int column) 获得指定列的名称
- getColumnTypeName(int column)获得指定列的类型
/**
* @Method: testResultSetMetaData
* @Description: 结果集的元数据
* @throws Exception
*/
@Test
public void testResultSetMetaData() throws Exception {
Connection conn = JdbcUtils.getConnection();
String sql = "select * from account";
PreparedStatement st = conn.prepareStatement(sql);
ResultSet rs = st.executeQuery();
//ResultSet.getMetaData()获得代表ResultSet对象元数据的ResultSetMetaData对象
ResultSetMetaData metadata = rs.getMetaData();
//getColumnCount() 返回resultset对象的列数
System.out.println(metadata.getColumnCount());
//getColumnName(int column) 获得指定列的名称
System.out.println(metadata.getColumnName(1));
//getColumnTypeName(int column)获得指定列的类型
System.out.println(metadata.getColumnTypeName(1));
JdbcUtils.release(conn, st, rs);
}使用元数据封装简单的JDBC框架
系统中所有实体对象都涉及到基本的CRUD操作。
所有实体的CUD操作代码基本相同，仅仅发送给数据库的SQL语句不同而已，因此可以把CUD操作的所有相同代码抽取到工具类的一个update方法中，并定义参数接收变化的SQL语句。
实体的R操作，除SQL语句不同之外，根据操作的实体不同，对ResultSet的映射也各不相同，因此可义一个query方法，除以参数形式接收变化的SQL语句外，可以使用策略模式由qurey方法的调用者决定如何把ResultSet中的数据映射到实体对象中。
封装通用的update方法和qurey方法
定义一个JdbcUtils工具类，工具类负责获取数据库连接，释放资源，执行SQL的update和query操作，代码如下：
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
public class JdbcUtils {
private static String driver = null;
private static String url = null;
private static String username = null;
private static String password = null;
static{
try{
//读取db.properties文件中的数据库连接信息
InputStream in = JdbcUtils.class.getClassLoader().getResourceAsStream("db.properties");
Properties prop = new Properties();
prop.load(in);
//获取数据库连接驱动
driver = prop.getProperty("driver");
//获取数据库连接URL地址
url = prop.getProperty("url");
//获取数据库连接用户名
username = prop.getProperty("username");
//获取数据库连接密码
password = prop.getProperty("password");
//加载数据库驱动
Class.forName(driver);
}catch (Exception e) {
throw new ExceptionInInitializerError(e);
}
}
/**
* @Method: getConnection
* @Description: 获取数据库连接对象
* @return Connection数据库连接对象
* @throws SQLException
*/
public static Connection getConnection() throws SQLException{
return DriverManager.getConnection(url, username,password);
}
/**
* @Method: release
* @Description: 释放资源，
* 要释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
* @param conn
* @param st
* @param rs
*/
public static void release(Connection conn,Statement st,ResultSet rs){
if(rs!=null){
try{
//关闭存储查询结果的ResultSet对象
rs.close();
}catch (Exception e) {
e.printStackTrace();
}
rs = null;
}
if(st!=null){
try{
//关闭负责执行SQL命令的Statement对象
st.close();
}catch (Exception e) {
e.printStackTrace();
}
}
if(conn!=null){
try{
//关闭Connection数据库连接对象
conn.close();
}catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* @Method: update
* @Description: 万能更新
* 所有实体的CUD操作代码基本相同，仅仅发送给数据库的SQL语句不同而已，
* 因此可以把CUD操作的所有相同代码抽取到工具类的一个update方法中，并定义参数接收变化的SQL语句
* @param sql 要执行的SQL
* @param params 执行SQL时使用的参数
* @throws SQLException
*/
public static void update(String sql,Object params[]) throws SQLException{
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try{
conn = getConnection();
st = conn.prepareStatement(sql);
for(int i=0;i<params.length;i++){
st.setObject(i+1, params[i]);
}
st.executeUpdate();
}finally{
release(conn, st, rs);
}
}
/**
* @Method: query
* @Description:万能查询
* 实体的R操作，除SQL语句不同之外，根据操作的实体不同，对ResultSet的映射也各不相同，
* 因此可义一个query方法，除以参数形式接收变化的SQL语句外，可以使用策略模式由qurey方法的调用者决定如何把ResultSet中的数据映射到实体对象中。
* @param sql 要执行的SQL
* @param params 执行SQL时使用的参数
* @param rsh 查询返回的结果集处理器
* @return
* @throws SQLException
*/
public static Object query(String sql,Object params[],ResultSetHandler rsh) throws SQLException{
Connection conn = null;
PreparedStatement st = null;
ResultSet rs = null;
try{
conn = getConnection();
st = conn.prepareStatement(sql);
for(int i=0;i<params.length;i++){
st.setObject(i+1, params[i]);
}
rs = st.executeQuery();
/**
* 对于查询返回的结果集处理使用到了策略模式，
* 在设计query方法时，query方法事先是无法知道用户对返回的查询结果集如何进行处理的，即不知道结果集的处理策略，
* 那么这个结果集的处理策略就让用户自己提供，query方法内部就调用用户提交的结果集处理策略进行处理
* 为了能够让用户提供结果集的处理策略，需要对用户暴露出一个结果集处理接口ResultSetHandler
* 用户只要实现了ResultSetHandler接口，那么query方法内部就知道用户要如何处理结果集了
*/
return rsh.handler(rs);
}finally{
release(conn, st, rs);
}
}
}在设计query方法时，对于查询返回的结果集处理使用到了策略模式，query方法事先是无法知道用户对返回的查询结果集如何进行处理的，即不知道结果集的处理策略， 那么这个结果集的处理策略就让用户自己提供，query方法内部就调用用户提交的结果集处理策略进行处理， 为了能够让用户提供结果集的处理策略，需要对用户暴露出一个结果集处理接口ResultSetHandler， 结果集处理器接口ResultSetHandler的定义如下：
import java.sql.ResultSet;
/**
* @ClassName: ResultSetHandler
* @Description:结果集处理器接口
*
*/
public interface ResultSetHandler {
/**
* @Method: handler
* @Description: 结果集处理方法
* @Anthor:孤傲苍狼
*
* @param rs 查询结果集
* @return
*/
public Object handler(ResultSet rs);
}用户只要实现了ResultSetHandler接口，那么就是针对查询结果集写了一个处理器，在query方法内部就调用用户自己写的处理器处理结果集。
编写常用的结果集处理器
为了提高框架的易用性，我们可以事先就针对结果集写好一些常用的处理器，比如将结果集转换成bean对象的处理器，将结果集转换成bean对象的list集合的处理器。
1、BeanHandler——将结果集转换成bean对象的处理器
import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
/**
* @ClassName: BeanHandler
* @Description: 将结果集转换成bean对象的处理器
*
*/
public class BeanHandler implements ResultSetHandler {
private Class<?> clazz;
public BeanHandler(Class<?> clazz){
this.clazz = clazz;
}
public Object handler(ResultSet rs) {
try{
if(!rs.next()){
return null;
}
Object bean = clazz.newInstance();
//得到结果集元数据
ResultSetMetaData metadata = rs.getMetaData();
int columnCount = metadata.getColumnCount();//得到结果集中有几列数据
for(int i=0;i<columnCount;i++){
String coulmnName = metadata.getColumnName(i+1);//得到每列的列名
Object coulmnData = rs.getObject(i+1);
Field f = clazz.getDeclaredField(coulmnName);//反射出类上列名对应的属性
f.setAccessible(true);
f.set(bean, coulmnData);
}
return bean;
}catch (Exception e) {
throw new RuntimeException(e);
}
}
}2、BeanListHandler——将结果集转换成bean对象的list集合的处理器
import java.lang.reflect.Field;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;
/**
* @ClassName: BeanListHandler
* @Description: 将结果集转换成bean对象的list集合的处理器
*
*/
public class BeanListHandler implements ResultSetHandler {
private Class<?> clazz;
public BeanListHandler(Class<?> clazz){
this.clazz = clazz;
}
public Object handler(ResultSet rs) {
try{
List<Object> list = new ArrayList<Object>();
while(rs.next()){
Object bean = clazz.newInstance();
ResultSetMetaData metadata = rs.getMetaData();
int count = metadata.getColumnCount();
for(int i=0;i<count;i++){
String name = metadata.getColumnName(i+1);
Object value = rs.getObject(name);
Field f = bean.getClass().getDeclaredField(name);
f.setAccessible(true);
f.set(bean, value);
}
list.add(bean);
}
return list.size()>0?list:null;
}catch (Exception e) {
throw new RuntimeException(e);
}
}
}当框架自身提供的结果集处理器不满足用户的要求时，那么用户就可以自己去实现ResultSetHandler接口，编写满足自己业务要求的结果集处理器。
有了上述的JdbcUtils框架之后，针对单个实体对象CRUD操作就非常方便了，如下所示：
import java.sql.SQLException;
import java.util.List;
import me.gacl.domain.Account;
import me.gacl.util.BeanHandler;
import me.gacl.util.BeanListHandler;
import me.gacl.util.JdbcUtils;
public class AccountDao {
public void add(Account account) throws SQLException{
String sql = "insert into account(name,money) values(?,?)";
Object params[] = {account.getName(),account.getMoney()};
JdbcUtils.update(sql, params);
}
public void delete(int id) throws SQLException{
String sql = "delete from account where id=?";
Object params[] = {id};
JdbcUtils.update(sql, params);
}
public void update(Account account) throws SQLException{
String sql = "update account set name=?,money=? where id=?";
Object params[] = {account.getName(),account.getMoney(),account.getId()};
JdbcUtils.update(sql, params);
}
public Account find(int id) throws SQLException{
String sql = "select * from account where id=?";
Object params[] = {id};
return (Account) JdbcUtils.query(sql, params, new BeanHandler(Account.class));
}
public List<Account> getAll() throws SQLException{
String sql = "select * from account";
Object params[] = {};
return (List<Account>) JdbcUtils.query(sql, params,new BeanListHandler(Account.class));
}
}九、Apache的DBUtils框架学习
commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。
commons-dbutilsAPI介绍：
- org.apache.commons.dbutils.QueryRunner
- org.apache.commons.dbutils.ResultSetHandler
工具类：
- org.apache.commons.dbutils.DbUtils
maven依赖如下：
<dependency>
<groupId>commons-dbutils</groupId>
<artifactId>commons-dbutils</artifactId>
<version>1.7</version>
</dependency>QueryRunner类使用讲解
该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
QueryRunner类提供了两个构造方法：
- 默认的构造方法
- 需要一个 javax.sql.DataSource 来作参数的构造方法。
QueryRunner类的主要方法
- public Object query(Connection conn, String sql, Object[] params, ResultSetHandler rsh) throws SQLException：执行一个查询操作，在这个查询中，对象数组中的每个元素值被用来作为查询语句的置换参数。该方法会自行处理 PreparedStatement 和 ResultSet 的创建和关闭。
- public Object query(String sql, Object[] params, ResultSetHandler rsh) throws SQLException: 几乎与第一种方法一样；唯一的不同在于它不将数据库连接提供给方法，并且它是从提供给构造方法的数据源(DataSource) 或使用的setDataSource 方法中重新获得 Connection。
- public Object query(Connection conn, String sql, ResultSetHandler rsh) throws SQLException : 执行一个不需要置换参数的查询操作。
- public int update(Connection conn, String sql, Object[] params) throws SQLException:用来执行一个更新（插入、更新或删除）操作。
- public int update(Connection conn, String sql) throws SQLException：用来执行一个不需要置换参数的更新操作。
使用QueryRunner类实现CRUD
import java.util.Date;
import java.util.List;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.sql.SQLException;
import javax.sql.rowset.serial.SerialClob;
import me.gacl.domain.User;
import me.gacl.util.JdbcUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.junit.Test;
/**
* @ClassName: DBUtilsCRUDTest
* @Description:使用dbutils框架的QueryRunner类完成CRUD,以及批处理
*
*/
public class QueryRunnerCRUDTest {
/*
*测试表
create table users(
id int primary key auto_increment,
name varchar(40),
password varchar(40),
email varchar(60),
birthday date
);
*/
@Test
public void add() throws SQLException {
//将数据源传递给QueryRunner，QueryRunner内部通过数据源获取数据库连接
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "insert into users(name,password,email,birthday) values(?,?,?,?)";
Object params[] = {"孤傲苍狼","123", "gacl@sina.com", new Date()};
//Object params[] = {"白虎神皇","123", "gacl@sina.com", "1988-05-07"};
qr.update(sql, params);
}
@Test
public void delete() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "delete from users where id=?";
qr.update(sql, 1);
}
@Test
public void update() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "update users set name=? where id=?";
Object params[] = { "ddd", 5};
qr.update(sql, params);
}
@Test
public void find() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users where id=?";
Object params[] = {2};
User user = (User) qr.query(sql, params, new BeanHandler(User.class));
System.out.println(user.getBirthday());
}
@Test
public void getAll() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users";
List list = (List) qr.query(sql, new BeanListHandler(User.class));
System.out.println(list.size());
}
/**
* @Method: testBatch
* @Description:批处理
* @throws SQLException
*/
@Test
public void testBatch() throws SQLException {
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "insert into users(name,password,email,birthday) values(?,?,?,?)";
Object params[][] = new Object[10][];
for (int i = 0; i < 10; i++) {
params[i] = new Object[] { "aa" + i, "123", "aa@sina.com",
new Date() };
}
qr.batch(sql, params);
}
//用dbutils完成大数据（不建议用）
/***************************************************************************
create table testclob
(
id int primary key auto_increment,
resume text
);
**************************************************************************/
@Test
public void testclob() throws SQLException, IOException{
QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "insert into testclob(resume) values(?)"; //clob
//这种方式获取的路径，其中的空格会被使用“%20”代替
String path = QueryRunnerCRUDTest.class.getClassLoader().getResource("data.txt").getPath();
//将“%20”替换回空格
path = path.replaceAll("%20", " ");
FileReader in = new FileReader(path);
char[] buffer = new char[(int) new File(path).length()];
in.read(buffer);
SerialClob clob = new SerialClob(buffer);
Object params[] = {clob};
runner.update(sql, params);
}
}ResultSetHandler接口使用讲解
该接口用于处理java.sql.ResultSet，将数据按要求转换为另一种形式。
ResultSetHandler接口提供了一个单独的方法：Object handle (java.sql.ResultSet .rs)
ResultSetHandler接口的实现类
- ArrayHandler：把结果集中的第一行数据转成对象数组。
- ArrayListHandler：把结果集中的每一行数据都转成一个数组，再存放到List中。
- BeanHandler：将结果集中的第一行数据封装到一个对应的JavaBean实例中。
- BeanListHandler：将结果集中的每一行数据都封装到一个对应的JavaBean实例中，存放到List里。
- ColumnListHandler：将结果集中某一列的数据存放到List中。
- KeyedHandler(name)：将结果集中的每一行数据都封装到一个Map里，再把这些map再存到一个map里，其key为指定的key。
- MapHandler：将结果集中的第一行数据封装到一个Map里，key是列名，value就是对应的值。
- MapListHandler：将结果集中的每一行数据都封装到一个Map里，然后再存放到List
测试dbutils各种类型的处理器
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import me.gacl.util.JdbcUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;
/**
* @ClassName: ResultSetHandlerTest
* @Description:测试dbutils各种类型的处理器
*
*/
public class ResultSetHandlerTest {
@Test
public void testArrayHandler() throws SQLException{
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users";
Object result[] = (Object[]) qr.query(sql, new ArrayHandler());
System.out.println(Arrays.asList(result)); //list toString()
}
@Test
public void testArrayListHandler() throws SQLException{
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users";
List<Object[]> list = (List) qr.query(sql, new ArrayListHandler());
for(Object[] o : list){
System.out.println(Arrays.asList(o));
}
}
@Test
public void testColumnListHandler() throws SQLException{
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users";
List list = (List) qr.query(sql, new ColumnListHandler("id"));
System.out.println(list);
}
@Test
public void testKeyedHandler() throws Exception{
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users";
Map<Integer,Map> map = (Map) qr.query(sql, new KeyedHandler("id"));
for(Map.Entry<Integer, Map> me : map.entrySet()){
int id = me.getKey();
Map<String,Object> innermap = me.getValue();
for(Map.Entry<String, Object> innerme : innermap.entrySet()){
String columnName = innerme.getKey();
Object value = innerme.getValue();
System.out.println(columnName + "=" + value);
}
System.out.println("----------------");
}
}
@Test
public void testMapHandler() throws SQLException{
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users";
Map<String,Object> map = (Map) qr.query(sql, new MapHandler());
for(Map.Entry<String, Object> me : map.entrySet())
{
System.out.println(me.getKey() + "=" + me.getValue());
}
}
@Test
public void testMapListHandler() throws SQLException{
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from users";
List<Map> list = (List) qr.query(sql, new MapListHandler());
for(Map<String,Object> map :list){
for(Map.Entry<String, Object> me : map.entrySet())
{
System.out.println(me.getKey() + "=" + me.getValue());
}
}
}
@Test
public void testScalarHandler() throws SQLException{
QueryRunner qr = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select count(*) from users"; //[13] list[13]
int count = ((Long)qr.query(sql, new ScalarHandler(1))).intValue();
System.out.println(count);
}
}DbUtils类使用详解
DbUtils提供如关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的所有方法都是静态的。主要方法如下：
- public static void close(…) throws java.sql.SQLException： DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭Connection、Statement和ResultSet。
- public static void closeQuietly(…): 这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLEeception。
- public static void commitAndCloseQuietly(Connection conn)： 用来提交连接，然后关闭连接，并且在关闭连接时不抛出SQL异常。
- public static boolean loadDriver(java.lang.String driverClassName)：这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异常ClassNotFoundException。
十、使用ThreadLocal进行更加优雅的事务处理
使用ThreadLocal + Filter进行统一的事务处理，这种方式主要是使用过滤器进行统一的事务处理，如下图所示：
编写一个事务过滤器TransactionFilter
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @ClassName: TransactionFilter
* @Description:ThreadLocal + Filter 统一处理数据库事务
*/
public class TransactionFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
Connection connection = null;
try {
//1、获取数据库连接对象Connection
connection = JdbcUtils.getConnection();
//2、开启事务
connection.setAutoCommit(false);
//3、利用ThreadLocal把获取数据库连接对象Connection和当前线程绑定
ConnectionContext.getInstance().bind(connection);
//4、把请求转发给目标Servlet
chain.doFilter(request, response);
//5、提交事务
connection.commit();
} catch (Exception e) {
e.printStackTrace();
//6、回滚事务
try {
connection.rollback();
} catch (SQLException e1) {
e1.printStackTrace();
}
HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
//req.setAttribute("errMsg", e.getMessage());
//req.getRequestDispatcher("/error.jsp").forward(req, res);
//出现异常之后跳转到错误页面
res.sendRedirect(req.getContextPath()+"/error.jsp");
}finally{
//7、解除绑定
ConnectionContext.getInstance().remove();
//8、关闭数据库连接
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
@Override
public void destroy() {
}
}我们在TransactionFilter中把获取到的数据库连接使用ThreadLocal绑定到当前线程之后，在DAO层还需要从ThreadLocal中取出数据库连接来操作数据库，因此需要编写一个ConnectionContext类来存储ThreadLocal，ConnectionContext类的代码如下：
import java.sql.Connection;
/**
* @ClassName: ConnectionContext
* @Description:数据库连接上下文
*
*/
public class ConnectionContext {
/**
* 构造方法私有化，将ConnectionContext设计成单例
*/
private ConnectionContext(){
}
//创建ConnectionContext实例对象
private static ConnectionContext connectionContext = new ConnectionContext();
/**
* @Method: getInstance
* @Description:获取ConnectionContext实例对象
*
* @return
*/
public static ConnectionContext getInstance(){
return connectionContext;
}
/**
* @Field: connectionThreadLocal
* 使用ThreadLocal存储数据库连接对象
*/
private ThreadLocal<Connection> connectionThreadLocal = new ThreadLocal<Connection>();
/**
* @Method: bind
* @Description:利用ThreadLocal把获取数据库连接对象Connection和当前线程绑定
*
* @param connection
*/
public void bind(Connection connection){
connectionThreadLocal.set(connection);
}
/**
* @Method: getConnection
* @Description:从当前线程中取出Connection对象
*
* @return
*/
public Connection getConnection(){
return connectionThreadLocal.get();
}
/**
* @Method: remove
* @Description: 解除当前线程上绑定Connection
*
*/
public void remove(){
connectionThreadLocal.remove();
}
}
扫一扫
1039
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
