[Spring-03]超简单的AOP概念解析

学哥斌

已于 2022-11-20 18:03:49 修改

阅读量240

点赞数

分类专栏： Spring 文章标签： spring aop java

于 2020-02-28 22:30:55 首次发布

本文链接：https://blog.csdn.net/qq_29051413/article/details/104556595

版权

Spring 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

文章目录

0、问题引入
1、AOP的相关概念
2、Spring中的AOP

0、问题引入

下面我们先看一个 OOP 的例子。

例如：现有三个类，Horse、Pig、Dog，这三个类中都有 eat 和 run 两个方法。

通过 OOP 思想中的继承，我们可以提取出一个 Animal 的父类，然后将 eat 和 run 方法放入父类中，Horse、Pig、Dog通过继承Animal类即可自动获得eat() 和 run() 方法。这样将会少些很多重复的代码。
在这里插入图片描述

OOP 编程思想可以解决大部分的代码重复问题。但是有一些问题是处理不了的。比如在父类 Animal 中的多个方法的相同位置出现了重复的代码，OOP 就解决不了。

/**
 * 动物父类
 */
public class Animal {
    /**
     * 身高
     */
    private String height;
    /**
     * 体重
     */
    private double weight;

    public void eat() {
        // 性能监控代码
        long start = System.currentTimeMillis();
        // 业务逻辑代码
        System.out.println("I can eat...");
        // 性能监控代码
        System.out.println("执行时长：" + (System.currentTimeMillis() - start) / 1000f + "s");
    }

    public void run() {
        // 性能监控代码
        long start = System.currentTimeMillis();
        // 业务逻辑代码
        System.out.println("I can run...");
        // 性能监控代码
        System.out.println("执行时长：" + (System.currentTimeMillis() - start) / 1000f + "s");
    }
}

这部分重复的代码，一般统称为横切逻辑代码。
在这里插入图片描述
横切逻辑代码存在的问题：

1、代码重复问题
2、横切逻辑代码和业务代码混杂在一起，代码臃肿，不便维护

AOP 就是用来解决这些问题的

AOP 另辟蹊径，提出横向抽取机制，将横切逻辑代码和业务逻辑代码分离。
在这里插入图片描述
代码拆分比较容易，难的是如何在不改变原有业务逻辑的情况下，悄无声息的将横向逻辑代码应用到原有的业务逻辑中，达到和原来一样的效果。

1、AOP的相关概念

1.1 AOP概述

1.1.1 什么是AOP

AOP：全称是 Aspect Oriented Programming 即：面向切面编程。
简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

1.1.2 AOP的作用及优势

在程序运行期间，不修改源码对已有方法进行增强。
减少重复代码、提高开发效率和维护方便

1.1.3 AOP的实现方式

使用动态代理技术。

1.2 AOP的具体运用

1.2.1 案例中的问题

下面有一个业务层实现类：

public class AccountServiceImpl implements AccountService {

    private IAccountDao accountDao;

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

    @Override
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }
}

这里存在一个问题：事务被自动控制了。换言之，我们使用了 connection 对象的setAutoCommit(true)
此方式控制事务，如果我们每次都执行一条 sql 语句，没有问题，但是如果业务方法一次要执行多条 sql语句，这种方式就无法实现功能了。
在业务层增加一个方法：

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
        //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);
        //2.5更新转出账户
        accountDao.updateAccount(source);

		int i=1/0;	// 模拟转账异常

        //2.6更新转入账户
        accountDao.updateAccount(target);
    }

当我们执行时，由于执行有异常，转账失败。但是因为我们是每次执行持久层方法都是独立事务，导致无法实现事务控制（不符合事务的一致性）。

1.2.2 问题的解决

让业务层来控制事务的提交和回滚。
首先创建一个获取连接的工具类：

/**
 * 连接的工具类，它用于从数据源中获取一个连接，并且实现和线程的绑定
 */
public class ConnectionUtils {

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

    private DataSource dataSource;

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

    /**
     * 获取当前线程上的连接
     * @return
     */
    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();
    }
}

然后创建一个管理事务的类：

/**
 * 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
 */
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();
        }
    }
}

修改持久层代码：

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

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

修改业务层代码，控制事务的提交和回滚：

/**
 * 账户的业务层实现类
 *
 * 事务控制应该都是在业务层
 */
public class AccountServiceImpl_OLD implements AccountService{

    private AccountDao accountDao;
    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

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

