Java 中反射、注解、动态代理、AOP 之间的联系

最新推荐文章于 2024-05-21 20:04:34 发布

菜皮日记

最新推荐文章于 2024-05-21 20:04:34 发布

阅读量131

点赞数

文章标签：后端

本文链接：https://blog.csdn.net/lipijin/article/details/132751101

版权

AOP 和 Aspect 是什么？

AOP 即 Aspect Orient Programming 是以一种编程范式，在不同业务中横着切一刀形成一个切面，在此切面上做一些相同的事情。Aspect 就是切面。

规定了一些概念性的东西：

Pointcut：是一个（组）基于正则表达式的表达式，有点绕，就是说他本身是一个表达式，但是他是基于正则语法的。通常一个pointcut，会选取程序中的某些我们感兴趣的执行点，或者说是程序执行点的集合。
JoinPoint：通过pointcut选取出来的集合中的具体的一个执行点，我们就叫JoinPoint.
Advice：在选取出来的JoinPoint上要执行的操作、逻辑。关于５种类型，我不多说，不懂的同学自己补基础。
Aspect：就是我们关注点的模块化。这个关注点可能会横切多个对象和模块，事务管理是横切关注点的很好的例子。它是一个抽象的概念，从软件的角度来说是指在应用程序不同模块中的某一个领域或方面。又pointcut 和advice组成。
Weaving：把切面应用到目标对象来创建新的 advised 对象的过程。

这些都是概念性的东西。本意是期望通过抽离相同业务逻辑，通过将增强代码动态织入（将增强代理和原有代码结合到一起形成增强后的代码），实现一次编写到处使用。

动态代理和 AOP 关系

动态代理跟 AOP 的思想跟代理有相似之处，都是代码复用。一套增强代码复用到不同地方。区别在于指定复用的方式不同。

动态代理指定增强代码复用在哪里是通过手动编写被代理类来的，而 AOP 则是声明式的，之后通过其他方式自动创建出代理类。类似于一个是命令式，一个是声明式。AOP 是动态代理的一次简化，隐藏了实现细节，让编写和使用动态代理更加简便。

但无论怎么简化，根本都是要生成代理类，只不过这个过程是编译期做，还是在运行时做，是开发人员手动编写还是框架自动生成。

AspectJ 就是编译期生成，可以由开发人员手动执行命令，也可以放在 maven 等自动执行。

Spring AOP 则是使用 JDK 或 CGLib 动态代理，在运行时动态生成的。

AspectJ 和 Spring AOP 都是什么关系

AspectJ 是 eclipse 下的项目，是一个 AOP 的实现框架，是一种对 Java 语言的扩展语言，在编译器将原来的 Java 代码中织入增强代码，生成增强后的 class 文件。

AspectJ 分为

编译时织入：通过 ajc 用编译生成 class 文件
编译后织入：已经 javac 生成 class 文件后，通过处理 class 文件得到新的织入后的 class 文件
加载时织入(LTW)：通过java agent机制在内存中操作类文件，可以不需要ajc的支持做到动态织入。

AspectJ 有自己的语法和编译命令，pointcut 定义切点，after 定义通知等。

下面是编译时织入的例子

// 定义被增强类
public class App {

    public void say() {
        System.out.println("App say");
    }

    public static void main(String[] args) {
        App app = new App();
        app.say();
    }
}

// 定义切面
public aspect AjAspect {

    // 切入点
    pointcut say():
            execution(* App.say(..));

    // 前置通知
    before(): say() {
        System.out.println("AjAspect before say");
    }
    // 后置通知
    after(): say() {
        System.out.println("AjAspect after say");
    }
}

AspectJ 语法是 Java 的扩展，所以 javac 无法编译，需要使用 AspectJ 提供的编译命令 ajc：

#!/usr/bin/env bash

ASPECTJ_TOOLS=/home/myths/.m2/repository/org/aspectj/aspectjtools/1.8.9/aspectjtools-1.8.9.jar
ASPECTJ_RT=/home/myths/.m2/repository/org/aspectj/aspectjrt/1.8.9/aspectjrt-1.8.9.jar

java -jar $ASPECTJ_TOOLS -cp $ASPECTJ_RT -sourceroots .

生成 class 文件：

// AjAspect 文件
import java.io.PrintStream;
import org.aspectj.lang.NoAspectBoundException;

public class AjAspect
{
  private static Throwable ajc$initFailureCause;
  public static final AjAspect ajc$perSingletonInstance;
  
  public static AjAspect aspectOf()
  {
    if (ajc$perSingletonInstance == null) {
      throw new NoAspectBoundException("AjAspect", ajc$initFailureCause);
    }
    return ajc$perSingletonInstance;
  }
  
  public static boolean hasAspect()
  {
    return ajc$perSingletonInstance != null;
  }
  
  private static void ajc$postClinit()
  {
    ajc$perSingletonInstance = new AjAspect();
  }
  
