03 事务，连接池DBCP，C3P0，DBUtils

事务

Transaction  其实指的一组操作，里面包含许多个单一的逻辑。只要有一个逻辑没有执行成功，那么都算失败。 所有的数据都回归到最初的状态(回滚)

事务的作用：
为了确保逻辑的成功。 例子： 银行的转账。

命令行方式：
开启事务
    start transaction;
提交或者回滚事务
    commit; 提交事务， 数据将会写到磁盘上的数据库
    rollback ;  数据回滚，回到最初的状态。
关闭自动提交功能
show variable like '%commit%';
查看autocommit默认是on
set autocommit = off；

代码方式：
代码里面的事务，主要是针对连接来的。
    1.  通过conn.setAutoCommit（false ）来关闭自动提交的设置。
    2. 提交事务  conn.commit();
    3. 回滚事务 conn.rollback();

    @Test
    public void testTransaction(){

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtil.getConn();

            //连接，事务默认就是自动提交的。 关闭自动提交。
            conn.setAutoCommit(false);

            String sql = "update account set money = money - ? where id = ?";
            ps = conn.prepareStatement(sql);

            //扣钱， 扣ID为1 的100块钱
            ps.setInt(1, 100);
            ps.setInt(2, 1);
            ps.executeUpdate();

            int a = 10 /0 ;

            //加钱， 给ID为2 加100块钱
            ps.setInt(1, -100);
            ps.setInt(2, 2);
            ps.executeUpdate();

            //成功： 提交事务。
            conn.commit();

        } catch (SQLException e) {
            try {
                //事变： 回滚事务
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();

        }finally {
            JDBCUtil.release(conn, ps, rs);
        }
    }

事务的特性，acid

* 原子性（Atomicity）
指的是 事务中包含的逻辑，不可分割。
* 一致性（Consistency）
指的是 事务执行前后。数据完整性
* 隔离性（Isolation）
指的是 事务在执行期间不应该受到其他事务的影响
* 持久性（Durability）
 指的是 事务执行成功，那么数据应该持久保存到磁盘上。

事务的安全隐患
 不考虑隔离级别设置，那么会出现以下问题。

* 读
脏读 不可重读读  幻读.

* 脏读，一个事务读到另外一个事务还未提交的数据

* 不可重复读 ，一个事务读到了另外一个事务提交的数据 ，造成了前后两次查询结果不一致。
* 写

    * 丢失更新

Read Uncommited【读未提交】

指的是 ： 一个事务可以读取到另一个事务还未提交的数据。 这就会引发 “脏读” 读取到的是数据库

内存中的数据，而并非真正磁盘上的数据。

例子：

    1. 开启一个命令行窗口A， 开始事务，然后查询表中记录。  设置当前窗口的事务隔离级别为

读未提交  命令如下：

            set session transaction isolation level read uncommitted;

    2. 另外在打开一个窗口B， 也开启事务， 然后执行 sql 语句， 但是不提交

    3. 在A窗口重新执行查询， 会看到B窗口没有提交的数据。
    查看隔离级别：select @@tx_isolation;
1. 设置A窗口的隔离级别为 读未提交

Read Commited 【读已提交】

这个隔离级别能够屏蔽 脏读的现象， 但是引发了另一个问题  ，不可重复读。
只能读取到其他事务已经提交的数据，那些没有提交的数据是读不出来的。但是这会造成一个问题是：

前后读取到的结果不一样。 发生了不可重复!!!, 所谓的不可重复读，就是不能执行多次读取，否则出

现结果不一 。 例子如下：

    1. 开启一个命令行窗口A， 开始事务，然后查询表中记录。  设置当前窗口的事务隔离级别为

读未提交  命令如下：
            set session transaction isolation level read committed;

    2. 另外在打开一个窗口B， 也开启事务， 然后执行 sql 语句， 但是不提交
    3. 在A窗口重新执行查询， 是不会看到B窗口刚才执行sql 语句的结果，因为它还没有提交。
    4. 在B窗口执行提交。
    5. 在A窗口中执行查看， 这时候才会看到B窗口已经修改的结果。
    6. 但是这会造成一个问题是： 在A窗口中， 第一次查看数据和第二次查看数据，结果不一样

。

Repeatable Read 【重复读】 -  MySql 默认的隔离级别就是这个。

该隔离级别， 可以让事务在自己的会话中重复读取数据，并且不会出现结果不一样的状况，即使其他事

务已经提交了，也依然还是显示以前的数据。

    1. 开启一个命令行窗口A， 开始事务，然后查询表中记录。  设置当前窗口的事务隔离级别为

