zoukankan html css js c++ java

09、JavaEEJDBC

JDBC基本用法

JDBC介绍

数据库驱动

SUN公司为了简化、统一对数据库的操作，定义了一套Java操作数据库的规范（接口），称之为JDBC。这套接口由数据库厂商去实现，这样，开发人员只需要学习jdbc接口，

并通过jdbc加载具体的驱动，就可以操作数据库。

JDBC全称为：Java Data Base Connectivity（java数据库连接），它主要由接口组成。
组成JDBC的２个包：

java.sql
javax.sql

开发JDBC应用需要以上2个包的支持外，还需要导入相应JDBC的数据库实现(即数据库驱动)。

编写JDBC程序

搭建开发环境

1、在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、新建一个Java工程，并导入数据驱动。

如果开发工具是IDEA的话，直接选择View -> Tool Windows -> Database -> Data Source -> MySql

配置好参数后，MySql驱动也在这里直接下载，直接Test Connection来测试连接，然后保存。此时会弹出一个数据库命令管理窗口，

可以用来输出SQL命令：

执行数据库命令后会在database中生成相应的数据库内容

3、编写程序从user表中读取数据，并打印在命令行窗口中。

public class JdbcDemo1 {
    public static void main(String[] args) throws Exception {
        // 1、数据库基本配置
        String url = "jdbc:mysql://localhost:3306/jdbcStudy";
        String username = "root";
        String password = "123456";
        // 2、加载MySql驱动
        //DriverManager.registerDriver(new Driver()); 不推荐
        Class.forName("com.mysql.jdbc.Driver");
        // 3、获取数据库连接
        Connection conn = DriverManager.getConnection(url, username, password);
        // 4、获取用于向数据库发送SQL语句的Statement
        Statement statement = conn.createStatement();
        String sql = "select id,name,password,email,birthday from users";
        // 5、想数据库发送SQL，并获取结果集ResultSet
        ResultSet resultSet = statement.executeQuery(sql);
        // 6、取出数据结果集
        while (resultSet.next()) {
            System.out.println("id=" + resultSet.getObject("id"));
            System.out.println("name=" + resultSet.getObject("name"));
            System.out.println("password=" + resultSet.getObject("password"));
            System.out.println("email=" + resultSet.getObject("email"));
            System.out.println("birthday=" + resultSet.getObject("birthday"));
        }
        // 7、关闭连接，释放资源
        resultSet.close();
        statement.close();
        conn.close();
    }
}

输出结果：

id=1
name=zhansan
password=123456
email=zs@sina.com
birthday=1980-12-04
id=2
name=lisi
password=123456
email=lisi@sina.com
birthday=1981-12-04
id=3
name=wangwu
password=123456
email=wangwu@sina.com
birthday=1979-12-04

DriverManager类讲解

Jdbc程序中的DriverManager用于加载驱动，并创建与数据库的链接，这个API的常用方法：

名称	描述
DriverManager.registerDriver(new Driver())	注册数据库驱动程序。
DriverManager.getConnection(url, user, password)	获取数据库的连接对象Connection。

注意：在实际开发中并不推荐采用registerDriver方法注册驱动。原因有二：

1、查看Driver的源代码可以看到，如果采用此种方式，会导致驱动程序注册两次，也就是在内存中会有两个Driver对象。
2、程序依赖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语句执行。

ResultSet类讲解

Jdbc程序中的ResultSet用于代表Sql语句的执行结果。Resultset封装执行结果时，采用的类似于表格的方式。ResultSet 对象维护了一个指向表格数据行的游标，

初始的时候，游标在第一行之前，调用ResultSet.next() 方法，可以使游标指向具体的数据行，进行调用方法获取该行的数据。

ResultSet既然用于封装执行结果的，所以该对象提供的都是用于获取数据的get方法：

名称	描述
getObject(int index)	通过索引获取任意类型的数据。
getObject(string columnName)	通过列名获取任意类型的数据。
getString(int index)	通过索引获取字符串类型的数据。
getString(String columnName)	通过列名获取字符串类型的数据。

ResultSet还提供了对结果集进行滚动的方法：

名称	描述
next()	移动到下一行
Previous()	移动到前一行
absolute(int row)	移动到指定行
beforeFirst()	移动resultSet的最前面。
afterLast()	移动到resultSet的最后面。

释放数据库资源

Jdbc程序运行完后，要释放创建的那些与数据库进行交互的对象，这些对象通常是ResultSet, Statement和Connection对象，特别是Connection对象，它是非常稀

有的资源，用完后必须马上释放，如果Connection不能及时、正确的关闭，极易导致系统宕机。Connection的使用原则是尽量晚创建，尽量早的释放。

为确保资源释放代码能运行，资源释放代码也一定要放在finally语句中。

数据库增删改查

Statement对象介绍

Jdbc中的Statement对象用于向数据库发送SQL语句，想完成对数据库的增删改查，只需要通过这个对象向数据库发送增删改查语句即可。

补充：我们可以通过Statement对象的getGeneratedKeys()方法来获取数据库自动生成的主键。