    @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 updateAccount(Account account) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.updateAccount(account);
            //3.提交事务
            txManager.commit();
        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
        }finally {
            //5.释放连接
            txManager.release();
        }

    }

    @Override
    public void deleteAccount(Integer acccountId) {
        try {
            //1.开启事务
            txManager.beginTransaction();
            //2.执行操作
            accountDao.deleteAccount(acccountId);
            //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);
            //2.5更新转出账户
            accountDao.updateAccount(source);

            int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
            //3.提交事务
            txManager.commit();

        }catch (Exception e){
            //4.回滚操作
            txManager.rollback();
            e.printStackTrace();
        }finally {
            //5.释放连接
            txManager.release();
        }
    }
}

依赖注入：

<?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="cn.klb.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

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

    <!--配置QueryRunner-->
    <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.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db1"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- 配置事务管理器-->
    <bean id="txManager" class="cn.klb.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!-- 配置Connection的工具类 ConnectionUtils -->
    <bean id="connectionUtils" class="cn.klb.utils.ConnectionUtils">
        <!-- 注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

测试类：

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

    @Autowired
    @Qualifier("accountService")
    private  IAccountService as;

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

解决问题的逻辑是：在前面执行的transfer方法时，每一步都是一个独立的连接，意味着一个独立的事务，修改后的业务层的transfer方法只使用了一个连接，意味着这些步骤都是一个事务下的，因此当中间发生异常时，直接回滚，不会真正执行。

1.2.3 新的问题

上一小节的代码，通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题：业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了。
试想一下，如果我们此时的事务管理类的提交、回滚和释放资源中任何一个方法名变更，都需要修改业务层的代码，况且这还只是一个业务层实现类，而实际的项目中这种业务层实现类可能有十几个甚至几十个。

1.2.4 动态代理回顾

1.2.4.1 动态代理的特点

字节码随用随创建，随用随加载。
它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
装饰者模式就是静态代理的一种体现。

1.2.4.2 动态代理常用的两种方式

基于接口的动态代理：
提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。
基于子类的动态代理：
提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
要求：被代理类不能用 final 修饰的类（最终类）。

1.2.4.3 使用JDK官方的Proxy类创建代理对象

此处使用的是一个演员的例子：在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪人来找了。下面我们就用代码演示出来。
创建一个演员接口：

public interface ActorInterface {
    /**
     * 基本演出
     * @param money
     */
    public void basicAct(float money);

    /**
     * 危险演出
     * @param money
     */
    public void dangerAct(float money);
}

创建演员接口的实现类：

public class Actor implements ActorInterface {
    @Override
    public void basicAct(float money) {
        System.out.println("拿到钱，开始基本的表演："+money);
    }

    @Override
    public void dangerAct(float money) {
        System.out.println("拿到钱，开始危险的表演："+money);
    }
}

没有代理的测试方法：

public class Client {
    public static void main(String[] args) {
        //一个剧组找演员：
        final Actor actor = new Actor();
        
        //没有经纪公司的时候，直接找演员。
        actor.basicAct(8000f);
        actor.dangerAct(50000f);
    }
}

控制台输出：
在这里插入图片描述
有代理的测试方法：

public class Client {
    public static void main(String[] args) {
        //一个剧组找演员：
        final Actor actor = new Actor();
        
        //创建一个代理对象代替actor
        ActorInterface proxyActor = (ActorInterface) Proxy.newProxyInstance(
                actor.getClass().getClassLoader(),
                actor.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        String name = method.getName();
                        Float money = (Float) args[0];
                        Object rtValue = null;
                        //每个经纪公司对不同演出收费不一样，此处开始判断
                        if ("basicAct".equals(name)) {
                            //基本演出，没有 2000 不演
                            if (money > 2000) {
                                //看上去剧组是给了 8000，实际到演员手里只有 4000
                                //这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
                                rtValue = method.invoke(actor, money / 2);
                            }
                        }
                        if ("dangerAct".equals(name)) {
                            //危险演出,没有 5000 不演
                            if (money > 5000) {
                                //看上去剧组是给了 50000，实际到演员手里只有 25000
                                //这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
                                rtValue = method.invoke(actor, money / 2);
                            }
                        }
                        return rtValue;
                    }
                });

        //剧组无法直接联系演员，而是由经纪公司找的演员
        proxyActor.basicAct(8000f);
        proxyActor.dangerAct(50000f);
    }
}

