事务与数据库连接池

目录

事务

事务的概述（理解）

在MySQL中操作事务（掌握） 

在JDBC中操作事务（掌握）

事务的特性（理解）

不考虑事务的隔离性会引发的问题（理解） 

设置事务的隔离级别（解决读的问题）

演示脏读

避免脏读和演示不可重复读

避免不可重复读

避免各种读

数据库连接池（使用开源的连接池）

连接池的概述

DataSource接口概述

常见的连接池

---

事务

事务的概述（理解）

1.概述：了解什么是事务

        事务是数据库提供的一个特性。

        事务：组成各个数据的执行的单元，要么都成功，要么都不成功。

2.转账的例子

        转账的功能，冠希给美美转1000元钱。

        使用事务

                先给冠希扣除掉1000元

                再给美美加上1000元

        事务结束了

在MySQL中操作事务（掌握） 

1.数据库的信息

        create table t_account(

                id int primary key auto_increment,

                username varchar(20),

                money double

        );

        insert into t_account values (null,'美美',10000);

        insert into t_account values (null,'冠希',10000);

        insert into t_account values (null,'小凤',10000);

        insert into t_account values (null,'熊大',10000);

        insert into t_account values (null,'熊二',10000);

2.在MySQL数据库中使用事务，提供两种方式（重点）

        模拟转账的例子，冠希给美美转钱

        第一种方式（使用命令的方式）

                start transaction;‐‐ 开启事务

                update t_account set money = money ‐ 1000 where username = '冠希';                        update t_account set money = money + 1000 where username = '美美';

                commit;‐‐ 提供事务（事务已经结束了，数据永久的保存到数据库中了）

                rollback;‐‐ 回滚事务（事务已经结束了，数据回滚到最初始化的状态）

        第二种方式（设置MySQL事务不默认提交的方式）

                MySQL数据库的事务是默认提交的。

                        update t_account set money = money ‐ 1000 where username = '冠希';‐‐ 这一条语句 默认使用了一个事务。

                设置让MySQL的数据库的事务不默认提交

                        set autocommit = off或者0‐‐ 设置MySQL事务的事务不默认提交

                编写SQL语句（执行完，都没有提交）

                        sql1

                        sql2

                需要手动的提交或者回顾

                        commit;

                        rollback;

                演示第二种方式

                        show variables like '%commit%'; ‐‐ 查看事务的是事务是否是默认提交

                        set autocommit = off;‐‐ 设置不默认提交                                                  update t_account set money = money ‐ 1000 where username = '冠希';                                update t_account set money = money + 1000 where username = '美美';                                commit;或者rollback;

在JDBC中操作事务（掌握）

1.操作事务，需要掌握的是Connection接口，提供了方法         void setAutoCommit(boolean autoCommit) ‐‐ 如果传入了false，设置了MySQL数据库的事务不默认提交的。

        void commit() ‐‐ 提交事务

        void rollback() ‐‐ 回滚事务

2.Connection接口的2个作用

        操作数据库，都需要使用Connection接口

        管理事务

事务的特性（理解）

事务的特性：

        原子性：原子性对应的英文是Atomicity，即表示事务中所有操作是不可再分割的原子单位。事务中所有操作要么全 部执行成功，要么全部执行失败；

        一致性：一致性对应的英文是Consistency，事务执行后，数据库状态与其它业务规则保持一致。例如转账业务，无 论事务执行成功与否，参与转账的两个账号余额之和应该是不变的；

        隔离性：隔离性对应的英文是Isolation，是指在并发操作中，不同事务之间应该隔离开来，使每个并发中的事务不 会相互干扰；

        持久性：持久性对应的英文是Durability，指的是一旦事务提交成功，事务中所有的数据操作都必须被持久化到数据 库中，即使提交事务后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据。

1.事务的特性

        原子性        ‐‐ 强调的是事务的不可分割的特性

        一致性        ‐‐ 强调的是事务执行前后数据需要保证一致

        隔离性        ‐‐ 强调的是多个事务同时操作一条记录，事务之间不能互相干扰

        持久性        ‐‐ 强调的是事务一旦结束了，数据将永久的保存到数据库中

2.这些特性都是数据库提供的

不考虑事务的隔离性会引发的问题（理解） 

1.脏读：一个事务读取到了另一个事务未提交的数据！

2.不可重复读：一个事务读取到了另一个事务提交的数据，导致了多次查询的结果不一致。强调的是update，修改记录 的数据。

3.虚度（幻读）：一个事务读取到了另一个事务提交的数据，导致了多次查询的结果不一致。强调是insert，向表中添 加一条数据。