CRUD操作-create

使用executeUpdate(String sql)方法完成数据添加操作，示例操作：

Statement st = conn.createStatement();
String sql = "insert into user(….) values(…..) "; 
int num = st.executeUpdate(sql);
if(num>0){
    System.out.println("插入成功！！！");
}

CRUD操作-update

使用executeUpdate(String sql)方法完成数据修改操作，示例操作：

Statement st = conn.createStatement();
String sql = “update user set name=‘’ where name=‘’"; 
int num = st.executeUpdate(sql);
if(num>0){
    System.out.println(“修改成功！！！");
}

CRUD操作-delete

使用executeUpdate(String sql)方法完成数据删除操作，示例操作：

Statement st = conn.createStatement();
String sql = “delete from user where id=1; 
int num = st.executeUpdate(sql);
if(num>0){
    System.out.println(“删除成功！！！");
}

CRUD操作-read

使用executeQuery(String sql)方法完成数据查询操作，示例操作：

Statement st = conn.createStatement();
String sql = “select * from user where id=1; 
ResultSet rs = st.executeUpdate(sql);
while(rs.next()){
    //根据获取列的数据类型，分别调用rs的相应方法映射到java对象中
}

jdbc对数据库增删改查

1、在mysql中创建一个库，并创建user表和插入表的数据。

create database jdbcStudy;
use jdbcStudy;
create table users(
    id int primary key,
    name varchar(40),
    password varchar(40),
    email varchar(60),
    birthday date
);

2、在src目录下创建一个db.properties文件，然后编写MySQL数据库的连接信息，代码如下所示

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcStudy
username=root
password=123456

3、编写一个JdbcUtils工具类，用于连接数据库，获取数据库连接和释放数据库连接，代码如下：

public class JdbcUtils {
    private static String driver;
    private static String url;
    private static String username;
    private static String password;
    static {
        try {
            // 读取db.properties中的数据库信息
            InputStream in = JdbcUtils.class.getClassLoader()
                    .getResourceAsStream("db.properties");
            Properties prop = new Properties();
            prop.load(in);
            driver = prop.getProperty("driver");
            url = prop.getProperty("url");
            username = prop.getProperty("username");
            password = prop.getProperty("password");
            // 加载数据库驱动
            Class.forName(driver);
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() throws SQLException {
        return (Connection) DriverManager.getConnection(url, username, password);
    }
    public static void release(Connection conn, Statement st, ResultSet set) {
        try {
            if (set != null) {
                set.close();
            }
            if (st != null) {
                st.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        set = null;
        st = null;
        conn = null;
    }
}

使用statement对象完成对数据库的CRUD操作

public class JdbcPerform {
    @Test
    public void insert() {
        Connection conn = null;
        Statement st = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            st = (Statement) conn.createStatement();
            String sql = "insert into users(id,name,password,email,birthday) values(3,'legend','123','bhsh@sina.com','1980-09-09')";
            int num = st.executeUpdate(sql);
            if (num > 0){
                System.out.println("插入成功！");
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, set);
        }
    }
    @Test
    public void delete() {
        Connection conn = null;
        Statement st = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "delete from users where id=3";
            st = (Statement) conn.createStatement();
            int num = st.executeUpdate(sql);
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, set);
        }
    }
    @Test
    public void update() {
        Connection conn = null;
        Statement st = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "update users set name='legend',email='42120@qq.com' where id=3";
            st = (Statement) conn.createStatement();
            int num = st.executeUpdate(sql);
            if (num > 0) {
                System.out.println("更新成功！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, set);
        }
    }
    @Test
    public void query(){
        Connection conn = null;
        Statement st = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "select * from users where id=3";
            st = (Statement) conn.createStatement();
            set = st.executeQuery(sql);
            if (set.next()) {
                System.out.println(set.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, set);
        }
    }
}

PreparedStatement对象介绍

PreperedStatement是Statement的子类，它的实例对象可以通过调用Connection.preparedStatement()方法获得，相对于Statement

对象而言：PreperedStatement可以避免SQL注入的问题。

Statement会使数据库频繁编译SQL，可能造成数据库缓冲区溢出。PreparedStatement可对SQL进行预编译，从而提高数据库的执行效率。

并且PreperedStatement对于sql中的参数，允许使用占位符的形式进行替换，简化sql语句的编写。

范例：使用PreparedStatement对象完成对数据库的CRUD操作

public class JdbcCRUDByPrepareStatement {
    // 插入数据
    @Test
    public void insert() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "insert into users(id,name,password,email,birthday) values(?,?,?,?,?)";
            st = (PreparedStatement) conn.prepareStatement(sql);
            st.setInt(1, 1);
            st.setString(2, "legend");
            st.setString(3, "123");
            st.setString(4, "42120@qq.com");
            st.setDate(5, new java.sql.Date(new Date().getTime()));
            int num = st.executeUpdate();
            if(num > 0) {
                System.out.println("插入成功！");
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, set);
        }
    }
    // 删除数据
    @Test
    public void delete() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "delete from users where id=?";
            st = (PreparedStatement) conn.prepareStatement(sql);
            st.setInt(1, 1);
            int num = st.executeUpdate();
            if (num > 0) {
                System.out.println("删除成功!");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, set);
        }
    }
    // 更新数据
    @Test
    public void update() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "update users set name=?,email=?,where id=?";
            st = (PreparedStatement) conn.prepareStatement(sql);
            st.setString(1, "vincent");
            st.setString(2, "1244@qq.com");
            st.setInt(3, 2);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, set);
        }
    }
    // 查询数据
    @Test
    public void query() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "select * from users where id=?";
            st = (PreparedStatement) conn.prepareStatement(sql);
            st.setInt(1, 1);
            set = st.executeQuery();
            if (set.next()) {
                System.out.println(set.getString("name"));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, st, set);
        }
    }
}