重复读  命令如下：

            set session transaction isolation level repeatable read;

    2. 另外在打开一个窗口B， 也开启事务， 然后执行 sql 语句， 但是不提交
    3. 在A窗口重新执行查询， 是不会看到B窗口刚才执行sql 语句的结果，因为它还没有提交。
    4. 在B窗口执行提交。
    5. 在A窗口中执行查看， 这时候查询结果，和以前的查询结果一致。不会发生改变。

Serializable 【可串行化】

该事务级别是最高级的事务级别了。

    1. 开启一个命令行窗口A， 开始事务，然后查询表中记录。  设置当前窗口的事务隔离级别为

读未提交  命令如下：

            set session transaction isolation level read serializable;

    2. 另外在打开一个窗口B， 也开启事务， 然后执行 sql 语句， 但是不提交

    3. 在A窗口重新执行查询， 会卡主，没有任何信息显示。
    4. 在B窗口执行提交。
    5. 在A窗口中执行查看， 这时候才会显示结果。

Serializable  可以防止上面的所有问题，但是都使用该隔离级别也会有些问题。 比如造成并发的性能问题。 其他的事务必须得等当前正在操作表的事务先提交，才能接着往下，否则只能一直在等着。
如果有一个连接的隔离级别设置为了串行化 ，那么谁先打开了事务， 谁就有了先执行的权利， 谁后打开事务，谁就只能得着，等前面的那个事务，提交或者回滚后，才能执行。  但是这种隔离级别一般比
较少用。 容易造成性能上的问题。 效率比较低。

按效率划分，从高到低

> 读未提交  > 读已提交  > 可重复读  > 可串行化

 按拦截程度 ，从高到底

> 可串行化 > 可重复读 > 读已提交 >  读未提交

丢失更新：
指一个事务去修改数据库， 另一个事务也修改数据库，最后的那个事务，不管是提交还是回滚都会造成前面一个事务的数据更新丢失

解决丢失更新，通常有两种方法:  悲观锁 和 乐观锁

悲观锁
可以在查询的时候，加入 for update

乐观锁

要求程序员自己控制。
通过比对版本或者比对字段的方式来实现的， 这与使用到的版本控制软件【SVN , GIT】机制是一样的。

事务总结
需要掌握的

1. 在代码里面使用事务
        conn.setAutoCommit(false);
        conn.commit();
        conn.rollback();

2. 事务只是针对连接连接对象，如果再开一个连接对象，那么那是默认的提交。
3. 事务是会自动提交的。

需要了解的

1.安全隐患：

读
        脏读
            一个事务读到了另一个事务未提交的数据
        不可重复读
            一个事务读到了另一个事务已提交的数据，造成前后两次查询结果不一致
        幻读
            一个事务读到了另一个事务insert的数据 ，造成前后查询结果不一致 。
    写

丢失更新。

2.隔离级别
读未提交

> 引发问题： 脏读

读已提交

> 解决： 脏读 ， 引发： 不可重复读

可重复读

> 解决： 脏读 、 不可重复读 ， 未解决： 幻读

可串行化

> 解决： 脏读、 不可重复读 、 幻读。

mySql 默认的隔离级别是 可重复读

Oracle 默认的隔离级别是  读已提交

如何扩展某一个方法?
 原有的方法逻辑，不是我们想要的。 想修改自己的逻辑
1. 直接改源码  无法实现。
2. 继承， 必须得知道这个接口的具体实现是谁。
3. 使用装饰者模式。

开源连接池：
DBCP

1. 导入jar文件
commons-dbcp-1.4.jar
commons-pool-1.5.6.jar
2. 不使用配置文件：

        public void testDBCP01(){

            Connection conn = null;
            PreparedStatement ps = null;
            try {

                //1. 构建数据源对象
                BasicDataSource dataSource = new BasicDataSource();
                //连的是什么类型的数据库， 访问的是哪个数据库 ， 用户名，

密码。。
                //jdbc:mysql://localhost/bank 主协议：子协议 ://本地/数据库
                dataSource.setDriverClassName("com.mysql.jdbc.Driver");
                dataSource.setUrl("jdbc:mysql://localhost/bank");
                dataSource.setUsername("root");
                dataSource.setPassword("root");

                //2. 得到连接对象
                conn = dataSource.getConnection();
                String sql = "insert into account values(null , ? , ?)";
                ps = conn.prepareStatement(sql);
                ps.setString(1, "admin");
                ps.setInt(2, 1000);

                ps.executeUpdate();

            } catch (SQLException e) {
                e.printStackTrace();
            }finally {
                JDBCUtil.release(conn, ps);
            }

        }

