AspectJ / AOP：如何通过类型“get-field”等限制编织？

Question

What condition should be fixed so that weaving occurs only for "method-execution"? For constructors, fields, etc. ("field-set", "field-get"...) it is not necessary.

@Pointcut("execution(* com.a.b.repository.c..*(..)) || 
@annotation(org.springframework.data.jpa.repository.Query) || 
target(org.springframework.data.jpa.repository.JpaRepository)")
public void executeARepository() { }

@Pointcut("call(* org.jooq.DSLContext.*(..))")
public void executeJOOQ() { }

@Pointcut("execution(* a.b.c.controller..*(..)) || execution(* a.b.c.d.controller..*(..))")
public void executeAControllers() { }

Answer 1

Before I answer the actual question, I want to comment on this recommendation:

why not create an annotation for the aop, and add that to the method(s) you want it to apply on? Stultuske

I think this is a particularly bad idea in general, because it causes one of the very problems AOP was invented to avoid: scattering a cross-cutting concern across a vast number of classes in a code base. That this rather naive approach to AOP is so common, does not make it any better. I like to think of it as "poor man's AOP".

If you annotate each method (or even just each class) you want to apply an aspect upon, it means that you are polluting your code base and breaking aspect encapsulation. Of course, that approach would work and still be better than scattering duplicate code implementing the cross-cutting concern, but still it is suboptimal and - most of all - a maintenance nightmare: You add a new class, forget the annotation, and the aspect will not be applied, which you might not even notice right away if it is just one of several dozen or hundred classes. It will be hidden in the noise.

What happens more often? That you add a new class or method (approximately every day) or that you need to adjust an aspect's pointcut, because you need to consider another base package or naming pattern or add an exceptional case (maybe twice a year)?

Compare the method-annotating approach to cleanly encapsulating the matching logic inside the aspect and maintaining the pointcut if you make a significant change to the code base. I would always opt for the latter, if possible. Scattering a multitude of annotations across the code base is just a last resort to me, if the pointcuts would be so convoluted and hard to maintain that the annotations would be the lesser evil. Of course, you can target annotations if they are used for other purposes anyway, eg Spring's @Controller or whatever. Then it would not mean to additionally pollute the code base.

---

Having gotten that topic off my chest, now let me help you answer the actual question: If you experience advice code firing for joinpoints other than method executions, probably (some part of) your pointcut is too broad. So let us check the pointcuts at hand:

execution(* a.b.c.controller..*(..)) ||
execution(* a.b.c.d.controller..*(..))

No problem here, both OR-connected pointcuts only target method executions.

call(* org.jooq.DSLContext.*(..))

I am not sure why here you use call instead of execution - maybe because JOOQ is an external dependency and you want to avoid binary weaving for the third-party classes and rather weave each caller via call , as opposed to weaving the callee at the execution site, but having to configure binary weaving for that. This is OK, no problem with weaving constructors or field read/write operations.

execution(* com.a.b.repository.c..*(..)) || 
@annotation(org.springframework.data.jpa.repository.Query) || 
target(org.springframework.data.jpa.repository.JpaRepository)

The execution pointcut is OK. The @annotation pointcut will probably fire twice per method, once for method call and once for method execution, unless of course the Spring classes are out of scope for compile-time weaving.

Now the target pointcut is the culprit for native AspectJ (not talking about Spring AOP here), because if fires for all joinpoints in JpaRepository instances, including constructors and field accessors. This is easy to fix by limiting matching for this sub-pointcut to method executions, eg like this:

execution(* com.a.b.repository.c..*(..)) || 
@annotation(org.springframework.data.jpa.repository.Query) || 
target(org.springframework.data.jpa.repository.JpaRepository) && execution(* *(..))