@AspectJ针对具有特定注释的类的所有方法的切入点

Question

我想监视具有指定注释（比如说@Monitor）的所有类的所有公共方法（注意：注释在类级别）。对此可能有什么切入点？ 注意：我使用@AspectJ风格的Spring AOP。

Answer 1

类似的东西：

@Before("execution(* com.yourpackage..*.*(..))") 
public void monitor(JoinPoint jp) { 
    if (jp.getTarget().getClass().isAnnotationPresent(Monitor.class)) { 
     // perform the monitoring actions 
    } 
} 

请注意，你不能此人之前都在同一类任何其他建议，因为注释将进行代理后丢失。

Answer 2

你应该结合一个类型切入点和方法切入点。

这些切入点就做好找到标有注释@Monitor一个类中的所有公共方法：

@Pointcut("within(@org.rejeev.Monitor *)") 
public void beanAnnotatedWithMonitor() {} 

@Pointcut("execution(public * *(..))") 
public void publicMethod() {} 

@Pointcut("publicMethod() && beanAnnotatedWithMonitor()") 
public void publicMethodInsideAClassMarkedWithAtMonitor() {} 

咨询最后切入点，结合了前两个，你就大功告成了！

如果你有兴趣，我写了一个cheat sheet与@AspectJ风格在这里与相应的example document在这里。

Answer 3

您也可以定义为切入点

public pointcut publicMethodInsideAClassMarkedWithAtMonitor() : execution(public * (@Monitor *).*(..)); 

Answer 4

最简单的方法似乎是：

@Around("execution(@MyHandling * com.exemple.YourService.*(..))") 
public Object aroundServiceMethodAdvice(final ProceedingJoinPoint pjp) 
    throws Throwable { 
    // perform actions before 

    return pjp.proceed(); 

    // perform actions after 
} 

它将拦截与“YourService” @MyHandling“特别注释的所有方法执行类。要毫无例外地拦截所有方法，只需将注释直接放在类上即可。

不管这里的私有/公共范围如何，但请记住，spring-aop不能在同一个实例中使用aspect方法调用（通常是私有方法），因为在这种情况下它不使用代理类。

我们在这里使用@Around的建议，但它基本上与@Before，@After或任何建议相同的语法。

顺便提一下，@MyHandling注释必须配置是这样的：

@Retention(RetentionPolicy.RUNTIME) 
@Target({ ElementType.METHOD, ElementType.TYPE }) 
public @interface MyHandling { 

} 

Answer 5

使用注释，如在问题说明。

译注：@Monitor

诠释类，app/PagesController.java：

package app; 
@Controller 
@Monitor 
public class PagesController { 
    @RequestMapping(value = "/", method = RequestMethod.GET) 
    public @ResponseBody String home() { 
     return "w00t!"; 
    } 
} 

上方法注释，app/PagesController.java：

package app; 
@Controller 
public class PagesController { 
    @Monitor 
    @RequestMapping(value = "/", method = RequestMethod.GET) 
    public @ResponseBody String home() { 
     return "w00t!"; 
    } 
} 

自定义注释，app/Monitor.java：

package app; 
@Component 
@Target(value = {ElementType.METHOD, ElementType.TYPE}) 
@Retention(value = RetentionPolicy.RUNTIME) 
public @interface Monitor { 
} 

看点的注释，app/MonitorAspect.java：

package app; 
@Component 
@Aspect 
public class MonitorAspect { 
    @Before(value = "@within(app.Monitor) || @annotation(app.Monitor)") 
    public void before(JoinPoint joinPoint) throws Throwable { 
     LogFactory.getLog(MonitorAspect.class).info("monitor.before, class: " + joinPoint.getSignature().getDeclaringType().getSimpleName() + ", method: " + joinPoint.getSignature().getName()); 
    } 

    @After(value = "@within(app.Monitor) || @annotation(app.Monitor)") 
    public void after(JoinPoint joinPoint) throws Throwable { 
     LogFactory.getLog(MonitorAspect.class).info("monitor.after, class: " + joinPoint.getSignature().getDeclaringType().getSimpleName() + ", method: " + joinPoint.getSignature().getName()); 
    } 
} 

启用AspectJ的，servlet-context.xml：

<aop:aspectj-autoproxy /> 

包括AspectJ库，pom.xml：

<artifactId>spring-aop</artifactId> 
<artifactId>aspectjrt</artifactId> 
<artifactId>aspectjweaver</artifactId> 
<artifactId>cglib</artifactId> 

Answer 6

你可以使用Spring的PerformanceMonitoringInterceptor和编程方式注册使用beanpostprocessor的建议。

@Target({ ElementType.TYPE, ElementType.METHOD }) 
@Retention(RetentionPolicy.RUNTIME) 
@Inherited 
@Documented 
public @interface Monitorable 
{ 

} 


public class PerformanceMonitorBeanPostProcessor extends ProxyConfig implements BeanPostProcessor, BeanClassLoaderAware, Ordered, 
    InitializingBean 
{ 

    private Class<? extends Annotation> annotationType = Monitorable.class; 

    private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader(); 

    private Advisor advisor; 

    public void setBeanClassLoader(ClassLoader classLoader) 
    { 
    this.beanClassLoader = classLoader; 
    } 

    public int getOrder() 
    { 
    return LOWEST_PRECEDENCE; 
    } 

    public void afterPropertiesSet() 
    { 
    Pointcut pointcut = new AnnotationMatchingPointcut(this.annotationType, true); 
    Advice advice = getInterceptor(); 
    this.advisor = new DefaultPointcutAdvisor(pointcut, advice); 
    } 

    private Advice getInterceptor() 
    { 
    return new PerformanceMonitoringInterceptor(); 
    } 

    public Object postProcessBeforeInitialization(Object bean, String beanName) 
    { 
    return bean; 
    } 

    public Object postProcessAfterInitialization(Object bean, String beanName) 
    { 
    if(bean instanceof AopInfrastructureBean) 
    { 
     return bean; 
    } 
    Class<?> targetClass = AopUtils.getTargetClass(bean); 
    if(AopUtils.canApply(this.advisor, targetClass)) 
    { 
     if(bean instanceof Advised) 
     { 
     ((Advised)bean).addAdvisor(this.advisor); 
     return bean; 
     } 
     else 
     { 
     ProxyFactory proxyFactory = new ProxyFactory(bean); 
     proxyFactory.copyFrom(this); 
     proxyFactory.addAdvisor(this.advisor); 
     return proxyFactory.getProxy(this.beanClassLoader); 
     } 
    } 
    else 
    { 
     return bean; 
    } 
    } 
} 

Answer 7

应该足够，以纪念你的一方面方法是这样的：

@After("@annotation(com.marcot.CommitTransaction)") 
    public void after() { 

看看this对这样的一步一步的指导。

Answer 8

从Spring的AnnotationTransactionAspect：

/** 
* Matches the execution of any public method in a type with the Transactional 
* annotation, or any subtype of a type with the Transactional annotation. 
*/ 
private pointcut executionOfAnyPublicMethodInAtTransactionalType() : 
    execution(public * ((@Transactional *)+).*(..)) && within(@Transactional *); 

Answer 9

使用

@Before("execution(* (@YourAnnotationAtClassLevel *).*(..))") 
    public void beforeYourAnnotation(JoinPoint proceedingJoinPoint) throws Throwable { 
}