GitHub-Spring
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Polishing

pull/1935/head
Juergen Hoeller 8 years ago
parent
4b30fe2b44
commit
45598ca53a
2 changed files with 61 additions and 59 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 91
      spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/InstantiationModelAwarePointcutAdvisorImpl.java
  2. 29
      spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java

91
spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/InstantiationModelAwarePointcutAdvisorImpl.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2015 the original author or authors. * Copyright 2002-2018 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -109,29 +109,22 @@ class InstantiationModelAwarePointcutAdvisorImpl
/** /**
* The pointcut for Spring AOP to use. Actual behaviour of the pointcut will change * The pointcut for Spring AOP to use.
* depending on the state of the advice. * Actual behaviour of the pointcut will change depending on the state of the advice.
*/ */
@Override @Override
public Pointcut getPointcut() { public Pointcut getPointcut() {
return this.pointcut; 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 @Override
public boolean isPerInstance() { public boolean isLazy() {
return (getAspectMetadata().getAjType().getPerClause().getKind() != PerClauseKind.SINGLETON); return this.lazy;
} }
/** @Override
* Return the AspectJ AspectMetadata for this advisor. public synchronized boolean isAdviceInstantiated() {
*/ return (this.instantiatedAdvice != null);
public AspectMetadata getAspectMetadata() {
return this.aspectInstanceFactory.getAspectMetadata();
} }
/** /**
@ -145,20 +138,26 @@ class InstantiationModelAwarePointcutAdvisorImpl
return this.instantiatedAdvice; return this.instantiatedAdvice;
} }
@Override private Advice instantiateAdvice(AspectJExpressionPointcut pcut) {
public boolean isLazy() { return this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pcut,
return this.lazy; this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
} }
/**
* 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 @Override
public synchronized boolean isAdviceInstantiated() { public boolean isPerInstance() {
return (this.instantiatedAdvice != null); return (getAspectMetadata().getAjType().getPerClause().getKind() != PerClauseKind.SINGLETON);
} }
/**
private Advice instantiateAdvice(AspectJExpressionPointcut pcut) { * Return the AspectJ AspectMetadata for this advisor.
return this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pcut, */
this.aspectInstanceFactory, this.declarationOrder, this.aspectName); public AspectMetadata getAspectMetadata() {
return this.aspectInstanceFactory.getAspectMetadata();
} }
public MetadataAwareAspectInstanceFactory getAspectInstanceFactory() { public MetadataAwareAspectInstanceFactory getAspectInstanceFactory() {
@ -213,33 +212,26 @@ class InstantiationModelAwarePointcutAdvisorImpl
} }
else { else {
switch (aspectJAnnotation.getAnnotationType()) { switch (aspectJAnnotation.getAnnotationType()) {
case AtAfter:
case AtAfterReturning:
case AtAfterThrowing:
this.isAfterAdvice = true;
this.isBeforeAdvice = false;
break;
case AtAround:
case AtPointcut: case AtPointcut:
this.isAfterAdvice = false; case AtAround:
this.isBeforeAdvice = false; this.isBeforeAdvice = false;
this.isAfterAdvice = false;
break; break;
case AtBefore: case AtBefore:
this.isAfterAdvice = false;
this.isBeforeAdvice = true; 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 { private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException {
inputStream.defaultReadObject(); inputStream.defaultReadObject();
try { try {
@ -250,11 +242,18 @@ 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. * Pointcut implementation that changes its behaviour when the advice is instantiated.
* Note that this is a <i>dynamic</i> pointcut. Otherwise it might * Note that this is a <i>dynamic</i> pointcut; otherwise it might be optimized out
* be optimized out if it does not at first match statically. * if it does not at first match statically.
*/ */
private class PerTargetInstantiationModelPointcut extends DynamicMethodMatcherPointcut { private class PerTargetInstantiationModelPointcut extends DynamicMethodMatcherPointcut {
@ -264,8 +263,9 @@ class InstantiationModelAwarePointcutAdvisorImpl
private LazySingletonAspectInstanceFactoryDecorator aspectInstanceFactory; private LazySingletonAspectInstanceFactoryDecorator aspectInstanceFactory;
private PerTargetInstantiationModelPointcut(AspectJExpressionPointcut declaredPointcut, public PerTargetInstantiationModelPointcut(AspectJExpressionPointcut declaredPointcut,
Pointcut preInstantiationPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory) { Pointcut preInstantiationPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
this.declaredPointcut = declaredPointcut; this.declaredPointcut = declaredPointcut;
this.preInstantiationPointcut = preInstantiationPointcut; this.preInstantiationPointcut = preInstantiationPointcut;
if (aspectInstanceFactory instanceof LazySingletonAspectInstanceFactoryDecorator) { if (aspectInstanceFactory instanceof LazySingletonAspectInstanceFactoryDecorator) {
@ -275,7 +275,8 @@ class InstantiationModelAwarePointcutAdvisorImpl
@Override @Override
public boolean matches(Method method, Class<?> targetClass) { 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)) || return (isAspectMaterialized() && this.declaredPointcut.matches(method, targetClass)) ||
this.preInstantiationPointcut.getMethodMatcher().matches(method, targetClass); this.preInstantiationPointcut.getMethodMatcher().matches(method, targetClass);
} }

29
spring-aop/src/main/java/org/springframework/aop/aspectj/annotation/ReflectiveAspectJAdvisorFactory.java
Unescape View File

@ -1,5 +1,5 @@
/* /*
* Copyright 2002-2016 the original author or authors. * Copyright 2002-2018 the original author or authors.
* *
* Licensed under the Apache License, Version 2.0 (the "License"); * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License. * you may not use this file except in compliance with the License.
@ -20,9 +20,9 @@ import java.io.Serializable;
import java.lang.annotation.Annotation; import java.lang.annotation.Annotation;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;
import java.util.Comparator; import java.util.Comparator;
import java.util.LinkedList;
import java.util.List; import java.util.List;
import org.aopalliance.aop.Advice; import org.aopalliance.aop.Advice;
@ -131,7 +131,7 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory); new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
List<Advisor> advisors = new LinkedList<Advisor>(); List<Advisor> advisors = new ArrayList<Advisor>();
for (Method method : getAdvisorMethods(aspectClass)) { for (Method method : getAdvisorMethods(aspectClass)) {
Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName); Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
if (advisor != null) { if (advisor != null) {
@ -157,7 +157,7 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
} }
private List<Method> getAdvisorMethods(Class<?> aspectClass) { private List<Method> getAdvisorMethods(Class<?> aspectClass) {
final List<Method> methods = new LinkedList<Method>(); final List<Method> methods = new ArrayList<Method>();
ReflectionUtils.doWithMethods(aspectClass, new ReflectionUtils.MethodCallback() { ReflectionUtils.doWithMethods(aspectClass, new ReflectionUtils.MethodCallback() {
@Override @Override
public void doWith(Method method) throws IllegalArgumentException { public void doWith(Method method) throws IllegalArgumentException {
@ -176,7 +176,7 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
* for the given introduction field. * for the given introduction field.
* <p>Resulting Advisors will need to be evaluated for targets. * <p>Resulting Advisors will need to be evaluated for targets.
* @param introductionField the field to introspect * @param introductionField the field to introspect
* @return {@code null} if not an Advisor * @return the Advisor instance, or {@code null} if not an Advisor
*/ */
private Advisor getDeclareParentsAdvisor(Field introductionField) { private Advisor getDeclareParentsAdvisor(Field introductionField) {
DeclareParents declareParents = introductionField.getAnnotation(DeclareParents.class); DeclareParents declareParents = introductionField.getAnnotation(DeclareParents.class);
@ -253,6 +253,15 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
AbstractAspectJAdvice springAdvice; AbstractAspectJAdvice springAdvice;
switch (aspectJAnnotation.getAnnotationType()) { 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: case AtBefore:
springAdvice = new AspectJMethodBeforeAdvice( springAdvice = new AspectJMethodBeforeAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory); candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
@ -277,15 +286,6 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
springAdvice.setThrowingName(afterThrowingAnnotation.throwing()); springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
} }
break; break;
case AtAround:
springAdvice = new AspectJAroundAdvice(
candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
break;
case AtPointcut:
if (logger.isDebugEnabled()) {
logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
}
return null;
default: default:
throw new UnsupportedOperationException( throw new UnsupportedOperationException(
"Unsupported advice type on method: " + candidateAdviceMethod); "Unsupported advice type on method: " + candidateAdviceMethod);
@ -299,6 +299,7 @@ public class ReflectiveAspectJAdvisorFactory extends AbstractAspectJAdvisorFacto
springAdvice.setArgumentNamesFromStringArray(argNames); springAdvice.setArgumentNamesFromStringArray(argNames);
} }
springAdvice.calculateArgumentBindings(); springAdvice.calculateArgumentBindings();
return springAdvice; return springAdvice;
} }

Write Preview
Loading…
Cancel
Save