Springフレームワークカリキュラム - パーソナルストーリーIOC（XML）、追加転送方法、および証明業務

1.に基づき：https://www.cnblogs.com/ccoonngg/p/11223340.html

2.転送インタフェースを増加させる方法AccountServiceの

    / * * 
     *転送
     * @paramはアウトアカウントのSourceID 
     考慮* @paramするtargetId 
     * @paramの送金額
     * / 
    無効（転送int型のSourceID、INTするtargetId、フロートマネー）;

3.実装クラスAccountServiceImplの増加

    @Override
     公共 ボイド転送（int型のSourceID、INTするtargetId、フロートマネー）{
         // 1.検索転送アカウント 
        アカウントsourceAccount = accountDao.findAccountById（ソースIDを）;
         // 2.アカウントに検索 
        アカウントtargetAccount = accountDao.findAccountById（するtargetIdを） ;
         // 3ターンアウトのアカウントの量削減に 
        sourceAccount.setMoney（sourceAccount.getMoney（） - マネー）;
         // 4.口座に増加量または減少 
        targetAccount.setMoney（targetAccount.getMoney（）+ マネー）;
         // 5。更新ロールアウトのアカウント
        accountDao.updateAccount（sourceAccount）;
         // 6アカウントに更新
        accountDao.updateAccount（targetAccount）; 
    }

4.ユニットテストのテストクラスの増加

    @Test
     公共 ボイド転送（）{
        として .transfer（1、2、100 ）。
    }

テスト・データベース後のコンテンツ実行部

6.もし、しかし、間違った文を挿入する前に、第6の工程のAccountServiceImplででしょう、例えば、

        // 5.アップデートアウトアカウント
        accountDao.updateAccount（sourceAccountを）;
         int型私は= 1。 / 0 ;
         // 6.更新アカウントに 
        accountDao.updateAccount（targetAccount）。

以下の結果をもう一度7部

アップデートのロールアウトのアカウントの前に、プログラムが間違っているので、実行を停止しますが、以前に行われてきました

これは、トランザクション・サポートではありません

理由

現在の取り決めの下で、Dbutils構成オブジェクトQueryRunnerは、それぞれが新しいQueryRunnerを作成します。

各タイム接続オブジェクトが操作を行う際に、データソースから来ます

<！ -配置QueryRunner - > 
<豆ID = "ランナー"クラス= "org.apache.commons.dbutils.QueryRunner"スコープ= "プロトタイプ"> 
    <！ -注入数据源- > 
    <コンストラクタ、引数名= "DS" REF = "データソース"> </コンストラクタ、引数> 
</豆> 

<！ -配置数据源- > 
<豆ID = "データソース"クラス= "com.mchange.v2.c3p0.ComboPooledDataSource" > 
    <！ -连接数据库的必备信息- > 
    <プロパティ名= "driverClass"値= "はcom.mysql.jdbc.Driver"> </ property>の
    <プロパティ名= "jdbcUrlと"値= "はjdbc：mysqlの：// localhostを：3306 /コング"> </ property>の
    <プロパティ名="ユーザー」値= "ルート"> </ property>の
    <プロパティ名= "パスワード"値= "123456"> </ property>の
</豆>

データベースと対話すること数回下図で見られるように

8.改善、改良されたコードが認識できないとなります

だからの面で新たなプロジェクトとして

1.関連する依存をインポートし、Mavenプロジェクトを作成します。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.cong</groupId>
    <artifactId>spring_accountTransfer_transaction</artifactId>
    <version>1.0-SNAPSHOT</version>

    <packaging>jar</packaging>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <!-- dbutils的依赖 -->
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.4</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>
    </dependencies>
</project>

2.在java目录下创建com.cong.utils.ConnectionUtils类

package com.cong.utils;

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

/**
 * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 *
 */
public class ConnectionUtils {
    //需要一个Connection类型的ThreadLocal，直接实例化出来
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
    //这个DataSource不能new，只能等着spring为我们注入，所以需要seter方法
    private DataSource dataSource;
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    //获取当前线程的连接
    public Connection getThreadConnection(){
        try{
            //1.先从ThreadLocal上获取
            Connection conn = tl.get();
            //2.判断当前线程上是否有连接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }

    /**
     * 把连接和线程解绑
     */
    public void removeConnection() {
        tl.remove();
    }
}

3.在utils包下创建TransactionManager类

package com.cong.utils;

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 * 这个类如何执行呢？与事务相关，首先要有connection，并且是当前线程的connection
 * 所以需要用到ConnectionUtils类
 * 并且提供一个setter方法，等着spring注入
 */
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();
        }
    }
}

