在Spring AOP实现中，使用的核心技术是动态代理，而这种动态代理实际上是JDK的一个特性(在JDK 1.3以上的版本里，实现了动态代理模式)。通过JDK的动态代理特性，可以为任意Java对象创建代理对象，对于具体使用来说，这个特性是通过Java Reflection API来完成的。
看此篇文章之前，可以先看看 JDK动态代理机制，对动态代理有个基础的了解先。
设计原理
以ProxyFactory的设计为中心，可以看到相关的类继承关系如图所示：
ProxyConfig里面封装了数据，为子类提供配置属性。AdvisedSupport封装了AOP对通知Advice（Advice）和通知器（Advisor）的相关操作。这些操作对于不同的AOP的代理对象的生成都是一样的。但对于其体的AOP代理对象的创建，AdvisedSupport把它交始它的子类们去完成。- 对于
ProxyCreatorSupport.可以将它看成是其子类创建AOP代理对象的一个辅助类。通过继承以上提到的‘类的功能实现。 - 具体的AOP代理对象的生成，根据不同的需要，分别由
ProxyFactoryBean,AspcctiProxyFactory和ProxyFactory来完成。对于需要使用AspectJ的AOP应用，AspectJProxyFactory起到集成Spring和AspectJ的作用。对于使用Spring AOP的应用，ProxyFactoryBean和ProxyFactoy都提供了AOP功能的封装。
ProxyFactoryBean生成AopProxy代理对象
ProxyFactoryBean的^OP实现需要依翰JDK或者CGLIB提供的Proxy特性。从FactoryBean中获取对象.是以getObject()方法作为入口完成的。
先看AopProxy生成过程的时序图：
从ProxyFactoryBean的入口getObject()开始：
public Object getObject() throws BeansException {
//初始化通知链
this.initializeAdvisorChain();
//这里对Singleton和prototype的类型进行区分，生成对应的proxy
if (this.isSingleton()) {
return this.getSingletonInstance(); //生成singleton的代理对象
} else {
if (this.targetName == null) {
this.logger.warn("Using non-singleton proxies with singleton targets is often undesirable. Enable prototype proxies by setting the 'targetName' property.");
}
return this.newPrototypeInstance(); //生成prototype的代理对象
}
}
//初始化通知链
private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
if (!this.advisorChainInitialized) {
if (!ObjectUtils.isEmpty(this.interceptorNames)) {
if (this.beanFactory == null) {
throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) - cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
}
if (this.interceptorNames[this.interceptorNames.length - 1].endsWith("*") && this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
throw new AopConfigException("Target required after globals");
}
String[] var1 = this.interceptorNames;
int var2 = var1.length;
//添加advisors 链的调用，通过interceptorNames属性进行配置，interceptorNames通过IoC从配置bean中读取而来
for(int var3 = 0; var3 < var2; ++var3) {
String name = var1[var3];
if (this.logger.isTraceEnabled()) {
this.logger.trace("Configuring advisor or advice '" + name + "'");
}
if (name.endsWith("*")) {
if (!(this.beanFactory instanceof ListableBeanFactory)) {
throw new AopConfigException("Can only use global advisors or interceptors with a ListableBeanFactory");
}
this.addGlobalAdvisor((ListableBeanFactory)this.beanFactory, name.substring(0, name.length() - "*".length()));
} else {
Object advice;
if (!this.singleton && !this.beanFactory.isSingleton(name)) {
advice = new ProxyFactoryBean.PrototypePlaceholderAdvisor(name);
} else {
advice = this.beanFactory.getBean(name);
}
this.addAdvisorOnChainCreation(advice, name);
}
}
}
this.advisorChainInitialized = true;
}
//生成singleton的代理对象
private synchronized Object getSingletonInstance() {
if (this.singletonInstance == null) {
this.targetSource = this.freshTargetSource();
if (this.autodetectInterfaces && this.getProxiedInterfaces().length == 0 && !this.isProxyTargetClass()) {
//根据AOP框架来判断需要代理的接口
Class<?> targetClass = this.getTargetClass();
if (targetClass == null) {
throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
}
//设置代理对象的接口
this.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
}
super.setFrozen(this.freezeProxy);
//使用ProxyFactory来生成需要的Proxy, createAopProxy是其父亲中实现的方法
this.singletonInstance = this.getProxy(this.createAopProxy());
}
return this.singletonInstance;
}
//通过createAopProxy返回的AopProxy来得到代理对象
protected Object getProxy(AopProxy aopProxy) {
return aopProxy.getProxy(this.proxyClassLoader);
}看看ProxyCreatorSupport的创建AopProxy对象：
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
this.activate();
}
//使用AopProxyFactory来取得AopProxy对象，AopProxyFactory是在构造函数中定义的，用的是DefaultAopProxyFactory
return this.getAopProxyFactory().createAopProxy(this);
}
public ProxyCreatorSupport() {
this.aopProxyFactory = new DefaultAopProxyFactory();
}接着是DefaultAopProxyFactory中的createAopProxy：
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
return new JdkDynamicAopProxy(config);
} else {
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.");
} else {
//如果targetClass是接口，使用JDK来生成，否者使用CGLIB来生成
return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
}
}
}通过上面的时序图和源码分析，可以看出ProxyFactoryBean生成AopProxy代理对象的基本过程。
前面介绍的ProxyFactoryBean在AopProxy代理对象和IoC容器配置之间起到了桥梁的作用。AopProxy代理对象可以由JDK或CGLIB来生成。而JdkDynamicAopProxy和CglibAopProxy实现的都是通过AopProxy接口。他们的继承关系如下：
JDK生成AopProxy代理对象
源码如下：
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
}
//从advised对象中取得代理对象的代理接口配置
Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
this.findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
//调用JDK生成代理对象
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}
在生成代理对象时，需要指明三个参数，一个是类装载器，一个是代理接口，另外一个就是Proxy回调方法所在的对象，这个对象需要实现InvocationHandler接口。
CGLIB生成AopProxy代理对象
源码如下：
public Object getProxy(@Nullable ClassLoader classLoader) {
if (logger.isDebugEnabled()) {
logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
}
//从advised中取得在IoC容器中配里的target对象
try {
Class<?> rootClass = this.advised.getTargetClass();
Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
Class<?> proxySuperClass = rootClass;
int x;
if (ClassUtils.isCglibProxyClass(rootClass)) {
proxySuperClass = rootClass.getSuperclass();
Class<?>[] additionalInterfaces = rootClass.getInterfaces();
Class[] var5 = additionalInterfaces;
int var6 = additionalInterfaces.length;
for(x = 0; x < var6; ++x) {
Class<?> additionalInterface = var5[x];
this.advised.addInterface(additionalInterface);
}
}
this.validateClassIfNecessary(proxySuperClass, classLoader);
//验证代理对象的接口设置
//创建并配置CGLIB的Enhancer.这个Enhancer对象是CGLIB的主要操作类
Enhancer enhancer = this.createEnhancer();
if (classLoader != null) {
enhancer.setClassLoader(classLoader);
if (classLoader instanceof SmartClassLoader && ((SmartClassLoader)classLoader).isClassReloadable(proxySuperClass)) {
enhancer.setUseCache(false);
}
}
//设置Enhancer对象，包括设置代理接口，回调方法
//来自advised的IoC配置，比如使用AOP的DynamicAdvisedlnterceptor拦截器
enhancer.setSuperclass(proxySuperClass);
enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
enhancer.setStrategy(new CglibAopProxy.ClassLoaderAwareUndeclaredThrowableStrategy(classLoader));
Callback[] callbacks = this.getCallbacks(rootClass);
Class<?>[] types = new Class[callbacks.length];
for(x = 0; x < types.length; ++x) {
types[x] = callbacks[x].getClass();
}
enhancer.setCallbackFilter(new CglibAopProxy.ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
enhancer.setCallbackTypes(types);
//通过Enhancer生成代理对象
return this.createProxyClassAndInstance(enhancer, callbacks);
} catch (IllegalArgumentException | CodeGenerationException var9) {
throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() + ": Common causes of this problem include using a final class or a non-visible class", var9);
} catch (Throwable var10) {
throw new AopConfigException("Unexpected AOP exception", var10);
}
}