2020-06-21

SSM-Spring【AOP进阶】

字数统计: 3.8k字 | 阅读时长: 19分

一、前言

在SSM-Spring【aop大致实现原理】中通过手动实现动态代理总结了Spring实现AOP的大致原理，SSM-Spring【实现AOP】中则总结了实现AOP的一个小案例，因此本文主要通过两者结合，将SSM-Spring【aop大致实现原理】中的案例修改为通过实现Spring的AOP来达到减少重复代码的效果。

二、原本的项目

（一）项目结构和数据库表

项目结构如下：
01_项目结构
数据库表结构：
该表为spring数据库下的名为account的表
01_数据库表结构
数据库表数据：
01_数据库表数据

（二）domain

Account.java:

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

    ......
}

（三）dao

IAccountDao.java:

/**
 * 操作账户的dao接口
 */
public interface IAccountDao {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id进行查询
     * @param id
     * @return
     */
    Account findById(Integer id);

    /**
     * 添加账户
     * @param account
     */
    void addAccount(Account account);

    /**
     * 删除账户
     * @param id
     */
    void delAccount(Integer id);

    /**
     * 更新账户信息
     * @param account
     */
    public void updateAccount(Account account);

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

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;
    }

    /**
     * 查询所有
     * @return
     */
    public List<Account> findAll() {
        try {
            return runner.query(connectionUtils.getConnection(), "select * from account", new BeanListHandler<Account>(Account.class));
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 根据id进行查询
     * @param id
     * @return
     */
    public Account findById(Integer id) {
        try {
            return runner.query(connectionUtils.getConnection(), "select * from account where id = ?", new BeanHandler<Account>(Account.class), id);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 添加账户
     * @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 id
     */
    public void delAccount(Integer id) {
        try {
            runner.update(connectionUtils.getConnection(), "delete from account where id = ?", id);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 更新账户信息
     * @param account
     */
    public void updateAccount(Account account) {
        try {
            runner.update(connectionUtils.getConnection(), "update account set name=?, money=? where id=?", account.getName(), account.getMoney(), account.getId());
        } 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

IAccountService.java:

public interface IAccountService {
    /**
     * 查询所有
     * @return
     */
    List<Account> findAll();

    /**
     * 根据id进行查询
     * @param id
     * @return
     */
    Account findById(Integer id);

    /**
     * 添加账户
     * @param account
     */
    void addAccount(Account account);

    /**
     * 删除账户
     * @param id
     */
    void delAccount(Integer id);

    /**
     * 修改账户信息
     * @param account
     */
    void updateAccount(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;
    }

    /**
     * 查询所有账户
     * @return
     */
    public List<Account> findAll() {
        return accountDao.findAll();
    }

    /**
     * 根据id查找单个账户
     * @param id
     * @return
     */
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

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

    /**
     * 删除账户
     * @param id
     */
    public void delAccount(Integer id) {
        accountDao.delAccount(id);
    }

    /**
     * 更新账户信息
     * @param account
     */
    public void updateAccount(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);
    }
}

（五）factory

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();
                        }
                    }
                });
    }
}

（六）utils

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();
        }
    }
}

（七）配置

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">
    <!-- 进行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>

三、XML方式实现AOP

（一）项目结构

02_项目结构

（二）domain

Account.java:

同上

（三）dao

IAccountDao.java:

同上

AccountDaoImpl.java:

同上

（四）service

IAccountService.java:

同上

AccountServiceImpl.java:

同上

（五）utils

ConnectionUtils.java:

同上

TransactionManager.java:

同上