Mysql大数据处理

大数据也称之为LOB(Large Objects)，LOB又分为：clob和blob，clob用于存储大文本，blob用于存储二进制数据，例如图像、声音、二进制文等。

在实际开发中，有时是需要用程序把大文本或二进制数据直接保存到数据库中进行储存的。

对MySQL而言只有blob，而没有clob，mysql存储大文本采用的是Text，Text和blob分别又分为：

TINYTEXT、TEXT、MEDIUMTEXT和LONGTEXT
TINYBLOB、BLOB、MEDIUMBLOB和LONGBLOB

JDBC处理大文本

对于MySQL中的Text类型，可调用如下方法设置

//注意length长度须设置，并且设置为int型
PreparedStatement.setCharacterStream(index, reader, length);

对MySQL中的Text类型，可调用如下方法获取

reader = resultSet. getCharacterStream(String columnLabel);2 string s = resultSet.getString(String columnLabel);

1、在src目录下创建配置文件db.properties和大数据文本data.txt，然后编写JdbcUtils工具类（上面已经有代码）：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcStudy
username=root
password=XDP

2、编写SQL测试脚本

create database jdbcstudy;
use jdbcstudy;
create table testclob
(
         id int primary key auto_increment,
         resume text
);

3、写入大文本数据到数据库和读取大文本数据

public class JdbcTextClob {
    // 向数据库插入大文本
    @Test
    public void add() {
        Connection conn = null;
        PreparedStatement statement = null;
        ResultSet set = null;
        Reader reader;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "insert into testclob(resume) values(?)";
            statement = (PreparedStatement) conn.prepareStatement(sql);
            //这种方式获取的路径，其中的空格会被使用“%20”代替
            String path = JdbcTextClob.class.getClassLoader().getResource("data.txt").getPath();
            // 将"%20替换回空格"
            path = path.replaceAll("%20", " ");
            File file = new File(path);
            reader = new FileReader(file);
            statement.setCharacterStream(1, reader, file.length());
            int num = statement.executeUpdate();
            if (num > 0) {
                System.out.println("插入成功！");
            }
            reader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, statement, set);
        }
    }
    // 读取数据库大文本数据
    @Test
    public void read() {
        Connection conn = null;
        PreparedStatement statement = null;
        ResultSet set = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "select resume from testclob where id=1";
            statement = (PreparedStatement) conn.prepareStatement(sql);
            set = statement.executeQuery();
            String contentStr = "";
            if(set.next()) {
                //使用resultSet.getString("字段名")获取大文本数据的内容
                String content = set.getString("resume");
                //使用resultSet.getCharacterStream("字段名")获取大文本数据的内容
                Reader reader = set.getCharacterStream("resume");
                char[] buf = new char[1024];
                int len = 0;
                FileWriter out = new FileWriter("D:/1.txt");
                while ((len = reader.read(buf)) > 0) {
                    contentStr += new String(buf);
                    out.write(buf, 0, len);
                    out.flush();
                }
                out.close();
                reader.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JdbcUtils.release(conn, statement, set);
        }
    }
}

JDBC处理二进制

对于MySQL中的BLOB类型，可调用如下方法设置：

PreparedStatement. setBinaryStream(i, inputStream, length);

对MySQL中的BLOB类型，可调用如下方法获取：

InputStream in  = resultSet.getBinaryStream(String columnLabel);
InputStream in  = resultSet.getBlob(String columnLabel).getBinaryStream();

1、编写SQL测试脚本

create table testblob
(
      id int primary key auto_increment,
      image longblob
);

2、编写测试代码如下：

public class JdbcBinaryBlob {
    // 向数据库中插入二进制数据
    @Test
    public void add(){
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try{
            conn = JdbcUtils.getConnection();
            String sql = "insert into testblob(image) values(?)";
            st = conn.prepareStatement(sql);
            //这种方式获取的路径，其中的空格会被使用“%20”代替
            String path = JdbcOperaBlob.class.getClassLoader().getResource("01.jpg").getPath();
            //将“%20”替换会空格
            path = path.replaceAll("%20", " ");
            File file = new File(path);
            FileInputStream fis = new FileInputStream(file);//生成的流
            st.setBinaryStream(1, fis,(int) file.length());
            int num = st.executeUpdate();
            if(num>0){
                System.out.println("插入成功！！");
            }
            fis.close();
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(conn, st, rs);
        }
    }
    
