@AspectJ punto de corte para todos los métodos de una clase con anotación específica

Question

Quiero monitorear todos los métodos públicos de todas las clases con la anotación especificada (digamos @Monitor) (nota: la anotación es a nivel de clase). ¿Cuál podría ser un punto de corte posible para esto? Nota: Estoy usando @AspectJ style Spring AOP.

Answer 1

Algo así:

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

Tenga en cuenta que no debe tener ningún otro tipo sobre la misma clase antes de ésta, debido a que las anotaciones se perderán después de proxy.

Answer 2

Debe combinar un punto de corte con un punto de corte de método.

Estos puntos de corte va a hacer el trabajo para encontrar todos los métodos públicos dentro de una clase marcada con una anotación @Monitor:

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

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

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

Consejo el último punto de corte que combina los dos primeros y ya está!

Si usted está interesado, he escrito un cheat sheet con el estilo @AspectJ aquí con un example document correspondiente aquí.

Answer 3

También puede definir el punto de corte como

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

Answer 4

La forma más sencilla parece ser:

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

    return pjp.proceed(); 

    // perform actions after 
} 

Se interceptará la ejecución de todos los métodos anotados específicamente con '@MyHandling' en 'YourService' clase. Para interceptar todos los métodos sin excepción, simplemente coloque la anotación directamente en la clase.

No importa el alcance privado/público aquí, pero tenga en cuenta que spring-aop no puede usar el aspecto para llamadas a métodos en la misma instancia (típicamente privadas), porque no usa la clase proxy en este caso.

Utilizamos el consejo de @Around aquí, pero básicamente es la misma sintaxis con @Before, @ After o cualquier consejo.

Por cierto, anotación @MyHandling debe estar configurado de esta manera:

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

} 

Answer 5

El uso de anotaciones, como se describe en la pregunta.

Anotación: @Monitor

anotación en la clase, app/PagesController.java:

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

anotación en el método, app/PagesController.java:

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

anotación personalizada, app/Monitor.java:

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

Aspecto para la anotación, 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()); 
    } 
} 

Habilitar AspectJ, servlet-context.xml:

<aop:aspectj-autoproxy /> 

incluyen bibliotecas AspectJ, pom.xml:

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

Answer 6

Usted podría utilizar PerformanceMonitoringInterceptor de primavera y programación registrar el consejo usando un procesador de beanpost.

@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

que debería ser suficiente para marcar su método aspecto como éste:

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

echar un vistazo a this para una guía paso a paso en este sentido.

Answer 8

desde la primavera de 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

Uso

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