import org.aopalliance.aop.Advice; //导入依赖的package包/类
/**
 * Proxy the target object with an interceptor that manages the context classloader. This should be applied only if
 * such management is needed. Additionally, this method uses a cache to prevent multiple proxies to be created for
 * the same object.
 * 
 * @param target
 * @return
 */
private Object createCLLProxy(final Object target) {
	try {
		return ProxyUtils.createProxy(classes, target, aopClassLoader, bundleContext,
				new Advice[] { new ServiceTCCLInterceptor(classLoader) });
	} catch (Throwable th) {
		log.error("Cannot create TCCL managed proxy; falling back to the naked object", th);
		if (th instanceof NoClassDefFoundError) {
			NoClassDefFoundError ncdfe = (NoClassDefFoundError) th;
			if (log.isWarnEnabled()) {
				DebugUtils.debugClassLoadingThrowable(ncdfe, bundleContext.getBundle(), classes);
			}
			throw ncdfe;
		}
	}

	return target;
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
private Advice determineTCCLAdvice(ServiceReference reference) {
	try {

		switch (iccl) {
		case CLIENT:
			return clientTCCLAdvice;
		case SERVICE_PROVIDER:
			return createServiceProviderTCCLAdvice(reference);
		case UNMANAGED:
			// do nothing
			return null;
		default:
			return null;
		}

	} finally {
		if (log.isTraceEnabled()) {
			log.trace(iccl + " TCCL used for invoking " + OsgiStringUtils.nullSafeToString(reference));
		}
	}
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
public void testMultipleInterceptorEquality() throws Exception {
	target = new Polygon();

	Advice interceptorA1 = createInterceptorWOServiceRequired();

	Advice interceptorA2 = new LocalBundleContextAdvice(bundleContext);
	Advice interceptorA3 = new ServiceTCCLInterceptor(null);

	Advice interceptorB1 = createInterceptorWOServiceRequired();
	Advice interceptorB2 = new LocalBundleContextAdvice(bundleContext);
	Advice interceptorB3 = new ServiceTCCLInterceptor(null);

	Object proxyA = createProxy(target, Shape.class, new Advice[] { interceptorA1, interceptorA2, interceptorA3 });
	Object proxyB = createProxy(target, Shape.class, new Advice[] { interceptorB1, interceptorB2, interceptorB3 });

	assertFalse(proxyA == proxyB);
	assertEquals(interceptorA1, interceptorB1);
	assertEquals(interceptorA2, interceptorB2);
	assertEquals(interceptorA3, interceptorB3);

	assertEquals(proxyA, proxyB);
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
public void testDifferentProxySetupButTargetHasEquals() throws Exception {
	target = new Implementor();

	Advice interceptorA1 = new LocalBundleContextAdvice(bundleContext);
	Advice interceptorB1 = new ServiceTCCLInterceptor(null);

	InterfaceWithEquals proxyA = (InterfaceWithEquals) createProxy(target, InterfaceWithEquals.class,
		new Advice[] { interceptorA1 });
	InterfaceWithEquals proxyB = (InterfaceWithEquals) createProxy(target, InterfaceWithEquals.class,
		new Advice[] { interceptorB1 });

	assertFalse(proxyA == proxyB);
	assertFalse("interceptors should not be equal", interceptorA1.equals(interceptorB1));

	assertEquals(((InterfaceWithEquals) target).doSmth(), proxyA.doSmth());
	assertEquals(((InterfaceWithEquals) target).doSmth(), proxyB.doSmth());

	assertEquals(proxyA, proxyB);
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
@Override
public String toString() {
	StringBuilder sb = new StringBuilder();
	Advice advice = this.advisor.getAdvice();
	sb.append(ClassUtils.getShortName(advice.getClass()));
	sb.append(": ");
	if (this.advisor instanceof Ordered) {
		sb.append("order ").append(((Ordered) this.advisor).getOrder()).append(", ");
	}
	if (advice instanceof AbstractAspectJAdvice) {
		AbstractAspectJAdvice ajAdvice = (AbstractAspectJAdvice) advice;
		sb.append(ajAdvice.getAspectName());
		sb.append(", declaration order ");
		sb.append(ajAdvice.getDeclarationOrder());
	}
	return sb.toString();
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
/**
 * Private constructor to share common code between impl-based delegate and reference-based delegate
 * (cannot use method such as init() to share common code, due the the use of final fields)
 * @param interfaceType static field defining the introduction
 * @param typePattern type pattern the introduction is restricted to
 * @param implementationClass implementation class
 * @param advice delegation advice
 */
private DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Class<?> implementationClass, Advice advice) {
	this.introducedInterface = interfaceType;
	ClassFilter typePatternFilter = new TypePatternClassFilter(typePattern);

	// Excludes methods implemented.
	ClassFilter exclusion = new ClassFilter() {
		@Override
		public boolean matches(Class<?> clazz) {
			return !(introducedInterface.isAssignableFrom(clazz));
		}
	};

	this.typePatternClassFilter = ClassFilters.intersection(typePatternFilter, exclusion);
	this.advice = advice;
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
@Override
public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
	if (adviceObject instanceof Advisor) {
		return (Advisor) adviceObject;
	}
	if (!(adviceObject instanceof Advice)) {
		throw new UnknownAdviceTypeException(adviceObject);
	}
	Advice advice = (Advice) adviceObject;
	if (advice instanceof MethodInterceptor) {
		// So well-known it doesn't even need an adapter.
		return new DefaultPointcutAdvisor(advice);
	}
	for (AdvisorAdapter adapter : this.adapters) {
		// Check that it is supported.
		if (adapter.supportsAdvice(advice)) {
			return new DefaultPointcutAdvisor(advice);
		}
	}
	throw new UnknownAdviceTypeException(advice);
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
@Override
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
	List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
	Advice advice = advisor.getAdvice();
	if (advice instanceof MethodInterceptor) {
		interceptors.add((MethodInterceptor) advice);
	}
	for (AdvisorAdapter adapter : this.adapters) {
		if (adapter.supportsAdvice(advice)) {
			interceptors.add(adapter.getInterceptor(advisor));
		}
	}
	if (interceptors.isEmpty()) {
		throw new UnknownAdviceTypeException(advisor.getAdvice());
	}
	return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
/**
 * 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));
	}
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws Exception {

	if (Advice.class.isAssignableFrom(bean.getClass()) || Pointcut.class.isAssignableFrom(bean.getClass())
			|| Advisor.class.isAssignableFrom(bean.getClass())
			|| MethodInterceptor.class.isAssignableFrom(bean.getClass())) {
		return bean;
	}

	List<DefaultPointcutAdvisor> defaultPointcutAdvisors = beanFactory
			.getBeansForType(DefaultPointcutAdvisor.class);
	for (DefaultPointcutAdvisor advisor : defaultPointcutAdvisors) {
		if (advisor.getPointcut().getClassFilter().matches(bean.getClass())) {
			ProxyFactory advisedSupport = new ProxyFactory();
			advisedSupport.setMethodInterceptor((MethodInterceptor) advisor.getAdvice());
			advisedSupport.setMethodMatcher(advisor.getPointcut().getmethodMatcher());
			advisedSupport
					.setTargetSource(new TargetSource(bean.getClass(), bean.getClass().getInterfaces(), bean));
			return advisedSupport.getProxy();
		}
	}
	return null;
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
private static void removeAdvisor(Object proxy, Class<? extends Advice> adviceClass) {
    if(!AopUtils.isAopProxy(proxy)) {
        return;
    }
    ProxyFactory proxyFactory = null;
    if(AopUtils.isJdkDynamicProxy(proxy)) {
        proxyFactory = findJdkDynamicProxyFactory(proxy);
    }
    if(AopUtils.isCglibProxy(proxy)) {
        proxyFactory = findCglibProxyFactory(proxy);
    }

    Advisor[] advisors = proxyFactory.getAdvisors();

    if(advisors == null || advisors.length == 0) {
        return;
    }

    for(Advisor advisor : advisors) {
        if(adviceClass.isAssignableFrom(advisor.getAdvice().getClass())) {
            proxyFactory.removeAdvisor(advisor);
            break;
        }
    }
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
private static boolean hasAdvice(Object proxy, Class<? extends Advice> adviceClass) {
    if(!AopUtils.isAopProxy(proxy)) {
        return false;
    }
    ProxyFactory proxyFactory = null;
    if(AopUtils.isJdkDynamicProxy(proxy)) {
        proxyFactory = findJdkDynamicProxyFactory(proxy);
    }
    if(AopUtils.isCglibProxy(proxy)) {
        proxyFactory = findCglibProxyFactory(proxy);
    }

    Advisor[] advisors = proxyFactory.getAdvisors();

    if(advisors == null || advisors.length == 0) {
        return false;
    }

    for(Advisor advisor : advisors) {
        if(adviceClass.isAssignableFrom(advisor.getAdvice().getClass())) {
            return true;
        }
    }
    return false;
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
/**
 * Private constructor to share common code between impl-based delegate and reference-based delegate
 * (cannot use method such as init() to share common code, due the use of final fields)
 * @param interfaceType static field defining the introduction
 * @param typePattern type pattern the introduction is restricted to
 * @param implementationClass implementation class
 * @param advice delegation advice
 */
private DeclareParentsAdvisor(Class<?> interfaceType, String typePattern, Class<?> implementationClass, Advice advice) {
	this.introducedInterface = interfaceType;
	ClassFilter typePatternFilter = new TypePatternClassFilter(typePattern);

	// Excludes methods implemented.
	ClassFilter exclusion = new ClassFilter() {
		@Override
		public boolean matches(Class<?> clazz) {
			return !(introducedInterface.isAssignableFrom(clazz));
		}
	};

	this.typePatternClassFilter = ClassFilters.intersection(typePatternFilter, exclusion);
	this.advice = advice;
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
@Override
protected Advice createMethodValidationAdvice(Validator validator) {

    if (validator == null) {
        return new CustomMethodValidationInterceptor(constraintViolationExceptionMapper);
    }

    return new CustomMethodValidationInterceptor(validator, constraintViolationExceptionMapper);
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
private Object createProxy(final Class<?> clazz, Advice cardinalityInterceptor) {
	ProxyFactory factory = new ProxyFactory();
	factory.setProxyTargetClass(true);
	factory.setOptimize(true);
	factory.setTargetClass(clazz);

	factory.addAdvice(cardinalityInterceptor);
	factory.setFrozen(true);

	return factory.getProxy(ProxyFactory.class.getClassLoader());
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
private Advice createCardinalityAdvice(Class<?> clazz) {
	ClassLoader classLoader = BundleDelegatingClassLoader.createBundleClassLoaderFor(bundleContext.getBundle());
	ServiceDynamicInterceptor interceptor = new ServiceDynamicInterceptor(bundleContext, null,
		OsgiFilterUtils.createFilter(OsgiFilterUtils.unifyFilter(clazz, null)), classLoader);
	// fast retry
	interceptor.setMandatoryService(true);
	interceptor.afterPropertiesSet();
	interceptor.getRetryTemplate().reset(1);
	return interceptor;

}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
public ProxyPlusCallback createServiceProxy(ServiceReference reference) {
	List advices = new ArrayList(4);

	// 1. the ServiceReference-like mixin
	Advice mixin = new ImportedOsgiServiceProxyAdvice(reference);
	advices.add(mixin);

	// 2. publication of bundleContext (if there is any)
	// TODO: make this configurable (so it can be disabled)
	advices.add(invokerBundleContextAdvice);

	// 3. TCCL handling (if there is any)
	Advice tcclAdvice = determineTCCLAdvice(reference);

	if (tcclAdvice != null)
		advices.add(tcclAdvice);

	// 4. add the infrastructure proxy
	// but first create the dispatcher since we need
	ServiceInvoker dispatcherInterceptor = createDispatcherInterceptor(reference);
	Advice infrastructureMixin = new InfrastructureOsgiProxyAdvice(dispatcherInterceptor);

	advices.add(infrastructureMixin);
	advices.add(dispatcherInterceptor);

	return new ProxyPlusCallback(ProxyUtils.createProxy(getInterfaces(reference), null, classLoader, bundleContext,
			advices), dispatcherInterceptor);
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
Advice createServiceProviderTCCLAdvice(ServiceReference reference) {
	Bundle bundle = reference.getBundle();
	// if reference is dead already, it's impossible to provide the service
	// class loader
	if (bundle == null)
		return null;

	return new ServiceTCCLInterceptor(ClassLoaderFactory.getBundleClassLoaderFor(bundle));
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
public static Object createProxy(Class<?>[] classes, Object target, final ClassLoader classLoader,
		BundleContext bundleContext, Advice[] advices) {
	final ProxyFactory factory = new ProxyFactory();

	ClassUtils.configureFactoryForClass(factory, classes);

	for (int i = 0; i < advices.length; i++) {
		factory.addAdvice(advices[i]);
	}

	if (target != null)
		factory.setTarget(target);

	// no need to add optimize since it means implicit usage of CGLib always
	// which is determined automatically anyway
	// factory.setOptimize(true);
	factory.setFrozen(true);
	factory.setOpaque(true);
	boolean isSecurityOn = (System.getSecurityManager() != null);
	try {
		if (isSecurityOn) {
			return AccessController.doPrivileged(new PrivilegedAction<Object>() {
				public Object run() {
					return factory.getProxy(classLoader);
				}
			});
		} else {
			return factory.getProxy(classLoader);
		}

	} catch (NoClassDefFoundError ncdfe) {
		DebugUtils.debugClassLoadingThrowable(ncdfe, bundleContext.getBundle(), classes);
		throw ncdfe;
	}
}
 

import org.aopalliance.aop.Advice; //导入依赖的package包/类
private Object createProxy(Object target, Class<?> intf, Advice[] advices) {
	ProxyFactory factory = new ProxyFactory();
	factory.addInterface(intf);
	if (advices != null)
		for (int i = 0; i < advices.length; i++) {
			factory.addAdvice(advices[0]);
		}

	factory.setTarget(target);
	return factory.getProxy();
}