2020-06-20

SSM-Spring【aop大致实现原理】

字数统计: 2.6k字 | 阅读时长: 12分

一、前言

ioc和aop是spring的两大特点，ioc已经学习完了，那么本文将一个项目的不断改进来阐述spring实现aop的大致原理。

二、V1.0版本

（一）domain

Account.java:

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

    //setters and getters
}

（二）dao层

为了减少篇幅，只提供了添加账户和转账操作.
IAccountDao.java:

/**
 * 操作账户的dao接口
 */
public interface IAccountDao {
    /**
     * 添加账户
     * @param account
     */
    void addAccount(Account account);

    /**
     * 根据用户名称查找对应账户
     * @param name
     * @return
     */
    Account findByName(String name);
}

AccountDaoImpl.java:

public class AccountDaoImpl implements IAccountDao {

    private QueryRunner runner;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }
    
    /**
     * 添加账户
     * @param account
     */
    public void addAccount(Account account) {
        try {
            runner.update("insert into account(name, money) values(?, ?)", account.getName(), account.getMoney());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }


    /**
     * 根据用户名称查找对应账户
     * @param name
     * @return
     */
    public Account findByName(String name) {
        //1、根据名称查找账户
        //2、若账户不存在则返回null；
        //3、若账户存在多个则报错
        //4、若账户存在一个则返回该账户
        try {
            List<Account> accounts = runner.query("select * from account where name = ?", new BeanListHandler<Account>(Account.class), name);
            if (accounts == null || accounts.size() == 0) {
                return null;
            }else if(accounts.size() > 1){
                throw new RuntimeException("结果集不唯一，数据有问题！");
            }else {
                return accounts.get(0);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }
}

（三）service层

IAccountService.java:

public interface IAccountService {
    /**
     * 添加账户
     * @param account
     */
    void addAccount(Account account);

    /**
     * 账户转账
     * @param sourceName
     * @param targetName
     * @param money
     */
    void transfer(String sourceName, String targetName, float money);
}

AccountServiceImpl.java:

public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    /**
     * 添加账户
     * @param account
     */
    public void addAccount(Account account) {
        accountDao.updateAccount(account);
    }

    /**
     * 账户转账
     * @param sourceName
     * @param targetName
     * @param money
     */
    public void transfer(String sourceName, String targetName, float money) {
            //查找source账户
            Account sourceAccount = accountDao.findByName(sourceName);
            //查找target账户
            Account targetAccount = accountDao.findByName(targetName);
            //source账户金额减少
            sourceAccount.setMoney(sourceAccount.getMoney() - money);
            //target账户金额增加
            targetAccount.setMoney(targetAccount.getMoney() + money);
            //更新source账户信息
            accountDao.updateAccount(sourceAccount);
        
            int a = 10/0;
        
            //更新target账户信息
            accountDao.updateAccount(targetAccount);
    }
}

仔细观察service中transfer方法的代码就会发现，当执行到35行时会产生异常，那么target的账户就不会增加，即：source账户的余额会减少，但是target账户的余额却不会增加。这在项目中是绝对不允许发生的事情。
那么有什么办法可以解决这个问题呢？
没错，我们可以手动进行事务控制。

三、V2.0版本

（一）工具类

因为在1.0版本中，转账操作这一个功能需要同时执行多个dao操作，即执行了多条sql语句，而自动事务控制的前提是每次只执行一条sql语句，因此就会出现问题。那么针对这个问题，2.0版本改进为手动进行事务控制。
但是如果需要手动进行事务控制，我们就必须确保多个操作使用的同一个Connection对象。
因此，如何确保是同一个Connection对象是关键问题。在该项目中使用ThreadLocal来实现这个目的，如下：
创建ConnectionUtils工具类：
ConnectionUtils.java:

/**
 * 获取一个Connection，并且实现和线程的绑定
 */
public class ConnectionUtils {
    private ThreadLocal<Connection> tl = new ThreadLocal<Connection>();

    private DataSource dataSource;

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

    public void setTl(ThreadLocal<Connection> tl) {
        this.tl = tl;
    }

    /**
     * 获取当前线程上的连接
     * @return
     */
    public Connection getConnection(){
        try {
            //1、先从ThreadLocal上获取
            Connection conn = tl.get();
            //2、判断当前线程上有无连接
            if(conn == null){
                //3、从DataSource中获取一个连接，并且存入到ThreadLocal中
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4、返回当前线程上的连接
            return conn;
        }catch (Exception e) {
            throw  new RuntimeException(e);
        }
    }

    /**
     * 解绑当前线程上的连接
     */
    public void removeConnection(){
        tl.remove();
    }
}

在提供一个事务管理工具类：
TransactionManager.java:

/**
 *  对事务进行管理的工具类
 */
public class TransactionManager {

    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils){
        this.connectionUtils = connectionUtils;
    }

    /**
     * 开启事务
     */
    public void beginTransaction(){
        try {
            connectionUtils.getConnection().setAutoCommit(false);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 提交事务
     */
    public void commit(){
        try {
            connectionUtils.getConnection().commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 回滚事务
     */
    public void rollback(){
        try {
            connectionUtils.getConnection().rollback();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 释放连接
     */
    public void release(){
        try {
            //将连接返回到连接池中
            connectionUtils.getConnection().close();    
            /*虽然已经将连接返回到连接池中，但是该连接已经不能继续使用；
            因为该连接仍然和线程绑定着，那么就有可能获取连接时，会误以为当前线程已经有连接并且该连接还可以使用
            所以为解决这种情况，就需要在连接释放后进行解绑*/
            connectionUtils.removeConnection();    //解绑
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

（二）dao层

AccountDaoImpl.java中的代码修改为：

public class AccountDaoImpl implements IAccountDao {

    private QueryRunner runner;
    private ConnectionUtils connectionUtils;

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    
    /**
     * 添加账户
     * @param account
     */
    public void addAccount(Account account) {
        try {
            runner.update(connectionUtils.getConnection(), "insert into account(name, money) values(?, ?)", account.getName(), account.getMoney());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 根据用户名称查找对应账户
     * @param name
     * @return
     */
    public Account findByName(String name) {
        //1、根据名称查找账户
        //2、若账户不存在则返回null；
        //3、若账户存在多个则报错
        //4、若账户存在一个则返回该账户
        try {
            List<Account> accounts = runner.query(connectionUtils.getConnection(), "select * from account where name = ?", new BeanListHandler<Account>(Account.class), name);
            if (accounts == null || accounts.size() == 0) {
                return null;
            }else if(accounts.size() > 1){
                throw new RuntimeException("结果集不唯一，数据有问题！");
            }else {
                return accounts.get(0);
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }
}

（三）service层

AccountServiceImpl.java的代码修改如下：

public class AccountServiceImpl2 implements IAccountService {

    private IAccountDao accountDao;
    private TransactionManager transactionManager;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void setTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    /**
     * 添加账户
     * @param account
     */
    public void addAccount(Account account) {
        try{
            //1、开启事务
            transactionManager.beginTransaction();
            //2、执行操作
            accountDao.addAccount(account);
            //3、提交事务
            transactionManager.commit();
        }catch (Exception e){
            //4、回滚
            transactionManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //5、释放资源
            transactionManager.release();
        }
    }

    /**
     * 账户转账
     * @param sourceName
     * @param targetName
     * @param money
     */
    public void transfer(String sourceName, String targetName, float money) {
        try{
            //1、开启事务
            transactionManager.beginTransaction();
            //2、执行操作
            //2.1、查找source账户
            Account sourceAccount = accountDao.findByName(sourceName);
            //2.2、查找target账户
            Account targetAccount = accountDao.findByName(targetName);
            //2.3、source账户金额减少
            sourceAccount.setMoney(sourceAccount.getMoney() - money);
            //2.4、target账户金额增加
            targetAccount.setMoney(targetAccount.getMoney() + money);
            //2.5、更新source账户信息
            accountDao.updateAccount(sourceAccount);
            
            int a = 10/0;
            
            //2.6、更新target账户信息
            accountDao.updateAccount(targetAccount);
            //3、提交事务
            transactionManager.commit();
        }catch (Exception e){
            //4、回滚
            transactionManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //5、释放资源
            transactionManager.release();
        }
    }
}

通过改进之后，再进行测试时，同样会产生异常，但是我们在捕捉到异常之后会进行事务回滚，因此source账户的余额不会减少，target账户的余额不会增加。
但是我们仔细观察又会发现一个问题：进行事务控制的代码基本上都是相同的，此时，我们的代码重复度太高。
所以我们的代码还需要进行改进，我们需要把公共代码进行抽取。

四、V3.0版本

为了解决2.0版本指出的问题，本项目使用了动态代理技术。
对于代理设计模式，可以参考如下文章：
Java设计模式–代理模式【静态代理】
Java设计模式–代理模式【动态代理】
Java设计模式–代理模式【动态代理二】

（一）代理对象工具类

BeanFactory.java:

/**
 * 用于创建service代理对象的工厂
 */
public class BeanFactory {
    private IAccountService accountService;         //被代理对象
    private TransactionManager transactionManager;  //事务控制对象

    public void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    public void setTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    /**
     * 获取IAccountService的方法
     * @return
     */
    public IAccountService getAccountService(){
        return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
                accountService.getClass().getInterfaces(),
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object rtValue = null;
                        try{
                            //1、开启事务
                            transactionManager.beginTransaction();
                            //2、执行操作
                            rtValue = method.invoke(accountService, args);
                            //3、提交事务
                            transactionManager.commit();
                            //4、返回结果
                            return rtValue;
                        }catch (Exception e){
                            //5、回滚
                            transactionManager.rollback();
                            throw new RuntimeException(e);
                        }finally {
                            //6、释放资源
                            transactionManager.release();
                        }
                    }
                });
    }
}

（二）service层

AccountServiceImpl.java:

public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao;

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    /**
     * 添加账户
     * @param account
     */
    public void addAccount(Account account) {
        accountDao.updateAccount(account);
    }

    /**
     * 账户转账
     * @param sourceName
     * @param targetName
     * @param money
     */
    public void transfer(String sourceName, String targetName, float money) {
            //查找source账户
            Account sourceAccount = accountDao.findByName(sourceName);
            //2.2、查找target账户
            Account targetAccount = accountDao.findByName(targetName);
            //2.3、source账户金额减少
            sourceAccount.setMoney(sourceAccount.getMoney() - money);
            //2.4、target账户金额增加
            targetAccount.setMoney(targetAccount.getMoney() + money);
            //2.5、更新source账户信息
            accountDao.updateAccount(sourceAccount);
        
            int a = 10/0;
        
            //2.6、更新target账户信息
            accountDao.updateAccount(targetAccount);
    }
}

（三）配置

<?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">
    <!-- 进行spring的基本配置 -->

<!--    配置accountService的代理对象-->
    <bean id="accountServiceProxy" factory-bean="beanFactory" factory-method="getAccountService"></bean>

<!--    配置BeanFactory-->
    <bean id="beanFactory" class="com.zuobiao.factory.BeanFactory">
        <property name="accountService" ref="accountService"></property>
        <property name="transactionManager" ref="transactionManager"></property>
    </bean>

    <bean id="transactionManager" class="com.zuobiao.utils.TransactionManager">
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!-- service层的基本配置 -->
    <bean id="accountService" class="com.zuobiao.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- dao层的配置 -->
    <bean id="accountDao" class="com.zuobiao.dao.impl.AccountDaoImpl">
        <property name="runner" ref="runner"></property>
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <bean id="connectionUtils" class="com.zuobiao.utils.ConnectionUtils">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置runner -->
    <!-- 此处记得最好配置为多例模式，否则可能会有线程安全问题-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"> 
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring?serverTimezone=UTC"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>
</beans>

（四）测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class test {

    @Autowired
    @Qualifier("accountServiceProxy")   //指定使用代理对象
    IAccountService accountService;

    @Test
    public void testTransfer(){
        accountService.transfer("aaa", "bbb", 100);
    }
}

五、总结

其实Spring实现aop也是使用了动态代理，因此理解本文中的代码对学习aop会有很大的帮助。

Java新手，若有错误，欢迎指正！

| 阅读量次