    //读取数据库中的二进制数据 
    @Test
    public void read() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try {
            conn = JdbcUtils.getConnection();
            String sql = "select image from testblob where id=?";
            st = conn.prepareStatement(sql);
            st.setInt(1, 1);
            rs = st.executeQuery();
            if (rs.next()) {
                //InputStream in = rs.getBlob("image").getBinaryStream();//这种方法也可以
                InputStream in = rs.getBinaryStream("image");
                int len = 0;
                byte buffer[] = new byte[1024];
                
                FileOutputStream out = new FileOutputStream("D:\\1.jpg");
                while ((len = in.read(buffer)) > 0) {
                    out.write(buffer, 0, len);
                }
                in.close();
                out.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JdbcUtils.release(conn, st, rs);
        }
    }
}

JDBC批处理

在实际开发中，有时候需要向数据库发送一批SQL语句执行，这时应避免向数据库一条条的发送执行，应采用JDBC的批处理机制，以提升执行效率。

JDBC实现批处理有两种方式：statement和preparedstatement

Statement完成批处理

1、使用Statement对象添加要批量执行SQL语句，如下：

Statement.addBatch(sql1);
Statement.addBatch(sql2);
Statement.addBatch(sql3);

2、执行批处理SQL语句：Statement.executeBatch();

3、清除批处理命令：Statement.clearBatch();

Statement批处理范例

1、编写测试的SQL脚本创建表

create table testbatch
(
      id int primary key,
      name varchar(20)
);

2、编写测试代码，如下所示：

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语句。例如：

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批处理

采用PreparedStatement.addBatch()实现批处理

优点：发送的是预编译后的SQL语句，执行效率高。
缺点：只能应用在SQL语句相同，但参数不同的批处理中。因此此种形式的批处理经常用于在同一个表中批量插入数据，或批量更新表的数据。

范例：PreparedStatement完成批处理

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 + "秒！！");
    }
}

JDBC数据处理

事务处理

事务指逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功。

例如：A——B转帐，对应于如下两条sql语句

update from account set money=money+100 where name='B';
update from account set money=money-100 where name='A';

事务四大特性

特性	描述
原子性(Atomicity)	原子性是指事务是一个不可分割的工作单位，事务中的操作要么全部成功，要么全部失败。
一致性(Consistency)	事务必须使数据库从一个一致性状态变换到另外一个一致性状态。以转账为例子，A向B转账，假设转账之前这两个用户的钱加起来总共是2000，那么A向B转账之后，不管这两个账户怎么转，A用户的钱和B用户的钱加起来的总额还是2000，这个就是事务的一致性。
隔离性(Isolation)	事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。
持久性(Durability)	持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。

事务的四大特性中最麻烦的是隔离性，下面重点介绍一下事务的隔离级别

事务的隔离级别

多个线程开启各自事务操作数据库中数据时，数据库系统要负责隔离操作，以保证各个线程在获取数据时的准确性。

如果事务不考虑隔离性，可能会引发如下问题：

脏读

脏读指一个事务读取了另外一个事务未提交的数据。这是非常危险的，假设Ａ向Ｂ转帐100元，对应sql语句如下所示

1.update account set money=money+100 where name='B';    
2.update account set money=money-100  where name='A';

当第1条语句执行完，第2条还没执行(A未提交时)，如果此时Ｂ查询自己的帐户，就会发现自己多了100元钱。如果A等B走后再回滚，B就会损失100元。

不可重复读

不可重复读指在一个事务内读取表中的某一行数据，多次读取结果不同。

例如：银行想查询A帐户余额，第一次查询A帐户为200元，此时A向帐户内存了100元并提交了，银行接着又进行了一次查询，此时A帐户为300元了。银行两次查询不一致，

可能就会很困惑，不知道哪次查询是准的。

　　不可重复读和脏读的区别是，脏读是读取前一事务未提交的脏数据，不可重复读是重新读取了前一事务已提交的数据。

　　很多人认为这种情况就对了，无须困惑，当然是后面的为准。我们可以考虑这样一种情况，比如银行程序需要将查询结果分别输出到电脑屏幕和写到文件中，结果在一个

事务中针对输出的目的地，进行的两次查询不一致，导致文件和屏幕中的结果不一致，银行工作人员就不知道以哪个为准了。

虚读(幻读)

　　虚读(幻读)是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。

如丙存款100元未提交，这时银行做报表统计account表中所有用户的总额为500元，然后丙提交了，这时银行再统计发现帐户为600元了，造成虚读同样会使银行不知所措，到

底以哪个为准。

事务隔离性的语句

MySQL数据库共定义了四种隔离级别：

Serializable(串行化)：可避免脏读、不可重复读、虚读情况的发生。
Repeatable read(可重复读)：可避免脏读、不可重复读情况的发生。
Read committed(读已提交)：可避免脏读情况发生。
Read uncommitted(读未提交)：最低级别，以上情况均无法保证。