控制台输出：
在这里插入图片描述

1.2.4.4 使用CGLib的Enhancer类创建代理对象

创建演员类：

public class Actor {//没有实现任何接口

    public void basicAct(float money) {
        System.out.println("拿到钱，开始基本的表演：" + money);
    }

    public void dangerAct(float money) {
        System.out.println("拿到钱，开始危险的表演：" + money);
    }
}

创建测试类：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class Client {
    public static void main(String[] args) {

        final Actor actor = new Actor();

        Actor cglibActor = (Actor) Enhancer.create(actor.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                String name = method.getName();
                Float money = (Float) args[0];
                Object rtValue = null;
                if("basicAct".equals(name)){
                    //基本演出
                    if(money > 2000){
                        rtValue = method.invoke(actor, money/2);
                    }
                }
                if("dangerAct".equals(name)){
                    //危险演出
                    if(money > 5000){
                        rtValue = method.invoke(actor, money/2);
                    }
                }
                return rtValue;
            }
        });

        cglibActor.basicAct(10000f);
        cglibActor.dangerAct(100000f);
    }
}

1.2.5 解决案例中的问题

业务层代码恢复原样：

public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

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

    @Override
    public List<Account> findAllAccount() {
        return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);
    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
        //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);
        //2.5更新转出账户
        accountDao.updateAccount(source);
        //2.6更新转入账户
        accountDao.updateAccount(target);
    }
}

用于创建Service的代理对象的工厂：

import com.itheima.service.IAccountService;
import com.itheima.utils.TransactionManager;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class BeanFactory {

    private AccountService accountService;

    private TransactionManager txManager;

    public void setTxManager(TransactionManager txManager) {
        this.txManager = txManager;
    }

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

    /**
     * 获取Service代理对象
     * @return
     */
    public AccountService getAccountService() {
        return (AccountService) 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.开启事务
                            txManager.beginTransaction();
                            //2.执行操作
                            rtValue = method.invoke(accountService, args);
                            //3.提交事务
                            txManager.commit();
                            //4.返回结果
                            return rtValue;
                        } catch (Exception e) {
                            //5.回滚操作
                            txManager.rollback();
                            throw new RuntimeException(e);
                        } finally {
                            //6.释放连接
                            txManager.release();
                        }
                    }
                });
    }
}

依赖注入：

<?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="proxyAccountService" factory-bean="beanFactory" factory-method="getAccountService"></bean>

    <!--配置beanfactory-->
    <bean id="beanFactory" class="cn.klb.factory.BeanFactory">
        <!-- 注入service -->
        <property name="accountService" ref="accountService"></property>
        <!-- 注入事务管理器 -->
        <property name="txManager" ref="txManager"></property>
    </bean>

     <!-- 配置Service -->
    <bean id="accountService" class="cn.klb.service.impl.AccountServiceImpl">
        <!-- 注入dao -->
        <property name="accountDao" ref="accountDao"></property>
    </bean>

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

    <!--配置QueryRunner-->
    <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.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db1"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>

    <!-- 配置事务管理器-->
    <bean id="txManager" class="cn.klb.utils.TransactionManager">
        <!-- 注入ConnectionUtils -->
        <property name="connectionUtils" ref="connectionUtils"></property>
    </bean>

    <!-- 配置Connection的工具类 ConnectionUtils -->
    <bean id="connectionUtils" class="cn.klb.utils.ConnectionUtils">
        <!-- 注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
</beans>

测试类：

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

    @Autowired
    @Qualifier("proxyAccountService")
    private  AccountService as;

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

}

使用了代理对象后，之前业务层控制事务的重复代码可以删除了。
注意一个细节，依赖注入中，txManager和accountDao注入的connectionUtils是同一个对象。

2、Spring中的AOP

2.1 Spring中AOP的细节

学习spring中的aop，目的是使用配置的方式实现上面的代理对象功能。

2.1.1 AOP相关术语