  static
  {
    try
    {
      
    }
    catch (Throwable localThrowable)
    {
      ajc$initFailureCause = localThrowable;
    }
  }
  
  public void ajc$before$AjAspect$1$682722c()
  {
    System.out.println("AjAspect before say");
  }
  
  public void ajc$after$AjAspect$2$682722c()
  {
    System.out.println("AjAspect after say");
  }
}

// App.class 文件
import java.io.PrintStream;

public class App
{
  public void say()
  {
    try
    {
      // 先调用 AjAspect 的 before，在执行原有的 say 方法内容
      AjAspect.aspectOf().ajc$before$AjAspect$1$682722c();System.out.println("App say");
    }
    catch (Throwable localThrowable)
    {
      // 最后调用 AjAspect 的 after
      AjAspect.aspectOf().ajc$after$AjAspect$2$682722c();throw localThrowable;
    }
    AjAspect.aspectOf().ajc$after$AjAspect$2$682722c();
  }
  
  public static void main(String[] args)
  {
    App app = new App();
    app.say();
  }
}

Spring AOP 常常与 AspectJ 混在一起，因为 Spring AOP 使用了 AspectJ 的注解，如：

package com.ywsc.fenfenzhong.aspectj.learn;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class LogAspect {
     @After("execution(* com.ywsc.fenfenzhong.aspectj.learn.SayHelloService.*(..))")
     public void log(){
         System.out.println("记录日志 ...");
     }
}

代码中的 @Aspect、@After 都是 org.aspectj.lang.annotation 包中的注解。

虽然 spring 中使用了这些 AspectJ 的注解定义 AOP，但实际织入则用的是动态代理，是运行时动态执行的，而没用使用 AspectJ 在编译器织入。

Spring 中通过解析标注有 @Aspect 注解的类，通过反射和动态代理的方式生成代理类实现增强。

定义注解：

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
    String value() default "";
}

编写 Aspect 切面：

@Aspect
@Component
public class SysLogAspect {
    private static final Logger LOGGER = LoggerFactory.getLogger(SysLogAspect.class);

    @Pointcut("@annotation(com.aldeo.common.annotation.Log)")
    public void logPointCut() {
    }

    @Around("logPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        long beginTime = System.currentTimeMillis();
        // 目标方法
        Object result = point.proceed();
        long time = System.currentTimeMillis() - beginTime;
      
      Log syslog = method.getAnnotation(Log.class);
        if (syslog != null) {
            // 注解上的描述
            LOGGER.info(syslog.value());
        }
      
        // 保存日志
        try {
            saveLog(point, time);
        } catch (Exception e) {
            LOGGER.error("==================================> saveSysLog.around.exception: " + e.getMessage(), e);
        }
        return result;
    }

在指定方法上标注注解，使用切面，实现 AOP 编程

@Log("测试自定义注解")
public String restPassword(){
    return "成功";
}

Springboot 中的 AOP 实现是基于 JDK 还是 CGLib？

默认是：

如果代理对象有接口，就用 JDK 动态代理
如果代理对象没有接口，那么就直接是 Cglib 动态代理。

SpringBoot 2.0 之后提供了一个配置项 spring.aop.proxy-target-class，他的自动配置文件中可以看到：

@Configuration
@ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class, AnnotatedElement.class })
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {

 @Configuration
 @EnableAspectJAutoProxy(proxyTargetClass = false)
 @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
 public static class JdkDynamicAutoProxyConfiguration {

 }

 @Configuration
 @EnableAspectJAutoProxy(proxyTargetClass = true)
 @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = true)
 public static class CglibAutoProxyConfiguration {

 }

}

如果此配置没有配置，或配置成了 true，都是用 CGlib，只有配置成 false 时才使用 JDK。

参考：

原生AspectJ用法分析以及Spring-AOP原理分析：https://blog.mythsman.com/post/5d301cf2976abc05b34546be/
Spring Boot 中的 AOP，到底是 JDK 动态代理还是 Cglib 动态代理？：https://bbs.huaweicloud.com/blogs/detail/314044
Spring AOP,AspectJ, CGLIB 有点晕：https://www.jianshu.com/p/fe8d1e8bd63e

本文由 mdnice 多平台发布

菜皮日记

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java 中反射、注解、动态代理、AOP 之间的联系

是一个（组）基于正则表达式的表达式，有点绕，就是说他本身是一个表达式，但是他是基于正则语法的。通常一个pointcut，会选取程序中的某些我们感兴趣的执行点，或者说是程序执行点的集合。是 eclipse 下的项目，是一个 AOP 的实现框架，是一种对 Java 语言的扩展语言，在编译器将原来的 Java 代码中织入增强代码，生成增强后的 class 文件。这些都是概念性的东西。动态代理指定增强代码复用在哪里是通过手动编写被代理类来的，而 AOP 则是声明式的，之后通过其他方式自动创建出代理类。
复制链接

扫一扫