设置事务的隔离级别（解决读的问题）

1.事务的隔离级别（设置数据库的隔离级别，根据级别的不同，解决上述的读的问题）         Read uncommitted‐‐ 什么都解决不了

        Read committed

        Repeatable read

        Serializable‐‐ 避免脏读，但是不可重复读和虚读有可能产生‐‐ 避免脏读和不可重复读，虚度有可能产生的‐‐ 避免各种读

2.4种隔离级别有安全性和效率

        安全 Serializable > Repeatable read > Read committed > Read uncommitted

        效率 Serializable < Repeatable read < Read committed < Read uncommitted

3.数据库都有自己默认的隔离级别

        MySQL的数据库，默认的隔离级别是Repeatable read，避免脏读和不可重复读。

演示脏读

1.脏读：一个事务读取到了另一个事物未提交的数据。

2.进行测试

        开启两个窗口，一个A窗口（左），一个B窗口（右）。

        在A窗口中，查询A窗口的隔离级别：select @@tx_isolation;

        设置A窗口的隔离级别为最低级别：set session transaction isolation level read uncommitted;

        在两个窗口中，都开启事物

                start transaction;

        在B窗口中完成转账的工作。（冠希给美美转1千钱）                    update t_account set money = money ‐ 1000 where username = '冠希';                         update t_account set money = money + 1000 where username = '美美';

                注意：B窗口的事物未提交。

        在A窗口中，查询的结果（美美）

                select * from t_account;

        在B窗口中，回滚的是事物

                rollback;

避免脏读和演示不可重复读

1.避免脏读的发生，提高的隔离级别。         set session  transaction isolation level  read committed;

        在两个窗口中，都开启事物

                start transaction;

        在B窗口中完成转账的工作。（冠希给美美转1千钱）                    update t_account set money = money ‐ 1000 where username = '冠希';                         update t_account set money = money + 1000 where username = '美美';

                注意：事物还是没有提交，但是你需要观察A窗口中是否能读取到B创建未提交的数据。

        在A窗口中，查询的结果（美美）

                select * from t_account;

        在B窗口中把事物提交了

                commit;

        在A窗口中，再查询一次钱。

                两次查询的结果不一致，发生了不可重复读。

避免不可重复读

1.设置隔离级别：set session  transaction isolation level  repeatable read;

        在两个窗口中，都开启事物

                start transaction;

                在B窗口中完成转账的工作。（冠希给美美转1千钱）                             update t_account set money = money ‐ 1000 where username = '冠希';                                 update t_account set money = money + 1000 where username = '美美';

                        注意：事物还是没有提交，但是你需要观察A窗口中是否能读取到B创建未提交的数据。

                在A窗口中，查询的结果（美美）

                        select * from t_account;

                在B窗口中把事物提交了

                        commit;

                在A窗口中，再查询一次钱。

                        两次查询的结果不一致，发生了不可重复读

避免各种读

1.设置隔离级别：set session transaction isolation level serializable;

        在两个窗口中，都开启事物

                start transaction;

        在B窗口中添加一条数据

                insert into t_account values (null,'小苍',10000);

                注意：没有提交事物

        在A窗口中查询数据库

                select * from t_account;

数据库连接池（使用开源的连接池）

连接池的概述

1.总结

        原来：需要自己创建连接和销毁连接，这样是比较消耗时间，资源等。

        现在：有一些连接池，已经创建好了一些连接，现在可以从连接池中获取到，这样就节省创建连接时间，直接使 用这些连接，归还到连接池中。

                节省创建连接与释放连接，性能消耗

                连接池中连接起到复用的作用，提升程序性能

2.连接池（池参数，如果不指定，有默认值）

        初始大小：10个

        最小空闲连接数：3个

        增量：一次创建的最小单位（5个）

        最大空闲连接数：12个

        最大连接数：20个

        最大的等待时间：1000毫秒

3.4个参数：任何的开源的连接池，4大参数都需要自己来设置

        驱动的名称‐‐ com.mysql.jdbc.Driver

        连接‐‐ jdbc:mysql:///day14

        用户名‐‐ root

        密码‐‐ root

DataSource接口概述

1.DataSource接口，SUN公司提供的接口，任何的连接池（开源的，自定义的）必须要实现该接口。

2.DataSource接口的方法

        Connection getConnection()

        开源的连接池已经实现了DataSource接口，通过getConnection()方法就能从连接池中获取到连接。

3.连接池

        创建连接池的时候，初始化好一些连接了

        用完之后，归还连接。

