代理模式与AOP开发

切面由额外功能和切入点两个部分组成，从动态代理开发中我们发现需要将额外功能添加到原始类的不同方法调用的前后，这实际上就是在定义切面的额外功能部分。

定义好了额外功能，我们要决定将额外功能添加到哪些方法上，这些需要被代理的原始方法就是切入点。

回过头看上面的图，比如我们需要在UserService类和OrderService类中所有方法执行前打印日志，那么我们要定义的额外功能就是打印日志，切入点就是这两个类中的所有方法。从图上看我们发现日志是一条线，但由于类对象描述的是三维空间中的一个实体，所以从三维空间来看，这些额外功能几乎就是从这些由方法构成的实体类中横切出来的一个面，在这个面上，额外功能都是一致的，而每个被切入的类方法不同。

2. AOP的底层原理

AOP编程的本质是动态代理编程，在SpringAOP中默认使用JDK动态代理，我们也可以通过配置调整为CGLib动态代理。所以说AOP面向切面编程本质上是由代理模式开发而逐渐衍生出来的一种范式。

从上述对两种动态代理方式的编码来看，我们自己去调用动态代理底层接口开发是比较麻烦的，SpringAOP通过对底层接口的封装降低了开发者的使用难度，这就是使用框架的好处。

3. 基于注解模式开发

SpringAOP提供了两种模式进行开发，一种是通过实现接口定义额外功能，然后通过配置文件定义切入点和组装切面，另一种是基于AspectJ提供的注解模式进行开发，可以实现在一个切面类中同时定义额外功能和切入点。

由于配置文件的模式逐渐被淘汰，本文中只介绍基于注解的开发模式。

• 引入依赖

      <!-- 基于SpringBoot -->    
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
      </dependency>
  

• 定义原始类

  @Service
  public class UserServiceImpl implements UserService {
  
    @Override
    public void login(String username, String password) {
      System.out.println("login succeed !");
    }
  
    @Override
    public void register(User user) {
      System.out.println("register succeed !");
    }
  }
  

• 定义切面类

  @Aspect
  @Component
  public class MyAspect {
    @Around("execution(* *..UserServiceImpl.*(..))")
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
      System.out.println("--- log before ---");
      Object ret = joinPoint.proceed();
      System.out.println("--- log after ---");
      return ret;
    
  }
  

• 测试

  @SpringBootTest
  public class UserServiceTest {
  	
    // 注意：这里我们虽然引用的是原始类接口，但spring已经自动为我们创建并注入了代理类对象
    @Autowired
    UserService userService;
  
    @Test
    void loginTest() {
      userService.login("admin", "123456");
    }
  
    @Test
    void registerTest() {
      userService.register(new User());
    }
  }
  

这里注意几个点：

• ProceedingJoinPoint joinPoint：这个很像Method method，实际上我们定义的log方法最终会被用在动态代理底层接口的调用中。
• @Aspect注解：声明切面类
• @Component注解：Spring在底层需要调用切面方法，这里要加入容器
• @Around注解：当我们想要在原始方法的前、后、前后甚至异常时执行额外功能时使用该注解，这个注解和log方法的声明是对应的，定义了这个注解调用方才会传入ProceedingJoinPoint joinPoint参数。这个注解是最为强大的，其他的@Before,@After等都是针对该注解使用方式的简化，本文暂不介绍。

4. 切点表达式

在上文中的@Around("execution(* *..UserServiceImpl.*(..))")中"execution(xxx)"用于定义切点，execution是切点函数，括号内是切点表达式。类似@Around和@Before,@After的关系，execution也是切点函数中最强大的，相应的它的切点表达式也是功能最丰富的。

切点表达式用于描述要切入的方法声明，整体分为三部分：

• 第一部分是方法修饰符+返回类型
• 第二部分是包名+类名+方法名
• 第三部分是参数类型

通过对这三个部分的描述我们可以唯一确定一个方法：

• * *..UserServiceImpl.*(..)：不管修饰符和返回值，所有包中的UserServiceImpl类中的所有方法

  前面的..表示忽略包的层级，后面的..表示不论是否有参数，不论有几个参数，不论参数类型是什么

