事务，数据库连接池与Sping JDBC

一.事务

1.概念
如果一个包含多个步骤的业务操作，被事务管理，那么这些操作要么同时成功，要么同时失败。
2.操作：
1.开启事务： start transaction;
2. 回滚：rollback;
3. 提交：commit;
3.事务的四大特性
原子性：事务是最小的执行单位，不允许被分割，事务的原子性确保动作要么全部完成，要么全部失败。
持久性：一个事务被提交后，他对数据库中数据的改变是持久的，即使数据库发生故障也不应该对其有任何影响。
一致性：执行事务前后，数据保持一致，多个事务对同一个数据读取的结果是相同的。
隔离性：并发访问数据库时，一个用户的事务不被其他事务所干扰，各并发事务之间数据库是独立的。
4.并发事务带来哪些问题
脏读：当一个事务正在访问数据库并对数据进行修改时，这次修改还未提交到数据库中，这时另一个事务也访问了这个数据，并且使用了这个数据，因为这个数据是本事务提交前的数据，所以第二个事务读到的数据就是脏数据，依据脏数据的操作可能是不正确的。
丢失修改：指在一个事务读取一个数据时，对数据进行了修改，同时另一事务也访问了该数据并修改，这样第一个事务的修改数据就丢失了，因此称之为丢失修改。
不可重复读:指在一个事务多次读取数据，在两次读取数据的之间时，一个新事务修改了我们的数据，那么本次事务的两次相同的读取数据呈现出不同的结果，因此称为不可重复读。
幻读：与不可重复读类似，当事务1读取了几条数据后，事务2插入了几条数据，事务1再次读取数据时发现多了几条数据，与之前的查询结果不符，像是幻觉，因此称之为幻读。
5.事务的隔离级别
读未提交：最低的隔离级别，允许读取未提交的数据变更，可能会导致脏读，不可重复读，幻读问题。
读已提交：解决脏读问题，但其他问题仍有可能发生 sqlServer oracle。
可重复读：阻止脏读，不可重复读，不可解决幻读 mysql SELECT @@tx_isolation。
可串行化：都可解决。
6.JDBC调用事务
使用Connection对象来管理事务

• 开启事务：setAutoCommit(boolean autoCommit) ：调用该方法设置参数为false，即开启事务
• 在执行sql之前开启事务
• 提交事务：commit()
• 当所有sql都执行完提交事务
• 回滚事务：rollback()
• 在catch中回滚事务

案例：

package com.zhongruan.demo1;

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

public class Demo1 {
    public static void main(String[] args) {
        Connection conn = null;
        PreparedStatement pst1 = null;
        PreparedStatement pst2 = null;
        try {
            conn = DBUtils.getconn();
            //关闭自动提交事务
            conn.setAutoCommit(false);
            //转出
            String sql1 = "update account set balance=balance-? where id=?";
            //转入
            String sql2 = "update account set balance=balance+? where id=?";
            pst1 = conn.prepareStatement(sql1);
            pst2 = conn.prepareStatement(sql2);
            pst1.setDouble(1, 300);
            pst1.setInt(2, 1);
            pst2.setDouble(1, 300);
            pst2.setInt(2, 2);
            pst1.executeUpdate();
            int i = 3 / 0;
            pst2.executeUpdate();
            //提交事务
            conn.commit();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            DBUtils.close(pst2, conn);
            DBUtils.close(pst1,null);
        }
    }
}

二.数据库连接池

1.概念：其实就是一个容器(集合)，存放数据库连接的容器。当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
2. 好处：
1. 节约资源
2. 用户访问高效
3.实现：
数据库连接池技术有2种：C3P0与druid。
C3P0：
步骤：
1.导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar 。
2.定义配置文件：
名称： c3p0.properties 或者 c3p0-config.xml
路径：直接将文件放在src目录下即可。
3. 创建核心对象 数据库连接池对象 ComboPooledDataSource。
4. 获取连接： getConnection。
案例：
配置文件c3p0-config.xml：

