public AspectJExpressionPointcut() 
{
	     	 
		this(DEFAULT_SUPPORTED_PRIMITIVES);
}

Create a new default AspectJExpressionPointcut.

 public AspectJExpressionPointcut(Set supportedPrimitives) 
{
		this.pointcutParser =
				PointcutParser.getPointcutParserSupportingSpecifiedPrimitivesAndUsingContextClassloaderForResolution(
						supportedPrimitives);
		this.pointcutParser.registerPointcutDesignatorHandler(new BeanNamePointcutDesignatorHandler());
}

Create a new AspectJExpressionPointcut with the given supported primitives.

Parameters:

supportedPrimitives - Set of org.aspectj.weaver.tools.PointcutPrimitive instances

 public AspectJExpressionPointcut(Class declarationScope,
    String[] paramNames,
    Class[] paramTypes) 
{
		this(DEFAULT_SUPPORTED_PRIMITIVES);
		this.pointcutDeclarationScope = declarationScope;
		if (paramNames.length != paramTypes.length) {
			throw new IllegalStateException(
					"Number of pointcut parameter names must match number of pointcut parameter types");
		}
		this.pointcutParameterNames = paramNames;
		this.pointcutParameterTypes = paramTypes;
}

Create a new AspectJExpressionPointcut with the given settings.

Parameters:

declarationScope - the declaration scope for the pointcut

paramNames - the parameter names for the pointcut

paramTypes - the parameter types for the pointcut

 public boolean equals(Object other) 
{
		if (this == other) {
			return true;
		}
		if (!(other instanceof AspectJExpressionPointcut)) {
			return false;
		}
		AspectJExpressionPointcut otherPc = (AspectJExpressionPointcut) other;
		return ObjectUtils.nullSafeEquals(this.getExpression(), otherPc.getExpression()) &&
				ObjectUtils.nullSafeEquals(this.pointcutDeclarationScope, otherPc.pointcutDeclarationScope) &&
				ObjectUtils.nullSafeEquals(this.pointcutParameterNames, otherPc.pointcutParameterNames) &&
				ObjectUtils.nullSafeEquals(this.pointcutParameterTypes, otherPc.pointcutParameterTypes);
}

 public ClassFilter getClassFilter() 
{
		checkReadyToMatch();
		return this;
}

 protected String getCurrentProxiedBeanName() 
{
		return ProxyCreationContext.getCurrentProxiedBeanName();
}

 public MethodMatcher getMethodMatcher() 
{
		checkReadyToMatch();
		return this;
}

 public PointcutExpression getPointcutExpression() 
{
		checkReadyToMatch();
		return this.pointcutExpression;
}