• * login(..)：不管修饰符和返回值，所有包所有类中的login方法

• * login(String, String)：不管修饰符和返回值，所有包所有类中的存在两个参数并且类型都为String的login方法
  

由于通过切点表达式来定义切点相对比较繁琐并且不好维护，这里就不再赘述，后续推荐使用基于注解的方式来定义切点。

5. 切点函数

上文中的execution是基于切点表达式使用的最强大的切点函数，其他的比如args，within都是基于execution的简化写法，不再赘述。

这里着重介绍一个切点函数：@annotation ， 这个函数允许我们自定义注解然后通过注解的形式定义切点，真正实现了指哪儿打哪儿的感觉。

• 自定义注解

  @Target(ElementType.METHOD)
  @Retention(RetentionPolicy.RUNTIME)
  public @interface Tx {}
  

• 定义切面

  @Aspect
  @Component
  public class MyAspect {
    @Around("@annotation(com.peter.aop.annotation.Tx)")
    public Object tx(ProceedingJoinPoint joinPoint) throws Throwable {
      System.out.println("--- tx before ---");
      Object ret = joinPoint.proceed();
      System.out.println("--- tx after ---");
      return ret;
    }
  }
  

• 在原始方法login上添加注解

  @Service
  public class UserServiceImpl implements UserService {
  
    @Override
    @Tx
    public void login(String username, String password) {
      System.out.println("login succeed !");
    }
  
    @Override
    public void register(User user) {
      System.out.println("register succeed !");
    }
  }
  

• 测试

  @SpringBootTest
  public class UserServiceTest {
  
    @Autowired
    UserService userService;
  	
    // 只有login方法添加了事务Tx操作
    @Test
    void loginTest() {
      userService.login("admin", "123456");
    }
  
    @Test
    void registerTest() {
      userService.register(new User());
    }
  }
  

6. Spring工厂如何创建代理对象

在上文我写了一个注释，我们使用@Autowired注入Bean的时候，Spring给我们注入的是代理对象，那么原始对象去哪里了？Spring如何做到自动创建代理对象的呢？

这个问题涉及到SpringBean的生命周期。在SpringBean完成初始化操作之后会调用BeanPostProcessor接口中的postProcessAfterInitialization方法（如果有实现类并加入了容器），Spring在这里创建了动态代理对象并替换掉容器中的原始对象，所以我们拿到的也就是代理对象了。

7. AOP开发的一个坑

在AOP编程中，如果我们在一个代理方法中直接调用了另一个代理方法，那么实际上另一个代理方法中的额外功能是不生效的，比如：

  @Override
  @Tx
  public void login(String username, String password) {
    System.out.println("login succeed !");
    this.register(new User());
  }

此时，register方法不会执行额外功能。实际上这是正常的，因为这个方法是在原始方法login内部执行的，自然使用的是原始对象。如果想要在内部使用代理register方法，则需要从工厂中独立获取代理对象，然后通过代理对象执行代理方法。

@Service
public class UserServiceImpl implements UserService {

  @Autowired
  private UserService userService;

  @Override
  @Tx
  public void login(String username, String password) {
    System.out.println("login succeed !");
//    this.register(new User());
    this.userService.register(new User());
  }


  @Override
  public void register(User user) {
    System.out.println("register succeed !");
  }
}

我们通过在原始对象中注入并调用代理对象的方式实现对代理方法的调用。

第五章 总结

AOP简单说就是通过代理类为原始类添加额外功能，好处是便于原始类的维护。

AOP是一个很重要的开发思想，既能将分散在各处的额外功能统一管理又能在需要的时候灵活的切入原始方法（切入点）组装成代理类进行功能扩展。

IOC解决了对象间解耦的问题，AOP解决功能间解耦的问题，两者本质上都是为了实现OCP，高内聚低耦合。

源码：https://github.com/PeterWangYong/blog-code/tree/master/aop

代理模式与AOP开发

标签：start   xtend   ble   vm虚拟机   call   不同   err   ast   过程   

原文地址：https://www.cnblogs.com/Peter2014/p/12989957.html