Spring AOP-编程的方式创建代理类（ProxyFactoryBean）

先来了解Spring对代理相关的几个概念：

1.通知(Advice):

通知定义了切面是什么以及何时使用。描述了切面要完成的工作和何时需要执行这个工作。

2.连接点(Joinpoint):

程序能够应用通知的一个“时机”，这些“时机”就是连接点，例如方法被调用时、异常被抛出时等等。

3.切入点(Pointcut)

通知定义了切面要发生的“故事”和时间，那么切入点就定义了“故事”发生的地点，例如某个类或方法的名称，Spring中允许我们方便的用正则表达式来指定

4.切面(Aspect)

通知和切入点共同组成了切面：时间、地点和要发生的“故事”

5.引入(Introduction)

引入允许我们向现有的类添加新的方法和属性(Spring提供了一个方法注入的功能）

6.目标(Target)

即被通知的对象，如果没有AOP,那么它的逻辑将要交叉别的事务逻辑，有了AOP之后它可以只关注自己要做的事（AOP让他做爱做的事）

7.代理(proxy)

应用通知的对象，详细内容参见设计模式里面的代理模式

8.织入(Weaving)

把切面应用到目标对象来创建新的代理对象的过程

编程的方式实现Aop代理类的创建一定会用到这个类ProxyFactoryBean

首先看这个类的继承关系：



很简单的继承关系，下面我们直接从上往下介绍。

ProxyConfig（建造类，是一个实体类）

这个类是代理类的基本配置信息，都能配置什么信息，看成员变量就知道：

//要代理的类是接口还是实体类，这个决定是产生JDK动态代理还是CGLib代理
private boolean proxyTargetClass = false;

private boolean optimize = false;
//这个代理类能不能转换为Advised类来得到一些状态信息
boolean opaque = false;
//是否暴露
boolean exposeProxy = false;
//被“冻结”的话任何的advice都将不起作用
private boolean frozen = false;

AdvisedSupport

Base class for AOP proxy configuration managers.（代理类的配置管理类）：

/** The AdvisorChainFactory to use */
//用这个类去建造代理类
AdvisorChainFactory advisorChainFactory = new DefaultAdvisorChainFactory();
//子类中设置进来的接口类
private List<Class> interfaces = new ArrayList<Class>();
//当Advice添加进来的时候，被包装为Advisor
private List<Advisor> advisors = new LinkedList<Advisor>();
………………
//适配器更合适，将Advice转换为interceptor
public void setAdvisorChainFactory(AdvisorChainFactory advisorChainFactory) {
Assert.notNull(advisorChainFactory, "AdvisorChainFactory must not be null");
this.advisorChainFactory = advisorChainFactory;
}
//添加Advisor
public void addAdvisor(Advisor advisor) {
int pos = this.advisors.size();
addAdvisor(pos, advisor);
}

这个类功能很明显，就是实现Advised的功能，可以对代理类进行配置，而且继承ProxyConfig，可以对代理类创建过程进行设置。

ProxyCreatorSupport

作用：代理类产生的配置信息支持。这个类的主要功能点是持有

private AopProxyFactory aopProxyFactory;

的引用，这个类是代理类的生产工厂，而且这个类还添加了监听的支持

private List<AdvisedSupportListener> listeners

。

//用工厂产生代理类
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);

ProxyFactoryBean

作用：客户端直接打交道的类，设置代理类的配置信息。

………………
this.aopProxyFactory = new DefaultAopProxyFactory();
………………
//设置拦截器
public void setInterceptorNames(String[] interceptorNames) {
this.interceptorNames = interceptorNames;
}
//设置代理接口
public void setProxyInterfaces(Class[] proxyInterfaces) throws ClassNotFoundException {
setInterfaces(proxyInterfaces);
}
//设置目标类
public void setTargetName(String targetName) {
this.targetName = targetName;
}
//设置是否单例
public void setSingleton(boolean singleton) {
this.singleton = singleton;
}
//得到代理对象
public Object getObject() throws BeansException {
initializeAdvisorChain();
if (isSingleton()) {
//是单例的
return getSingletonInstance();
}
else {
//是多例的
return newPrototypeInstance();
}
}
//得到最终的代理类
protected Object getProxy(AopProxy aopProxy) {
return aopProxy.getProxy(this.proxyClassLoader);
}

这里补充得到多例的类代理的方法：

private synchronized Object newPrototypeInstance() {
ProxyCreatorSupport copy = new ProxyCreatorSupport(getAopProxyFactory());
// The copy needs a fresh advisor chain, and a fresh TargetSource.
//刷新bean工厂得到最新的name的bean，因为可能相同的名称但是不是一个bean了，所以重新得到重新配置
TargetSource targetSource = freshTargetSource();
copy.copyConfigurationFrom(this, targetSource, freshAdvisorChain());
if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProx
// Rely on AOP infrastructure to tell us what interfaces to proxy.
copy.setInterfaces(
ClassUtils.getAllInterfacesForClass(targetSource.getTargetClass(),
}
copy.setFrozen(this.freezeProxy);

if (logger.isTraceEnabled()) {
logger.trace("Using ProxyCreatorSupport copy: " + copy);
}
return getProxy(copy.createAopProxy());
}

其中createAopProxy（）方法调用的是父类ProxyCreatorSupport的方法，具体实现是负责生产代理对象AopProxy，子类负责调用

ProxyFactory 相当于工厂类自己又调用工厂类AopProxyFactory去完成 。

然后再转到DefaultAopProxyFactory看具体的建造过程：