如何使用 Spring AOP 或 AspectJ 拦截给定方法中的每个方法调用

Question

 class Test {

@override
public String a(){
b();
d();
}


private String b() {
c();
}

private String c(){
d();
}
private String d(){}

}

我想拦截从覆盖方法 A() 调用的 class 测试的每个方法，并想知道每个方法（如 b()、c() 在处理某些业务时花费了多少时间逻辑分开。

如何使用 Spring AOP 或 Aspectj 实现它？

Answer 1

Spring AOP是通过代理来应用的，当你从外部调用bean的方法时，使用了代理，方法可以被拦截，但是当你从内部调用方法时class，不使用代理，直接使用class。

你有三个选择

第一个也是简单的方法，如果您使用 public 方法没有问题，那就是将函数 b()、c() 和 d() 移动到另一个 bean .这样每次调用这个方法都会被拦截。

public class Test {
    public String a() { ... }
}

public class Test2 {
    public String b() { ... }
    public String c() { ... }
    public String d() { ... }
}

如果您想将所有内容保存在同一个文件中，也可以将其用作内部静态 class。

public class Test {
    public String a() { ... }
    public static class Test2 {
        public String b() { ... }
        public String c() { ... }
        public String d() { ... }
    }
}

您应该在 Test 的构造函数中自动装配 Test2。

public class Test {
    private final Test2 test2;    
    @Autowired public Test(final Test2 test2) {
        this.test2 = test2;
    }
    public String a() { 
        test2.b();
        test2.c();
        test2.d();
    }
}

最后创建 around 方法。

@Around(value = "execution(* package.of.the.class.Test.*(..))")
public Object aroundA(ProceedingJoinPoint pjp) throws Throwable { ... }

@Around(value = "execution(* package.of.the.class.Test2.*(..))")
public Object aroundBCD(ProceedingJoinPoint pjp) throws Throwable { 
    long start = System.currentTimeMillis();
    Object output = pjp.proceed();
    long elapsedTime = System.currentTimeMillis() - start;
    // perform side efects with elapsed time e.g. print, store...
    return output;
}

或类似

@Around(value = "execution(* package.of.the.class.Test.*(..)) || " +
                "execution(* package.of.the.class.Test2.*(..))")
public Object aroundABCD(ProceedingJoinPoint pjp) throws Throwable { ... }

第二个选项是使用 CGLIB bean，封装私有方法和自我注入。

您仅使用作用域注解声明了一个 CGLIB bean

@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
@Bean public Test test() {
    return new Test();
}

自己注入并封装私有方法如下

public class Test {
    @Autowired private Test test;
    // ...
    public String a() {
        test.b(); // call through proxy (it is intercepted)
    }
    String b() { ... } // package private method
    // ...
}

第三个解决方案是使用 LWT Load-Time weaving，它使用 aspectj 而不是 spring aop。这允许甚至在同一个 class 中拦截方法调用。您可以使用官方 spring 文档来实现它，但是您必须使用 java 代理才能运行.

调用方式

如果您需要知道特定方法是否调用了被拦截的函数，您可以对选项 1 或 2 使用 Thread.currentThread().getStackTrace()。如果您使用 aspectj（选项 3），您可以拦截cflow().

方法

Answer 2

为了

编织成私有方法，
在一个 class,
动态确定控制流并将拦截限制为仅由您的接口方法直接或间接调用的方法

您需要从 Spring AOP（proxy-based，许多限制，缓慢）切换到 AspectJ using LTW (load-time weaving)，如 Spring 手册中所述。

这里有一个纯 AspectJ 的例子（没有 Spring，只有 Java SE），你可以很容易地适应你的需要：

示例界面

package de.scrum_master.app;

public interface TextTransformer {
  String transform(String text);
}

Class 实现接口，包括。 main方法：

如您所见，我编写了一个像您这样的示例，还使方法花费时间以便稍后在方面进行测量：

package de.scrum_master.app;

public class Application implements TextTransformer {
  @Override
  public String transform(String text) {
    String geekSpelling;
    try {
      geekSpelling = toGeekSpelling(text);
      return toUpperCase(geekSpelling);
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }

  }

  private String toGeekSpelling(String text) throws InterruptedException {
    Thread.sleep(100);
    return replaceVovels(text).replaceAll("[lL]", "1");
  }

  private String replaceVovels(String text) throws InterruptedException {
    Thread.sleep(75);
    return text.replaceAll("[oO]", "0").replaceAll("[eE]", "Ɛ");
  }

  private String toUpperCase(String text) throws InterruptedException {
    Thread.sleep(50);
    return text.toUpperCase();
  }

  public static void main(String[] args) throws InterruptedException {
    System.out.println(new Application().transform("Hello world!"));
  }
}

看点：

package de.scrum_master.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import static java.lang.System.currentTimeMillis;

@Aspect
public class TimingAspect {
  @Around("execution(* *(..)) && cflow(execution(* de.scrum_master.app.TextTransformer.*(..)))")
  public Object measureExecutionTime(ProceedingJoinPoint thisJoinPoint) throws Throwable {
    long startTime = currentTimeMillis();
    Object result = thisJoinPoint.proceed();
    System.out.println(thisJoinPoint + " -> " + (currentTimeMillis() - startTime) + " ms");
    return result;
  }
}

控制台日志：

execution(String de.scrum_master.app.Application.replaceVovels(String)) -> 75 ms
execution(String de.scrum_master.app.Application.toGeekSpelling(String)) -> 189 ms
execution(String de.scrum_master.app.Application.toUpperCase(String)) -> 63 ms
execution(String de.scrum_master.app.Application.transform(String)) -> 252 ms
HƐ110 W0R1D!

您也可以通过将切入点从 cflow() 更改为 cflowbelow():

来排除 transform(..) 方法

@Around("execution(* *(..)) && cflowbelow(execution(* de.scrum_master.app.TextTransformer.*(..)))")

那么控制台日志就是：

execution(String de.scrum_master.app.Application.replaceVovels(String)) -> 77 ms
execution(String de.scrum_master.app.Application.toGeekSpelling(String)) -> 179 ms
execution(String de.scrum_master.app.Application.toUpperCase(String)) -> 62 ms
HƐ110 W0R1D!

顺便说一下，请阅读 AspectJ and/or Spring AOP 手册。

如何使用 Spring AOP 或 AspectJ 拦截给定方法中的每个方法调用

How to intercept each method call within given method using Spring AOP or AspectJ

java

aspectj

spring-aop

spring-aspects