Spring AOP方面在单独的模块中使用

Question

I have an aspect com.x.NiceAspect in one maven project module, and a class com.x.NiceClass in a separate maven module. Those modules have the same POM parent, together creating one project.

The thing I am trying to achieve is to have a universal aspect that I can include in all my maven modules in this project.

Now the pointcut in the NiceAspect is ie execution(* com.x.. .set (..)) meaning all setter methods in mine package.

I want this aspect to run with the second module, especially to join NiceClass

How can I achieve this?

Moreover suppose that the Aspect wants an argument of a class that's defined in that second module, then I end up with a circular dependency..

Any help appreciated

Kind regards,

x.

Answer 1

In Spring Boot:

Suppose in module 'A' we implement our aspect classes. Then we need to make them visible to Spring (Boot):

@Configuration
@ComponentScan(basePackages = "root.package.containing.the.defined.aspecs")
public class AspectsModuleConfiguration {
  //...
}

In module B which has a (Maven) dependency to A, we import the above configuration class.

@SpringBootApplication
@Import(AspectsModuleConfiguration.class)
public class ModuleBApplicationClass {
//...
}

Answer 2

If you have all your projects declared as sub projects in the main pom the one containing the aspect (and thus the aspect itself) will be available to the other two, and basically any of the subprojects will have as dependency the other subprojects.

You will not have a circular dependency due to packaging:

• if you package any of your prject as an executable jar, then in order for it to run you need to add the other two subbrojects' jars to the first one's classpath when u run it

• if you package any of your subprojects as a war (and the other two as jars) then when packaging with maven the other two subproject's jars will be added to the war's lib folder effectively making them available to the war's classpath at runtime.

Answer 3

• I want this aspect to run with the second module, especially to join NiceClass

  If the pointcut matches a method from "another" module, the aspect will apply. You need to do nothing special, besides setting your dependencies correctly. eg have your AOP configuration globally imported.

• Moreover suppose that the Aspect wants an argument of a class that's defined in that second module, then I end up with a circular dependency..

  The aspect dependency on the class argument should not result in circular dependency, since you have a parent POM that connects the two, and at runtime both of the modules are in a classpath.

In general, it is recommended to follow Aspect structure as described by Spring documentation => create an overall SystemArchitecture aspect, and then add more narrowed scope aspects as needed:

@Aspect
public class SystemArchitecture {

  /**
   * A join point is in the web layer if the method is defined
   * in a type in the com.xyz.someapp.web package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.web..*)")
  public void inWebLayer() {}

  /**
   * A join point is in the service layer if the method is defined
   * in a type in the com.xyz.someapp.service package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.service..*)")
  public void inServiceLayer() {}

  /**
   * A join point is in the data access layer if the method is defined
   * in a type in the com.xyz.someapp.dao package or any sub-package
   * under that.
   */
  @Pointcut("within(com.xyz.someapp.dao..*)")
  public void inDataAccessLayer() {}

  /**
   * A business service is the execution of any method defined on a service
   * interface. This definition assumes that interfaces are placed in the
   * "service" package, and that implementation types are in sub-packages.
   * 
   * If you group service interfaces by functional area (for example, 
   * in packages com.xyz.someapp.abc.service and com.xyz.def.service) then
   * the pointcut expression "execution(* com.xyz.someapp..service.*.*(..))"
   * could be used instead.
   *
   * Alternatively, you can write the expression using the 'bean'
   * PCD, like so "bean(*Service)". (This assumes that you have
   * named your Spring service beans in a consistent fashion.)
   */
  @Pointcut("execution(* com.xyz.someapp.service.*.*(..))")
  public void businessService() {}

  /**
   * A data access operation is the execution of any method defined on a 
   * dao interface. This definition assumes that interfaces are placed in the
   * "dao" package, and that implementation types are in sub-packages.
   */
  @Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")
  public void dataAccessOperation() {}

}

This way any future aspects you may need, can reuse the over all System Architecture approach as well as live together with the actual module they are applied to.