10.spring中事务的使用-基础

1.看图

2.实体类Account：

package com.domin;

import java.io.Serializable;

//账户的实体类
public class Account implements Serializable {
    private  Integer id;
    private  String name;
    private  Float money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Float getMoney() {
        return money;
    }

    public void setMoney(Float money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

3.业务层接口IAccountService

package com.service;

import com.domin.Account;

import java.util.List;

//账户的业务层接口
public interface IAccountService {
    /*查询所有*/
    List<Account> findAllAccount();
    /*查询一个*/
    Account findAccountById(Integer accountId);
    /*保存操作*/
    void saveAccount(Account account);
    /*更新操作*/
    void updateAccout(Account account);
    /*删除操作*/
    void delectAccout(Integer accountId);
    /*事务的解说*/
    /*转账操作
    *   转账源头名称
    *   转账目的名称
    *   转账金额
    * */
    /*被表现层调用，业务层写好参数：功能描述*/
    void transfer(String sourceName , String targetName , Float money);
}

4.业务层实现类：AccountServiceIpm

（包含事务的一整套操作）

package com.service.Ipm;

import com.dao.IAccountDao;
import com.domin.Account;
import com.service.IAccountService;
import com.utils.TransactionManager;

import java.util.List;

/*账户的实现类*/
public class AccountServiceIpm implements IAccountService {

   private IAccountDao accountDao;
   /*使用事务管理：那就注入实例对象，来使用*/
   private TransactionManager txManager;

    //accountDao的set方法
    public void setAccountDao(IAccountDao accountDao) {

        this.accountDao = accountDao;
    }
    /*注入灵魂*/
    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }


    @Override
    public List<Account> findAllAccount() {
        try{
            //1.开启事务（都是持久层写的方法）
            txManager.beginTransaction();
            //2.执行操作
            List<Account> accounts = accountDao.findAllAccount();
            //3.提交事物
            txManager.commit();
            //4.返回结果
            return accounts;
        }catch (Exception e){
            //5.回滚操作
            txManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            txManager.release();
        }
    }
    @Override
    public Account findAccountById(Integer accountId) {
        try{
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            Account account = accountDao.findAccountById(accountId);
            //3.提交事物
            txManager.commit();
            //4.返回结果
            return account;
        }catch (Exception e){
            //5.回滚操作
            txManager.rollback();
            /*抛掉异常*/
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            txManager.release();
        }

    }

    @Override
    public void saveAccount(Account account)
    {
        try{
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.saveAccount(account);
            //3.提交事物
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }

    @Override
    public void updateAccout(Account account) {

        try{
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.updateAccout(account);
            //3.提交事物
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }

    @Override
    public void delectAccout(Integer accountId) {

        try{
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.delectAccout(accountId);
            //3.提交事物
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }

    /*转账*/

    @Override
    public void transfer(String sourceName, String targetName, Float money) {

        try{
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
                //2.1.根据名称查询转出账户
                Account source = accountDao.findAccountByName(sourceName);
                //2.2.根据名称查询转入账户
                Account target = accountDao.findAccountByName(targetName);
                //2.3.转出账户减钱
                source.setMoney(source.getMoney()-money);
                //2.4.转入账户加钱
                target.setMoney(target.getMoney()+money);
                int i = 1/0;
                //2.5.更新转出账户
                accountDao.updateAccout(source);
                //2.6.更新转入账户
                accountDao.updateAccout(target);

            //3.提交事物
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
            /*打出异常*/
            e.printStackTrace();
        }finally {
            //5.释放连接
            txManager.release();
        }

    }
}

5.持久层实现类AccountDaoImp：

package com.dao.Ipm;

import com.dao.IAccountDao;
import com.domin.Account;
import com.utils.ConnectionUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.util.List;

/*账户的持久层实现类*/
public class AccountDaoImp implements IAccountDao {
    private QueryRunner runner;
    /*让spring容器提供的set方法*/
    /*使用runner对象*/
    private ConnectionUtils connectionUtils;
    public void setRunner(QueryRunner runner) {

        this.runner = runner;
    }

    /*注入ConnectionUtils对象，脱离直接使用的dataSource，而是从绑定的线程取*/
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    @Override
    public List<Account> findAllAccount() {
        /*泛型使用字解码创建对象*/
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public Account findAccountById(Integer accountId) {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account where id = ?",new BeanHandler<Account>(Account.class),accountId);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public void saveAccount(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"insert into account(name,money)value(?,?)",account.getName(),account.getMoney());
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public void updateAccout(Account account) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public void delectAccout(Integer accountId) {
        try{
            runner.update(connectionUtils.getThreadConnection(),"delete from account where id=?",accountId);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    @Override
    public Account findAccountByName(String accountName) {
        try{
          List<Account> accounts = runner.query(connectionUtils.getThreadConnection(),"select * from account where name = ?",new BeanListHandler<Account>(Account.class),accountName);
            if (accounts == null || accounts.size() == 0){
                return null;
            }
            if (accounts.size()>1){
                throw new RuntimeException("结果集不唯一，数据有问题");
            }
            return accounts.get(0);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
/*
* 此时加入数据源之后：我们的dao已经有connect连接数据源的支持，
* 同时它不再通过QueryRunner进行连接（注入）数据源
* 同时我们也通过工具类的方式将线程和连接进行绑定，并且编写了事务的管理
*
*
*
* */

}

6.连接工具类ConnectionUtils：

package com.utils;


/*
* 连接的工具类：它用于从数据源中获取一个连接，并且实现和线程的绑定（只有统一调度才不会发生改变：转账一个变一个不变）
*
*
* */

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

public class ConnectionUtils {

        private ThreadLocal<Connection> ts = new ThreadLocal<Connection>();

        /*万一没有数据源，注入一个再说*/
        private DataSource dataSource;

        public void setDataSource(DataSource dataSource) {
            this.dataSource = dataSource;
        }

    /*
        * 获取当前线程上的连接(写的一个方法)
        *       线程上有没有，没有就从数据源中取一个存进去，并且绑定
        * */
        public Connection getThreadConnection(){
            try {
                //1.先从ThreadLocal上获取
                Connection conn = ts.get();
                //2.判断是否当前线程上有连接
                if (conn == null) {
                    //3.从数据源中获取一个连接，并且存入ThreadLocal中（也就是绑定线程）
                    conn = dataSource.getConnection();
                }
                //4.返回当前线程上的连接
                return conn;
            }catch (Exception e){
                throw new RuntimeException(e);
            }
        }
        /*连接之后不用了，就进行线程的解绑，线程还回池中*/
        public void removeConnection(){
            ts.remove();
        }
}

7.事务管理TransactionManager：

package com.utils;

/*
* 和事务管理相关的工具类，它包含了，开启事物，提交事物，回滚事物和释放连接
*
*
* */
/*怎么执行事务的整体呢？？*/
/*注入连接ConnectionUtils事务的连接工具类*/

public class TransactionManager {

    /*怎么调用，连接的方法注入进来就可以使用*/
    private ConnectionUtils connectionUtils;
    /*注入并且使用*/
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    /*
    * 开启事务
    */
    public void beginTransaction(){
        try{
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();//在命令行打印异常信息在程序中出错的位置及原因
        }
    }
    /*
     * 提交事务
     */
    public void commit(){
        try{
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();//在命令行打印异常信息在程序中出错的位置及原因
        }
    }
    /*
     * 回滚事务
     */
    public void rollback(){
        try{
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();//在命令行打印异常信息在程序中出错的位置及原因
        }
    }
    /*
     * 释放连接事务
     */
    public void release(){
        try{
            connectionUtils.getThreadConnection().close();
            connectionUtils.removeConnection();
        }catch (Exception e){
            e.printStackTrace();//在命令行打印异常信息在程序中出错的位置及原因
        }
    }
/*
* 自己理解：各种池：也就是说，当服务器启动的时候，如果需要使用该线程的时候，那么程序就会从线程池当中调出一个线程出来使用，这就叫做池
* 例如：数据库连接池、线程池
*线程池：当服务器tomcat一启动的时候，会初始化一堆的线程，也就是操作系统的线程管理，然后放到一个容器当中，接下来我们每次访问时，它都会从线程池中拿出一个线程提供给我们使用（如果关闭线程的时候并不是真正的关闭，而是把线程还回池中）
*2.事务的控制都写完了，那么就可以去改造业务层的代码，使他们都在统一的线程下执行，以免发生操作不一样
*
* */
}

8.配置文件bean.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--        配置IAccountService的实例-->
    <bean id="accountService" class="com.service.Ipm.AccountServiceIpm">
        <!--注入类的实例accountDao，so创建持久层类的实例就不用写了-->
        <!--这时候还没有accountDao的创建实体类，这时候他会报错，所以引入一下创建accountDao对象，然后这里注入的地方就是实现了调用-->
        <property name="accountDao" ref="accountDao"></property>

        <!--注入是位于管理器txManager 它使用了了-->
        <property name="txManager" ref="txManager"></property>
    </bean>
    <bean id="accountDao" class="com.dao.Ipm.AccountDaoImp">
        <property name="runner" ref="runner"></property>
        <!--因为他在使用-->
        <!--注入connectionUtils工具类-->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源ds-->
       <!-- <constructor-arg name="ds" ref="dataSource"></constructor-arg>-->
    </bean>
    <!--引入配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--连接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/eesy"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <!--配置工具类ConnectionUtils-->
    <!--在连接事务中注入dataSource，以方便有时不用，没有时拿出一个使用-->
    <bean id="connectionUtils" class="com.utils.ConnectionUtils">
       <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--配置管理事物的工具类-->
    <bean id="txManager" class="com.utils.TransactionManager">
        <!--里面使用到了connectionUtils-->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

</beans>

9.依赖pom.xml

<!--依赖添加-->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>commons-dbutils</groupId>
      <artifactId>commons-dbutils</artifactId>
      <version>1.6</version>
    </dependency>

    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.6</version>
    </dependency>

    <dependency>
      <groupId>c3p0</groupId>
      <artifactId>c3p0</artifactId>
      <version>0.9.1.2</version>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
<!--测试类-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.0.2.RELEASE</version>
      <scope>test</scope>
    </dependency>


  </dependencies>

10.测试TestCode：

package com.itheima;

import com.domin.Account;
import com.service.IAccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

@RunWith(SpringJUnit4ClassRunner.class)
/*说明位置*/
@ContextConfiguration(locations ="classpath:bean.xml")
/*pom.xml加上spring-test依赖*/

public class TestCode {
    @Autowired
    private IAccountService as;

    @Test
    public void testTransfer(){
        as.transfer("qi","hello",1000f);
//        as.transfer("qi","hello",(float)1000.0);
//       两种强转一样
    }

}
总结：初步理解：理解事务之前，先讲一个你日常生活中最常干的事：取钱。 
比如你去取1000块钱，大体有：你去取钱，取1000，银行卡扣掉1000元钱；然后机子出1000元钱。这两个步骤必须是要么都执行要么都不执行。如果银行卡扣除了1000块但是ATM出钱失败的话，你将会损失1000元；如果银行卡扣钱失败但是机子却出了1000块，那么银行将损失1000元。所以，如果一个步骤成功另一个步骤失败对双方都不是好事，如果不管哪一个步骤失败了以后，整个取钱过程都能回滚，也就是完全取消所有操作的话，这对双方都是极好的。 
事务就是用来解决类似问题的。事务是一系列的动作，它们综合在一起才是一个完整的工作单元，这些动作必须全部完成，如果有一个失败的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过一样。 在企业级应用程序开发中，事务管理必不可少的技术，用来确保数据的完整性和一致性。

程序步骤：

1.连接工具类的编写：如果没有连接，取一个线程来连接and关闭连接（扔回池中）

2.事务的管理类编写：使用private ConnectionUtils connectionUtils;注入连接（绑定）到线程，实现事务的操作

3.先在业务层接口写入：public void transfer(String sourceName , String targetName , Float money);

4.业务层实现类：通过注入一个事务的对象来管理每一个操作，使它是同一个线程中的事务private TransactionManager txManager;

5.持久层接口：/*被业务层调用。持久层应写好方法*/ Account findAccountByName(String accountName);

6.持久层实现类：这时候已经不再往QueryRunner中注入了，避免事务每次都从该数据池中获取，所以在bean.xml中，取消<constructor-arg name="ds" ref="dataSource"></constructor-arg>的注入，而改成在工具类中注入

<!--配置工具类ConnectionUtils-->
<!--在连接事务中注入dataSource，以方便有时不用，没有时拿出一个使用-->
<bean id="connectionUtils" class="com.utils.ConnectionUtils">
   <property name="dataSource" ref="dataSource"></property>
</bean>

7.配置文件的注入：

<!--注入是位于管理器txManager 它使用了了-->
<property name="txManager" ref="txManager"></property>注入在业务层：因为在业务层中使用了

<!--注入connectionUtils工具类-->
<property name="connectionUtils" ref="connectionUtils"></property>在持久层使用了连接工具类

工具类的注入：

<!--配置工具类ConnectionUtils-->
<!--在连接事务中注入dataSource，以方便有时不用，没有时拿出一个使用-->
<bean id="connectionUtils" class="com.utils.ConnectionUtils">
   <property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置管理事物的工具类-->
<bean id="txManager" class="com.utils.TransactionManager">
    <!--里面使用到了connectionUtils-->
    <property name="connectionUtils" ref="connectionUtils"></property>
</bean>

注：本文章只供自己学习，有上面错误的地方，请多多指教。其次代码过于臃肿，后面继续优化，只是理解一下事务的基本概念和使用