spring事务声明

spring事务声明

JdbcTemplate事务

操作数据库； Spring提供了JdbcTemplate能快捷的操作数据库； JdbcTemplate和QueryRunner差不多；

JdbcTemplate使用步骤：

1）、导包；

- spring-jdbc-4.0.0.RELEASE.jar
- spring-orm-4.0.0.RELEASE.jar
- spring-tx-4.0.0.RELEASE.jar

2）、写配置

<!--获取配置文件-->
    <context:property-placeholder location="db.properties"/>
    <!--        配置3cp0-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close" id="dataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///mybatis?characterEncoding=utf-8&amp;useSSL=false&amp;serverTimezone=UTC&amp;rewriteBatchedStatements=true"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
​
    </bean>
<!--    <bean class="com.alibaba.druid.pool.DruidDataSource" id="druidDataSource">-->
<!--        <property name="driverClassName" value="${driverClass}"/>-->
<!--        <property name="url" value="${jdbcUrl}"/>-->
<!--        <property name="username" value="${user}"/>-->
<!--        <property name="password" value="${password}"/>-->
<!--    </bean>-->
<!--    使用jar包配置获取连接-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="dataSource2">
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>
​

test

​
   ApplicationContext ioc = new ClassPathXmlApplicationContext("ApplicationContext.xml");
    JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
    NamedParameterJdbcTemplate namedJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);
​
    /**
     * 实验9：创建BookDao，自动装配JdbcTemplate对象
     */
    @Test
    public void test09(){
        EmployeeDao bean = ioc.getBean(EmployeeDao.class);
        Employee employee = new Employee();
        employee.setEmpName("哈哈2");
        employee.setSalary(998.98);
        bean.saveEmployee(employee);
    }
​
    /**
     * 实验8：重复实验7，以SqlParameterSource形式传入参数值
     */
    @Test
    public void test08(){
        String sql = "INSERT INTO employee(emp_name,salary) VALUES(:empName,:salary)";
        Employee employee = new Employee();
        employee.setEmpName("哈哈");
        employee.setSalary(998.98);
​
        //
        int i = namedJdbcTemplate.update(sql, new BeanPropertySqlParameterSource(employee));
        System.out.println(i);
​
    }
​
    /**
     * 实验7：使用带有具名参数的SQL语句插入一条员工记录，并以Map形式传入参数值
     *
     * 具名参数：（具有名字的参数，参数不是占位符了，而是一个变量名）
     *         语法格式：   :参数名
     * Spring有一个支持具名参数功能的JdbcTemplate
     *
     * 占位符参数：?的顺序千万不能乱。传参的时候一定注意；
     */
    @Test
    public void test07(){
        String sql = "INSERT INTO employee(emp_name,salary) VALUES(:empName,:salary)";
​
        //Map
        Map<String, Object> paramMap = new HashMap<>();
        //将所有具名参数的值都放在map中；
        paramMap.put("empName", "田七");
        paramMap.put("salary", 9887.98);
        int update = namedJdbcTemplate.update(sql, paramMap);
        System.out.println(update);
    }
​
    /**
     * 实验6：查询最大salary
     */
    @Test
    public void test06(){
        String sql = "select max(salary) from employee";
        //无论是返回单个数据还是单个对象，都是调用queryForObject
        Double object = jdbcTemplate.queryForObject(sql, Double.class);
        System.out.println(object);
    }
​
    /**
     * 实验5：查询salary>4000的数据库记录，封装为List集合返回
     */
    @Test
    public void test05(){
        String sql = "SELECT emp_id empId,emp_name empName,salary FROM employee WHERE salary>?";
        //封装List；集合里面元素的类型
        List<Employee> list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Employee.class), 4000);
​
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
​
    /**
     * 实验4：查询emp_id=5的数据库记录，封装为一个Java对象返回；
     * javaBean需要和数据库中字段名一致，否则无法完成封装；
     *
     * jdbcTemplate在方法级别进行了区分
     * 查询集合：jdbcTemplate.query()
     * 查询单个对象：jdbcTemplate.queryForObject()
     *         如果查询没结果就报错；
     *
     */
    @Test
    public void test04(){
        String sql = "SELECT emp_id empId,emp_name empName,salary FROM employee WHERE emp_id=?";
        //RowMapper：每一行记录和javaBean的属性如何映射
        Employee employee = null;
        try {
            employee = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Employee.class), 50);
        } catch (DataAccessException e) {
​
        }
        System.out.println(employee);
    }
​
    /**
     * 实验3：批量插入；
     */
    @Test
    public void test03(){
        String  sql ="INSERT INTO employee(emp_name,salary) VALUES(?,?)";
        //List<Object[]>
        //List的长度就是sql语句要执行的次数
        //Object[]：每次执行要用的参数
        List<Object[]> batchArgs = new ArrayList<Object[]>();
        batchArgs.add(new Object[]{"张三",1998.98});
        batchArgs.add(new Object[]{"李四",2998.98});
        batchArgs.add(new Object[]{"王五",3998.98});
        batchArgs.add(new Object[]{"赵六",4998.98});
​
        int[] is = jdbcTemplate.batchUpdate(sql, batchArgs);
        for (int i : is) {
            System.out.println(i);
        }
    }
