我需要使用Aspectj修改旧代码方法的返回类型。
class MyClass{
public void processTracker(TrackInfo trackInfo) {
if (isValid(this.getStatus()) {
process(trackInfo);
}
}
boolean isValid(Status status){
...
}
}
我希望isValid
方法通过TrackInfo
对象的其他基于逻辑的状态(将参数传递给processTracker
方法)返回true / false
使用processTracker
方法会给我带来参数,但不会提供修改isValid返回值的选项
@Around("execution(* MyClass.processTracker(..))
尊重isValid
不会让我访问参数trackInfo
2个方面是不可能的,因为此代码在多线程中运行... 我没有使用Spring,也无法向旧代码中添加自定义注释。
有什么想法吗?
答案 0 :(得分:1)
实际上,您的问题很难理解,可能是因为您的英语水平不是特别好。特别是,我不知道您为什么认为多线程在这里会成为问题。也许您可以更详细地说明这一点。
无论如何,我在这里为您提供两种AOP解决方案:
如示例代码所示,如果process(TrackInfo)
条件确实是if
中的整个逻辑,则从方面直接调用processTracker(TrackInfo)
。从语义上讲,您只需替换被拦截方法的整个逻辑。
如果processTracker(TrackInfo)
中实际上有更多逻辑,并且您的示例代码被过度简化,例如外科医生,则需要用更精细的知识进行切割,并应用AOP术语中通常被称为的内容虫洞图案。
应用程序+助手类:
由于示例代码不完整,我不得不猜测并组成一个MCVE,下一次我希望您这样做是因为这实际上是您的工作,而不是我的。
package de.scrum_master.app;
public enum Status {
VALID, INVALID
}
package de.scrum_master.app;
public class TrackInfo {
private String info;
public TrackInfo(String info) {
this.info = info;
}
public String getInfo() {
return info;
}
@Override
public String toString() {
return "TrackInfo(" + info + ")";
}
}
package de.scrum_master.app;
import static de.scrum_master.app.Status.*;
public class MyClass {
private Status status = VALID;
public void processTracker(TrackInfo trackInfo) {
if (isValid(getStatus()))
process(trackInfo);
}
public void process(TrackInfo trackInfo) {
System.out.println("Processing " + trackInfo);
}
private Status getStatus() {
if (status == VALID)
status = INVALID;
else
status = VALID;
return status;
}
boolean isValid(Status status) {
return status == VALID;
}
public static void main(String[] args) {
MyClass myClass = new MyClass();
myClass.processTracker(new TrackInfo("normal"));
myClass.processTracker(new TrackInfo("whatever"));
myClass.processTracker(new TrackInfo("special"));
}
}
如您所见,我只是将有效性从无效更改为有效,并在每次调用时返回,只是在运行main方法时获得不同的结果。
控制台日志为:
Processing TrackInfo(whatever)
到目前为止,太好了。不让我们假设如果TrackInfo
与字符串“ special”相匹配,我们要始终假设有效性检查的结果为true。
1。)processTracker(TrackInfo)
package de.scrum_master.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import de.scrum_master.app.MyClass;
import de.scrum_master.app.TrackInfo;
@Aspect
public class SimpleAspect {
@Around("execution(* de.scrum_master.app.MyClass.processTracker(..)) && args(trackInfo) && target(myClass)")
public void modifyValidityCheck(ProceedingJoinPoint thisJoinPoint, TrackInfo trackInfo, MyClass myClass) throws Throwable {
if (trackInfo.getInfo().equalsIgnoreCase("special")) {
// Kick off processing based on some special logic
myClass.process(trackInfo);
}
else {
// Proceed normally
thisJoinPoint.proceed();
}
}
}
在这里,我们不需要知道有效性检查的结果,而仅在需要时直接调用process(TrackInfo)
。日志输出更改为:
Processing TrackInfo(whatever)
Processing TrackInfo(special)
2。)虫眼图案解决方案
实际上,我们实际上是将调用方法TrackInfo
中的processTracker(TrackInfo)
作为上下文信息提取到isValid(Status status)
中,以便在必要时可以直接修改有效性检查结果。
package de.scrum_master.aspect;
import static de.scrum_master.app.Status.*;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import de.scrum_master.app.Status;
import de.scrum_master.app.TrackInfo;
@Aspect
public class WormholePatternAspect {
@Pointcut("execution(* de.scrum_master.app.MyClass.processTracker(..)) && args(trackInfo)")
public static void processTracker(TrackInfo trackInfo) {}
@Pointcut("execution(* de.scrum_master.app.MyClass.getStatus())")
public static void getStatus() {}
@Around("getStatus() && cflow(processTracker(trackInfo))")
public Status modifyValidityCheck(ProceedingJoinPoint thisJoinPoint, TrackInfo trackInfo) throws Throwable {
if (trackInfo.getInfo().equalsIgnoreCase("special")) {
// Return true based on some special logic
return VALID;
}
else {
// Proceed normally
return (Status) thisJoinPoint.proceed();
}
}
}
控制台日志与第一个方面相同,但是如果processTracker(TrackInfo)
中包含更多逻辑,则其余部分也将被执行,而不是像第一个方面那样被切断(替换)。 / p>
选择。如果适用,我建议使用更简单的解决方案。虫洞模式很优雅,但更难理解,并且由于cflow()
而需要运行时调用栈分析,因此它也应该稍慢一些。