快速学习-AOP 的相关概念

49路末班车

 关注

阅读 88

2022-03-11


第1章 AOP 的相关概念[理解]

1.1 AOP 概述

1.1.1 什么是 AOP

快速学习-AOP 的相关概念_proxy

1.1.2 AOP 的作用及优势

​作用：​

在程序运行期间，不修改源码对已有方法进行增强。

​优势：​

减少重复代码

提高开发效率

维护方便

1.1.3 AOP 的实现方式

使用动态代理技术

1.2 AOP 的具体应用

1.2.1 案例中问题

这是我们昨天课程中做的增删改查例子。下面是客户的业务层实现类。我们能看出什么问题吗?

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

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

请看下面的示例：

我们在业务层中多加入一个方法。

​业务层接口​

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

​业务层实现类​

@Override
public void transfer(String sourceName, String targetName, Float money) {
  //根据名称查询两个账户信息
  Account source = accountDao.findByName(sourceName);
  Account target = accountDao.findByName(targetName);
  //转出账户减钱，转入账户加钱
  source.setMoney(source.getMoney() - money);
  target.setMoney(target.getMoney() + money);
  //更新两个账户
  accountDao.update(source);
  int i = 1 / 0; //模拟转账异常
  accountDao.update(target);
}

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

1.2.2 问题的解决

​解决办法：​

让业务层来控制事务的提交和回滚。（这个我们之前已经在 web 阶段讲过了）

​改造后的业务层实现类：​

注：此处没有使用 spring 的 IoC.

public class AccountServiceImpl implements IAccountService{

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

    @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.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 IActor {
  /**
   * 基本演出
   * @param money
   */
  public void basicAct(float money);
  /**
   * 危险演出
   * @param money
   */
  public void dangerAct(float money);
}
/**
 * 一个演员
 */
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor {
  public void basicAct(float money) {
    System.out.println("拿到钱，开始基本的表演：" + money);
  }
  public void dangerAct(float money) {
    System.out.println("拿到钱，开始危险的表演：" + money);
  }
}
public class Client {
  public static void main(String[] args) {
    //一个剧组找演员：
    final Actor actor = new Actor(); //直接
    /**
     * 代理：
     * 间接。
     * 获取代理对象：
     * 要求：
     * 被代理类最少实现一个接口
     * 创建的方式
     * Proxy.newProxyInstance(三个参数)
     * 参数含义：
     * ClassLoader：和被代理对象使用相同的类加载器。
     * Interfaces：和被代理对象具有相同的行为。实现相同的接口。
     * InvocationHandler：如何代理。
     * 策略模式：使用场景是：
     * 数据有了，目的明确。
     * 如何达成目标，就是策略。
     * 
     */
    IActor proxyActor = (IActor) Proxy.newProxyInstance(
      actor.getClass().getClassLoader(),
      actor.getClass().getInterfaces(),
      new InvocationHandler() {
        /**
         * 执行被代理对象的任何方法，都会经过该方法。
         * 此方法有拦截的功能。
         * 
         * 参数：
         * proxy：代理对象的引用。不一定每次都用得到
         * method：当前执行的方法对象
         * args：执行方法所需的参数
         * 返回值：
         * 当前执行方法的返回值
         */
        @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;
        }
      });
    //没有经纪公司的时候，直接找演员。
    // actor.basicAct(1000f);
    // actor.dangerAct(5000f);
    //剧组无法直接联系演员，而是由经纪公司找的演员
    proxyActor.basicAct(8000 f);
    proxyActor.dangerAct(50000 f);
  }
}

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);
  }
}
public class Client {
  /**
   * 基于子类的动态代理
   * 要求：
   * 被代理对象不能是最终类
   * 用到的类：
   * Enhancer
   * 用到的方法：
   * create(Class, Callback)
   * 方法的参数：
   * Class：被代理对象的字节码
   * Callback：如何代理
   * @param args
   */
  public static void main(String[] args) {
    final Actor actor = new Actor();
    Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
      new MethodInterceptor() {
        /**
        * 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
        方法进行增强。
        * 
        * 参数：
        * 前三个和基于接口的动态代理是一样的。
        * MethodProxy：当前执行方法的代理对象。
        * 返回值：
        * 当前执行方法的返回值
        */
        @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(10000);
    cglibActor.dangerAct(100000);
  }
}

思考：

这个故事（示例）讲完之后，我们从中受到什么启发呢？它到底能应用在哪呢？

1.2.5 解决案例中的问题

public class BeanFactory {
  /**
   * 创建账户业务层实现类的代理对象
   * @return
   */
  public static IAccountService getAccountService() {
    //1.定义被代理对象
    final IAccountService accountService = new AccountServiceImpl();
    //2.创建代理对象
    IAccountService proxyAccountService = (IAccountService)
    Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
      accountService.getClass().getInterfaces(), new InvocationHandler() {
        /**
         * 执行被代理对象的任何方法，都会经过该方法。
         * 此处添加事务控制
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          Object rtValue = null;
          try {
            //开启事务
            TransactionManager.beginTransaction();
            //执行业务层方法
            rtValue = method.invoke(accountService, args);
            //提交事务
            TransactionManager.commit();
          } catch (Exception e) {
            //回滚事务
            TransactionManager.rollback();
            e.printStackTrace();
          } finally {
            //释放资源
            TransactionManager.release();
          }
          return rtValue;
        }
      });
    return proxyAccountService;
  }
}

当我们改造完成之后，业务层用于控制事务的重复代码就都可以删掉了。



相关推荐

Spring中aop的相关概念

彪悍的鼹鼠 40 0 0

IOC和AOP相关概念

流计算Alink 68 0 0

15. AOP 相关概念

吃面多放酱 97 0 0

AOP的概念

_铁马冰河_ 157 0 0

一文掌握AOP相关概念，理解AOP工作流程

北冥有一鲲 145 0 0

AOP中的概念

Xin_So 118 0 0

AOP相关

汤姆torn 58 0 0

机器学习及深度学习的相关概念补充

眼君 99 0 0

CI/CD相关概念学习

中间件小哥 80 0 0

Spring系列22：Spring AOP 概念与快速入门篇

罗蓁蓁 67 0 0

精彩评论（0）

0 0 举报