mysql数据库查询当前事务隔离级别：

select @@tx_isolation

mysql数据库设置事务隔离级别：

set transaction isolation level 隔离级别名

MySQL不同隔离级别的并发

1、当把事务的隔离级别设置为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窗口查询

2、当把事务的隔离级别设置为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窗口

3、当把事务的隔离级别设置为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窗口

4、当把事务的隔离级别设置为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结束事务才能插入

操作事务命令

1、编写测试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转帐这个业务场景。

开启事务(start transaction)

使用"start transaction"开启MySQL数据库的事务，如下所示：

我们首先在数据库中模拟转账失败的场景，首先执行update语句让A用户的money减少100块钱，如下图所示：

然后我们关闭当前操作的dos命令行窗口，这样就导致了刚才执行的update语句的数据库的事务没有被提交，那么我们对A用户的修改就不算

是是真正的修改了，下次在查询A用户的money时，依然还是之前的1000，如下图所示：

提交事务(commit)

下面我们在数据库模拟A——B转账成功的场景

我们手动提交(commit)数据库事务之后，A——B转账100块钱的这个业务操作算是真正成功了，A账户中少了100，B账户中多了100。

回滚事务(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);
        }
    }
}

数据库连接池

　用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万

次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。如下图所示：

连接池性能优化

连接池的基本概念

数据库连接是一种关键的有限的昂贵的资源,这一点在多用户的网页应用程序中体现的尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程

序的性能指标。数据库连接池正式针对这个问题提出来的。数据库连接池负责分配，管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而不是重新建立一个。

如下图所示：

数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中, 这些数据库连接的数量是由最小数据库连接数来设定的.无论这些数据库连接是否被使用,连接池都将一直保

证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到

等待队列中.

数据库连接池的最小连接数和最大连接数的设置要考虑到以下几个因素:

1、最小连接数:是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费.

2、最大连接数:是连接池能申请的最大连接数,如果数据库连接请求超过次数,后面的数据库连接请求将被加入到等待队列中,这会影响以后的数据库操作

3、如果最小连接数与最大连接数相差很大:那么最先连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接

在使用完不会马上被释放,他将被放到连接池中等待重复使用或是空间超时后被释放.

编写数据库连接池

编写连接池需实现java.sql.DataSource接口。DataSource接口中定义了两个重载的getConnection方法：

Connection getConnection()
Connection getConnection(String username, String password)

实现DataSource接口，并实现连接池功能的步骤：

1、在DataSource构造函数中批量创建与数据库的连接，并把创建的连接加入LinkedList对象中。

2、实现getConnection方法，让getConnection方法每次调用时，从LinkedList中取一个Connection返回给用户。

3、当用户使用完Connection，调用Connection.close()方法时，Collection对象应保证将自己返回到LinkedList中,而不要把conn还给数据库。Collection保证将自己返回到Linked

List中是此处编程的难点

数据库连接池核心代码

　　使用动态代理技术构建连接池中的connection

proxyConn = (Connection) Proxy.newProxyInstance(this.getClass()
            .getClassLoader(), conn.getClass().getInterfaces(),
            new InvocationHandler() {
            //此处为内部类，当close方法被调用时将conn还回池中,其它方法直接执行
            public Object invoke(Object proxy, Method method,
                      Object[] args) throws Throwable {
                if (method.getName().equals("close")) {
                    pool.addLast(conn);
                    return null;
            }
            return method.invoke(conn, args);
        }
    });

数据库连接池编写范例：

 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;
    }
}

db.properties配置文件如下：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcStudy
username=root
password=XDP
jdbcPoolInitSize=10

编写工具类测试连接池：