Return the underlying AspectJ pointcut expression.

 public int hashCode() 
{
		int hashCode = ObjectUtils.nullSafeHashCode(this.getExpression());
		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutDeclarationScope);
		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterNames);
		hashCode = 31 * hashCode + ObjectUtils.nullSafeHashCode(this.pointcutParameterTypes);
		return hashCode;
}

 public boolean isRuntime() 
{
		checkReadyToMatch();
		return this.pointcutExpression.mayNeedDynamicTest();
}

 public boolean matches(Class targetClass) 
{
		checkReadyToMatch();
		try {
			return this.pointcutExpression.couldMatchJoinPointsInType(targetClass);
		}
		catch (BCException ex) {
			logger.debug("PointcutExpression matching rejected target class", ex);
			return false;
		}
}

 public boolean matches(Method method,
    Class targetClass) 
{
		return matches(method, targetClass, false);
}

 public boolean matches(Method method,
    Class targetClass,
    boolean beanHasIntroductions) 
{
		checkReadyToMatch();
		Method targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);
		ShadowMatch shadowMatch = null;
		try {
			shadowMatch = getShadowMatch(targetMethod, method);
		}
		catch (ReflectionWorld.ReflectionWorldException ex) {
			// Could neither introspect the target class nor the proxy class - >
			// let's simply consider this method as non-matching.
			return false;
		}
		// Special handling for this, target, @this, @target, @annotation
		// in Spring - we can optimize since we know we have exactly this class,
		// and there will never be matching subclass at runtime.
		if (shadowMatch.alwaysMatches()) {
			return true;
		}
		else if (shadowMatch.neverMatches()) {
			return false;
		}
		else {
		  // the maybe case
		  return (beanHasIntroductions || matchesIgnoringSubtypes(shadowMatch) || matchesTarget(shadowMatch, targetClass));
		}
}

 public boolean matches(Method method,
    Class targetClass,
    Object[] args) 
{
		checkReadyToMatch();
		ShadowMatch shadowMatch = null;
		ShadowMatch originalShadowMatch = null;
		try {
			shadowMatch = getShadowMatch(AopUtils.getMostSpecificMethod(method, targetClass), method);
			originalShadowMatch = getShadowMatch(method, method);
		}
		catch (ReflectionWorld.ReflectionWorldException ex) {
			// Could neither introspect the target class nor the proxy class - >
			// let's simply consider this method as non-matching.
			return false;
		}
		// Bind Spring AOP proxy to AspectJ "this" and Spring AOP target to AspectJ target,
		// consistent with return of MethodInvocationProceedingJoinPoint
		ProxyMethodInvocation pmi = null;
		Object targetObject = null;
		Object thisObject = null;
		try {
			MethodInvocation mi = ExposeInvocationInterceptor.currentInvocation();
			targetObject = mi.getThis();
			if (!(mi instanceof ProxyMethodInvocation)) {
				throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
			}
			pmi = (ProxyMethodInvocation) mi;
			thisObject = pmi.getProxy();
		}
		catch (IllegalStateException ex) {
			// No current invocation...
			// TODO: Should we really proceed here?
			logger.debug("Couldn't access current invocation - matching with limited context: " + ex);
		}
		JoinPointMatch joinPointMatch = shadowMatch.matchesJoinPoint(thisObject, targetObject, args);
		/*
		 * Do a final check to see if any this(TYPE) kind of residue match. For
		 * this purpose, we use the original method's (proxy method's) shadow to
		 * ensure that 'this' is correctly checked against. Without this check,
		 * we get incorrect match on this(TYPE) where TYPE matches the target
		 * type but not 'this' (as would be the case of JDK dynamic proxies).
		 * < p >See SPR-2979 for the original bug.
		 */
		if (pmi != null) {  // there is a current invocation
			RuntimeTestWalker originalMethodResidueTest = new RuntimeTestWalker(originalShadowMatch);
			if (!originalMethodResidueTest.testThisInstanceOfResidue(thisObject.getClass())) {
				return false;
			}
		}
		if (joinPointMatch.matches() && pmi != null) {
			bindParameters(pmi, joinPointMatch);
		}
		return joinPointMatch.matches();
}

 public  void setBeanFactory(BeanFactory beanFactory) 
{
		this.beanFactory = beanFactory;
}

 public  void setParameterNames(String[] names) 
{
		this.pointcutParameterNames = names;
}

Set the parameter names for the pointcut.

 public  void setParameterTypes(Class[] types) 
{
		this.pointcutParameterTypes = types;
}

Set the parameter types for the pointcut.

 public  void setPointcutDeclarationScope(Class pointcutDeclarationScope) 
{
		this.pointcutDeclarationScope = pointcutDeclarationScope;
}

Set the declaration scope for the pointcut.

 public String toString() 
{
		StringBuffer sb = new StringBuffer();
		sb.append("AspectJExpressionPointcut: ");
		if (this.pointcutParameterNames != null && this.pointcutParameterTypes != null) {
			sb.append("(");
			for (int i = 0; i <  this.pointcutParameterTypes.length; i++) {
				sb.append(this.pointcutParameterTypes[i].getName());
				sb.append(" ");
				sb.append(this.pointcutParameterNames[i]);
				if ((i+1) <  this.pointcutParameterTypes.length) {
					sb.append(", ");
				}
			}
			sb.append(")");
		}
		sb.append(" ");
		if (getExpression() != null) {
			sb.append(getExpression());
		}
		else {
			sb.append("< pointcut expression not set >");
		}
		return sb.toString();
}