​
    /**
     * 实验2：将emp_id=5的记录的salary字段更新为1300.00
     */
    @Test
    public void test02(){
        String sql = "UPDATE employee SET salary=? WHERE emp_id=?";
        int update = jdbcTemplate.update(sql, 1300.00,5);
        System.out.println("更新员工："+update);
    }
​
    @Test
    public void test() throws SQLException {
        DataSource bean = ioc.getBean(DataSource.class);
        Connection connection = bean.getConnection();
        System.out.println(connection);
        connection.close();
​
    }
​
    @Test
    public void test01() throws SQLException {
        System.out.println(jdbcTemplate);
    }
​
}
​

面向接口使用

@Repository
public class productDAO implements productDAOimpl{
    @Autowired
    JdbcTemplate jdbcTemplate;
    @Override
    public List<product> query() {
        String sql ="select id,name,price,cid from t_product";
        List<product> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper(product.class));
        return query;
    }
}

产品类

@NoArgsConstructor
@Data
@AllArgsConstructor
public class product {
    private Integer id;
    private String name;
    private double price;
    private int cid;
}

依赖注入

<context:component-scan base-package="dao"></context:component-scan>

test

@Test
public  void test3(){
    productDAO bean = applicationContext.getBean(productDAO.class);
    List<product> query = bean.query();
    System.out.println(query);
}

1.声明式事务

dao

//dao依赖注入
@Repository
public class BookDAO {
//    自动装配
    @Autowired
    JdbcTemplate jdbcTemplate;
    public int aInt(int id){
        String sql = "update bs_book set sales=sales+1 where id=?";
       return jdbcTemplate.update(sql,id);
    }
    public int bInt(int id){
        String sql = "update bs_book set stock=stock-1 where id=?";
        return jdbcTemplate.update(sql,id);
    }
}

service

@Service
public class BookService {
    @Autowired
    BookDAO bookDAO;
//    添加事务
@Transactional
    public void clean(int id){
//        加销量
        bookDAO.aInt(id);
//         减库存
        bookDAO.bInt(id);
    }
}

xml

<!--    引用外部文件-->
    <context:property-placeholder location="classpath:conf/db.properties"/>
<!--    配置数据库连接池-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="comboPooledDataSource">
                <property name="driverClass" value="${ClassDriver}"/>
                <property name="jdbcUrl" value="${jdbcUrl}"/>
                <property name="user" value="${user}"/>
                <property name="password" value="${password}"/>
    </bean>
<!--    配置jdbcTemplate-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <constructor-arg name="dataSource" ref="comboPooledDataSource"/>
    </bean>
<!-- ioc依赖注入   -->
    <context:component-scan base-package="com.tc"/>
<!--    配置事务控制器-->
 <!--1:配置事务管理器（切面）让其进行事务控制；一定导入面向切面编程的几个包
           spring-aspects-4.0.0.RELEASE.jar
           com.springsource.net.sf.cglib-2.2.0.jar
           com.springsource.org.aopalliance-1.0.0.jar
           com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
   -->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
<!--     控制住数据源   构造方法传入数据库连接池-->
        <constructor-arg name="dataSource" ref="comboPooledDataSource"/>
    </bean>
<!--2:开启基于注解的事务控制模式；依赖tx名称空间  -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!--3:给事务方法加注解@Transactional  -->

test

public class BookTest {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("conf/jdbc.xml");
    @Test
    public void test(){
        BookService bean = applicationContext.getBean(BookService.class);
        bean.clean(13);
    }
}

@Transactional的使用

@Transactional注解中常用参数说明

参数名称	功能描述
readOnly	该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。例如：@Transactional(readOnly=true) 优化数据
rollbackFor	该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如：指定单一异常类：@Transactional(rollbackFor=RuntimeException.class)指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class})
rollbackForClassName	该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。例如：指定单一异常类名称：@Transactional(rollbackForClassName="RuntimeException")指定多个异常类名称：@Transactional(rollbackForClassName={"RuntimeException","Exception"})
noRollbackFor	该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚。例如：指定单一异常类：@Transactional(noRollbackFor=RuntimeException.class)指定多个异常类：@Transactional(noRollbackFor={RuntimeException.class, Exception.class})
noRollbackForClassName	该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。例如：指定单一异常类名称：@Transactional(noRollbackForClassName="RuntimeException")指定多个异常类名称：@Transactional(noRollbackForClassName={"RuntimeException","Exception"})
propagation	该属性用于设置事务的传播行为，例如：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true)
isolation	该属性用于设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况，通常使用数据库的默认隔离级别即可，基本不需要进行设置
timeout	该属性用于设置事务的超时秒数，默认值为-1表示永不超时

 