public class JdbcPoolUtils {
    private static JdbcPool sPool = new JdbcPool();
    // 从数据库连接池中获取数据库连接对象
    public static Connection getConnection() throws SQLException {
        return sPool.getConnection();
    }
    // 释放资源
    public static void release(Connection conn, Statement st, ResultSet set) {
        try {
            if (set != null) {
                set.close();
                set = null;
            }
            if (st != null) {
                st.close();
                st = null;
            }
            if (conn != null) {
                conn.close();
                conn = null;
            }
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

开源数据库连接池

现在很多WEB服务器(Weblogic, WebSphere, Tomcat)都提供了DataSoruce的实现，即连接池的实现。通常我们把DataSource的实现，按其英文含义称之为数据源，数据源中都包含了数据库连接池的实现。

也有一些开源组织提供了数据源的独立实现：

DBCP 数据库连接池
C3P0 数据库连接池

在使用了数据库连接池之后，在项目的实际开发中就不需要编写连接数据库的代码了，直接从数据源获得数据库的连接。

DBCP数据源

DBCP 是 Apache 软件基金组织下的开源连接池实现，要使用DBCP数据源，需要应用程序应在系统中增加如下两个 jar 文件：

Commons-dbcp.jar：连接池的实现
Commons-pool.jar：连接池实现的依赖库

Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。

范例：在应用程序中加入dbcp连接池

1、导入相关jar包：commons-dbcp-1.2.2.jar、commons-pool.jar

2、在类目录下加入dbcp的配置文件：dbcpconfig.properties

#连接设置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbcstudy
username=root
password=XDP
#<!-- 初始化连接 -->
initialSize=10
#最大连接数量
maxActive=50
#<!-- 最大空闲连接 -->
maxIdle=20
#<!-- 最小空闲连接 -->
minIdle=5
#<!-- 超时等待时间以毫秒为单位 6000毫秒/1000等于60秒 -->
maxWait=60000
#JDBC驱动建立连接时附带的连接属性属性的格式必须为这样：[属性名=property;] 
#注意："user" 与 "password" 两个属性会被明确地传递，因此这里不需要包含他们。
connectionProperties=useUnicode=true;characterEncoding=UTF8
#指定由连接池所创建的连接的自动提交（auto-commit）状态。
defaultAutoCommit=true
#driver default 指定由连接池所创建的连接的只读（read-only）状态。
#如果没有设置该值，则“setReadOnly”方法将不被调用。（某些驱动并不支持只读模式，如：Informix）
defaultReadOnly=
#driver default 指定由连接池所创建的连接的事务级别（TransactionIsolation）。
#可用值为下列之一：（详情可见javadoc。）NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
defaultTransactionIsolation=READ_UNCOMMITTED

3、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中创建池

public class JdbcUtils_DBCP {
    /**
     * 在java中，编写数据库连接池需实现java.sql.DataSource接口，每一种数据库连接池都是DataSource接口的实现
     * DBCP连接池就是java.sql.DataSource接口的一个具体实现
     */
    private static DataSource ds = null;
    //在静态代码块中创建数据库连接池
    static{
        try{
            //加载dbcpconfig.properties配置文件
            InputStream in = JdbcUtils_DBCP.class.getClassLoader().getResourceAsStream("dbcpconfig.properties");
            Properties prop = new Properties();
            prop.load(in);
            //创建数据源
            ds = BasicDataSourceFactory.createDataSource(prop);
        }catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    
    /**
    * @Method: getConnection
    * @Description: 从数据源中获取数据库连接
    * @return Connection
    * @throws SQLException
    */ 
    public static Connection getConnection() throws SQLException{
        //从数据源中获取数据库连接
        return ds.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();
            }
        }
    }
}

4、测试DBCP数据源

public class DataSourceTest {  
    @Test
    public void dbcpDataSourceTest() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try{
            //获取数据库连接
            conn = JdbcUtils_DBCP.getConnection();
            String sql = "insert into test1(name) values(?)";
            st = conn.prepareStatement(sql);
            st.setString(1, "gacl");
            st.executeUpdate();
            //获取数据库自动生成的主键
            rs = st.getGeneratedKeys();
            if(rs.next()){
                System.out.println(rs.getInt(1));
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            //释放资源
            JdbcUtils_DBCP.release(conn, st, rs);
        }
    }
}

C3P0数据源

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。C3P0数据源在项目开发中使用得比较多。

c3p0与dbcp区别:

dbcp没有自动回收空闲连接的功能
c3p0有自动回收空闲连接功能

范例：在应用程序中加入C3P0连接池

1、导入相关jar包：

c3p0-0.9.2-pre1.jar、mchange-commons-0.2.jar，如果操作的是Oracle数据库，那么还需要导入c3p0-oracle-thin-extras-0.9.2-pre1.jar

2、在类目录下加入C3P0的配置文件：c3p0-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--
c3p0-config.xml必须位于类路径下面
private static ComboPooledDataSource ds;
static{
    try {
        ds = new ComboPooledDataSource("MySQL");
    } catch (Exception e) {
        throw new ExceptionInInitializerError(e);
    }
}
-->
<c3p0-config>
    <!--
    C3P0的缺省(默认)配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource();”这样写就表示使用的是C3P0的缺省(默认)配置信息来创建数据源
    -->
    <default-config>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy</property>
        <property name="user">root</property>
        <property name="password">XDP</property>
        
        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </default-config>
    <!--
    C3P0的命名配置，
    如果在代码中“ComboPooledDataSource ds = new ComboPooledDataSource("MySQL");”这样写就表示使用的是name是MySQL的配置信息来创建数据源
    -->
    <named-config name="MySQL">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbcstudy</property>
        <property name="user">root</property>
        <property name="password">XDP</property>
        
        <property name="acquireIncrement">5</property>
        <property name="initialPoolSize">10</property>
        <property name="minPoolSize">5</property>
        <property name="maxPoolSize">20</property>
    </named-config>
</c3p0-config>

3、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中创建池

public class JdbcUtils_C3P0 {
    private static ComboPooledDataSource ds = null;
    //在静态代码块中创建数据库连接池
    static{
        try{
            //通过代码创建C3P0数据库连接池
            /*ds = new ComboPooledDataSource();
            ds.setDriverClass("com.mysql.jdbc.Driver");
            ds.setJdbcUrl("jdbc:mysql://localhost:3306/jdbcstudy");
            ds.setUser("root");
            ds.setPassword("XDP");
            ds.setInitialPoolSize(10);
            ds.setMinPoolSize(5);
            ds.setMaxPoolSize(20);*/
            
            //通过读取C3P0的xml配置文件创建数据源，C3P0的xml配置文件c3p0-config.xml必须放在src目录下
            //ds = new ComboPooledDataSource();//使用C3P0的默认配置来创建数据源
            ds = new ComboPooledDataSource("MySQL");//使用C3P0的命名配置来创建数据源
        }catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    
    /**
    * @Method: getConnection
    * @Description: 从数据源中获取数据库连接
    * @Anthor:孤傲苍狼
    * @return Connection
    * @throws SQLException
    */ 
    public static Connection getConnection() throws SQLException{
        //从数据源中获取数据库连接
        return ds.getConnection();
    }
    
    /**
    * @Method: release
    * @Description: 释放资源，
    * 释放的资源包括Connection数据库连接对象，负责执行SQL命令的Statement对象，存储查询结果的ResultSet对象
    * @Anthor:孤傲苍狼
    *
    * @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();
            }
        }
    }
}

4、测试C3P0数据源

public class DataSourceTest {
    
    @Test
    public void c3p0DataSourceTest() {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try{
            conn = JdbcUtils_C3P0.getConnection();
            String sql = "insert into test1(name) values(?)";
            st = conn.prepareStatement(sql);
            st.setString(1, "gacl");
            st.executeUpdate();
            //获取数据库自动生成的主键
            rs = st.getGeneratedKeys();
            if(rs.next()){
                System.out.println(rs.getInt(1));
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            JdbcUtils_C3P0.release(conn, st, rs);
        }
    }
}

配置Tomcat数据源

在实际开发中，我们有时候还会使用服务器提供给我们的数据库连接池，比如我们希望Tomcat服务器在启动的时候可以帮我们创建一个数据库连接池，那么我们在应用程序中就不需要手动去

创建数据库连接池，直接使用Tomcat服务器创建好的数据库连接池即可。要想让Tomcat服务器在启动的时候帮我们创建一个数据库连接池，那么需要简单配置一下Tomcat服务器。

JNDI技术简介

JNDI(Java Naming and Directory Interface)，Java命名和目录接口，它对应于J2SE中的javax.naming包，

　　这套API的主要作用在于：它可以把Java对象放在一个容器中（JNDI容器），并为容器中的java对象取一个名称，以后程序想获得Java对象，只需通过名称检索即可。其核心API为Context，

它代表JNDI容器，其lookup方法为检索容器中对应名称的对象。Tomcat服务器创建的数据源是以JNDI资源的形式发布的，所以说在Tomat服务器中配置一个数据源实际上就是在配置一个JNDI资

源，通过查看Tomcat文档，我们知道使用如下的方式配置tomcat服务器的数据源：

<Context>
  <Resource name="jdbc/datasource" auth="Container"
            type="javax.sql.DataSource" username="root" password="XDP"
            driverClassName="com.mysql.jdbc.Driver" 
            url="jdbc:mysql://localhost:3306/jdbcstudy"
            maxActive="8" maxIdle="4"/>
</Context>

Tomcat服务器创建好数据源之后是以JNDI的形式绑定到一个JNDI容器中的，我们可以把JNDI想象成一个大大的容器，我们可以往这个容器中存放一些对象，一些资源，JNDI容器中存放的对象和资

源都会有一个独一无二的名称，应用程序想从JNDI容器中获取资源时，只需要告诉JNDI容器要获取的资源的名称，JNDI根据名称去找到对应的资源后返回给应用程序。我们平时做javaEE开发时，服

务器会为我们的应用程序创建很多资源，比如request对象，response对象，服务器创建的这些资源有两种方式提供给我们的应用程序使用：第一种是通过方法参数的形式传递进来，比如我们在Servlet

中写的doPost和doGet方法中使用到的request对象和response对象就是服务器以参数的形式传递给我们的。第二种就是JNDI的方式，服务器把创建好的资源绑定到JNDI容器中去，应用程序想要使用资

源时，就直接从JNDI容器中获取相应的资源即可。

对于上面的name="jdbc/datasource"数据源资源，在应用程序中可以用如下的代码去获取

Context initCtx = new InitialContext();
Context envCtx = (Context) initCtx.lookup("java:comp/env");
dataSource = (DataSource)envCtx.lookup("jdbc/datasource");

此种配置下，数据库的驱动jar文件需放置在tomcat的lib下。

配置Tomcat数据源

1、在Web项目的WebRoot目录下的META-INF目录创建一个context.xml文件

2、在context.xml文件配置tomcat服务器的数据源

<Context>
   <Resource 
       name="jdbc/datasource" 
       auth="Container"
       type="javax.sql.DataSource" 
       username="root" 
       password="XDP"
       driverClassName="com.mysql.jdbc.Driver" 
       url="jdbc:mysql://localhost:3306/jdbcstudy"
       maxActive="8" 
       maxIdle="4"/>
</Context>

3、将数据库的驱动jar文件需放置在tomcat的lib下

4、在获取数据库连接的工具类(如jdbcUtils)的静态代码块中获取JNDI容器中的数据源

public class JdbcUtils_JNDI {
    private static DataSource ds = null;
    //在静态代码块中创建数据库连接池
    static{
        try{
             //初始化JNDI
            Context initCtx = new InitialContext();
             //得到JNDI容器
            Context envCtx = (Context) initCtx.lookup("java:comp/env");
             //从JNDI容器中检索name为jdbc/datasource的数据源
            ds = (DataSource)envCtx.lookup("jdbc/datasource");
        }catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
    }
    
    /**
    * @Method: getConnection
    * @Description: 从数据源中获取数据库连接
    * @return Connection
    * @throws SQLException
    */ 
    public static Connection getConnection() throws SQLException{
        //从数据源中获取数据库连接
        return ds.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();
            }
        }
    }
}

4、写一个Servlet测试JNDI数据源

public class JNDITest extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        try{
            //获取数据库连接
            conn = JdbcUtils_JNDI.getConnection();
            String sql = "insert into test1(name) values(?)";
            st = conn.prepareStatement(sql);
            st.setString(1, "gacl");
            st.executeUpdate();
            //获取数据库自动生成的主键
            rs = st.getGeneratedKeys();
            if(rs.next()){
                System.out.println(rs.getInt(1));
            }
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            //释放资源
            JdbcUtils_JNDI.release(conn, st, rs);
        }
    }
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}

