Spring AOP – 用于类和方法的自定义注解

huangapple
go评论110阅读模式
英文:

Spring AOP - Custom Annotation for Class and Method

问题

以下是翻译好的部分：

现有的答案很好地解释了如何使用自定义注解来记录方法执行时间。我想知道是否有办法在类和方法都使用相同的注解，但切入点在使用时应该是不同的。

  1. @LogExecutionTime
  2. public class MyServiceImpl implements MyService {
  4.     public void run(){
  5.        // 逻辑
  6.     }
  8.     public void walk(){
  9.        // 逻辑
  10.     }
  12.     private void breather(){
  13.        // 逻辑
  14.     }
  15. }

如果注解用于类，则类内的所有方法都应被视为在切面类中进行执行时间记录（类似于 execution(* com.me.package.MyServiceImpl.*(..))）。然而，如果注解仅用于类内的单个方法，也应该将仅有的该方法视为在切面日志类中进行记录（类似于 execution(* com.you.package.YourServiceImpl.forward(..))）。

  1. public class YourServiceImpl implements YourService {
  3.     @LogExecutionTime
  4.     public void forward(){
  5.        // 逻辑
  6.     }
  8.     @LogExecutionTime
  9.     public void backward(){
  10.        // 逻辑
  11.     }
  13.     private void upward(){
  14.        // 逻辑
  15.     }
  16. }

注解类：

  1. package com.myproj.core.utils.annotation;
  3. import static java.lang.annotation.RetentionPolicy.RUNTIME;
  5. import java.lang.annotation.Retention;
  7. @Retention(RUNTIME)
  8. public @interface LogExecutionTime {
  10. }

用于注解的切面类（使用 @kriegaex 建议的切入点）：

  1. package com.myproj.core.utils;
  3. import java.time.Duration;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  9. import java.time.Instant;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  13. /**
  14.  * 记录方法执行时间的切面类
  15.  */
  16. @Aspect
  17. public class MyMethodExecutionLoggingAspect {
  18.     
  19.     private static final Logger LOG = LoggerFactory.getLogger(MyMethodExecutionLoggingAspect.class);
  20.     
  21.     /**
  22.      * 此方法将记录方法执行时间
  23.      * 
  24.      * @param joinPoint
  25.      * @return object
  26.      * @throws Throwable
  27.      */
  28.     @Around("execution(* (@com.myproj.core.utils.annotation.LogExecutionTime *).*(..)) || execution(@com.myproj.core.utils.annotation.LogExecutionTime * *(..))")
  29.     public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
  31.         String className = joinPoint.getTarget().getClass().getSimpleName();
  32.         String methodName = joinPoint.getSignature().getName();
  33.         Instant start = Instant.now();
  35.         try {
  36.             return joinPoint.proceed();
  37.         } finally {
  39.             long end = Duration.between(start, Instant.now()).toMillis();
  41.             if (end > 0) {
  42.                 LOG.debug("方法执行时间：{}毫秒 | {}.{}", end, className, methodName);
  43.             }
  44.         }
  46.     }
  47.     
  48. }

在 spring.xml 中进行 Spring Bean 定义：

  1. <bean class="com.myproj.core.utils.MyMethodExecutionLoggingAspect" />
英文:

Existing answers gives nice explanation on how to use Custom Annotation for method execution time logging. I am wondering if there is way to use same annotation for both Class and Method, but Pointcut should be different where it is used.

  1. @LogExecutionTime
  2. public class MyServiceImpl implements MyService {
  4.     public void run(){
  5.        // logic
  6.     }
  8.     public void walk(){
  9.        // logic
  10.     }
  12.     private void breather(){
  13.        // logic
  14.     }
  15. }

If Annotation is used for class all methods inside class should be considered for Execution Time Logging in Aspect Class (like execution(* com.me.package.MyServiceImpl.*(..))). However if the Annotation is only used for single method inside the class, it is should also consider that only method in Aspect Logging Class. (like execution(* com.you.package.YourServiceImpl.forward(..))).

  1. public class YourServiceImpl implements YourService {
  3.     @LogExecutionTime
  4.     public void forward(){
  5.        // logic
  6.     }
  8.     @LogExecutionTime
  9.     public void backward(){
  10.        // logic
  11.     }
  13.     private void upward(){
  14.        // logic
  15.     }
  16. }