4.在java目录下创建com.cong.pojo.Account类

package com.cong.pojo;

public class Account {
    private int id;
    private String name;
    private float money;

    public int getId() {
        return id;
    }

    public void setId(int 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 +
                '}';
    }
}

5.在java目录下创建com.cong.dao包，并且创建Account持久层相关的接口和类

package com.cong.dao;
import com.cong.pojo.Account;
import java.util.List;
public interface AccountDao {
    List<Account> findAllAccount();//find all
    Account findAccountById(int id);//find one
    void saveAccount(Account account);//save
    void updateAccount(Account account);//update
    void deleteAccount(int id);//delete
}



package com.cong.dao;
import com.cong.pojo.Account;
import com.cong.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;
/**
 * 从bean.xml中可以发现
 * <bean id="accountDao" class="com.cong.dao.AccountDaoImpl">
 <property name="runner" ref="runner"></property>
 * </bean>
 * <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
 *      <constructor-arg name="ds" ref="dataSource"></constructor-arg>
 * </bean>
 * accountDao注入了一个QueryRunner对象，QueryRunner就会从连接池里面自动获取一个连接
 *但是我们现在不希望它从连接池里面自动获取，所以需要在AccountDaoImpl里面有一个ConnectionUtils对象，来获取连接
 * 然后需要对runner的query方法添加一个连接的参数
 */