1、Joinpoint(连接点）
所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。
2、Pointcut（切入点）
所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
3、Advice（通知/ 增强）
所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。
在这里插入图片描述
4、Introduction（引介）
引介是一种特殊的通知，在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方法或 Field。
5、Target（目标对象）
代理的目标对象。
6、Weaving（织入）
是指把增强应用到目标对象来创建新的代理对象的过程。
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
7、Proxy（代理）
一个类被 AOP 织入增强后，就产生一个结果代理类。
8、Aspect（切面）
是切入点和通知（引介）的结合。

2.1.2 spring中AOP要明确的事情

我们要做的：
编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP 编程人员来做。
在配置文件中，声明切入点与通知间的关系，即切面。：AOP 编程人员来做。
spring框架做的：
Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

2.2 基于XML的AOP配置

2.2.1 环境搭建

2.2.1.1 准备必要的代码

这里主要了解AOP配置，业务层用输出语句代替，持久层省略。
创建业务层接口：

/**
 * 账户的业务层接口
 */
public interface AccountService {

    /**
     * 模拟保存账户
     */
   void saveAccount();

    /**
     * 模拟更新账户
     * @param i
     */
   void updateAccount(int i);

    /**
     * 删除账户
     * @return
     */
   int  deleteAccount();
}

模拟业务层实现类：

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements AccountService{

    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("执行了更新"+i);

    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

2.2.1.2 导入必备的jar包坐标

<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>5.0.2.RELEASE</version>
	</dependency>
	
	<dependency>
		<groupId>org.aspectj</groupId>
		<artifactId>aspectjweaver</artifactId>
		<version>1.8.7</version>
	</dependency>
</dependencies>

2.2.1.3 创建spring的配置文件并导入约束

<?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">
        
</beans>

2.2.1.4 配置spring的IOC

<!-- 配置srping的Ioc,把service对象配置进来-->
<bean id="accountService" class="cn.klb.service.impl.AccountServiceImpl"></bean>

2.2.1.5 抽取公共代码制作成Advice

这里创建一个日志类作为Advice：

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
public class Logger {

    /**
     * 用于打印日志：计划让其在切入点方法执行之前执行（切入点方法就是业务层方法）
     */
    public  void printLog(){
        System.out.println("Logger类中的pringLog方法开始记录日志了。。。");
    }
}

2.2.2 配置步骤

2.2.2.1 把日志类用bean标签配置起来

<!-- 配置Logger类 -->
<bean id="logger" class="com.itheima.utils.Logger"></bean>

2.2.2.2 使用 aop:config 声明aop配置

<!--
aop:config
	作用：用于声明开始 aop 的配置
-->

<aop:config>
	<!-- 配置的代码都写在此处 -->
</aop:config>

2.2.2.3 使用 aop:aspect 配置切面

<!--
aop:aspect
	作用：用于配置切面。
	属性：
		id：给切面提供一个唯一标识。
		ref：引用配置好的Advice类 bean 的 id。
-->

<aop:aspect id="txAdvice" ref="txManager">
	<!--配置通知的类型要写在此处-->
</aop:aspect>

2.2.2.4 使用 aop:pointcut 配置切入点表达式

<!--
	aop:pointcut
	作用：
		用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。
	属性：
		expression：用于定义切入点表达式。
		id：用于给切入点表达式提供一个唯一标识
-->

<aop:pointcut id="pt1" expression="execution(public void cn.klb.service.impl.AccountServiceImpl.saveAccount())"/>

expression(表达式)中的表达式具体写法如下：
访问修饰符返回值包名.包名.包名...类名.方法名(参数列表)
标准的表达式写法：
public void cn.klb.service.impl.AccountServiceImpl.saveAccount()
访问修饰符可以省略：
void cn.klb.service.impl.AccountServiceImpl.saveAccount()
返回值可以使用通配符，表示任意返回值:
* cn.klb.service.impl.AccountServiceImpl.saveAccount()
包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.:
* *.*.*.*.AccountServiceImpl.saveAccount())
包名可以使用..表示当前包及其子包:
* *..AccountServiceImpl.saveAccount()
类名和方法名都可以使用*来实现通配:
* *..*.*()

2.2.2.5 使用 aop:xxx 配置对应的通知类型

<!--
aop:before
	作用：用于配置前置通知。指定增强的方法在切入点方法之前执行.
	属性：
		method:用于指定Advice类中的增强方法名称
		ponitcut-ref：用于指定切入点的表达式的引用
		poinitcut：用于指定切入点表达式 
	执行时间点：切入点方法执行之前执行
-->

<!--表示给cn.klb.service.impl下所有类所有方法进行增强，Advice为 printLog-->
<aop:before method="printLog" pointcut="execution(* cn.klb.service.impl.*.*(..))"></aop:before>

2.2.2.6 完整的配置

<?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">

    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="cn.klb.service.impl.AccountServiceImpl"></bean>

    <!-- 配置Logger类 -->
    <bean id="logger" class="cn.klb.utils.Logger"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--配置切面 -->
        <aop:aspect id="logAdvice" ref="logger">
            <aop:pointcut id="pt1" expression="execution(public void cn.klb.service.impl.AccountServiceImpl.saveAccount())"/>
            <aop:before method="printLog" pointcut-ref="pt1"></aop:before>
        </aop:aspect>
    </aop:config>

</beans>

2.2.2.7 测试方法

/**
 * 测试AOP的配置
 */
public class AOPTest {

    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        //3.执行方法
        as.saveAccount();
    }
}