2. 使用配置文件方式：

    Connection conn = null;
        PreparedStatement ps = null;
        try {
            BasicDataSourceFactory factory = new BasicDataSourceFactory();
            Properties properties = new Properties();
            InputStream is = new FileInputStream("src//dbcpconfig.properties");
            properties.load(is);
            DataSource dataSource = factory.createDataSource(properties);

            //2. 得到连接对象
            conn = dataSource.getConnection();
            String sql = "insert into account values(null , ? , ?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "liangchaowei");
            ps.setInt(2, 100);

            ps.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, ps);
        }

C3P0
 拷贝jar文件 到 lib目录
c3p0-0.9.1.2.jar
不使用配置文件方式

        Connection conn = null;
        PreparedStatement ps = null;
        try {
            //1. 创建datasource
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            //2. 设置连接数据的信息
            dataSource.setDriverClass("com.mysql.jdbc.Driver");

            dataSource.setJdbcUrl("jdbc:mysql://localhost/bank");
            dataSource.setUser("root");
            dataSource.setPassword("root");

            //2. 得到连接对象
            conn = dataSource.getConnection();
            String sql = "insert into account values(null , ? , ?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "admi234n");
            ps.setInt(2, 103200);

            ps.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(conn, ps);
        }

使用配置文件方式

     //默认会找 xml 中的 default-config 分支。
            ComboPooledDataSource dataSource = new ComboPooledDataSource();

            //2. 得到连接对象
            conn = dataSource.getConnection();
            String sql = "insert into account values(null , ? , ?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, "admi234n");
            ps.setInt(2, 103200);

c3p0-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>

    <!-- default-config 默认的配置，  -->
  <default-config>
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost/xx</property>
    <property name="user">root</property>
    <property name="password">xx</property>

    <property name="initialPoolSize">10</property>
    <property name="maxIdleTime">30</property>
    <property name="maxPoolSize">100</property>
    <property name="minPoolSize">10</property>
    <property name="maxStatements">200</property>
  </default-config>

   <!-- This app is massive! -->
  <named-config name="oracle">
    <property name="acquireIncrement">50</property>
    <property name="initialPoolSize">100</property>
    <property name="minPoolSize">50</property>
    <property name="maxPoolSize">1000</property>

    <!-- intergalactoApp adopts a different approach to configuring statement caching -->
    <property name="maxStatements">0</property>
    <property name="maxStatementsPerConnection">5</property>

    <!-- he's important, but there's only one of him -->
    <user-overrides user="master-of-the-universe">
      <property name="acquireIncrement">1</property>
      <property name="initialPoolSize">1</property>
      <property name="minPoolSize">1</property>
      <property name="maxPoolSize">5</property>
      <property name="maxStatementsPerConnection">50</property>
    </user-overrides>
  </named-config>

</c3p0-config>

DBUtils：
commons-dbutils-1.4.jar
增删改

                //dbutils 只是帮我们简化了CRUD 的代码， 但是连接的创建以及

获取工作。 不在他的考虑范围
        QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());

        //增加
        //queryRunner.update("insert into account values (null , ? , ? )", "aa"

,1000);

        //删除
        //queryRunner.update("delete from account where id = ?", 5);

        //更新
        //queryRunner.update("update account set money = ? where id = ?", 10000000 , 6);

查询

1. 直接new接口的匿名实现类

       QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());

        Account  account =  queryRunner.query("select * from account where id = ?",

new ResultSetHandler<Account>(){

            @Override
            public Account handle(ResultSet rs) throws SQLException {
                Account account  =  new Account();
                while(rs.next()){
                    String name = rs.getString("name");
                    int money = rs.getInt("money");

                    account.setName(name);
                    account.setMoney(money);
                }
                return account;
            }

         }, 6);

        System.out.println(account.toString());

2. 直接使用框架已经写好的实现类

    * 查询单个对象

        QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
        //查询单个对象
        Account account = queryRunner.query("select * from account where id = ?",
                new BeanHandler<Account>(Account.class), 8);
    //Account.class内部通过反射获取类的实例
    //Account.class.newInstance()

    * 查询多个对象

        QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
        List<Account> list = queryRunner.query("select * from account ",
                new BeanListHandler<Account>(Account.class));
    

ResultSetHandler 常用的实现类
以下两个是使用频率最高的

BeanHandler,  查询到的单个数据封装成一个对象
    BeanListHandler, 查询到的多个数据封装 成一个List<对象>

其他
    ArrayHandler,  查询到的单个数据封装成一个数组
    ArrayListHandler,  查询到的多个数据封装成一个集合 ，集合里面的元素是数组。
   
    MapHandler,  查询到的单个数据封装成一个map
    MapListHandler,查询到的多个数据封装成一个集合 ，集合里面的元素是map。

ColumnListHandler
KeyedHandler
ScalarHandler 用于处理平均值，总的个数

