org.springframework.aop.IntroductionAdvisor Java Examples

/**
 * Helper method to create a {@link PermissionCheckedCollection} from an existing <code>Collection</code>
 * 
 * @param <TT>              the type of the <code>Collection</code>
 * @param collection        the <code>Collection</code> to proxy
 * @param isCutOff          <tt>true</tt> if permission checking was cut off before completion
 * @param sizeUnchecked     number of entries from the original collection that were not checked
 * @param sizeOriginal      number of entries in the original, pre-checked collection
 * @return                  a <code>Collection</code> of the same type but including the
 *                          {@link PermissionCheckedCollection} interface
 */
@SuppressWarnings("unchecked")
public static final <TT> Collection<TT> create(
        Collection<TT> collection,
        boolean isCutOff, int sizeUnchecked, int sizeOriginal)
{
    // Create the mixin
    DelegatingIntroductionInterceptor mixin = new PermissionCheckedCollectionMixin<Integer>(
            isCutOff,
            sizeUnchecked,
            sizeOriginal
            );
    // Create the advisor
    IntroductionAdvisor advisor = new DefaultIntroductionAdvisor(mixin, PermissionCheckedCollection.class);
    // Proxy
    ProxyFactory pf = new ProxyFactory(collection);
    pf.addAdvisor(advisor);
    Object proxiedObject = pf.getProxy();
    
    // Done
    return (Collection<TT>) proxiedObject;
}
 

/**
 * Copy the AOP configuration from the given AdvisedSupport object,
 * but allow substitution of a fresh TargetSource and a given interceptor chain.
 * @param other the AdvisedSupport object to take proxy configuration from
 * @param targetSource the new TargetSource
 * @param advisors the Advisors for the chain
 */
protected void copyConfigurationFrom(AdvisedSupport other, TargetSource targetSource, List<Advisor> advisors) {
	copyFrom(other);
	this.targetSource = targetSource;
	this.advisorChainFactory = other.advisorChainFactory;
	this.interfaces = new ArrayList<Class<?>>(other.interfaces);
	for (Advisor advisor : advisors) {
		if (advisor instanceof IntroductionAdvisor) {
			validateIntroductionAdvisor((IntroductionAdvisor) advisor);
		}
		Assert.notNull(advisor, "Advisor must not be null");
		this.advisors.add(advisor);
	}
	updateAdvisorArray();
	adviceChanged();
}
 

/**
 * Add all of the given advisors to this proxy configuration.
 * @param advisors the advisors to register
 */
public void addAdvisors(Collection<Advisor> advisors) {
	if (isFrozen()) {
		throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
	}
	if (!CollectionUtils.isEmpty(advisors)) {
		for (Advisor advisor : advisors) {
			if (advisor instanceof IntroductionAdvisor) {
				validateIntroductionAdvisor((IntroductionAdvisor) advisor);
			}
			Assert.notNull(advisor, "Advisor must not be null");
			this.advisors.add(advisor);
		}
		updateAdvisorArray();
		adviceChanged();
	}
}
 

@Override
public void removeAdvisor(int index) throws AopConfigException {
	if (isFrozen()) {
		throw new AopConfigException("Cannot remove Advisor: Configuration is frozen.");
	}
	if (index < 0 || index > this.advisors.size() - 1) {
		throw new AopConfigException("Advisor index " + index + " is out of bounds: " +
				"This configuration only has " + this.advisors.size() + " advisors.");
	}

	Advisor advisor = this.advisors.get(index);
	if (advisor instanceof IntroductionAdvisor) {
		IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
		// We need to remove introduction interfaces.
		for (int j = 0; j < ia.getInterfaces().length; j++) {
			removeInterface(ia.getInterfaces()[j]);
		}
	}

	this.advisors.remove(index);
	updateAdvisorArray();
	adviceChanged();
}
 

/**
 * Copy the AOP configuration from the given AdvisedSupport object,
 * but allow substitution of a fresh TargetSource and a given interceptor chain.
 * @param other the AdvisedSupport object to take proxy configuration from
 * @param targetSource the new TargetSource
 * @param advisors the Advisors for the chain
 */
