浅谈AOP以及AspectJ和Spring-AOP

10次阅读

共计 19357 个字符，预计需要花费 49 分钟才能阅读完成。

AOP（Aspect Orient Programming），作为面向对象编程的一种补充，广泛应用于处理一些具有横切性质的系统级服务，如日志收集、事务管理、安全检查、缓存、对象池管理等。AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。

面向切面的编程（AOP）是一种编程范式，旨在通过允许横切关注点的分离，提高模块化。AOP 提供切面来将跨越对象关注点模块化。虽然现在可以获得许多 AOP 框架，但在这里我们要区分的只有两个流行的框架：Spring AOP 和 AspectJ。

Aspect 被翻译方面或者切面，相当于 OOP 中的类，就是封装用于横插入系统的功能。例如日志、事务、安全验证等。

JoinPoint(连接点)是 AOP 中的一个重要的关键概念。JoinPoint 可以看做是程序运行时的一个执行点。打个比方，比如执行 System.out.println(“Hello”)这个函数，println()就是一个 joinpoint；再如给一个变量赋值也是一个 joinpoint；还有最常用的 for 循环，也是一个 joinpoint。

理论上说，一个程序中很多地方都可以被看做是 JoinPoint，但是 AspectJ 中，只有下面所示的几种执行点被认为是 JoinPoint：

<center> 表 1 JoinPoint 的类型 </center>

JoinPoint	说明	示例
method call	函数调用	比如调用 Logger.info()，这是一处 JoinPoint
method execution	函数执行	比如 Logger.info()的执行内部，是一处 JoinPoint。注意它和 method call 的区别。method call 是调用某个函数的地方。而 execution 是某个函数执行的内部。
constructor call	构造函数调用	和 method call 类似
constructor execution	构造函数执行	和 method execution 类似
field get	获取某个变量	比如读取 User.name 成员
field set	设置某个变量	比如设置 User.name 成员
pre-initialization	Object 在构造函数中做得一些工作。
initialization	Object 在构造函数中做得工作
static initialization	类初始化	比如类的 static{}
handler	异常处理	比如 try catch(xxx)中，对应 catch 内的执行
advice execution	这个是 AspectJ 的内容

这里列出了 AspectJ 所认可的 JoinPoint 的类型。实际上，连接点也就是你想把新的代码插在程序的哪个地方，是插在构造方法中，还是插在某个方法调用前，或者是插在某个方法中，这个地方就是 JoinPoint，当然，不是所有地方都能给你插的，只有能插的地方，才叫 JoinPoint。

PointCut 通俗地翻译为切入点，一个程序会有多个 Join Point，即使同一个函数，也还分为 call 和 execution 类型的 Join Point，但并不是所有的 Join Point 都是我们关心的，Pointcut 就是提供一种使得开发者能够选择自己需要的 JoinPoint 的方法。PointCut 分为 call、execution、target、this、within 等关键字。与 joinPoint 相比，pointcut 就是一个具体的切点。

Advice 翻译为通知或者增强(Advisor)，就是我们插入的代码以何种方式插入，相当于 OOP 中的方法，有 Before、After 以及 Around。

Before

前置通知用于将切面代码插入方法之前，也就是说，在方法执行之前，会首先执行前置通知里的代码. 包含前置通知代码的类就是切面。

After

后置通知的代码在调用被拦截的方法后调用。

Around

环绕通知能力最强，可以在方法调用前执行通知代码，可以决定是否还调用目标方法。也就是说它可以控制被拦截的方法的执行，还可以控制被拦截方法的返回值。

Target 指的是需要切入的目标类或者目标接口。

Proxy 是代理，AOP 工作时是通过代理对象来访问目标对象。其实 AOP 的实现是通过动态代理，离不开代理模式，所以必须要有一个代理对象。

Weaving 即织入，在目标对象中插入切面代码的过程就叫做织入。

AspectJ 是一个面向切面的框架，他定义了 AOP 的一些语法，有一个专门的字节码生成器来生成遵守 java 规范的 class 文件。

AspectJ 的通知类型不仅包括我们之前了解过的三种通知：前置通知、后置通知、环绕通知，在 Aspect 中还有异常通知以及一种最终通知即无论程序是否正常执行, 最终通知的代码会得到执行。

