public ConByConInfo(Advisor advisor, Class<?> calledClass, Class<?> callingClass, int callingIndex, Constructor<?> called, long calledConHash, Method wrappingMethod, Interceptor[] in) { super(advisor, calledClass, called, calledConHash, wrappingMethod, in, callingClass); this.callingIndex = callingIndex; Advisor tempAdvisor = advisor; if (advisor.getClazz() != callingClass) { tempAdvisor = advisor.manager.getAdvisor(callingClass); } this.calling = tempAdvisor.constructors[callingIndex]; }
public MethodByConInfo(Advisor advisor, Class<?> calledClass, Class<?> callingClass, int callingIndex, Method m, long calledMethodHash, Interceptor[] in) { super(advisor, calledClass, m, calledMethodHash, in, callingClass); this.callingIndex = callingIndex; Advisor tempAdvisor = advisor; if (advisor.getClazz() != callingClass) { tempAdvisor = advisor.manager.getAdvisor(callingClass); } calling = tempAdvisor.constructors[callingIndex]; }
private void initClassContainer() { if (Advised.class.isAssignableFrom(key.getClazz())) { classAdvisor = AspectManager.instance().getAdvisor(key.getClazz()); } else { classAdvisor = getCachedContainer(manager); if (classAdvisor == null) { classAdvisor = createAndCacheContainer(); } } }
/** * Attempt to invoke the original interceptor chain attached to the * field read in the target class. * For now we don't bother attempting to use optimized invocations since we * are using reflection anyway */ private Object invokeOriginalChainIfExists(Invocation invocation, Field field, Object targetObject) throws Throwable { //Don't attach to caller chain, since we don't have caller interception for fields //Try to attach to chain on target object ClassAdvisor advisor = AspectManager.instance().getAdvisor(field.getDeclaringClass()); Class<?> calledClass = field.getDeclaringClass(); if (isAdvised(calledClass)) { if (advisor != null && advisor.hasAspects()) { int index = advisor.getFieldIndex(field); if (index >= 0) { FieldInfo jp = advisor.getFieldReadInfos()[index]; return jp.getWrapper().invoke(null, new Object[] {targetObject}); } } } return invocation.invokeNext(); }
/** * Attempt to invoke the original interceptor chain attached to the * field write in the target class. * For now we don't bother attempting to use optimized invocations since we * are using reflection anyway */ private Object invokeOriginalChainIfExists(Invocation invocation, Field field, Object targetObject, Object value) throws Throwable { //Don't attach to caller chain, since we don't have caller interception for fields //Try to attach to chain on target object ClassAdvisor advisor = AspectManager.instance().getAdvisor(field.getDeclaringClass()); Class<?> calledClass = field.getDeclaringClass(); if (isAdvised(calledClass)) { if (advisor != null && advisor.hasAspects()) { int index = advisor.getFieldIndex(field); if (index >= 0) { FieldInfo jp = advisor.getFieldWriteInfos()[index]; return jp.getWrapper().invoke(null, new Object[] {targetObject, value}); } } } return invocation.invokeNext(); }
try advisorClass = manager.getAdvisor(info.getClazz()).getClass();
if (isAdvised(callingClass)) ClassAdvisor advisor = AspectManager.instance().getAdvisor(callingClass); if (advisor != null) if (isAdvised(callingMethod.getDeclaringClass())) ClassAdvisor advisor = AspectManager.instance().getAdvisor(callingMethod.getDeclaringClass()); if (advisor != null) if (isAdvised(calledClass)) ClassAdvisor advisor = AspectManager.instance().getAdvisor(constructor.getDeclaringClass());
if (isAdvised(callingClass)) ClassAdvisor advisor = AspectManager.instance().getAdvisor(callingClass); if (advisor != null) if (isAdvised(callingMethod.getDeclaringClass())) ClassAdvisor advisor = AspectManager.instance().getAdvisor(callingMethod.getDeclaringClass()); if (advisor != null)