控制台输出如下：
在这里插入图片描述

2.2.3 环绕通知

配置方式：

<?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">

	<!-- 配置srping的Ioc,把service对象配置进来-->
	<bean id="accountService" class="cn.klb.service.impl.AccountServiceImpl"></bean>
	
	<!-- 配置Logger类 -->
	<bean id="logger" class="cn.klb.utils.Logger"></bean>
	
	<!--配置AOP-->
	<aop:config>
		<!-- 配置切入点表达式 -->
		<aop:pointcut id="pt1" expression="execution(* cn.klb.service.impl.*.*(..))"></aop:pointcut>
		
		<!--配置切面 -->
	    <aop:aspect id="logAdvice" ref="logger">
			<!-- 配置环绕通知 -->
			<aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
		</aop:aspect>
		
	</aop:config>

</beans>

Logger类增加一个方法：

public Object aroundPringLog(ProceedingJoinPoint pjp){
	Object rtValue = null;
	try{
		Object[] args = pjp.getArgs();//得到方法执行所需的参数
		
		System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
		
		rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）
		
		System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");
		
		return rtValue;
	}catch (Throwable t){
	
		System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
		throw new RuntimeException(t);
	}finally {
	
		System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
	}
}

**aop:around **
作用：
用于配置环绕通知。
属性：
method：指定通知中方法的名称；
pointct：定义切入点表达式；
pointcut-ref：指定切入点表达式的引用。
说明：
它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。
注意：
通常情况下，环绕通知都是独立使用的。
spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参数。在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。

2.3 基于注解的AOP配置

2.3.1 环境搭建

2.3.1.1 导入jar包的坐标

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

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>

2.3.1.2 配置文件中导入context命名空间

<?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">

</beans>

2.3.1.3 把资源使用注解配置

/**
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService{

    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
        int i=1/0;
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("执行了更新"+i);

    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

2.3.1.4 配置文件中指定spring要扫描的包

<context:component-scan base-package="cn.klb"></context:component-scan>

2.3.2 配置步骤

2.3.2.1 Advice类使用注解配置

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect	//表示当前类是一个切面类
public class Logger {

}

2.3.2.2 增强的方法上使用注解配置Advice

/**
 * 用于记录日志的工具类，它里面提供了公共的代码
 */
@Component("logger")
@Aspect//表示当前类是一个切面类
public class Logger {

    @Pointcut("execution(* cn.klb.service.impl.*.*(..))")
    private void pt1(){}

    /**
     * 前置通知
     */
    @Before("pt1()")
    public  void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始记录日志了。。。");
    }

    /**
     * 后置通知
     */
    @AfterReturning("pt1()")
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始记录日志了。。。");
    }
    /**
     * 异常通知
     */
    @AfterThrowing("pt1()")
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始记录日志了。。。");
    }

    /**
     * 最终通知
     */
    @After("pt1()")
    public  void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始记录日志了。。。");
    }
}

2.3.2.3 配置文件中开启spring对AOP的支持

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

2.3.3 环绕通知的注解配置

@Around
作用：
把当前方法看成是环绕通知。
属性：
value：用于指定切入点表达式，还可以指定切入点表达式的引用。
在Advice类中添加方法：

	@Around("pt1()")
	public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }

2.3.5 完全不用XML配置方式

@Configuration
@ComponentScan(basePackages="cn.klb")
@EnableAspectJAutoProxy
public class SpringConfiguration {
}

学哥斌

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
[Spring-03]超简单的AOP概念解析

1、AOP的相关概念1.1 AOP概述1.1.1 什么是AOP AOP：全称是 Aspect Oriented Programming 即：面向切面编程。简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。1.1.2 AOP的作用及优势在程序运行期间，不修改源码对已有方法进行增强。减少重复代码...
复制链接

扫一扫