AspectJ 提供了一套自己的表达式语言即切点表达式，切入点表达式可以标识切面织入到哪些类的哪些方法当中。只要把切面的实现配置好，再把这个切入点表达式写好就可以了，不需要一些额外的 xml 配置。

切点表达式语法：

execution(
    modifiers-pattern? // 访问权限匹配   如 public、protected
    ret-type-pattern // 返回值类型匹配
    declaring-type-pattern? // 全限定性类名
    name-pattern(param-pattern) // 方法名(参数名)
    throws-pattern? // 抛出异常类型
)

注意:
1. 中间以空格隔开, 有问号的属性表示可以省略。
2. 表达式中特殊符号说明：

a: * 代表 0 到多个任意字符，通常用作某个包下面的某些类以及某些方法。
b: .. 放在方法参数中，代表任意个参数，放在包名后面表示当前包及其所有子包路径。
c: + 放在类名后，表示当前类及其子类，放在接口后，表示当前接口及其实现类。

<center> 表 2 方法表达式 </center>

表达式	含义
java.lang.String	匹配 String 类型
java.*.String	匹配 java 包下的任何“一级子包”下的 String 类型，如匹配 java.lang.String，但不匹配 java.lang.ss.String
java..*	匹配 java 包及任何子包下的任何类型, 如匹配 java.lang.String、java.lang.annotation.Annotation
java.lang.*ing	匹配任何 java.lang 包下的以 ing 结尾的类型
java.lang.Number+	匹配 java.lang 包下的任何 Number 的自类型，如匹配 java.lang.Integer，也匹配 java.math.BigInteger

<center> 表 3 参数表达式 </center>

参数	含义
()	表示方法没有任何参数
(..)	表示匹配接受任意个参数的方法
(..,java.lang.String)	表示匹配接受 java.lang.String 类型的参数结束，且其前边可以接受有任意个参数的方法
(java.lang.String,..)	表示匹配接受 java.lang.String 类型的参数开始，且其后边可以接受任意个参数的方法
(*,java.lang.String)	表示匹配接受 java.lang.String 类型的参数结束，且其前边接受有一个任意类型参数的方法

举个栗子：execution(public * com.zhoujunwen.service.*.*(..))，该表达式表示 com.zhoujunwen.service 包下的 public 访问权限的任意类的任意方法。