protected void copyConfigurationFrom(AdvisedSupport other, TargetSource targetSource, List<Advisor> advisors) {
	copyFrom(other);
	this.targetSource = targetSource;
	this.advisorChainFactory = other.advisorChainFactory;
	this.interfaces = new ArrayList<Class<?>>(other.interfaces);
	for (Advisor advisor : advisors) {
		if (advisor instanceof IntroductionAdvisor) {
			validateIntroductionAdvisor((IntroductionAdvisor) advisor);
		}
		Assert.notNull(advisor, "Advisor must not be null");
		this.advisors.add(advisor);
	}
	updateAdvisorArray();
	adviceChanged();
}
 

/**
 * Add all of the given advisors to this proxy configuration.
 * @param advisors the advisors to register
 */
public void addAdvisors(Collection<Advisor> advisors) {
	if (isFrozen()) {
		throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
	}
	if (!CollectionUtils.isEmpty(advisors)) {
		for (Advisor advisor : advisors) {
			if (advisor instanceof IntroductionAdvisor) {
				validateIntroductionAdvisor((IntroductionAdvisor) advisor);
			}
			Assert.notNull(advisor, "Advisor must not be null");
			this.advisors.add(advisor);
		}
		updateAdvisorArray();
		adviceChanged();
	}
}
 

@Override
public void removeAdvisor(int index) throws AopConfigException {
	if (isFrozen()) {
		throw new AopConfigException("Cannot remove Advisor: Configuration is frozen.");
	}
	if (index < 0 || index > this.advisors.size() - 1) {
		throw new AopConfigException("Advisor index " + index + " is out of bounds: " +
				"This configuration only has " + this.advisors.size() + " advisors.");
	}

	Advisor advisor = this.advisors.get(index);
	if (advisor instanceof IntroductionAdvisor) {
		IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
		// We need to remove introduction interfaces.
		for (int j = 0; j < ia.getInterfaces().length; j++) {
			removeInterface(ia.getInterfaces()[j]);
		}
	}

	this.advisors.remove(index);
	updateAdvisorArray();
	adviceChanged();
}
 

/**
 * Helper method to create a {@link PermissionCheckCollection} from an existing <code>Collection</code>
 * 
 * @param <TT>              the type of the <code>Collection</code>
 * @param collection        the <code>Collection</code> to proxy
 * @param targetResultCount the desired number of results or default to the collection size
 * @param cutOffAfterTimeMs the number of milliseconds to wait before cut-off or zero to use the system default
 *                          time-based cut-off.
 * @param cutOffAfterCount  the number of permission checks to process before cut-off or zero to use the system default
 *                          count-based cut-off.
 * @return                  a <code>Collection</code> of the same type but including the
 *                          {@link PermissionCheckCollection} interface
 */
@SuppressWarnings("unchecked")
public static final <TT> Collection<TT> create(
        Collection<TT> collection,
        int targetResultCount, long cutOffAfterTimeMs, int cutOffAfterCount)
{
    if (targetResultCount <= 0)
    {
        targetResultCount = collection.size();
    }
    // Create the mixin
    DelegatingIntroductionInterceptor mixin = new PermissionCheckCollectionMixin<Integer>(
            targetResultCount,
            cutOffAfterTimeMs,
            cutOffAfterCount);
    // Create the advisor
    IntroductionAdvisor advisor = new DefaultIntroductionAdvisor(mixin, PermissionCheckCollection.class);
    // Proxy
    ProxyFactory pf = new ProxyFactory(collection);
    pf.addAdvisor(advisor);
    Object proxiedObject = pf.getProxy();
    
    // Done
    return (Collection<TT>) proxiedObject;
}
 

/**
 * Helper method to create a {@link PermissionCheckedValue} from an existing <code>Object</code>.
 * 
 * @param object        the <code>Object</code> to proxy
 * @return                  a <code>Object</code> of the same type but including the
 *                          {@link PermissionCheckedValue} interface
 */