一、事务的基本要素（ACID）

　　1、原子性（Atomicity）：事务开始后所有操作，要么全部做完，要么全部不做，不可能停滞在中间环节。事务执行过程中出错，会回滚到事务开始前的状态，所有的操作就像没有发生一样。也就是说事务是一个不可分割的整体，就像化学中学过的原子，是物质构成的基本单位。

　　 2、一致性（Consistency）：事务开始前和结束后，数据库的完整性约束没有被破坏 。比如A向B转账，不可能A扣了钱，B却没收到。

　　 3、隔离性（Isolation）：同一时间，只允许一个事务请求同一数据，不同的事务之间彼此没有任何干扰。比如A正在从一张银行卡中取钱，在A取钱的过程结束前，B不能向这张卡转账。

　　 4、持久性（Durability）：事务完成后，事务对数据库的所有更新将被保存到数据库，不能回滚。

二、事务的并发问题

　　1、脏读：事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据（必须避免）

　　2、不可重复读：事务 A 多次读取同一数据，事务 B 在事务A多次读取的过程中，对数据作了更新并提交，导致事务A多次读取同一数据时，结果 不一致。

　　3、幻读：系统管理员A将数据库中所有学生的成绩从具体分数改为ABCDE等级，但是系统管理员B就在这个时候插入了一条具体分数的记录，当系统管理员A改结束后发现还有一条记录没有改过来，就好像发生了幻觉一样，这就叫幻读。

• 小结：不可重复读的和幻读很容易混淆，不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表

三、MySQL事务隔离级别

事务隔离级别	脏读	不可重复读	幻读
读未提交（read-uncommitted）	是	是	是
不可重复读（read-committed）	否	是	是
可重复读（repeatable-read）	否	否	是
串行化（serializable）	否	否	否

mysql默认的事务隔离级别为 可重复读（repeatable-read）

1.Read uncommitted

读未提交，顾名思义，就是一个事务可以读取另一个未提交事务的数据。

事例：老板要给程序员发工资，程序员的工资是3.6万/月。但是发工资时老板不小心按错了数字，按成3.9万/月，该钱已经打到程序员的户口，但是事务还没有提交，就在这时，程序员去查看自己这个月的工资，发现比往常多了3千元，以为涨工资了非常高兴。但是老板及时发现了不对，马上回滚差点就提交了的事务，将数字改成3.6万再提交。

分析：实际程序员这个月的工资还是3.6万，但是程序员看到的是3.9万。他看到的是老板还没提交事务时的数据。这就是脏读。

那怎么解决脏读呢？Read committed！读提交，能解决脏读问题。

2.Read committed

读提交，顾名思义，就是一个事务要等另一个事务提交后才能读取数据。

事例：程序员拿着信用卡去享受生活（卡里当然是只有3.6万），当他埋单时（程序员事务开启），收费系统事先检测到他的卡里有3.6万，就在这个时候！！程序员的妻子要把钱全部转出充当家用，并提交。当收费系统准备扣款时，再检测卡里的金额，发现已经没钱了（第二次检测金额当然要等待妻子转出金额事务提交完）。程序员就会很郁闷，明明卡里是有钱的…

分析：这就是读提交，若有事务对数据进行更新（UPDATE）操作时，读操作事务要等待这个更新操作事务提交后才能读取数据，可以解决脏读问题。但在这个事例中，出现了一个事务范围内两个相同的查询却返回了不同数据，这就是不可重复读。

那怎么解决可能的不可重复读问题？Repeatable read ！

3.Repeatable read

重复读，就是在开始读取数据（事务开启）时，不再允许修改操作

事例：程序员拿着信用卡去享受生活（卡里当然是只有3.6万），当他埋单时（事务开启，不允许其他事务的UPDATE修改操作），收费系统事先检测到他的卡里有3.6万。这个时候他的妻子不能转出金额了。接下来收费系统就可以扣款了。

分析：重复读可以解决不可重复读问题。写到这里，应该明白的一点就是，不可重复读对应的是修改，即UPDATE操作。但是可能还会有幻读问题。因为幻读问题对应的是插入INSERT操作，而不是UPDATE操作。

什么时候会出现幻读？

事例：程序员某一天去消费，花了2千元，然后他的妻子去查看他今天的消费记录（全表扫描FTS，妻子事务开启），看到确实是花了2千元，就在这个时候，程序员花了1万买了一部电脑，即新增INSERT了一条消费记录，并提交。当妻子打印程序员的消费记录清单时（妻子事务提交），发现花了1.2万元，似乎出现了幻觉，这就是幻读。

那怎么解决幻读问题？Serializable！

4.Serializable 序列化

Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用。

值得一提的是：大多数数据库默认的事务隔离级别是Read committed，比如Sql Server , Oracle。Mysql的默认隔离级别是Repeatable read。