AspectJ 下载地址(http://www.eclipse.org/aspect…，在下载页面选择合适的版本下载，目前最新稳定版是 1.9.1。下载完之后双加 jar 包安装，安装界面如下：

安装目录用 tree 命令可以看到如下结构(省去 doc 目录)：

├── LICENSE-AspectJ.html
├── README-AspectJ.html
├── bin
│   ├── aj
│   ├── aj5
│   ├── ajbrowser
│   ├── ajc
│   └── ajdoc
└── lib
    ├── aspectjrt.jar
    ├── aspectjtools.jar
    ├── aspectjweaver.jar
    └── org.aspectj.matcher.jar

42 directories, 440 files

bin：存放 aj、aj5、ajc、ajdoc、ajbrowser 等命令，其中 ajc 命令最常用，它的作用类似于 javac。
doc：存放了 AspectJ 的使用说明、参考手册、API 文档等文档。
lib：该路径下的 4 个 JAR 文件是 AspectJ 的核心类库。

注意安装完成后，需要配置将 aspectjrt.jar 配置到 CLASSPATH 中，并且将 bin 目录配置到 PATH 中。下面以 MacOs 配置为例：

JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_144.jdk/Contents/Home
CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:/Users/yourname/Documents/software/aspectj1.9.1/lib/aspectjrt.jar

M2_HOME=/Users/yourname/Documents/software/apache-maven-3.5.0
PATH=$JAVA_HOME/bin:$M2_HOME/bin:/usr/local/bin:/Users/yourname/Documents/software/aspectj1.9.1/bin:$PATH

注意：其中 /Users/yourname/Documents/software/aspectj1.9.1/lib/aspectjrt.jar 替换为自己安装 AspectJ 的路径的 lib，/Users/yourname/Documents/software/aspectj1.9.1/bin替换为安装 AspectJ 的 bin 目录

验证 AspectJ 的切面功能，写个单纯的 AspectJ 的 demo，实现方法日志埋点，在方法后增强。

业务代码(AuthorizeService.java)：

package com.zhoujunwen.aop;

/**
* 不用太过于较真业务逻辑的处理，大概意思大家懂就好。* @author zhoujunwen
* @version 1.0.0
*/
public class AuthorizeService {
    private static final String USERNAME = "zhoujunwen";
    private static final String PASSWORD = "123456";
    public void login(String username, String password) {if (username == null || username.length() == 0) {System.out.print("用户名不能为空");
            return;
        }
        if (password == null || password.length() == 0) {System.out.print("用户名不能为空");
            return;
        }
        if (!USERNAME.equals(username) || !PASSWORD.equals(password)) {System.out.print("用户名或者密码不对");
            return;
        }
        System.out.print("登录成功");
    }

    public static void main(String[] args) {AuthorizeService as = new AuthorizeService();
        as.login("zhoujunwen", "123456");
    }
}

日志埋点切面逻辑(LogAspect.java)：

package com.zhoujunwen.aop;

public aspect LogAspect {pointcut logPointcut():execution(void AuthorizeService.login(..));
    after():logPointcut(){System.out.println("**** 处理日志 ****"); 
    }
}

将上述两个文件文件放置在同一个目录，在当前目录下执行 acj 编译和织入命令:

ajc -d . AuthorizeService.java LogAspect.java

如果配置一切 OK 的话，不会出现异常或者错误，并在当前目录生成 com/zhoujunwen/aop/AuthorizeService.class 和com/zhoujunwen/aop/LogAspect.class两个字节码文件, 执行 tree(自己编写的类似 Linux 的 tree 命令)命令查看目录结构：

zhoujunwendeMacBook-Air:aop zhoujunwen$ tree
.
├── AuthorizeService.java
├── LogAspect.java
└── com
    └── zhoujunwen
        └── aop
            ├── AuthorizeService.class
            └── LogAspect.class

3 directories, 4 files

最后执行 java 执行命令：

java com/zhoujunwen/aop/AuthorizeService

输出日志内容：
登录成功 处理日志

ajc 可以理解为 javac 命令，都用于编译 Java 程序，区别是 ajc 命令可识别 AspectJ 的语法；我们可以将 ajc 当成一个增强版的 javac 命令。执行 ajc 命令后的 AuthorizeService.class 文件不是由原来的 AuthorizeService.java 文件编译得到的，该 AuthorizeService.class 里新增了打印日志的内容——这表明AspectJ 在编译时“自动”编译得到了一个新类，这个新类增强了原有的 AuthorizeService.java 类的功能，因此 AspectJ 通常被称为编译时增强的 AOP 框架。

为了验证上述的结论，我们用 javap 命令反编译 AuthorizeService.class 文件。javap 是 Java class 文件分解器，可以反编译（即对 javac 编译的文件进行反编译），也可以查看 java 编译器生成的字节码。用于分解 class 文件。

javap -p -c com/zhoujunwen/aop/AuthorizeService.class

输出内容如下, 在 login 方法的 code 为 0、3 以及 91、94 的地方，会发现 invokestatic 和com/zhoujunwen/aop/LogAspect的代码，这说明上面的结论是正确的。

Compiled from "AuthorizeService.java"
public class com.zhoujunwen.aop.AuthorizeService {
  private static final java.lang.String USERNAME;

  private static final java.lang.String PASSWORD;

  public com.zhoujunwen.aop.AuthorizeService();
    Code:
       0: aload_0
       1: invokespecial #16                 // Method java/lang/Object."<init>":()V
       4: return

  public void login(java.lang.String, java.lang.String);
    Code:
       0: invokestatic  #70                 // Method com/zhoujunwen/aop/LogAspect.aspectOf:()Lcom/zhoujunwen/aop/LogAspect;
       3: invokevirtual #76                 // Method com/zhoujunwen/aop/LogAspect.ajc$before$com_zhoujunwen_aop_LogAspect$2$9fd5dd97:()V
       6: aload_1
       7: ifnull        17
      10: aload_1
      11: invokevirtual #25                 // Method java/lang/String.length:()I
      14: ifne          28
      17: getstatic     #31                 // Field java/lang/System.out:Ljava/io/PrintStream;
      20: ldc           #37                 // String 用户名不能为空
      22: invokevirtual #39                 // Method java/io/PrintStream.print:(Ljava/lang/String;)V
      25: goto          99
      28: aload_2
      29: ifnull        39
      32: aload_2
      33: invokevirtual #25                 // Method java/lang/String.length:()I
      36: ifne          50
      39: getstatic     #31                 // Field java/lang/System.out:Ljava/io/PrintStream;
      42: ldc           #37                 // String 用户名不能为空
      44: invokevirtual #39                 // Method java/io/PrintStream.print:(Ljava/lang/String;)V
      47: goto          99
      50: ldc           #8                  // String zhoujunwen
      52: aload_1
      53: invokevirtual #45                 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      56: ifeq          68
      59: ldc           #11                 // String 123456
      61: aload_2
      62: invokevirtual #45                 // Method java/lang/String.equals:(Ljava/lang/Object;)Z
      65: ifne          79
      68: getstatic     #31                 // Field java/lang/System.out:Ljava/io/PrintStream;
      71: ldc           #49                 // String 用户名或者密码不对
      73: invokevirtual #39                 // Method java/io/PrintStream.print:(Ljava/lang/String;)V
      76: goto          99
      79: getstatic     #31                 // Field java/lang/System.out:Ljava/io/PrintStream;
      82: ldc           #51                 // String 登录成功
      84: invokevirtual #39                 // Method java/io/PrintStream.print:(Ljava/lang/String;)V
      87: goto          99
      90: astore_3
      91: invokestatic  #70                 // Method com/zhoujunwen/aop/LogAspect.aspectOf:()Lcom/zhoujunwen/aop/LogAspect;
      94: invokevirtual #73                 // Method com/zhoujunwen/aop/LogAspect.ajc$after$com_zhoujunwen_aop_LogAspect$1$9fd5dd97:()V
      97: aload_3
      98: athrow
      99: invokestatic  #70                 // Method com/zhoujunwen/aop/LogAspect.aspectOf:()Lcom/zhoujunwen/aop/LogAspect;
     102: invokevirtual #73                 // Method com/zhoujunwen/aop/LogAspect.ajc$after$com_zhoujunwen_aop_LogAspect$1$9fd5dd97:()V
     105: return
    Exception table:
       from    to  target type
           6    90    90   Class java/lang/Throwable

  public static void main(java.lang.String[]);
    Code:
       0: new           #1                  // class com/zhoujunwen/aop/AuthorizeService
       3: dup
       4: invokespecial #57                 // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: ldc           #8                  // String zhoujunwen
      11: ldc           #11                 // String 123456
      13: invokevirtual #58                 // Method login:(Ljava/lang/String;Ljava/lang/String;)V
      16: return
}

Spring AOP 也是对目标类增强，生成代理类。但是与 AspectJ 的最大区别在于——Spring AOP 的运行时增强，而 AspectJ 是编译时增强。

dolphin 叔叔 文章中写道自己曾经误以为 AspectJ 是 Spring AOP 的一部分，我想大多数人都没有弄清楚 AspectJ 和 Spring AOP 的关系。

当你不用 Spring AOP 提供的注解时，Spring AOP 和 AspectJ 没半毛钱的关系，前者是 JDK 动态代理，用到了 CGLIB(Code Generation Library)，CGLIB 是一个代码生成类库，可以在运行时候动态是生成某个类的子类。代理模式为要访问的目标对象提供了一种途径，当访问对象时，它引入了一个间接的层。后者是静态代理，在编译阶段就已经编译到字节码文件中。Spring 中提供了前置通知 org.springframework.aop.MethodBeforeAdvice、后置通知org.springframework.aop.AfterReturningAdvice，环绕通知org.aopalliance.intercept.MethodInvocation(通过反射实现，invoke(org.aopalliance.intercept.MethodInvocation mi) 中的 MethodInvocation 获取目标方法，目标类，目标字段等信息)，异常通知 org.springframework.aop.ThrowsAdvice。这些通知能够切入目标对象，Spring AOP 的核心是代理 Proxy，其主要实现类是org.springframework.aop.framework.ProxyFactoryBean,ProxyFactoryBean 中proxyInterfaces 为代理指向的目标接口，Spring AOP 无法截获未在该属性指定的接口中的方法，interceptorNames是拦截列表，target是目标接口实现类，一个代理只能有一个 target。

Spring AOP 的核心类 org.springframework.aop.framework.ProxyFactoryBean 虽然能实现 AOP 的行为，但是这种方式具有局限性，需要在代码中显式的调用 ProxyFactoryBean 代理工厂类，举例：UserService 是一个接口，UserServiceImpl 是 UserService 的实现类，ApplicationContext context 为 Spring 上下文，调用方式为UserService userService =（UserService）context.getBean("userProxy");。

完整的配置如下：

<bean id="userService" class="com.zhoujunwen.UserServiceImpl"></bean>  

<!-- 定义前置通知,com.zhoujunwen.BeforeLogAdvice 实现了 org.springframework.aop.MethodBeforeAdvice -->  
<bean id="beforeLogAdvice" class="com.zhoujunwen.BeforeLogAdvice"></bean>  
<!-- 定义后置通知，com.zhoujunwen.AfterLogAdvice 实现了 org.springframework.aop.AfterReturningAdvice -->  
<bean id="afterLogAdvice" class="com.zhoujunwen.AfterLogAdvice"></bean>  
<!-- 定义异常通知，com.zhoujunwen.ThrowsLogAdvice 实现了 org.springframework.aop.ThrowsAdvice-->  
<bean id="throwsLogAdvice" class="com.zhoujunwen.ThrowsLogAdvice"></bean>  
<!-- 定义环绕通知，com.zhoujunwen.LogAroundAdvice 实现了 org.aopalliance.intercept.MethodInvocation -->  
<bean id="logAroundAdvice" class="com.zhoujunwen.LogAroundAdvice"></bean>  

<!-- 定义代理类，名 称为 userProxy，将通过 userProxy 访问业务类中的方法 -->  
<bean id="userProxy" class="org.springframework.aop.framework.ProxyFactoryBean">  
    <property name="proxyInterfaces">  
        <value>com.zhoujunwen.UserService</value>  
    </property>  
    <property name="interceptorNames">  
        <list>           
         <value>beforeLogAdvice</value>  
         <!-- 织入后置通知 -->  
         <value>afterLogAdvice</value>  
         <!-- 织入异常通知 -->  
         <value>throwsLogAdvice</value>  
         <!-- 织入环绕通知 -->  
         <value>logAroundAdvice</value>  
        </list>  
    </property>  
    <property name="target" ref="userService"></property>  
</bean>

当然，上述的局限性 spring 官方也给出了解决方案，让 AOP 的通知在服务调用方毫不知情的下就进行织入，可以通过 org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator 自动代理。

<bean id="myServiceAutoProxyCreator" class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">  
        <property name="interceptorNames">  
                <list>
                         <value>logAroundAdvice</value> 
                </list>  
        </property>  
        <property name="beanNames">  
                <value>*Service</value>  
        </property>  
</bean>

这个 BeanNameAutoProxyCreator 的 bean 中指明上下文中所有调用以 Service 结尾的服务类都会被拦截，执行 logAroundAdvice 的 invoke 方法。同时它会自动生成 Service 的代理，这样在使用的时候就可以直接取服务类的 bean，而不用再像上面那样还用取代理类的 bean。

对于 BeanNameAutoProxyCreator 创建的代理，可以这样调用：UserService userService = (UserService) context.getBean("userService"); ，context 为 spring 上下文。

当你用到 Spring AOP 提供的注入 @Before、@After 等注解时，Spring AOP 和 AspectJ 就有了关系。在开发中引入了 org.aspectj:aspectjrt:1.6.11 和org.aspectj:aspectjweaver:1.6.11两个包，这是因为 Spring AOP 使用了 AspectJ 的 Annotation，使用了 Aspect 来定义切面, 使用 Pointcut 来定义切入点，使用 Advice 来定义增强处理。虽然 Spring AOP 使用了 Aspect 的 Annotation，但是并没有使用它的编译器和织入器。

Spring AOP 其实现原理是 JDK 动态代理，在运行时生成代理类。为了启用 Spring 对 @AspectJ 切面配置的支持，并保证 Spring 容器中的目标 Bean 被一个或多个切面自动增强，必须在 Spring 配置文件中添加如下配置

<aop:aspectj-autoproxy/>

当启动了 @AspectJ 支持后，在 Spring 容器中配置一个带 @Aspect 注释的 Bean，Spring 将会自动识别该 Bean，并将该 Bean 作为切面 Bean 处理。切面 Bean 与普通 Bean 没有任何区别，一样使用 <bean.../> 元素进行配置，一样支持使用依赖注入来配置属性值。

业务逻辑代码(AuthorizeService.java)：

package com.zhoujunwen.engine.service;

import org.springframework.stereotype.Service;

/**
 * Created with IntelliJ IDEA.
 * Date: 2018/10/25
 * Time: 12:47 PM
 * Description:
 *
 * @author zhoujunwen
 * @version 1.0
 */
@Service
public class AuthorizeService {
    private static final String USERNAME = "zhoujunwen";
    private static final String PASSWORD = "123456";
    public void login(String username, String password) {if (username == null || username.length() == 0) {System.out.print("用户名不能为空");
            return;
        }
        if (password == null || password.length() == 0) {System.out.print("用户名不能为空");
            return;
        }
        if (!USERNAME.equals(username) || !PASSWORD.equals(password)) {System.out.print("用户名或者密码不对");
            return;
        }
        System.out.print("登录成功");
    }
}

切面逻辑代码(LogAspect.java)

package com.zhoujunwen.engine.service;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * Created with IntelliJ IDEA.
 * Date: 2018/10/25
 * Time: 1:04 PM
 * Description:
 *
 * @author zhoujunwen
 * @version 1.0
 */
@Aspect
@Component
public class LogAspect {@After("execution(* com.zhoujunwen.engine.service.AuthorizeService.login(..))")
    public void logPointcut(){System.out.println("*** 处理日志 ***");
    }
}

这样是实现了对 AuthorizeService.login()方法的后置通知。不需要在 xml 中其他配置，当然前提是开启 <aop:aspectj-autoproxy/> aspectj 的自动代理。
测试调用代码：

AuthorizeService authorizeService = SpringContextHolder.getBean(AuthorizeService.class);
authorizeService.login("zhangsan", "zs2018");

业务代码，日志埋点(MeasurementService.java)：

package com.zhoujunwen.engine.measurement;

import com.zhoujunwen.common.base.AccountInfo;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

/**
 * metrics 切面接口
 * @create 2018-08-16- 上午 10:13
 */
@Service
public class MeasurementService {private static final Logger LOGGER = LoggerFactory.getLogger(MeasurementService.class);

    public String gainZhimaLog(AccountInfo accountInfo) {if (NumberUtils.isNumber(accountInfo.getZhimaPoint())) {return "正常";} else if (StringUtils.contains(accountInfo.getZhimaPoint(), "*")) {return "未授权";} else {return "未爬到";}
    }

    public String gainJiebeiLog(AccountInfo accountInfo) {if (NumberUtils.isNumber(accountInfo.getJiebeiQuota())) {return "正常";}
        return "未爬到";

    }

    public String gainHuabeiLog(AccountInfo accountInfo) {if (accountInfo.getCreditQuota() != null) {return "正常";} else {return "未爬到";}
    }
}

切面逻辑，统计日志中个字段的总和(KeywordMeasurement.java)：

package com.zhoujunwen.engine.measurement;

import com.zhoujunwen.common.base.AccountInfo;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;

/**
 * 关键字段监控统计 <br>
 *
 * @create 2018-08-15- 下午 5:41
 */
public class KeywordMeasurement {

    private String invokeCountFieldName = "";
    /**
     * 调用次数
     */
    public void summary(JoinPoint joinPoint, Object result) {
        try {

            String msg;
            String resultStr = "";
            if (result instanceof String) {resultStr = (String) result;
            }
            if (StringUtils.isBlank(resultStr)) {return;}
            if ("正常".equals(resultStr)) {msg = "_ok";} else if ("未爬到".equals(resultStr)) {msg = "_empty";} else {msg = "_star";}

            String methodName = joinPoint.getSignature().getName();
            Object args[] = joinPoint.getArgs();
            AccountInfo accountInfo = null;
            for (Object arg : args) {if (arg.getClass().getName().contains("AccountInfo")) {accountInfo = (accountInfo) arg;
                }
            }
           
            if (methodName.contains("Zhima")) {invokeCountFieldName = "zhima" + msg;} else if (methodName.contains("Jiebei")) {invokeCountFieldName = "jiebei" + msg;} else if (methodName.contains("Huabei")) {invokeCountFieldName = "huabei" + msg;} else {return;}
            // TODO 写入到 influxDB
        } catch (Exception e) {//skip}
    }
}

完整的配置（后置通知，并需要返回结果）:

<bean id="keywordMeasurement" class="com.zhoujunwen.engine.measurement.KeywordMeasurement"/>

<aop:config proxy-target-class="true">
    <aop:aspect id="keywordMeasurementAspect" ref="keywordMeasurement">
        <aop:pointcut id="keywordMeasurementPointcut"
                      expression="execution(* com.zhoujunwen.engine.measurement.SdkMeasurementService.gain*(..))"/>
                <!-- 统计 summary,summary 方法有两个参数 JoinPoint 和 Object-->
        <aop:after-returning method="summary" returning="result" pointcut-ref="keywordMeasurementPointcut"/>
    </aop:aspect>
</aop:config>

其他可用的配置(省略了 rt、count、qps 的 aspect)：

<!-- 统计 RT,rt 方法只有一个参数 ProceedingJoinPoint-->
<aop:around method="rt" pointcut-ref="keywordMeasurementPointcut"/> 
<!-- 统计调用次数,count 方法只有一个参数 JoinPoint-->
<aop:after method="count" pointcut-ref="keywordMeasurementPointcut"/>
<!-- 统计 QPS,qps 方法只有一个参数 JoinPoint-->
<aop:after method="qps" pointcut-ref="keywordMeasurementPointcut"/>

注意：关于 Spring AOP 中，切面代理类一定是由 Spirng 容器管理，所以委托类也需要交由 Spring 管理，不可以将委托类实例交由自己创建的容器管理（比如放入自己创建的 Map 中）, 如果这么做了，当调用委托类实例的时候，切面是不生效的。
原因：（1）实现实现和目标类相同的接口，spring 会使用 JDK 的 java.lang.reflect.Proxy 类，它允许 Spring 动态生成一个新类来实现必要的接口，织入通知，并且把这些接口的任何调用都转发到目标类。
（2）生成子类调用，spring 使用 CGLIB 库生成目标类的一个子类，在创建这个子类的时候，spring 织入通知，并且把对这个子类的调用委托到目标类。

AspectJ 和 Spring AOP 都是对目标类增强，生成代理类。

AspectJ 是在编译期间将切面代码编译到目标代码的，属于静态代理；Spring AOP 是在运行期间通过代理生成目标类，属于动态代理。

AspectJ 是静态代理，故而能够切入 final 修饰的类，abstract 修饰的类；Spring AOP 是动态代理，其实现原理是通过 CGLIB 生成一个继承了目标类 (委托类) 的代理类，因此，final 修饰的类不能被代理，同样 static 和 final 修饰的方法也不会代理，因为 static 和 final 方法是不能被覆盖的。在 CGLIB 底层，其实是借助了 ASM 这个非常强大的 Java 字节码生成框架。关于 CGLB 和 ASM 的讨论将会新开一个篇幅探讨。

Spring AOP 支持注解，在使用 @Aspect 注解创建和配置切面时将更加方便。而使用 AspectJ，需要通过.aj 文件来创建切面，并且需要使用 ajc（Aspect 编译器）来编译代码。

首先需要考虑，Spring AOP 致力于提供一种能够与 Spring IoC 紧密集成的面向切面框架的实现，以便于解决在开发企业级项目时面临的常见问题。明确你在应用横切关注点 (cross-cutting concern) 时（例如事物管理、日志或性能评估），需要处理的是 Spring beans 还是 POJO。如果正在开发新的应用，则选择 Spring AOP 就没有什么阻力。但是如果你正在维护一个现有的应用（该应用并没有使用 Spring 框架），AspectJ 就将是一个自然的选择了。为了详细说明这一点，假如你正在使用 Spring AOP，当你想将日志功能作为一个通知 (advice) 加入到你的应用中，用于追踪程序流程，那么该通知 (Advice) 就只能应用在 Spring beans 的连接点 (Joinpoint) 之上。

另一个需要考虑的因素是，你是希望在编译期间进行织入 (weaving)，还是编译后(post-compile) 或是运行时(run-time)。Spring 只支持运行时织入。如果你有多个团队分别开发多个使用 Spring 编写的模块（导致生成多个 jar 文件，例如每个模块一个 jar 文件），并且其中一个团队想要在整个项目中的所有 Spring bean（例如，包括已经被其他团队打包了的 jar 文件）上应用日志通知（在这里日志只是用于加入横切关注点的举例），那么通过配置该团队自己的 Spring 配置文件就可以轻松做到这一点。之所以可以这样做，就是因为 Spring 使用的是运行时织入。

还有一点，因为 Spring 基于代理模式（使用 CGLIB），它有一个使用限制，即无法在使用 final 修饰的 bean 上应用横切关注点。因为代理需要对 Java 类进行继承，一旦使用了关键字 final，这将是无法做到的。在这种情况下，你也许会考虑使用 AspectJ，其支持编译期织入且不需要生成代理。于此相似，在 static 和 final 方法上应用横切关注点也是无法做到的。因为 Spring 基于代理模式。如果你在这些方法上配置通知，将导致运行时异常，因为 static 和 final 方法是不能被覆盖的。在这种情况下，你也会考虑使用 AspectJ，因为其支持编译期织入且不需要生成代理。

如果你希望使用一种易于实现的方式，就选择 Spring AOP 吧，因为 Spring AOP 支持注解，在使用 @Aspect 注解创建和配置切面时将更加方便。而使用 AspectJ，你就需要通过.aj 文件来创建切面，并且需要使用 ajc（Aspect 编译器）来编译代码。所以如果你确定之前提到的限制不会成为你的项目的障碍时，使用 Spring AOP。AspectJ 的一个间接局限是，因为 AspectJ 通知可以应用于 POJO 之上，它有可能将通知应用于一个已配置的通知之上。对于一个你没有注意到这切面问题的大范围应用的通知，这有可能导致一个无限循环。在下面这种情况下，当 proceed 即将被调用时，日志通知会被再次应用，这样就导致了嵌套循环。

public aspectLogging {Object around() : execution(public * * (..))
  Sysytem.out.println(thisJoinPoint.getSignature());
  return proceed();}

诚挚感谢以下文章及作者，也是让我在参考实践以及理论总结的过程中学习到了很多东西。不做无头无脑的抄袭者，要做阅读他人的文章，汲取精粹，亲自实践得出结论。尊重原创，尊重作者！

AspectJ(一) 一些该了解的概念
AspectJ 框架，比用 spring 实现 AOP 好用很多哟！
比较分析 Spring AOP 和 AspectJ 之间的差别
AspectJ 基本用法
应用 Spring AOP（一）
AspectJ 官方 doc 文档
Spring AOP,AspectJ, CGLIB 有点晕

const btw = new BTWPlugin();
btw.init({
    id: 'main',
    blogId: '16456-1570500048991-724',
    name: '下雨就像弹钢琴',
    qrcode: 'https://www.zhoujunwen.com/wp-content/uploads/2019/09/qrcode_for_gh_f7c7e6ace303_258-1.jpg',
    keyword: '阅读全文',
});

</script>

该文首发《虚怀若谷》个人博客，转载前请务必署名，转载请标明出处。

古之善为道者，微妙玄通，深不可识。夫唯不可识，故强为之容：

豫兮若冬涉川，犹兮若畏四邻，俨兮其若客，涣兮若冰之释，敦兮其若朴，旷兮其若谷，混兮其若浊。

孰能浊以静之徐清？孰能安以动之徐生？

保此道不欲盈。夫唯不盈，故能敝而新成。

请关注我的微信公众号：下雨就像弹钢琴，Thanks♪(･ω･)ﾉ

正文完

发表至： java

2019-10-09

0

网络协议 15 – P2P 协议：小种子大学问

关于java:Spock单元测试框架实战指南八-常用mock封装成基类

Java并发指南4Java中的锁-Lock和synchronized

关于java:Spring-Boot-自动配置的原理核心注解以及利用自动配置实现了自定义-Starter-组件

高逼格企业级MySQL数据库备份方案原来是这样

浅谈AOP以及AspectJ和Spring-AOP

导言

关键概念

Aspect

JoinPoint

PointCut

Advice

Target

Proxy

Weaving

AspectJ

AspectJ 的介绍

AspectJ 的安装以及常用命令

AspectJ 的 demo

SpringAOP

Spring AOP 介绍

Spring AOP 与 Aspect 无关性

Spring AOP 与 AspectJ 有关性

Spring AOP 注解使用 demo

全注解实现

xml 配置实现

AspectJ 和 Spring AOP 的区别和选择

两者的联系和区别

选择对比

参考文章

站内搜索