@SuppressWarnings("unchecked")
public static final <T extends Object> T create(T object)
{
    // Create the mixin
    DelegatingIntroductionInterceptor mixin = new PermissionCheckedValueMixin();
    // Create the advisor
    IntroductionAdvisor advisor = new DefaultIntroductionAdvisor(mixin, PermissionCheckedValue.class);
    // Proxy
    ProxyFactory pf = new ProxyFactory(object);
    pf.addAdvisor(advisor);
    Object proxiedObject = pf.getProxy();
    
    // Done
    return (T) proxiedObject;
}
 

/**
 * Copy the AOP configuration from the given AdvisedSupport object,
 * but allow substitution of a fresh TargetSource and a given interceptor chain.
 * @param other the AdvisedSupport object to take proxy configuration from
 * @param targetSource the new TargetSource
 * @param advisors the Advisors for the chain
 */
protected void copyConfigurationFrom(AdvisedSupport other, TargetSource targetSource, List<Advisor> advisors) {
	copyFrom(other);
	this.targetSource = targetSource;
	this.advisorChainFactory = other.advisorChainFactory;
	this.interfaces = new ArrayList<>(other.interfaces);
	for (Advisor advisor : advisors) {
		if (advisor instanceof IntroductionAdvisor) {
			validateIntroductionAdvisor((IntroductionAdvisor) advisor);
		}
		Assert.notNull(advisor, "Advisor must not be null");
		this.advisors.add(advisor);
	}
	updateAdvisorArray();
	adviceChanged();
}
 

/**
 * Add all of the given advisors to this proxy configuration.
 * @param advisors the advisors to register
 */
public void addAdvisors(Collection<Advisor> advisors) {
	if (isFrozen()) {
		throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
	}
	if (!CollectionUtils.isEmpty(advisors)) {
		for (Advisor advisor : advisors) {
			if (advisor instanceof IntroductionAdvisor) {
				validateIntroductionAdvisor((IntroductionAdvisor) advisor);
			}
			Assert.notNull(advisor, "Advisor must not be null");
			this.advisors.add(advisor);
		}
		updateAdvisorArray();
		adviceChanged();
	}
}
 

@Override
public void removeAdvisor(int index) throws AopConfigException {
	if (isFrozen()) {
		throw new AopConfigException("Cannot remove Advisor: Configuration is frozen.");
	}
	if (index < 0 || index > this.advisors.size() - 1) {
		throw new AopConfigException("Advisor index " + index + " is out of bounds: " +
				"This configuration only has " + this.advisors.size() + " advisors.");
	}

	Advisor advisor = this.advisors.get(index);
	if (advisor instanceof IntroductionAdvisor) {
		IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
		// We need to remove introduction interfaces.
		for (int j = 0; j < ia.getInterfaces().length; j++) {
			removeInterface(ia.getInterfaces()[j]);
		}
	}

	this.advisors.remove(index);
	updateAdvisorArray();
	adviceChanged();
}
 

/**
 * Copy the AOP configuration from the given AdvisedSupport object,
 * but allow substitution of a fresh TargetSource and a given interceptor chain.
 * @param other the AdvisedSupport object to take proxy configuration from
 * @param targetSource the new TargetSource
 * @param advisors the Advisors for the chain
 */
protected void copyConfigurationFrom(AdvisedSupport other, TargetSource targetSource, List<Advisor> advisors) {
	copyFrom(other);
	this.targetSource = targetSource;
	this.advisorChainFactory = other.advisorChainFactory;
	this.interfaces = new ArrayList<>(other.interfaces);
	for (Advisor advisor : advisors) {
		if (advisor instanceof IntroductionAdvisor) {
			validateIntroductionAdvisor((IntroductionAdvisor) advisor);
		}
		Assert.notNull(advisor, "Advisor must not be null");
		this.advisors.add(advisor);
	}
	updateAdvisorArray();
	adviceChanged();
}
 