编写JDBC框架

DataBaseMetaData

Connection.getDatabaseMetaData()获得代表DatabaseMetaData元数据的DatabaseMetaData对象。

名称	描述
getURL()	返回一个String类对象，代表数据库的URL。
getUserName()	返回连接当前数据库管理系统的用户名。
getDatabaseProductName()	返回数据库的产品名称。
getDatabaseProductVersion()	返回数据库的版本号。
getDriverName()	返回驱动驱动程序的名称。
getDriverVersion()	返回驱动程序的版本号。
isReadOnly()	返回一个boolean值，指示数据库是否只允许读操作。

范例：

@Test
public void testDataBaseMetaData() throws SQLException {
    Connection conn = JdbcUtils.getConnection();
    DatabaseMetaData metadata = conn.getMetaData();
    //getURL()：返回一个String类对象，代表数据库的URL
    System.out.println(metadata.getURL());
    //getUserName()：返回连接当前数据库管理系统的用户名
    System.out.println(metadata.getUserName());
    //getDatabaseProductName()：返回数据库的产品名称
    System.out.println(metadata.getDatabaseProductName());
    //getDatabaseProductVersion()：返回数据库的版本号
    System.out.println(metadata.getDatabaseProductVersion());
    //getDriverName()：返回驱动驱动程序的名称
    System.out.println(metadata.getDriverName());
    //getDriverVersion()：返回驱动程序的版本号
    System.out.println(metadata.getDriverVersion());
    //isReadOnly()：返回一个boolean值，指示数据库是否只允许读操作
    System.out.println(metadata.isReadOnly());
    JdbcUtils.release(conn, null, null);
}

