Spring AOP 代理对象的生成 part3

这一节我们探究一下在Spring AOP中目标对象的代理对象的生成过程。

我们会设计到三个主要的类：

ProxyFactoryBean

ProxyCreatorSupport

AdvisedSupport

从上到下时继承的关系。为便于区分我们称之为子类ProxyFactoryBean，父类ProxyCreatorSupport和祖类AdvisedSupport。

生成代理对象过程从子类ProxyFactoryBean开始的。

这个一个FactoryBean，我们会在配置文件中配置这个bean，通过这个bean获取代理对象的。因为的他名字就是代理工厂Bean。

获取代理对象是通过getObject方法，我们把对目标对象的增强都封装在了这个方法中。

@Override
public Object getObject() throws BeansException {
initializeAdvisorChain();
if (isSingleton()) {
return getSingletonInstance();
}
else {
if (this.targetName == null) {
logger.warn("Using non-singleton proxies with singleton targets is often undesirable. " +
"Enable prototype proxies by setting the 'targetName' property.");
}
return newPrototypeInstance();
}
}

在这个方法开始的时候，有一个方法initializeAdvisorChain，这个是用来初始化通知器链的方法。

一、初始化通知器链的过程

在初始化通知器链的过程时，spring会读取配置文件，获得通知器链的名字，然后根据名字，通过getBean方法，获得它的实例。

然后将实例保存起来，具体的保存时通过下面的这个方法：

addAdvisorOnChainCreation(advice, name);
private void addAdvisorOnChainCreation(Object next, String name) {
// We need to convert to an Advisor if necessary so that our source reference
// matches what we find from superclass interceptors.
Advisor advisor = namedBeanToAdvisor(next);
if (logger.isTraceEnabled()) {
logger.trace("Adding advisor with name '" + name + "'");
}
addAdvisor(advisor);
}

主要调用的方法就是addAdvisor(advisor);很简单。

不过这个方法是祖类AdvisedSupport中定义的。

AdvisedSupport中有一个Linkedlist属性，用于存放通知器。它是私有的。

public void addAdvisor(Advisor advisor) {
int pos = this.advisors.size();
addAdvisor(pos, advisor);
}
@Override
public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
if (advisor instanceof IntroductionAdvisor) {
validateIntroductionAdvisor((IntroductionAdvisor) advisor);
}
addAdvisorInternal(pos, advisor);
}
private void addAdvisorInternal(int pos, Advisor advisor) throws AopConfigException {
Assert.notNull(advisor, "Advisor must not be null");
if (isFrozen()) {
throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
}
if (pos > this.advisors.size()) {
throw new IllegalArgumentException(
"Illegal position " + pos + " in advisor list with size " + this.advisors.size());
}

this.advisors.add(pos, advisor);
updateAdvisorArray();
adviceChanged();
}

此时就将通知器保存进了AdvisedSupport中，后面还会用到，具体是下一篇博客。

通知器链初始完成之后，就开始生成代理对象了。

二、生成代理对象

在getObject 中我们看到，根据目标对象是否是单例提供两种生成代理对象的方式。

我们首先看单例模式的情况:getSingletonInstance();

private synchronized Object getSingletonInstance() {
if (this.singletonInstance == null) {
this.targetSource = freshTargetSource();
if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
// Rely on AOP infrastructure to tell us what interfaces to proxy.
Class<?> targetClass = getTargetClass();
if (targetClass == null) {
throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
}
setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
}
// Initialize the shared singleton instance.
super.setFrozen(this.freezeProxy);
this.singletonInstance = getProxy(createAopProxy());
}
return this.singletonInstance;
}

主要看最后一行this.singletonInstance = getProxy(createAopProxy());代码。

getProxy的实现如下：

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

此时有一个类AopProxy，这个类就是spring中负责生产代理对象的类。准确的说这是一个接口。具体工作是由他的实现类完成的。

在Spring中还提供了一个生成这个AopProxy实现类的工厂类：AopProxyFactory 。其实这个AopProxyFactory 也是一个接口。

所以，在这个地方spring使用的时抽象工厂模式。在spring中AopProxyFactory 只有一个实现类DefaultAopProxyFactory。

AopProxy由两个直接的实现类JdkDynamicAopProxy和ObjenesisCglibAopProxy。

总结一下就是：由DefaultAopProxyFactory负责生成两个AopProxy。由JdkDynamicAopProxy和ObjenesisCglibAopProxy负责生成代理对象。

逻辑表述完毕。我们看下源码实现。

这行代码有一个参数createAopProxy()

this.singletonInstance = getProxy(createAopProxy());

我们看下这个方法createAopProxy()

这个方法定义在 父类ProxyCreatorSupport中了

protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}

我们解释一下，createAopProxy 这个方法就是创建AopProxy，刚才我们表述过，这个是由AopProxyFactory 工厂创建的。

Ok，我们需要继续看getAopProxyFactory（）这个方法，获取AopProxyFactory 工厂的方法。

public AopProxyFactory getAopProxyFactory() {
return this.aopProxyFactory;
}

这个方法很简单，返回本身的aopProxyFactory对象，这个又是什么呢，我们看ProxyCreatorSupport父类的构造函数：

public ProxyCreatorSupport() {
this.aopProxyFactory = new DefaultAopProxyFactory();
}

我们发现就是默认的DefaultAopProxyFactory 工厂类。

那么createAopProxy(this); 这个方法就是DefaultAopProxyFactory 类中的方法了。

我们看下这个方法：

@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
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.");
}
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
else {
return new JdkDynamicAopProxy(config);
}
}

在这个方法中我们看到了两个AopProxy实现类的创建过程。

我们还看这个createAopProxy(this);他传递的参数时this

他是自然ProxyCreatorSupport这个类的一个实例。

由于ProxyCreatorSupport是AdvisedSupport 子类，所以这个参数就可以理解了。为什么要传递这个AdvisedSupport 参数我们等下说明。

现在我们假设创建的类是JdkDynamicAopProxy；

这个类是用来创建代理对象的，我们看下这个方法aopProxy.getProxy(this.proxyClassLoader);

那么getProxy 就是JdkDynamicAopProxy中的方法：

@Override
public Object getProxy(ClassLoader classLoader) {
……
return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
}

这个是上一博客讲的jdk生成代理对象的方法。现在我们来看此处的三个参数：

第一个ClassLoader ，AOP使用了一个默认的ClassLoader 。事实上我们使用任何一个类都可以得到ClassLoader 。这个目标对象无关。

proxiedInterfaces 这个参数就是需要从AdvisedSupport中获取的。在这个getSingletonInstance() 方法最开始时，有一个方法 setInterfaces，这个方法在AdvisedSupport中定义，就是将接口信息保存进了AdvisedSupport中list中。这也是在createAopProxy(this);方法传递this，即传递AdvisedSupport的原因。

第三个this：此处的this 就是JdkDynamicAopProxy，因为这个类实现了InvocationHandler这个接口这就意味着 在JdkDynamicAopProxy 还有一个invoke方法。我们稍后分析这个方法，在下一篇博客中分析。以我们刚才的分析，此时生成了目标对象的代理对象。