@Override
public void removeAdvisor(int index) throws AopConfigException {
	if (isFrozen()) {
		throw new AopConfigException("Cannot remove Advisor: Configuration is frozen.");
	}
	if (index < 0 || index > this.advisors.size() - 1) {
		throw new AopConfigException("Advisor index " + index + " is out of bounds: " +
				"This configuration only has " + this.advisors.size() + " advisors.");
	}

	Advisor advisor = this.advisors.get(index);
	if (advisor instanceof IntroductionAdvisor) {
		IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
		// We need to remove introduction interfaces.
		for (int j = 0; j < ia.getInterfaces().length; j++) {
			removeInterface(ia.getInterfaces()[j]);
		}
	}

	this.advisors.remove(index);
	updateAdvisorArray();
	adviceChanged();
}
 

/**
 * Add all of the given advisors to this proxy configuration.
 * @param advisors the advisors to register
 */
public void addAdvisors(Collection<Advisor> advisors) {
	if (isFrozen()) {
		throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
	}
	if (!CollectionUtils.isEmpty(advisors)) {
		for (Advisor advisor : advisors) {
			if (advisor instanceof IntroductionAdvisor) {
				validateIntroductionAdvisor((IntroductionAdvisor) advisor);
			}
			Assert.notNull(advisor, "Advisor must not be null");
			this.advisors.add(advisor);
		}
		updateAdvisorArray();
		adviceChanged();
	}
}
 

@Override
public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
	if (advisor instanceof IntroductionAdvisor) {
		validateIntroductionAdvisor((IntroductionAdvisor) advisor);
	}
	addAdvisorInternal(pos, advisor);
}
 

private void validateIntroductionAdvisor(IntroductionAdvisor advisor) {
	advisor.validateInterfaces();
	// If the advisor passed validation, we can make the change.
	Class<?>[] ifcs = advisor.getInterfaces();
	for (Class<?> ifc : ifcs) {
		addInterface(ifc);
	}
}
 

/**
 * Determine whether the Advisors contain matching introductions.
 */
private static boolean hasMatchingIntroductions(Advisor[] advisors, Class<?> actualClass) {
	for (Advisor advisor : advisors) {
		if (advisor instanceof IntroductionAdvisor) {
			IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
			if (ia.getClassFilter().matches(actualClass)) {
				return true;
			}
		}
	}
	return false;
}
 

@Override
public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
	if (advisor instanceof IntroductionAdvisor) {
		validateIntroductionAdvisor((IntroductionAdvisor) advisor);
	}
	addAdvisorInternal(pos, advisor);
}
 

@Override
public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
	if (advisor instanceof IntroductionAdvisor) {
		validateIntroductionAdvisor((IntroductionAdvisor) advisor);
	}
	addAdvisorInternal(pos, advisor);
}
 

/**
 * Determine whether the Advisors contain matching introductions.
 */
private static boolean hasMatchingIntroductions(Advised config, Class<?> actualClass) {
	for (int i = 0; i < config.getAdvisors().length; i++) {
		Advisor advisor = config.getAdvisors()[i];
		if (advisor instanceof IntroductionAdvisor) {
			IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
			if (ia.getClassFilter().matches(actualClass)) {
				return true;
			}
		}
	}
	return false;
}
 

/**
 * Can the given advisor apply at all on the given class?
 * <p>This is an important test as it can be used to optimize out a advisor for a class.
 * This version also takes into account introductions (for IntroductionAwareMethodMatchers).
 * @param advisor the advisor to check
 * @param targetClass class we're testing
 * @param hasIntroductions whether or not the advisor chain for this bean includes
 * any introductions
 * @return whether the pointcut can apply on any method
 */
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
	if (advisor instanceof IntroductionAdvisor) {
		return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
	}
	else if (advisor instanceof PointcutAdvisor) {
		PointcutAdvisor pca = (PointcutAdvisor) advisor;
		return canApply(pca.getPointcut(), targetClass, hasIntroductions);
	}
	else {
		// It doesn't have a pointcut so we assume it applies.
		return true;
	}
}
 