元数据
Meata data
描述数据的数据 String sql , 描述这份sql字符串的数据叫做元数据
数据库元数据 DatabaseMetaData

参数元数据 ParameterMetaData

结果集元数据 ResultSetMetaData

dbutils自定义：

import java.sql.ResultSet;
/**
 * 查询返回结果接口
 * @author fly
 *
 * @param <T>
 */
public interface ResultSetHandler<T> {
    public T handle(ResultSet rs);
}

import java.sql.Connection;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.fly.util.JDBCUtil2;

public class MyQueryRunner {
    /**
     * 通用查询功能
     * @param sql 需要操作的sql语句
     * @param rsh 定义查询返回的类型
     * @param args sql语句的参数
     * @return 查询的结果
     */
    public<T> T query(String sql,ResultSetHandler<T> rsh,Object...args) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs=null;
        try {
            conn = JDBCUtil2.getConn();
            ps = conn.prepareStatement(sql);
//            参数元数据
            ParameterMetaData metaData = ps.getParameterMetaData();
            int count = metaData.getParameterCount();
            for (int i = 0; i < count; i++) {
                ps.setObject(i+1,args[i]);
            }
            rs = ps.executeQuery();
            T t = rsh.handle(rs);
            return t;

        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtil2.closeAll(conn, ps, rs);
        }
        return null;
    }
    /**
     * 通用的增删改功能
     * @param sql 需要操作的sql语句
     * @param args sql语句的参数
     * @return 受影响的行数
     */
    public int update(String sql,Object...args) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JDBCUtil2.getConn();
            ps = conn.prepareStatement(sql);
            ParameterMetaData metaData = ps.getParameterMetaData();
            int count = metaData.getParameterCount();
            for (int i = 0; i < count; i++) {
                ps.setObject(i+1,args[i]);
            }
            int update = ps.executeUpdate();
            return update;
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            JDBCUtil2.closeAll(conn, ps);
        }
        return (Integer) null;
    }
}

测试：

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

import org.junit.Test;

public class TestCRUD {
    @Test
    public void queryDemo() {
        MyQueryRunner queryRunner = new MyQueryRunner();
        String sql = "select * from account where id=?";
        Account account = queryRunner.query(sql, new ResultSetHandler<Account>() {

            @Override
            public Account handle(ResultSet rs) {
                try {
                    Account account = new Account();
                    if (rs.next()) {
                        account.setName(rs.getString("name"));
                        account.setMoney(rs.getInt("money"));
                    }
                    return account;
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, 1);
        System.out.println(account.toString());
    }
    @Test
    public void queryDemo2() {
        MyQueryRunner queryRunner = new MyQueryRunner();
        String sql = "select * from account where id>?";
        List<Account> accounts = queryRunner.query(sql, new

ResultSetHandler<List<Account>>() {

            @Override
            public List<Account> handle(ResultSet rs) {
                try {
                    List<Account> list = new ArrayList<>();
                    while (rs.next()) {
                        Account account = new Account();
                        account.setName(rs.getString("name"));
                        account.setMoney(rs.getInt("money"));
                        list.add(account);
                    }
                    return list;
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                return null;
            }

        }, 1);
        for (Account account : accounts) {
            System.out.println(account.toString());
        }
    }
    @Test
    public void updateDamo() {
        MyQueryRunner queryRunner = new MyQueryRunner();
//        String sql = "insert into account values(null,?,?)";
//        String sql = "update account set money=? where name=?";
        String sql = "delete from account where name=?";
//        int update = queryRunner.update(sql,1000,"lisi");
        int update = queryRunner.update(sql,"lisi");
        System.out.println(update);
    }
}

JDBCUti：

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

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class JDBCUtil2 {

    static ComboPooledDataSource dataSource = null;
    static {
        dataSource = new ComboPooledDataSource();
    }
    /**
     * 返回DataSource
     * @return
     */
    public static DataSource getDataSouse() {
        return dataSource;
    }
    /**
     * 返回连接对象
     * @return
     */
    public static Connection getConn() {
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 释放资源
     * @param conn
     * @param st
     * @param rs
     */
    public static void closeAll(Connection conn,Statement st,ResultSet rs) {
        closeRs(rs);
        closeSt(st);
        closeConn(conn);
    }
    public static void closeAll(Connection conn,Statement st) {
        closeSt(st);
        closeConn(conn);
    }

    private static void closeRs(ResultSet rs) {
        try {
            if (rs!=null) {
                rs.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            rs = null;
        }
    }
    private static void closeSt(Statement st) {
        try {
            if (st!=null) {
                st.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            st = null;
        }
    }
    private static void closeConn(Connection conn) {
        try {
            if (conn!=null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            conn = null;
        }
    }
}