运行结果如下：

ParameterMetaData

PreparedStatement.getParameterMetaData() 获得代表PreparedStatement元数据的ParameterMetaData对象。

Select * from user where name=? And password=?

ParameterMetaData对象的常用方法：

名称	描述
getParameterCount()	获得指定参数的个数。
getParameterType(int param)	获得指定参数的sql类型，MySQL数据库驱动不支持。

范例：

@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);
}

（3）ResultSetMetaData

ResultSet. getMetaData() 获得代表ResultSet对象元数据的ResultSetMetaData对象。

名称	描述
getColumnCount()	返回resultset对象的列数。
getColumnName(int column)	获得指定列的名称。
getColumnTypeName(int column)	获得指定列的类型。

范例：

@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操作，代码如下：

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的定义如下：

public interface ResultSetHandler {
    
    /**
    * @Method: handler
    * @Description: 结果集处理方法
    * @param rs 查询结果集
    * @return
    */ 
    public Object handler(ResultSet rs);
}

用户只要实现了ResultSetHandler接口，那么就是针对查询结果集写了一个处理器，在query方法内部就调用用户自己写的处理器处理结果集。

编写常用的结果集处理器

为了提高框架的易用性，我们可以事先就针对结果集写好一些常用的处理器，比如将结果集转换成bean对象的处理器，将结果集转换成bean对象的list集合的处理器。

1、BeanHandler——将结果集转换成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集合的处理器

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操作就非常方便了，如下所示：

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));
    }
}

编写的这个JDBC框架就是模拟Apache的DBUtils框架的实现，下一篇将具体介绍Apache的DBUtils框架。

查看全文

相关阅读:
课堂练习
 日程管理测试用例
 日程管理APP的测试计划和测试矩阵
 日程管理Bug Report
图书管理系统活动图
 团队如何做决定？
课堂练习
 课堂练习（NABCD Model）
课堂练习
 日程管理的测试计划和测试矩阵

原文地址：https://www.cnblogs.com/pengjingya/p/14904710.html