（六）配置

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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置ioc -->
    <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>

    <!-- 开始配置aop -->
    <aop:config>
        <aop:pointcut id="pt1" expression="execution(* com.zuobiao.service.impl.*.*(..))"/>
        <aop:aspect id="transaction" ref="transactionManager">
            <!-- 前置通知：开始事务 -->
            <aop:before method="beginTransaction" pointcut-ref="pt1"></aop:before>
            <!-- 后置通知：提交事务 -->
            <aop:after-returning method="commit" pointcut-ref="pt1"></aop:after-returning>
            <!-- 异常通知：回滚事务 -->
            <aop:after-throwing method="rollback" pointcut-ref="pt1"></aop:after-throwing>
            <!-- 最终通知：释放连接 -->
            <aop:after method="release" pointcut-ref="pt1"></aop:after>
        </aop:aspect>
    </aop:config>
</beans>

四、注解方式实现AOP

（一）项目结构

03_项目结构

（二）domain

Account.java:

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

    ......
}

（三）dao

IAccountDao.java:

同上

AccountDaoImpl.java:

@Repository("accountDao")
public class AccountDaoImpl implements IAccountDao {

    @Autowired
    private QueryRunner runner;

    @Autowired
    private ConnectionUtils connectionUtils;

    /**
     * 查询所有
     * @return
     */
    public List<Account> findAll() {
        try {
            return runner.query(connectionUtils.getConnection(), "select * from account", new BeanListHandler<Account>(Account.class));
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 根据id进行查询
     * @param id
     * @return
     */
    public Account findById(Integer id) {
        try {
            return runner.query(connectionUtils.getConnection(), "select * from account where id = ?", new BeanHandler<Account>(Account.class), id);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }

    /**
     * 添加账户
     * @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 id
     */
    public void delAccount(Integer id) {
        try {
            runner.update(connectionUtils.getConnection(), "delete from account where id = ?", id);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }

    /**
     * 更新账户信息
     * @param account
     */
    public void updateAccount(Account account) {
        try {
            runner.update(connectionUtils.getConnection(), "update account set name=?, money=? where id=?", account.getName(), account.getMoney(), account.getId());
        } 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

IAccountService.java:

同上

AccountServiceImpl.java:

@Service("accountService")
public class AccountServiceImpl implements IAccountService {

    @Autowired
    private IAccountDao accountDao;

    /**
     * 查询所有账户
     * @return
     */
    public List<Account> findAll() {
        return accountDao.findAll();
    }

    /**
     * 根据id查找单个账户
     * @param id
     * @return
     */
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

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

    /**
     * 删除账户
     * @param id
     */
    public void delAccount(Integer id) {
        accountDao.delAccount(id);
    }

    /**
     * 更新账户信息
     * @param account
     */
    public void updateAccount(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);
    }
}

（五）utils

ConnectionUtils.java:

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

    @Autowired
    private DataSource dataSource;

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

    /**
     * 获取当前线程上的连接
     * @return
     */
    public Connection getConnection(){
        //1、先从ThreadLocal上获取
        Connection conn = tl.get();
        //2、判断当前线程上有无连接
        try {
            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:

/**
 *  对事务进行管理的工具类
 */
@Component("transactionManager")
@Aspect
public class TransactionManager {

    @Autowired
    private ConnectionUtils connectionUtils;

    @Pointcut("execution(* com.zuobiao.service.impl.*.*(..))")
    private void pt1(){}

    /**
     * 开启事务
     */
    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();
        }
    }

    /**
     * 编写环绕通知解决顺序问题
     * @param pjp
     * @return
     */
    @Around("pt1()")
    public Object around(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();
            beginTransaction();
            rtValue = pjp.proceed(args);
            commit();
            return rtValue;
        }catch (Throwable e){
            rollback();
            throw new RuntimeException(e);
        }finally {
            release();
        }
    }
}

（六）配置

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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置ioc -->
    <context:component-scan base-package="com.zuobiao"></context:component-scan>

    <!-- 配置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>

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

五、总结

Spring的AOP实现原理就是动态代理，因此不需要自己手动实现动态代理。
能达到使用较少代码且简简单单就能实现方法增强（提取公共代码，提高代码可重用度）的目的。

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

| 阅读量次