【Spring源码】AOP部分源码解读

在之前的文章【设计模式】动态代理模式和【设计模式】策略模式中都讲到了AOP中有用到，今天就带领大家读读部分源码。

话不多说，我们直接先来看类图，之后再逐步分析：



首先根据类图中的入口，直接来看类

ProxyFactoryBean

，可以看到类ProxyFactoryBean实现了FactoryBean接口，实现这个接口的方法，我们就直接去看他的getObject方法(关于这点不太清楚的同学可以看楼主之前的博客：BeanFactory和FactoryBean详解)：

public Object getObject() throws BeansException {
initializeAdvisorChain();
if (isSingleton()) {
return getSingletonInstance();
}
else {
return newPrototypeInstance();
}
}

可以看到方法很简单，就是区分获取单例和原型的类，其中其他代码省略了，这两个方法最终返回的都是如下方法结果：

getProxy(createAopProxy())

下面就来看createAopProxy方法：

protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
//此处调用AopProxyFactory的createAopProxy方法
return getAopProxyFactory().createAopProxy(this);
}

这里的

AopProxyFactory

其实就是一个简单工厂模式，根据入参返回不同的对象类，其核心方法：

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}

代码很简单，就是根据不同才config获取不同的Proxy实现类。下面来看看AopProxy的三个实现类。

CglibAopProxy类：

public Object getProxy(ClassLoader classLoader) {
try {
Class<?> rootClass = this.advised.getTargetClass();
Class<?> proxySuperClass = rootClass;
........省略部分代码

Enhancer enhancer = createEnhancer();
if (classLoader != null) {
enhancer.setClassLoader(classLoader);
if (classLoader instanceof SmartClassLoader &&
((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
enhancer.setUseCache(false);
}
}
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));

Callback[] callbacks = getCallbacks(rootClass);
Class<?>[] types = new Class<?>[callbacks.length];
for (int x = 0; x < types.length; x++) {
types[x] = callbacks[x].getClass();
}
enhancer.setCallbackFilter(new ProxyCallbackFilter(
this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
return createProxyClassAndInstance(enhancer, callbacks);
}
catch (CodeGenerationException ex) {
。。。省略
catch (IllegalArgumentException ex) {
。。。省略
}
catch (Throwable ex) {
。。。省略
}
}

读者可以看到这就是一个很典型的采用Cglib的动态代理，这里就不多说了，接下来看类

JdkDynamicAopProxy

：

public Object getProxy(ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

这里就更不用多说了，不太清除的同学可以去看看引言里的动态代理模式那篇文章，至于ObjenesisCglibAopProxy这里就不多说了，它就是在CglibAopProxy的功能上加入了初始化代理类时不调用其构造器的功能，这个大家可以自行搜索下

Objenesis

接口，很简单。

最后来看上面未说的getProxy方法：

protected Object getProxy(AopProxy aopProxy) {
return aopProxy.getProxy(this.proxyClassLoader);
}

这就很简单啦，就是根据传入的不同的

AopProxy

实现类来通过不同的方式获取代理对象，就是一个简单的接口调用。

欢迎关注个人博客：blog.scarlettbai.com