public class AccountDaoImpl implements AccountDao {
    private QueryRunner runner;
    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }
    private ConnectionUtils connectionUtils;
    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(int id) {
        try{
            return runner.query(connectionUtils.getThreadConnection(),"select * from account where id = ? ",new BeanHandler<Account>(Account.class),id);
        }catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

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

    @Override
    public void updateAccount(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 deleteAccount(int id) {
        try {
            runner.update(connectionUtils.getThreadConnection(),"delete from account where id = ?",id);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

6.在java目录下创建com.cong.service，并且创建服务层相关的接口和类

package com.cong.service;

import com.cong.pojo.Account;

import java.util.List;

public interface AccountService {
    List<Account> findAllAccount();//find all
    Account findAccountById(int id);//find one
    void saveAccount(Account account);//save
    void updateAccount(Account account);//update
    void deleteAccount(int id);//delete
    /**
     * 转账
     * @param sourceId  转出账户
     * @param targetId  转入账户
     * @param money     转账金额
     */
    void transfer(int sourceId, int targetId, float money);
}



package com.cong.service;

import com.cong.dao.AccountDao;
import com.cong.pojo.Account;
import com.cong.utils.TransactionManager;

import java.util.List;

/**
 * 账户的业务层实现类
 * 事务控制应该都在业务层的
 */
public class AccountServiceImpl implements AccountService {
    //业务层都是调用持久层的，所以需要有一个持久层的对象
    private AccountDao accountDao;
    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    //添加事务支持需要用到TransactionManager的对象,这个对象不能自己创建，只能有spring注入，所以有setter方法
    private TransactionManager tm;
    public void setTm(TransactionManager tm) {
        this.tm = tm;
    }

    /**
     * 以下所有操作都可以加上事务控制
     * 开启事务，执行操作，提交事务（返回结果），回滚操作，关闭事务
     */
    @Override
    public List<Account> findAllAccount() {
        try {
            //1.开启事务
            tm.beginTransaction();
            //2.执行操作
            List<Account> accounts = accountDao.findAllAccount();
            //3.提交事务
            tm.commit();
            //4.返回结果
            return accounts;
        }catch (Exception e){
            //5.回滚操作
            tm.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.关闭事务
            tm.release();
        }
    }

    @Override
    public Account findAccountById(int id) {
        try {
            //1.开启事务
            tm.beginTransaction();
            //2.执行操作
            Account account = accountDao.findAccountById(id);
            //3.提交事务
            tm.commit();
            //4.返回结果
            return account;
        }catch (Exception e){
            //5.回滚操作
            tm.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.关闭事务
            tm.release();
        }
    }

    @Override
    public void saveAccount(Account account) {
        try {
            //1.开启事务
            tm.beginTransaction();
            //2.执行操作
            accountDao.saveAccount(account);
            //3.提交事务
            tm.commit();
        }catch (Exception e){
            //5.回滚操作
            tm.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.关闭事务
            tm.release();
        }

    }

    @Override
    public void updateAccount(Account account) {
        try {
            //1.开启事务
            tm.beginTransaction();
            //2.执行操作
            accountDao.updateAccount(account);
            //3.提交事务
            tm.commit();
        }catch (Exception e){
            //5.回滚操作
            tm.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.关闭事务
            tm.release();
        }

    }

    @Override
    public void deleteAccount(int id) {
        try {
            //1.开启事务
            tm.beginTransaction();
            //2.执行操作
            accountDao.deleteAccount(id);
            //3.提交事务
            tm.commit();
        }catch (Exception e){
            //5.回滚操作
            tm.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.关闭事务
            tm.release();
        }
    }

    @Override
    public void transfer(int sourceId, int targetId, float money) {
        try {
            //1.开启事务
            tm.beginTransaction();
            //2.执行操作
            //2.1.查找转账账户
            Account sourceAccount = accountDao.findAccountById(sourceId);
            //2.2.查找转入账户
            Account targetAccount = accountDao.findAccountById(targetId);
            //2.3.转出账户减少金额
            sourceAccount.setMoney(sourceAccount.getMoney() - money);
            //2.4.转入账户增减金额
            targetAccount.setMoney(targetAccount.getMoney() + money);
            //2.5.更新转出账户
            accountDao.updateAccount(sourceAccount);
            //2.6.更新转入账户
            accountDao.updateAccount(targetAccount);
            //3.提交事务
            tm.commit();
        }catch (Exception e){
            //5.回滚操作
            tm.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.关闭事务
            tm.release();
        }
    }
}

7.在resources下创建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">
    <!-- 配置Service -->
    <bean id="accountService" class="com.cong.service.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
        <property name="tm" ref="tm"></property>
    </bean>

    <!--配置Dao对象-->
    <bean id="accountDao" class="com.cong.dao.AccountDaoImpl">
        <!-- 注入QueryRunner -->
        <property name="runner" ref="runner"></property>
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!--配置QueryRunner-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--<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://localhost:3306/cong"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
    <bean id="connectionUtils" class="com.cong.utils.ConnectionUtils">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <bean id="tm" class="com.cong.utils.TransactionManager">
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>
</beans>

8.在test，java下创建测试类

import com.cong.pojo.Account;
import com.cong.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
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")
public class AccountServiceTest {
    @Autowired
    AccountService as;
    @Test
    public void transfer(){
        as.transfer(1,2,100);
    }
   @Test
    public void testFindAll(){
       List<Account> list = as.findAllAccount();
       for (Account account : list) {
           System.out.println(account.toString());
       }
   }
    @Test
    public void testFindOne(){
        Account account = as.findAccountById(1);
        System.out.println(account.toString());
    }
    @Test
    public void testSave(){
       Account account = new Account();
       account.setName("cong");
       account.setMoney(5);
       as.saveAccount(account);
    }
    @Test
    public void testUpdate(){
        Account account = new Account();
        account.setName("rainbow");
        account.setMoney(50000);
        account.setId(3);
        as.updateAccount(account);
    }
    @Test
    public void testDelete(){
        as.deleteAccount(4);
    }
}

9.单元测试transfer，前后结果

10.一样，在转账的过程中添加一个会出错的语句

            //2.5.更新转出账户
            int i = 1/0;
            accountDao.updateAccount(sourceAccount);
            //2.6.更新转入账户
            accountDao.updateAccount(targetAccount);

11.运行结果，程序报错，数据库中的内容没有改变

 

 11.以上案例虽然添加了事务管理，但是有一些弊端‘

　　*配置文件非常麻烦，很多依赖注入乱七八糟

　　*service用到事务管理器TransactionManager，dao用到connectionUtils

　　* 事务管理器也用到connectionUtils，它们之间都有一些互相依赖

　　*更重要的是AccountServiceImpl中代码有很多的重复

所以就需要用到aop