From 915afa77f46a95a13332286b4ab99705c6bec02e Mon Sep 17 00:00:00 2001 From: Juergen Hoeller Date: Thu, 9 Aug 2018 03:02:52 +0200 Subject: [PATCH] Polishing --- ...ntiationModelAwarePointcutAdvisorImpl.java | 90 +++++++++---------- .../ReflectiveAspectJAdvisorFactory.java | 18 ++-- 2 files changed, 54 insertions(+), 54 deletions(-) diff --git a/spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/InstantiationModelAwarePointcutAdvisorImpl.java b/spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/InstantiationModelAwarePointcutAdvisorImpl.java index 0f2d462278e..db2c9f40073 100644 --- a/spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/InstantiationModelAwarePointcutAdvisorImpl.java +++ b/spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/InstantiationModelAwarePointcutAdvisorImpl.java @@ -116,29 +116,22 @@ final class InstantiationModelAwarePointcutAdvisorImpl /** - * The pointcut for Spring AOP to use. Actual behaviour of the pointcut will change - * depending on the state of the advice. + * The pointcut for Spring AOP to use. + * Actual behaviour of the pointcut will change depending on the state of the advice. */ @Override public Pointcut getPointcut() { return this.pointcut; } - /** - * This is only of interest for Spring AOP: AspectJ instantiation semantics - * are much richer. In AspectJ terminology, all a return of {@code true} - * means here is that the aspect is not a SINGLETON. - */ @Override - public boolean isPerInstance() { - return (getAspectMetadata().getAjType().getPerClause().getKind() != PerClauseKind.SINGLETON); + public boolean isLazy() { + return this.lazy; } - /** - * Return the AspectJ AspectMetadata for this advisor. - */ - public AspectMetadata getAspectMetadata() { - return this.aspectInstanceFactory.getAspectMetadata(); + @Override + public synchronized boolean isAdviceInstantiated() { + return (this.instantiatedAdvice != null); } /** @@ -152,21 +145,27 @@ final class InstantiationModelAwarePointcutAdvisorImpl return this.instantiatedAdvice; } - @Override - public boolean isLazy() { - return this.lazy; + private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) { + Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut, + this.aspectInstanceFactory, this.declarationOrder, this.aspectName); + return (advice != null ? advice : EMPTY_ADVICE); } + /** + * This is only of interest for Spring AOP: AspectJ instantiation semantics + * are much richer. In AspectJ terminology, all a return of {@code true} + * means here is that the aspect is not a SINGLETON. + */ @Override - public synchronized boolean isAdviceInstantiated() { - return (this.instantiatedAdvice != null); + public boolean isPerInstance() { + return (getAspectMetadata().getAjType().getPerClause().getKind() != PerClauseKind.SINGLETON); } - - private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) { - Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut, - this.aspectInstanceFactory, this.declarationOrder, this.aspectName); - return (advice != null ? advice : EMPTY_ADVICE); + /** + * Return the AspectJ AspectMetadata for this advisor. + */ + public AspectMetadata getAspectMetadata() { + return this.aspectInstanceFactory.getAspectMetadata(); } public MetadataAwareAspectInstanceFactory getAspectInstanceFactory() { @@ -221,33 +220,26 @@ final class InstantiationModelAwarePointcutAdvisorImpl } else { switch (aspectJAnnotation.getAnnotationType()) { - case AtAfter: - case AtAfterReturning: - case AtAfterThrowing: - this.isAfterAdvice = true; - this.isBeforeAdvice = false; - break; - case AtAround: case AtPointcut: - this.isAfterAdvice = false; + case AtAround: this.isBeforeAdvice = false; + this.isAfterAdvice = false; break; case AtBefore: - this.isAfterAdvice = false; this.isBeforeAdvice = true; + this.isAfterAdvice = false; + break; + case AtAfter: + case AtAfterReturning: + case AtAfterThrowing: + this.isBeforeAdvice = false; + this.isAfterAdvice = true; + break; } } } - @Override - public String toString() { - return "InstantiationModelAwarePointcutAdvisor: expression [" + getDeclaredPointcut().getExpression() + - "]; advice method [" + this.aspectJAdviceMethod + "]; perClauseKind=" + - this.aspectInstanceFactory.getAspectMetadata().getAjType().getPerClause().getKind(); - - } - private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException { inputStream.defaultReadObject(); try { @@ -258,11 +250,18 @@ final class InstantiationModelAwarePointcutAdvisorImpl } } + @Override + public String toString() { + return "InstantiationModelAwarePointcutAdvisor: expression [" + getDeclaredPointcut().getExpression() + + "]; advice method [" + this.aspectJAdviceMethod + "]; perClauseKind=" + + this.aspectInstanceFactory.getAspectMetadata().getAjType().getPerClause().getKind(); + } + /** * Pointcut implementation that changes its behaviour when the advice is instantiated. - * Note that this is a dynamic pointcut. Otherwise it might - * be optimized out if it does not at first match statically. + * Note that this is a dynamic pointcut; otherwise it might be optimized out + * if it does not at first match statically. */ private final class PerTargetInstantiationModelPointcut extends DynamicMethodMatcherPointcut { @@ -273,7 +272,7 @@ final class InstantiationModelAwarePointcutAdvisorImpl @Nullable private LazySingletonAspectInstanceFactoryDecorator aspectInstanceFactory; - private PerTargetInstantiationModelPointcut(AspectJExpressionPointcut declaredPointcut, + public PerTargetInstantiationModelPointcut(AspectJExpressionPointcut declaredPointcut, Pointcut preInstantiationPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory) { this.declaredPointcut = declaredPointcut; @@ -285,7 +284,8 @@ final class InstantiationModelAwarePointcutAdvisorImpl @Override public boolean matches(Method method, Class targetClass) { - // We're either instantiated and matching on declared pointcut, or uninstantiated matching on either pointcut + // We're either instantiated and matching on declared pointcut, + // or uninstantiated matching on either pointcut... return (isAspectMaterialized() && this.declaredPointcut.matches(method, targetClass)) || this.preInstantiationPointcut.getMethodMatcher().matches(method, targetClass); } diff --git a/spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java b/spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java index 1d74071687e..9c7f6161da1 100644 --- a/spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java +++ b/spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java @@ -246,6 +246,15 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto AbstractAspectJAdvice springAdvice; switch (aspectJAnnotation.getAnnotationType()) { + case AtPointcut: + if (logger.isDebugEnabled()) { + logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'"); + } + return null; + case AtAround: + springAdvice = new AspectJAroundAdvice( + candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); + break; case AtBefore: springAdvice = new AspectJMethodBeforeAdvice( candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); @@ -270,15 +279,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto springAdvice.setThrowingName(afterThrowingAnnotation.throwing()); } break; - case AtAround: - springAdvice = new AspectJAroundAdvice( - candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); - break; - case AtPointcut: - if (logger.isDebugEnabled()) { - logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'"); - } - return null; default: throw new UnsupportedOperationException( "Unsupported advice type on method: " + candidateAdviceMethod);