获取了对应的增强器之后，就是对需要代理的目标类进行代理的创建了。</br>
createProxy方法主要是对，ProxyFactory对象进行初始化，为真正的代理的创建做准备。
protected Object createProxy(
Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
ProxyFactory proxyFactory = new ProxyFactory();
// Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
//从ProxyConfig（创建代理的配置的便捷超类，以确保所有代理创建者具有一致的属性）复制设置的代理属性
proxyFactory.copyFrom(this);
//确定给定的bean是否应该使用其目标类而不是其接口进行代理
// 1.proxyTargetClass属性设置的值a，2.beanName对应的Bean设置的preserveTargetClass
if (!shouldProxyTargetClass(beanClass, beanName)) {
// Must allow for introductions; can't just set interfaces to the target's interfaces only.
//获取所有的需要代理的类的相关的接口，并加入ProxyFactory的interfaces属性中
Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
for (Class<?> targetInterface : targetInterfaces) {
proxyFactory.addInterface(targetInterface);
}
}
//将给定的拦截器统一封装为Advisor类型的
Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
//将代理的增强类挨个加入ProxyFactory的advisors属性中
for (Advisor advisor : advisors) {
proxyFactory.addAdvisor(advisor);
}
//设置对应的代理目标bean
proxyFactory.setTargetSource(targetSource);
//用户自定义的代理
customizeProxyFactory(proxyFactory);
//控制代理工厂被设置了之后，是否还允许修改通知，默认为false（即在被配置之后，不允许修改代理的配置）
proxyFactory.setFrozen(this.freezeProxy);
//返回子类返回的Advisors是否已预过滤以匹配bean的目标类，允许在构建AOP调用的顾问程序链时跳过ClassFilter检查
if (advisorsPreFiltered()) {
proxyFactory.setPreFiltered(true);
}
return proxyFactory.getProxy(this.proxyClassLoader);
}
(1)获取当前设置的代理属性（ProxyConfig类中）
(2)判断是否用目标类进行代理而不是接口进行代理，并添加代理接口
(3)添加Advisor到proxyFactory中
(4)设置需要被代理的类
(5)根据用户是否实现了customizeProxyFactory方法，来看是否进一步对proxyFactory进行处理
(6)进行代理的获取操作
这里对拦截器的封装进行解析：
protected Advisor[] buildAdvisors(String beanName, Object[] specificInterceptors) {
// Handle prototypes correctly...
//获取并解析所有的interceptorName，一般都是空的
Advisor[] commonInterceptors = resolveInterceptorNames();
List<Object> allInterceptors = new ArrayList<Object>();
if (specificInterceptors != null) {
//将特定Bean的拦截器集合放到一起
allInterceptors.addAll(Arrays.asList(specificInterceptors));
if (commonInterceptors != null) {
//如果设置了首先应用CommonInterceptors就把commonInterceptors放到拦截器集合最前面，如果不是则按顺序
if (this.applyCommonInterceptorsFirst) {
allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
}
else {
allInterceptors.addAll(Arrays.asList(commonInterceptors));
}
}
}
if (logger.isDebugEnabled()) {
int nrOfCommonInterceptors = (commonInterceptors != null ? commonInterceptors.length : 0);
int nrOfSpecificInterceptors = (specificInterceptors != null ? specificInterceptors.length : 0);
logger.debug("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
" common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
}
Advisor[] advisors = new Advisor[allInterceptors.size()];
for (int i = 0; i < allInterceptors.size(); i++) {
//使用Advisor适配器注册类（默认为GlobalAdvisorAdapterRegistry）来对拦截器进行封装
advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
}
return advisors;
}
现在对warp方法进行解析，这个方法的作用是对所有的拦截器进行统一的封装，封装为Advisor。
public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
//如果需要封装的对象---是---Advisor类型就不需要处理
if (adviceObject instanceof Advisor) {
return (Advisor) adviceObject;
}
//此方法值对Advisor和Advice类型两种数据进行封装，如果不知就不能封装
if (!(adviceObject instanceof Advice)) {
throw new UnknownAdviceTypeException(adviceObject);
}
Advice advice = (Advice) adviceObject;
//如果需要封装的对象---是---MethodInterceptor类型，则使用DefaultPointcutAdvisor不需要适配
if (advice instanceof MethodInterceptor) {
// So well-known it doesn't even need an adapter.
return new DefaultPointcutAdvisor(advice);
}
//如果是Advisor的适配器那么也同样需要进行封装
for (AdvisorAdapter adapter : this.adapters) {
// Check that it is supported.
//检查是否是支持适配的类型
if (adapter.supportsAdvice(advice)) {
return new DefaultPointcutAdvisor(advice);
}
}
throw new UnknownAdviceTypeException(advice);
}
当proxyFactory初始化之后就是进行代理的创建了
public Object getProxy(ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
protected final synchronized AopProxy createAopProxy() {
//active这个值的作用是在创建第一个AOP代理时设置为true，并告诉对应的监听器第一个AOP在创建
if (!this.active) {
activate();
}
//创建代理
return getAopProxyFactory().createAopProxy(this);
}
&esmp;接下来就是进行代理的创建
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
//在这里判断代理的设置属性，
//optimize：代理是否应该执行积极的优化，默认为false
//proxyTargetClass：是否直接代理目标类以及任何接口
//hasNoUserSuppliedProxyInterfaces: 判断是否又用户提供的代理接口
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
//如果需要代理的类是接口则使用jdk代理
if (targetClass.isInterface()) {
return new JdkDynamicAopProxy(config);
}
//使用cglib代理方式
return CglibProxyFactory.createCglibProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}
从上面看到又三个判断条件，影响spring的代理使用方式：
(1)optimize: 用来控制通过CGLIB创建的代理是否使用激进的优化策略，除非完全了解AOP如何进行优化的，则不应该设置这个值（这个值只对CGLIB代理方法有用）</br>
(2)proxyTargetClass: 这个属性为true时，目标类本身被代理而不是目标类的接口，如果这个属性值被设置为true，则使用CGLIB</br>
(3)hasNoUserSuppliedProxyInterfaces：是否存在用户自定义的代理的接口</br>
如果目标实现了接口，可以使用JDK代理（默认），也可以强制使用CGLIB方法进行代理的创建，如果目标对象没有实现接口，则必须使用CGLIB库。</br>
JDK动态代理只能对实现了接口的类生成代理，而不能针对类。</br>
CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，因为是继承，所以这个类或方法最好不要声明为final类型的。</br>
对于JDK的动态代理使用，我们需要自定义一个类实现InvocationHandler，并实现其中需要重写的3个函数：1.构造函数，将代理的对象传入；2.invoke方法，此方法中实现了AOP增强的所有逻辑；3.getProxy方法。同理spring使用JDK的动态代理同样需要用这种方式，因此JdkDynamicAopProxy类实现了InvocationHandler类并且会在invoke方法中把AOP的核心逻辑写在其中。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
MethodInvocation invocation;
Object oldProxy = null;
boolean setProxyContext = false;
TargetSource targetSource = this.advised.targetSource;
Class<?> targetClass = null;
Object target = null;
try {
//如果没有在代理接口中定义equal方法，并且代理的方法是equals方法
if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
// The target does not implement the equals(Object) method itself.
return equals(args[0]);
}
//同上是对hashCode方法的处理
if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
// The target does not implement the hashCode() method itself.
return hashCode();
}
//如果代理方法是接口中的方法并且方法是Advised相同的类或者接口则进行处理
//Class类的isAssignableFrom(Class cls)表示如果调用这个方法的class或接口 与参数cls表示的类或接口相同，或者是
//参数cls表示的类或接口的父类，则返回true
if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
method.getDeclaringClass().isAssignableFrom(Advised.class)) {
// Service invocations on ProxyConfig with the proxy config...
return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
}
Object retVal;
//如果目标对象存在内部的自我调用，则需要暴露代理
//exposeProxy： 设置代理是否应该由AOP框架作为ThreadLocal公开，以便通过AopContext类进行检索。如果建议的对象需要自己调用另一个建议的方法，这将非常有用
if (this.advised.exposeProxy) {
// Make invocation available if necessary.
oldProxy = AopContext.setCurrentProxy(proxy);
setProxyContext = true;
}
// May be null. Get as late as possible to minimize the time we "own" the target,
// in case it comes from a pool.
target = targetSource.getTarget();
if (target != null) {
targetClass = target.getClass();
}
// Get the interception chain for this method.
//获取当前方法的连接器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
// Check whether we have any advice. If we don't, we can fallback on direct
// reflective invocation of the target, and avoid creating a MethodInvocation.
if (chain.isEmpty()) {
// We can skip creating a MethodInvocation: just invoke the target directly
// Note that the final invoker must be an InvokerInterceptor so we know it does
// nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
//如果不存在任何拦截器，则直接进行切点方法的调用
retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
}
else {
// We need to create a method invocation...
//将拦截器链封装在ReflectiveMethodInvocation对象中，以便使用proceed方法调用
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
//执行拦截方法
retVal = invocation.proceed();
}
// Massage return value if necessary.
Class<?> returnType = method.getReturnType();
//返回结果
if (retVal != null && retVal == target && returnType.isInstance(proxy) &&
!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
// Special case: it returned "this" and the return type of the method
// is type-compatible. Note that we can't help if the target sets
// a reference to itself in another returned object.
retVal = proxy;
}
else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
throw new AopInvocationException(
"Null return value from advice does not match primitive return type for: " + method);
}
return retVal;
}
finally {
if (target != null && !targetSource.isStatic()) {
// Must have come from TargetSource.
targetSource.releaseTarget(target);
}
if (setProxyContext) {
// Restore old proxy.
AopContext.setCurrentProxy(oldProxy);
}
}
}
现在对proceed进行解析
public Object proceed() throws Throwable {
// We start with an index of -1 and increment early.
//检查是否所有的拦截器方法都执行完了，执行完了之后就调用切点方法
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
//获取下一个需要执行的拦截器
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//如果拦截器是InterceptorAndDynamicMethodMatcher(内部框架类，将MethodInterceptor实例与MethodMatcher组合，用作顾问程序链中的元素)类型的
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
//对对应的方法和目标类以及参数进行匹配，如果匹配上则执行拦截方法，不匹配则不执行，调用下一个拦截器
if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
else {
//如果是普通的拦截器，所以我们只是调用它。普通的拦截器有：ExposeInvocationInterceptor，DelegatingIntroductionInterceptor，MethodBeforeAdviceInterceptor，AspectJAroundAdvice，AspectJAfterThrowingAdvice，AspectJAfterAdvice等
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
网友评论