Annotation Class

  1. package com.myproj.core.utils.annotation;
  3. import static java.lang.annotation.RetentionPolicy.RUNTIME;
  5. import java.lang.annotation.Retention;
  7. @Retention(RUNTIME)
  8. public @interface LogExecutionTime {
  10. }

Aspect Class for Annotation (using pointcuts as suggested by @kriegaex)

  1. package com.myproj.core.utils;
  3. import java.time.Duration;
  5. import org.aspectj.lang.ProceedingJoinPoint;
  6. import org.aspectj.lang.annotation.Around;
  7. import org.aspectj.lang.annotation.Aspect;
  9. import java.time.Instant;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  13. /**
  14.  * Aspect class to Log Method Execution time
  15.  */
  16. @Aspect
  17. public class MyMethodExecutionLoggingAspect {
  18. 	
  19. 	private static final Logger LOG = LoggerFactory.getLogger(MyMethodExecutionLoggingAspect.class);
  20. 	
  21. 	/**
  22. 	 * This method will log Method Execution Time
  23. 	 * 
  24. 	 * @param joinPoint
  25. 	 * @return object
  26. 	 * @throws Throwable
  27. 	 */
  28. 	@Around(&quot;execution(* (@com.myproj.core.utils.annotation.LogExecutionTime *).*(..)) || execution(@com.myproj.core.utils.annotation.LogExecutionTime * *(..))&quot;)
  29. 	public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
  31. 		String className = joinPoint.getTarget().getClass().getSimpleName();
  32. 		String methodName = joinPoint.getSignature().getName();
  33. 		Instant start = Instant.now();
  35. 		try {
  36. 			return joinPoint.proceed();
  37. 		} finally {
  39. 			long end = Duration.between(start, Instant.now()).toMillis();
  41. 			if (end &gt; 0) {
  42. 				LOG.debug(&quot;METHOD EXECUTION TIME LAPSED: {}ms | {}.{}&quot;, end, className, methodName);
  43. 			}
  44. 		}
  46. 	}
  47. 	
  48. }

Spring Bean Definition in spring.xml

&lt;bean class=&quot;com.myproj.core.utils.MyMethodExecutionLoggingAspect&quot; /&gt;

答案1

得分: 1

你的示例代码中的 @annotation() 部分没有意义，因为你没有指定方法注解类型。应该像这样使用 @annotation(fully.qualified.AnnotationType)。

如果要匹配类注解，可以使用 @within(fully.qualified.AnnotationType)，如此处所述（https://stackoverflow.com/a/57385491/1082681）。

因此，你可以使用如下的切入点：

  1. @annotation(fully.qualified.AnnotationType)
  2.   || @within(fully.qualified.AnnotationType)

或者，根据我在这里的回答（https://stackoverflow.com/a/53452483/1082681），你还可以使用更加难懂的版本：

  1. execution(* (@fully.qualified.AnnotationType *).*(..))
  2.   || execution(@fully.qualified.AnnotationType * *(..))
英文:

Your sample code with @annotation() does not make sense because you do not specify a method annotation type. It should be something like @annotation(fully.qualified.AnnotationType) instead.

For matching class annotations you want to use @within(fully.qualified.AnnotationType), as described here.

So you could use a pointcut like

  1. @annotation(fully.qualified.AnnotationType)
  2.   || @within(fully.qualified.AnnotationType)

Alternatively, according to my answer here, you could also use the more cryptic version

  1. execution(* (@fully.qualified.AnnotationType *).*(..))
  2.   || execution(@fully.qualified.AnnotationType * *(..))

huangapple
  • 本文由 发表于 2020年10月7日 17:39:41
  • 转载请务必保留本文链接：https://go.coder-hub.com/64241314.html
  • java
  • spring
  • spring-aop
  • spring-boot
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定