org.springframework.aop.DynamicIntroductionAdvice Java Examples

/**
 * Cannot add introductions this way unless the advice implements IntroductionInfo.
 */
@Override
public void addAdvice(int pos, Advice advice) throws AopConfigException {
	Assert.notNull(advice, "Advice must not be null");
	if (advice instanceof IntroductionInfo) {
		// We don't need an IntroductionAdvisor for this kind of introduction:
		// It's fully self-describing.
		addAdvisor(pos, new DefaultIntroductionAdvisor(advice, (IntroductionInfo) advice));
	}
	else if (advice instanceof DynamicIntroductionAdvice) {
		// We need an IntroductionAdvisor for this kind of introduction.
		throw new AopConfigException("DynamicIntroductionAdvice may only be added as part of IntroductionAdvisor");
	}
	else {
		addAdvisor(pos, new DefaultPointcutAdvisor(advice));
	}
}
 

/**
 * Cannot add introductions this way unless the advice implements IntroductionInfo.
 */
@Override
public void addAdvice(int pos, Advice advice) throws AopConfigException {
	Assert.notNull(advice, "Advice must not be null");
	if (advice instanceof IntroductionInfo) {
		// We don't need an IntroductionAdvisor for this kind of introduction:
		// It's fully self-describing.
		addAdvisor(pos, new DefaultIntroductionAdvisor(advice, (IntroductionInfo) advice));
	}
	else if (advice instanceof DynamicIntroductionAdvice) {
		// We need an IntroductionAdvisor for this kind of introduction.
		throw new AopConfigException("DynamicIntroductionAdvice may only be added as part of IntroductionAdvisor");
	}
	else {
		addAdvisor(pos, new DefaultPointcutAdvisor(advice));
	}
}
 

/**
 * Cannot add introductions this way unless the advice implements IntroductionInfo.
 */
@Override
public void addAdvice(int pos, Advice advice) throws AopConfigException {
	Assert.notNull(advice, "Advice must not be null");
	if (advice instanceof IntroductionInfo) {
		// We don't need an IntroductionAdvisor for this kind of introduction:
		// It's fully self-describing.
		addAdvisor(pos, new DefaultIntroductionAdvisor(advice, (IntroductionInfo) advice));
	}
	else if (advice instanceof DynamicIntroductionAdvice) {
		// We need an IntroductionAdvisor for this kind of introduction.
		throw new AopConfigException("DynamicIntroductionAdvice may only be added as part of IntroductionAdvisor");
	}
	else {
		addAdvisor(pos, new DefaultPointcutAdvisor(advice));
	}
}
 

/**
 * Cannot add introductions this way unless the advice implements IntroductionInfo.
 */
@Override
public void addAdvice(int pos, Advice advice) throws AopConfigException {
	Assert.notNull(advice, "Advice must not be null");
	if (advice instanceof IntroductionInfo) {
		// We don't need an IntroductionAdvisor for this kind of introduction:
		// It's fully self-describing.
		addAdvisor(pos, new DefaultIntroductionAdvisor(advice, (IntroductionInfo) advice));
	}
	else if (advice instanceof DynamicIntroductionAdvice) {
		// We need an IntroductionAdvisor for this kind of introduction.
		throw new AopConfigException("DynamicIntroductionAdvice may only be added as part of IntroductionAdvisor");
	}
	else {
		addAdvisor(pos, new DefaultPointcutAdvisor(advice));
	}
}
 

public DelegatePerTargetObjectIntroductionInterceptor(Class<?> defaultImplType, Class<?> interfaceType) {
	this.defaultImplType = defaultImplType;
	this.interfaceType = interfaceType;
	// Create a new delegate now (but don't store it in the map).
	// We do this for two reasons:
	// 1) to fail early if there is a problem instantiating delegates
	// 2) to populate the interface map once and once only
	Object delegate = createNewDelegate();
	implementInterfacesOnObject(delegate);
	suppressInterface(IntroductionInterceptor.class);
	suppressInterface(DynamicIntroductionAdvice.class);
}
 

/**
 * Both constructors use this init method, as it is impossible to pass
 * a "this" reference from one constructor to another.
 * @param delegate the delegate object
 */
private void init(Object delegate) {
	Assert.notNull(delegate, "Delegate must not be null");
	this.delegate = delegate;
	implementInterfacesOnObject(delegate);

	// We don't want to expose the control interface
	suppressInterface(IntroductionInterceptor.class);
	suppressInterface(DynamicIntroductionAdvice.class);
}
 

@Override
public void validateInterfaces() throws IllegalArgumentException {
	for (Class<?> ifc : this.interfaces) {
		if (this.advice instanceof DynamicIntroductionAdvice &&
				!((DynamicIntroductionAdvice) this.advice).implementsInterface(ifc)) {
		 throw new IllegalArgumentException("DynamicIntroductionAdvice [" + this.advice + "] " +
				 "does not implement interface [" + ifc.getName() + "] specified for introduction");
		}
	}
}
 

public DelegatePerTargetObjectIntroductionInterceptor(Class<?> defaultImplType, Class<?> interfaceType) {
	this.defaultImplType = defaultImplType;
	this.interfaceType = interfaceType;
	// Create a new delegate now (but don't store it in the map).
	// We do this for two reasons:
	// 1) to fail early if there is a problem instantiating delegates
	// 2) to populate the interface map once and once only
	Object delegate = createNewDelegate();
	implementInterfacesOnObject(delegate);
	suppressInterface(IntroductionInterceptor.class);
	suppressInterface(DynamicIntroductionAdvice.class);
}
 

