public class AspectJExpressionPointcut extends AbstractExpressionPointcut implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware
Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression.
The pointcut expression value is an AspectJ expression. This can reference other pointcuts and use composition and other operations.
Naturally, as this is to be processed by Spring AOP's proxy-based model, only method execution pointcuts are supported.
TRUE| Constructor and Description |
|---|
AspectJExpressionPointcut()
Create a new default AspectJExpressionPointcut.
|
AspectJExpressionPointcut(Class<?> declarationScope,
String[] paramNames,
Class<?>[] paramTypes)
Create a new AspectJExpressionPointcut with the given settings.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
equals(Object other) |
ClassFilter |
getClassFilter()
Return the ClassFilter for this pointcut.
|
protected String |
getCurrentProxiedBeanName() |
MethodMatcher |
getMethodMatcher()
Return the MethodMatcher for this pointcut.
|
org.aspectj.weaver.tools.PointcutExpression |
getPointcutExpression()
Return the underlying AspectJ pointcut expression.
|
int |
hashCode() |
boolean |
isRuntime()
Is this MethodMatcher dynamic, that is, must a final call be made on the
MethodMatcher.matches(java.lang.reflect.Method, Class, Object[]) method at
runtime even if the 2-arg matches method returns true? |
boolean |
matches(Class<?> targetClass)
Should the pointcut apply to the given interface or target class?
|
boolean |
matches(Method method,
Class<?> targetClass)
Perform static checking whether the given method matches.
|
boolean |
matches(Method method,
Class<?> targetClass,
boolean hasIntroductions)
Perform static checking whether the given method matches.
|
boolean |
matches(Method method,
Class<?> targetClass,
Object... args)
Check whether there a runtime (dynamic) match for this method,
which must have matched statically.
|
void |
setBeanFactory(BeanFactory beanFactory)
Callback that supplies the owning factory to a bean instance.
|
void |
setParameterNames(String... names)
Set the parameter names for the pointcut.
|
void |
setParameterTypes(Class<?>... types)
Set the parameter types for the pointcut.
|
void |
setPointcutDeclarationScope(Class<?> pointcutDeclarationScope)
Set the declaration scope for the pointcut.
|
String |
toString() |
getExpression, getLocation, onSetExpression, setExpression, setLocationpublic AspectJExpressionPointcut()
public AspectJExpressionPointcut(Class<?> declarationScope, String[] paramNames, Class<?>[] paramTypes)
declarationScope - the declaration scope for the pointcutparamNames - the parameter names for the pointcutparamTypes - the parameter types for the pointcutpublic void setPointcutDeclarationScope(Class<?> pointcutDeclarationScope)
public void setParameterNames(String... names)
public void setParameterTypes(Class<?>... types)
public void setBeanFactory(BeanFactory beanFactory)
BeanFactoryAwareInvoked after the population of normal bean properties
but before an initialization callback such as
InitializingBean.afterPropertiesSet() or a custom init-method.
setBeanFactory in interface BeanFactoryAwarebeanFactory - owning BeanFactory (never null).
The bean can immediately call methods on the factory.BeanInitializationExceptionpublic ClassFilter getClassFilter()
PointcutgetClassFilter in interface Pointcutnull)public MethodMatcher getMethodMatcher()
PointcutgetMethodMatcher in interface Pointcutnull)public org.aspectj.weaver.tools.PointcutExpression getPointcutExpression()
public boolean matches(Class<?> targetClass)
ClassFiltermatches in interface ClassFiltertargetClass - the candidate target classpublic boolean matches(Method method, @Nullable Class<?> targetClass, boolean hasIntroductions)
IntroductionAwareMethodMatcherMethodMatcher.matches(java.lang.reflect.Method, Class) method
if the caller supports the extended IntroductionAwareMethodMatcher interface.matches in interface IntroductionAwareMethodMatchermethod - the candidate methodtargetClass - the target class (may be null, in which case
the candidate class must be taken to be the method's declaring class)hasIntroductions - true if the object on whose behalf we are
asking is the subject on one or more introductions; false otherwisepublic boolean matches(Method method, @Nullable Class<?> targetClass)
MethodMatcherIf this returns false or if the MethodMatcher.isRuntime()
method returns false, no runtime check (i.e. no
MethodMatcher.matches(java.lang.reflect.Method, Class, Object[]) call)
will be made.
matches in interface MethodMatchermethod - the candidate methodtargetClass - the target class (may be null, in which case
the candidate class must be taken to be the method's declaring class)public boolean isRuntime()
MethodMatcherMethodMatcher.matches(java.lang.reflect.Method, Class, Object[]) method at
runtime even if the 2-arg matches method returns true?
Can be invoked when an AOP proxy is created, and need not be invoked again before each method invocation,
isRuntime in interface MethodMatcherMethodMatcher.matches(java.lang.reflect.Method, Class, Object[]) method
is required if static matching passedpublic boolean matches(Method method, @Nullable Class<?> targetClass, Object... args)
MethodMatcherThis method is invoked only if the 2-arg matches method returns
true for the given method and target class, and if the
MethodMatcher.isRuntime() method returns true. Invoked
immediately before potential running of the advice, after any
advice earlier in the advice chain has run.
matches in interface MethodMatchermethod - the candidate methodtargetClass - the target class (may be null, in which case
the candidate class must be taken to be the method's declaring class)args - arguments to the methodMethodMatcher.matches(Method, Class)