在这里插入代码片<c3p0-config>
    <!-- 使用默认的配置读取连接池对象 -->
    <default-config>
        <!--  连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb2</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <!-- 连接池参数 -->
        <!--初始化申请的连接数量-->
        <property name="initialPoolSize">5</property>
        <!--最大的连接数量-->
        <property name="maxPoolSize">10</property>
        <!--超时时间-->
        <property name="checkoutTimeout">3000</property>
    </default-config>

    <named-config name="otherc3p0">
        <!--  连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb1</property>
        <property name="user">root</property>
        <property name="password">123456</property>

        <!-- 连接池参数 -->
        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">8</property>
        <property name="checkoutTimeout">1000</property>
    </named-config>
</c3p0-config>

package com.zhongruan.demo1;

import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;

public class Demo_C3p0 {
    public static void main(String[] args) throws SQLException {
        // 1.创建combo类
        DataSource ds = new ComboPooledDataSource();
        for (int i=0;i<11;i++){
            //2.直接获取对象
            Connection conn = ds.getConnection();
            System.out.println(conn);
            if (i==5){
                conn.close();
            }
        }
    }
}

druid：
1.步骤：
1.导入jar包 druid-1.0.9.jar
2. 定义配置文件：
是properties形式的
可以叫任意名称，可以放在任意目录下
3.加载配置文件。Properties
4.获取数据库连接池对象：通过工厂来来获取 DruidDataSourceFactory
5.获取连接：getConnection
2.定义工具类
1.定义一个类 JDBCUtils
3. 提供静态代码块加载配置文件，初始化连接池对象
3.提供方法
1.获取连接方法：通过数据库连接池获取连接
4. 释放资源
5. 获取连接池的方法
案例：
配置文件druid.properties：

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb2
username=root
password=123456
initialSize=5
maxActive=10
maxWait=3000

工具类JDBCUtils：

package com.zhongruan.demo1;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JDBCUtils {
    private static  DataSource ds=null;
     static {
        try {
            //1.导入jar包
            //2.定义配置文件
            //3.加载配置文件
            Properties pro = new Properties();
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            pro.load(is);
            //获取数据库连接对象
            ds = DruidDataSourceFactory.createDataSource(pro);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
     }
    /**
     * 获取连接
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /**
     * 释放资源
     */
    public static void close(Statement stmt, Connection conn){
        close(null,stmt,conn);
    }

    public static void close(PreparedStatement pst, Connection conn){
        if (pst != null) {
            try {
                pst.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }

        }
    }

    public static void close(ResultSet rs , Statement stmt, Connection conn){
        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();
            }
        }
    }

    /**
     * 获取连接池方法
     */

    public static DataSource getDateSource()  {
        return ds;
    }

}

三.Spring JDBC

Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发。
步骤：
1.导入jar包
2. 创建JdbcTemplate对象。依赖于数据源DataSource
JdbcTemplate template = new JdbcTemplate(ds);
3.调用JdbcTemplate的方法来完成CRUD的操作
* update():执行DML语句。增、删、改语句
* queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
* 注意：这个方法查询的结果集长度只能是1
* queryForList():查询结果将结果集封装为list集合
* 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
* query():查询结果，将结果封装为JavaBean对象
* query的参数：RowMapper
* 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
* new BeanPropertyRowMapper<类型>(类型.class)
* queryForObject：查询结果，将结果封装为对象
* 一般用于聚合函数的查询
案例：
定义类调用上文中的JDBCUtils

package com.zhongruan.demo1;
import org.springframework.jdbc.core.JdbcTemplate;
public class Demo2 {
    public static void main(String[] args) {
        //1.导入jar包
        //2.创建JDBCTemplate对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDateSource());
        //3.定义sql语句
        String sql = "insert into account(Name,balance) values(?,?)";
        int count = template.update(sql, "王五", 1500);
        if (count>0){
            System.out.println("添加成功!!");
        }else{
            System.out.println("添加失败!!");
        }
    }
}