/**
 * Both constructors use this init method, as it is impossible to pass
 * a "this" reference from one constructor to another.
 * @param delegate the delegate object
 */
private void init(Object delegate) {
	Assert.notNull(delegate, "Delegate must not be null");
	this.delegate = delegate;
	implementInterfacesOnObject(delegate);

	// We don't want to expose the control interface
	suppressInterface(IntroductionInterceptor.class);
	suppressInterface(DynamicIntroductionAdvice.class);
}
 

@Override
public void validateInterfaces() throws IllegalArgumentException {
	for (Class<?> ifc : this.interfaces) {
		if (this.advice instanceof DynamicIntroductionAdvice &&
				!((DynamicIntroductionAdvice) this.advice).implementsInterface(ifc)) {
		 throw new IllegalArgumentException("DynamicIntroductionAdvice [" + this.advice + "] " +
				 "does not implement interface [" + ifc.getName() + "] specified for introduction");
		}
	}
}
 

public DelegatePerTargetObjectIntroductionInterceptor(Class<?> defaultImplType, Class<?> interfaceType) {
	this.defaultImplType = defaultImplType;
	this.interfaceType = interfaceType;
	// Create a new delegate now (but don't store it in the map).
	// We do this for two reasons:
	// 1) to fail early if there is a problem instantiating delegates
	// 2) to populate the interface map once and once only
	Object delegate = createNewDelegate();
	implementInterfacesOnObject(delegate);
	suppressInterface(IntroductionInterceptor.class);
	suppressInterface(DynamicIntroductionAdvice.class);
}
 

/**
 * Both constructors use this init method, as it is impossible to pass
 * a "this" reference from one constructor to another.
 * @param delegate the delegate object
 */
private void init(Object delegate) {
	Assert.notNull(delegate, "Delegate must not be null");
	this.delegate = delegate;
	implementInterfacesOnObject(delegate);

	// We don't want to expose the control interface
	suppressInterface(IntroductionInterceptor.class);
	suppressInterface(DynamicIntroductionAdvice.class);
}
 

@Override
public void validateInterfaces() throws IllegalArgumentException {
	for (Class<?> ifc : this.interfaces) {
		if (this.advice instanceof DynamicIntroductionAdvice &&
				!((DynamicIntroductionAdvice) this.advice).implementsInterface(ifc)) {
		throw new IllegalArgumentException("DynamicIntroductionAdvice [" + this.advice + "] " +
				"does not implement interface [" + ifc.getName() + "] specified for introduction");
		}
	}
}
 

public DelegatePerTargetObjectIntroductionInterceptor(Class<?> defaultImplType, Class<?> interfaceType) {
	this.defaultImplType = defaultImplType;
	this.interfaceType = interfaceType;
	// Create a new delegate now (but don't store it in the map).
	// We do this for two reasons:
	// 1) to fail early if there is a problem instantiating delegates
	// 2) to populate the interface map once and once only
	Object delegate = createNewDelegate();
	implementInterfacesOnObject(delegate);
	suppressInterface(IntroductionInterceptor.class);
	suppressInterface(DynamicIntroductionAdvice.class);
}
 

/**
 * Both constructors use this init method, as it is impossible to pass
 * a "this" reference from one constructor to another.
 * @param delegate the delegate object
 */
private void init(Object delegate) {
	Assert.notNull(delegate, "Delegate must not be null");
	this.delegate = delegate;
	implementInterfacesOnObject(delegate);

	// We don't want to expose the control interface
	suppressInterface(IntroductionInterceptor.class);
	suppressInterface(DynamicIntroductionAdvice.class);
}
 

@Override
public void validateInterfaces() throws IllegalArgumentException {
	for (Class<?> ifc : this.interfaces) {
		if (this.advice instanceof DynamicIntroductionAdvice &&
				!((DynamicIntroductionAdvice) this.advice).implementsInterface(ifc)) {
		throw new IllegalArgumentException("DynamicIntroductionAdvice [" + this.advice + "] " +
				"does not implement interface [" + ifc.getName() + "] specified for introduction");
		}
	}
}
 

/**
 * Create a DefaultIntroductionAdvisor for the given advice.
 * @param advice the Advice to apply
 * @param intf the interface to introduce
 */
public DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice, Class<?> intf) {
	Assert.notNull(advice, "Advice must not be null");
	this.advice = advice;
	addInterface(intf);
}
 

/**
 * Create a DefaultIntroductionAdvisor for the given advice.
 * @param advice the Advice to apply
 * @param intf the interface to introduce
 */
public DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice, Class<?> intf) {
	Assert.notNull(advice, "Advice must not be null");
	this.advice = advice;
	addInterface(intf);
}
 

/**
 * Create a DefaultIntroductionAdvisor for the given advice.
 * @param advice the Advice to apply
 * @param intf the interface to introduce
 */
public DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice, Class<?> intf) {
	Assert.notNull(advice, "Advice must not be null");
	this.advice = advice;
	addInterface(intf);
}
 

/**
 * Create a DefaultIntroductionAdvisor for the given advice.
 * @param advice the Advice to apply
 * @param intf the interface to introduce
 */
public DefaultIntroductionAdvisor(DynamicIntroductionAdvice advice, Class<?> intf) {
	Assert.notNull(advice, "Advice must not be null");
	this.advice = advice;
	addInterface(intf);
}