常见的连接池

1. DBCP连接池，apache开源组织提供开源连接池对象。
2. C3P0连接池，开源的连接池对象。
3. DRUID连接池，阿里巴巴提供开源连接池对象。

概述：
Druid首先是一个数据库连接池。Druid是目前最好的数据库连接池，在功能、性能、扩展性方面，都超过其 他数据库连接池，包括DBCP、C3P0、BoneCP、Proxool、JBoss DataSource。Druid已经在阿里巴巴部署了 超过600个应用，经过一年多生产环境大规模部署的严苛考验。

功能：
1、替换DBCP和C3P0。Druid提供了一个高效、功能强大、可扩展性好的数据库连接池。最主要使用功能。
2、可以监控数据库访问性能，Druid内置提供了一个功能强大的StatFilter插件，能够详细统计SQL的执行性 能，这对于线上分析数据库访问性能有帮助。
3、数据库密码加密。直接把数据库密码写在配置文件中，这是不好的行为，容易导致安全问题。 DruidDruiver和DruidDataSource都支持PasswordCallback。
4、SQL执行日志，Druid提供了不同的LogFilter，能够支持Common-Logging、Log4j和JdkLog，你可以按需 要选择相应的LogFilter，监控你应用的数据库访问情况。
5、扩展JDBC，如果你要对JDBC层有编程的需求，可以通过Druid提供的Filter机制，很方便编写JDBC层的扩 展插件。

使用：
1. 导入开发的jar包druid-1.1.10.jar
2. 编写测试程序

package cn.tx.demo1;

 import com.alibaba.druid.pool.DruidDataSource;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;

 /**
 * 测试连接池对象
*/
public class JdbcTest6 {
    public static void main(String[] args) {
        // 创建连接池对象，从连接池中获取到连接对象
        DruidDataSource dataSource = new DruidDataSource();
        // 设置4个参数 驱动类 地址 用户名 密码
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///jdbcdemo");
        dataSource.setUsername("root");
        dataSource.setPassword("root");

        // 设置初始化连接个数，默认是0
        dataSource.setInitialSize(5);
        // 设置最大连接数
        dataSource.setMaxActive(10);
        // 最大等待时间，单位是毫秒 2秒
        dataSource.setMaxWait(2000);
 
        // 定义链接对象
        Connection conn = null;
        PreparedStatement stmt = null;
 
        try {
            // 获取到连接对象
            conn = dataSource.getConnection();
            // 编写SQL语句
            String sql = "insert into t_user values (null,?,?,?)";
            // 预编译SQL语句
            stmt = conn.prepareStatement(sql);
            // 设置值
            stmt.setString(1,"eee");
            stmt.setString(2,"eee");
            stmt.setString(3,"eee");
            // 执行sql
            stmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 释放资源
            if(stmt != null){
                try {
                    stmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(conn != null){
                try {
                    // 把conn关闭了，其实连接池的底层已经对close方法进行增强。原来是销毁连接，现在是归还连接。
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
 
}

3. 使用配置文件的方式

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///jdbcdemo
username=root
password=root
initialSize=5
maxActive=10
maxWait=3000
maxIdle=6
minIdle=3

 4. 编写工具类

package cn.tx.utils;

    import com.alibaba.druid.pool.DruidDataSourceFactory;

    import javax.sql.DataSource;
    import java.io.InputStream;
    import java.sql.*;
    import java.util.Properties;

    /**
     * JDBC的工具类 1.0版本
     * JDBC的工具类 2.0版本（智能一些），编写properties属性文件，程序就可以读取属性文件
     * JDBC的工具类 3.0版本，加入连接池对象
     */
public class JdbcUtils2 {

    // 连接池对象
    private static DataSource DATA_SOURCE;

    static{
        // 加载属性文件
        Properties pro = new Properties();
        InputStream inputStream = JdbcUtils2.class.getResourceAsStream("/druid.properties");
        try {
            // 加载属性文件
            pro.load(inputStream);
            // 创建连接池对象
            DATA_SOURCE = DruidDataSourceFactory.createDataSource(pro);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 从连接池中获取连接，返回。
     * @return
     */
    public static Connection getConnection(){

        Connection conn = null;
        try {
            conn = DATA_SOURCE.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
 
    /**
     * 关闭资源
     * @param conn
     * @param stmt
     * @param rs
     */
    public static void close(Connection conn, Statement stmt, ResultSet rs){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
 
    /**
     * 关闭资源
     * @param conn
     * @param stmt
     */
    public static void close(Connection conn, Statement stmt){
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
 
}