private void validateIntroductionAdvisor(IntroductionAdvisor advisor) {
	advisor.validateInterfaces();
	// If the advisor passed validation, we can make the change.
	Class<?>[] ifcs = advisor.getInterfaces();
	for (Class<?> ifc : ifcs) {
		addInterface(ifc);
	}
}
 

private void validateIntroductionAdvisor(IntroductionAdvisor advisor) {
	advisor.validateInterfaces();
	// If the advisor passed validation, we can make the change.
	Class<?>[] ifcs = advisor.getInterfaces();
	for (Class<?> ifc : ifcs) {
		addInterface(ifc);
	}
}
 

@Override
public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
	if (advisor instanceof IntroductionAdvisor) {
		validateIntroductionAdvisor((IntroductionAdvisor) advisor);
	}
	addAdvisorInternal(pos, advisor);
}
 

/**
 * Determine whether the Advisors contain matching introductions.
 */
private static boolean hasMatchingIntroductions(Advised config, Class<?> actualClass) {
	for (int i = 0; i < config.getAdvisors().length; i++) {
		Advisor advisor = config.getAdvisors()[i];
		if (advisor instanceof IntroductionAdvisor) {
			IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
			if (ia.getClassFilter().matches(actualClass)) {
				return true;
			}
		}
	}
	return false;
}
 

/**
 * Can the given advisor apply at all on the given class?
 * <p>This is an important test as it can be used to optimize out a advisor for a class.
 * This version also takes into account introductions (for IntroductionAwareMethodMatchers).
 * @param advisor the advisor to check
 * @param targetClass class we're testing
 * @param hasIntroductions whether or not the advisor chain for this bean includes
 * any introductions
 * @return whether the pointcut can apply on any method
 */
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
	if (advisor instanceof IntroductionAdvisor) {
		return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
	}
	else if (advisor instanceof PointcutAdvisor) {
		PointcutAdvisor pca = (PointcutAdvisor) advisor;
		return canApply(pca.getPointcut(), targetClass, hasIntroductions);
	}
	else {
		// It doesn't have a pointcut so we assume it applies.
		return true;
	}
}
 

/**
 * Can the given advisor apply at all on the given class?
 * <p>This is an important test as it can be used to optimize out a advisor for a class.
 * This version also takes into account introductions (for IntroductionAwareMethodMatchers).
 * @param advisor the advisor to check
 * @param targetClass class we're testing
 * @param hasIntroductions whether or not the advisor chain for this bean includes
 * any introductions
 * @return whether the pointcut can apply on any method
 */
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
	if (advisor instanceof IntroductionAdvisor) {
		return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
	}
	else if (advisor instanceof PointcutAdvisor) {
		PointcutAdvisor pca = (PointcutAdvisor) advisor;
		return canApply(pca.getPointcut(), targetClass, hasIntroductions);
	}
	else {
		// It doesn't have a pointcut so we assume it applies.
		return true;
	}
}
 

/**
 * Can the given advisor apply at all on the given class?
 * <p>This is an important test as it can be used to optimize out a advisor for a class.
 * This version also takes into account introductions (for IntroductionAwareMethodMatchers).
 * @param advisor the advisor to check
 * @param targetClass class we're testing
 * @param hasIntroductions whether or not the advisor chain for this bean includes
 * any introductions
 * @return whether the pointcut can apply on any method
 */
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
	if (advisor instanceof IntroductionAdvisor) {
		return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
	}
	else if (advisor instanceof PointcutAdvisor) {
		PointcutAdvisor pca = (PointcutAdvisor) advisor;
		return canApply(pca.getPointcut(), targetClass, hasIntroductions);
	}
	else {
		// It doesn't have a pointcut so we assume it applies.
		return true;
	}
}
 

/**
 * Determine whether the Advisors contain matching introductions.
 */
private static boolean hasMatchingIntroductions(Advisor[] advisors, Class<?> actualClass) {
	for (Advisor advisor : advisors) {
		if (advisor instanceof IntroductionAdvisor) {
			IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
			if (ia.getClassFilter().matches(actualClass)) {
				return true;
			}
		}
	}
	return false;
}