spring-aop-ProxyFactoryBean 源码分析

在阅读本篇之前，请先阅读http://wangxinchun.iteye.com/blog/2079024，重复的逻辑，本篇不再进行分析～
在spring框架有一个鲜明的特点，一般的服务 都有编程式的和配置式的两种实现。
编程方式的使用往往比较明了，但是功能相对弱，使用不够简洁。配置式的往往能结合spring的ioc框架，提供更松散更强大的功能，兼容并蓄在spring框架在所有方面都表现的淋漓尽致。

相对于ProxyFactory 实现AOP拦截的方式，ProxyFactoryBean  是通过配置实现所有拦截功能。

使用case：
业务类

public interface LoginService {
	public boolean login(User user);
}
public class LoginServiceImpl implements LoginService {
	public boolean login(User user) {
		System.out.println(user);
		if (user == null) {
			return false;
		} else if (user.getUsername() == "xinchun.wang" && user.getPassword() == "123456") {
			return true;
		}
		return false;
	}
}

增强（Advice，Interceptor）

public class AfterAdvice1 implements AfterReturningAdvice{
	public void afterReturning(Object returnValue, Method method,
			Object[] args, Object target) throws Throwable {
		System.out.println("AfterAdvice1.afterReturning() execute ");
	}
}
public class AfterAdvice2 implements AfterReturningAdvice{
	public void afterReturning(Object returnValue, Method method,
			Object[] args, Object target) throws Throwable {
		System.out.println("AfterAdvice2.afterReturning() execute ");
	}
}

public class BeforeAdvice1 implements MethodBeforeAdvice{
	public void before(Method method, Object[] args, Object target)
			throws Throwable {
		System.out.println("BeforeAdvice1.before() execute ");
	}
}
public class BeforeAdvice2 implements MethodBeforeAdvice{
	public void before(Method method, Object[] args, Object target)
			throws Throwable {
		System.out.println("BeforeAdvice2.before() execute ");
	}
}

其他辅助工具代码：

public class BeanFactoryUtils implements BeanFactoryAware{
	private static BeanFactory beanFactory;
	public static BeanFactoryUtils getInstance(){
		return (BeanFactoryUtils)beanFactory.getBean("factoryUtil");
	}
	public void setBeanFactory(BeanFactory bf) throws BeansException {
        beanFactory = bf;		
	}
	public BeanFactory getBeanFactory() {
		return beanFactory;
	}
}

applicationContext.xml 配置

<bean id="afterAdvice1" class="com.qunar.service.AfterAdvice1" />
	<bean id="afterAdvice2" class="com.qunar.service.AfterAdvice2" />
	<bean id="beforeAdvice1" class="com.qunar.service.BeforeAdvice1" />
	<bean id="beforeAdvice2" class="com.qunar.service.BeforeAdvice1" />
<bean id="loginService" class="com.qunar.service.LoginServiceImpl"/>
	<bean id="factoryUtil" class=" com.qunar.util.BeanFactoryUtils" />
	<bean id="loginServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!--这里代理的是接口 -->
		<property name="proxyInterfaces">
			<value> com.qunar.service.LoginService</value>
		</property>
		<!--是ProxyFactoryBean要代理的目标类 -->
		<property name="target">
			<ref bean="loginService" />
		</property>
		<!--程序中的Advice -->
		<property name="interceptorNames">
			<list>
				<value>afterAdvice1</value>
				<value>afterAdvice2</value>
				<value>beforeAdvice1</value>
				<value>beforeAdvice2</value>
			</list>
		</property>
	</bean>

测试：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:META-INF/spring/applicationContext.xml"})
public class LoginServiceImplTest {
	@Test
	public void proxyLoginTest() {
		LoginService loginService = (LoginService)BeanFactoryUtils.getInstance().getBeanFactory().getBean("loginServiceProxy");
		loginService.login(new User("xinchun.wang","123456"));
	}
}

输出：
BeforeAdvice1.before() execute
BeforeAdvice1.before() execute
com.qunar.vo.User@111b910
AfterAdvice2.afterReturning() execute
AfterAdvice1.afterReturning() execute

概述：
ProxyFactoryBean 在继承体系上和ProxyFactory并没有太多差异，但是ProxyFactoryBean实现了 BeanFactoryAware BeanClassLoaderAware FactoryBean 三个接口，熟悉IOC容器的话，可以知晓ProxyFactoryBean 和IOC容器有了交融的地方了，ProxyFactoryBean 正是借助IOC容器的配置，找到Advice增强和target对象。
下面进入源码剖析

public class ProxyFactoryBean extends ProxyCreatorSupport
		implements FactoryBean<Object>, BeanClassLoaderAware, BeanFactoryAware {

	/**
	 * interceptor 名字的通配符
	 */
	public static final String GLOBAL_SUFFIX = "*";

	protected final Log logger = LogFactory.getLog(getClass());
  //拦截器的名字
	private String[] interceptorNames;
	//代理对象的名字
	private String targetName;

	private boolean autodetectInterfaces = true;

	private boolean singleton = true;
	//这个类在ProxyFactory 已经说过了，可以参考下。是做拦截器的解析的。
	private AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();

	private boolean freezeProxy = false;

	private transient ClassLoader proxyClassLoader = ClassUtils.getDefaultClassLoader();

	private transient boolean classLoaderConfigured = false;
  //IOC容器
	private transient BeanFactory beanFactory;

	/** Whether the advisor chain has already been initialized */
	private boolean advisorChainInitialized = false;

	/** 如果但是，singletonInstance 可以缓存  */
	private Object singletonInstance;


	/**
	 * 设置代理的接口，如果没有设置，那么会用cglib2做代理。
	 */
	public void setProxyInterfaces(Class[] proxyInterfaces) throws ClassNotFoundException {
		setInterfaces(proxyInterfaces);
	}

	/**
	  设置interceptorNames 拦截器的名字，但是这些名字必须在IOC容器里注册了。
	  interceptorNames 对应的名字的类型可以是 Interceptor, Advisor or Advice，
	  最后一项可以是IOC容器中的任何一个，如果他不是Advice 也不是 Advisor，会使用
	  SingletonTargetSource 进行包装这个对象，如果 target 或者 targetSource 或者targetName
	  设置了，那么 interceptorNames 只能包含 Advice/Advisor bean names.*/
	
	public void setInterceptorNames(String[] interceptorNames) {
		this.interceptorNames = interceptorNames;
	}

	/**
	 * 设置targetname
	 */
	public void setTargetName(String targetName) {
		this.targetName = targetName;
	}

	/**
	 * 设置是否自动检测接口，默认是true，如果为false，那么所有的借口都是cglib来代理。
	 */
	public void setAutodetectInterfaces(boolean autodetectInterfaces) {
		this.autodetectInterfaces = autodetectInterfaces;
	}

	/**
	 * 设置是否单件模式
	 */
	public void setSingleton(boolean singleton) {
		this.singleton = singleton;
	}

	/**
	 *you know。。。
	 */
	public void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry) {
		this.advisorAdapterRegistry = advisorAdapterRegistry;
	}

	@Override
	public void setFrozen(boolean frozen) {
		this.freezeProxy = frozen;
	}

	
	public void setProxyClassLoader(ClassLoader classLoader) {
		this.proxyClassLoader = classLoader;
		this.classLoaderConfigured = (classLoader != null);
	}

	public void setBeanClassLoader(ClassLoader classLoader) {
		if (!this.classLoaderConfigured) {
			this.proxyClassLoader = classLoader;
		}
	}
  //拥有了beanfacotry的能力了。
	public void setBeanFactory(BeanFactory beanFactory) {
		this.beanFactory = beanFactory;
		checkInterceptorNames();
	}


	/**
	 * 对象获取的输入，深入分析此处!!!
	 */
	public Object getObject() throws BeansException {
		initializeAdvisorChain(); //第一次获取会初始化注册的advice 并进行包装 为Advisor
		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(); //多例的情况
		}
	}


	public Class<?> getObjectType() {
		synchronized (this) {
			if (this.singletonInstance != null) {
				return this.singletonInstance.getClass();
			}
		}
		Class[] ifcs = getProxiedInterfaces();
		if (ifcs.length == 1) {
			return ifcs[0];
		}
		else if (ifcs.length > 1) {
			return createCompositeInterface(ifcs);
		}
		else if (this.targetName != null && this.beanFactory != null) {
			return this.beanFactory.getType(this.targetName);
		}
		else {
			return getTargetClass();
		}
	}

	public boolean isSingleton() {
		return this.singleton;
	}


	/**
	 *根据提供的接口列表，组装一个综合接口，实现所有的参数接口
	 */
	protected Class createCompositeInterface(Class[] interfaces) {
		return ClassUtils.createCompositeInterface(interfaces, this.proxyClassLoader);
	}

	/**
	 * 返回单例的代理对象
	 */
	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()); //创建单例 createAopProxy 里使用 AopProxyFactory 根据当前配置创建aop代理（这块的细节参考ProxyFactory的讲解）
		}
		return this.singletonInstance;
	}

	  //返回一个新的代理对象
	private synchronized Object newPrototypeInstance() {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating copy of prototype ProxyFactoryBean config: " + this);
		}
  
    // copy 一份当前ProxyFacotryBean的配置 getAopProxyFactory 返回的工厂是可以复用的，他没有状态
		ProxyCreatorSupport copy = new ProxyCreatorSupport(getAopProxyFactory());
		// The copy needs a fresh advisor chain, and a fresh TargetSource.
		TargetSource targetSource = freshTargetSource();
		copy.copyConfigurationFrom(this, targetSource, freshAdvisorChain()); //浅copy
		if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
			// Rely on AOP infrastructure to tell us what interfaces to proxy.
			copy.setInterfaces(
					ClassUtils.getAllInterfacesForClass(targetSource.getTargetClass(), this.proxyClassLoader));
		}
		copy.setFrozen(this.freezeProxy);

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

	/**
	 * 返回一个代理对象 AopProxy 有jdk 和cglib两种实现
	 */
	protected Object getProxy(AopProxy aopProxy) {
		return aopProxy.getProxy(this.proxyClassLoader);
	}

	/**
	 * 检查处理interceptorNames 最后一个配置 是否是advice 或者advisor ，否则设置为target
	 */
	private void checkInterceptorNames() {
		if (!ObjectUtils.isEmpty(this.interceptorNames)) {
			String finalName = this.interceptorNames[this.interceptorNames.length - 1];
			if (this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
				//如果最后一个对象是设置的tareget实例
				if (!finalName.endsWith(GLOBAL_SUFFIX) && !isNamedBeanAnAdvisorOrAdvice(finalName)) {
					// finalName 不是拦截器
					this.targetName = finalName;
					if (logger.isDebugEnabled()) {
						logger.debug("Bean with name '" + finalName + "' concluding interceptor chain " +
								"is not an advisor class: treating it as a target or TargetSource");
					}
					String[] newNames = new String[this.interceptorNames.length - 1];
					System.arraycopy(this.interceptorNames, 0, newNames, 0, newNames.length);
					this.interceptorNames = newNames;
				}
			}
		}
	}

	/**
	 * 判断是否是Advisor 或者Advice
	 */
	private boolean isNamedBeanAnAdvisorOrAdvice(String beanName) {
		Class namedBeanClass = this.beanFactory.getType(beanName);
		if (namedBeanClass != null) {
			return (Advisor.class.isAssignableFrom(namedBeanClass) || Advice.class.isAssignableFrom(namedBeanClass));
		}
		// Treat it as an target bean if we can't tell.
		if (logger.isDebugEnabled()) {
			logger.debug("Could not determine type of bean with name '" + beanName +
					"' - assuming it is neither an Advisor nor an Advice");
		}
		return false;
	}

	
	private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
		if (this.advisorChainInitialized) {
			return;
		}

		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));
			}

			// 如果指定了全局拦截器，那么必须显示指定targetSource 或者targetName
			if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&
					this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
				throw new AopConfigException("Target required after globals");
			}

			for (String name : this.interceptorNames) {
				if (logger.isTraceEnabled()) {
					logger.trace("Configuring advisor or advice '" + name + "'");
				}

				if (name.endsWith(GLOBAL_SUFFIX)) { //如果匹配后缀*
					if (!(this.beanFactory instanceof ListableBeanFactory)) {
						throw new AopConfigException(
								"Can only use global advisors or interceptors with a ListableBeanFactory");
					}
					addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
							name.substring(0, name.length() - GLOBAL_SUFFIX.length())); //添加通配的advisor
				}

				else {
					// 
					Object advice;
					if (this.singleton || this.beanFactory.isSingleton(name)) {
						// 如果是单例，直接添加 Advisor/Advice to the chain.
						advice = this.beanFactory.getBean(name); 
					}
					else {
						//生成一个占位的advisor
						advice = new PrototypePlaceholderAdvisor(name);
					}
					addAdvisorOnChainCreation(advice, name);
				}
			}
		}

		this.advisorChainInitialized = true;
	}


	/**
	 * 返回独立的 advisor 列表，每次创建prototype 实例的时候，都要
	 */
	private List<Advisor> freshAdvisorChain() {
		Advisor[] advisors = getAdvisors();
		List<Advisor> freshAdvisors = new ArrayList<Advisor>(advisors.length);
		for (Advisor advisor : advisors) {
			if (advisor instanceof PrototypePlaceholderAdvisor) { //如果是占位advisor实例
				PrototypePlaceholderAdvisor pa = (PrototypePlaceholderAdvisor) advisor;
				if (logger.isDebugEnabled()) {
					logger.debug("Refreshing bean named '" + pa.getBeanName() + "'");
				}
				if (this.beanFactory == null) {
					throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
							"- cannot resolve prototype advisor '" + pa.getBeanName() + "'");
				}
				Object bean = this.beanFactory.getBean(pa.getBeanName());
				Advisor refreshedAdvisor = namedBeanToAdvisor(bean);
				freshAdvisors.add(refreshedAdvisor);
			}
			else {
				// Add the shared instance.
				freshAdvisors.add(advisor);
			}
		}
		return freshAdvisors;
	}

	/**
	  增加全局的通知器
	 */
	private void addGlobalAdvisor(ListableBeanFactory beanFactory, String prefix) {
		String[] globalAdvisorNames =
				BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, Advisor.class); //找到所有Advisor
		String[] globalInterceptorNames =
				BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, Interceptor.class); //找到所有Interceptor
		List<Object> beans = new ArrayList<Object>(globalAdvisorNames.length + globalInterceptorNames.length);
		Map<Object, String> names = new HashMap<Object, String>(beans.size());
		for (String name : globalAdvisorNames) {
			Object bean = beanFactory.getBean(name);
			beans.add(bean);
			names.put(bean, name);
		}
		for (String name : globalInterceptorNames) {
			Object bean = beanFactory.getBean(name);
			beans.add(bean);
			names.put(bean, name);
		}
		OrderComparator.sort(beans); 
		for (Object bean : beans) {
			String name = names.get(bean);
			if (name.startsWith(prefix)) {
				addAdvisorOnChainCreation(bean, name);
			}
		}
	}

	/**
	 * 当advice 创建的时候，增加Advice到拦截器列表
	 */
	private void addAdvisorOnChainCreation(Object next, String name) {
		Advisor advisor = namedBeanToAdvisor(next);
		if (logger.isTraceEnabled()) {
			logger.trace("Adding advisor with name '" + name + "'");
		}			
		addAdvisor(advisor);
	}
	
	private TargetSource freshTargetSource() {
		if (this.targetName == null) {
			if (logger.isTraceEnabled()) {
				logger.trace("Not refreshing target: Bean name not specified in 'interceptorNames'.");
			}
			return this.targetSource;
		}
		else {
			if (this.beanFactory == null) {
				throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
						"- cannot resolve target with name '" + this.targetName + "'");
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Refreshing target with name '" + this.targetName + "'");
			}
			Object target = this.beanFactory.getBean(this.targetName);
			return (target instanceof TargetSource ? (TargetSource) target : new SingletonTargetSource(target));
		}
	}

	/**
	 * Advisor or Advice转换为 Advisor
	 */
	private Advisor namedBeanToAdvisor(Object next) {
		try {
			return this.advisorAdapterRegistry.wrap(next);
		}
		catch (UnknownAdviceTypeException ex) {
			throw new AopConfigException("Unknown advisor type " + next.getClass() +
					"; Can only include Advisor or Advice type beans in interceptorNames chain except for last entry," +
					"which may also be target or TargetSource", ex);
		}
	}

	@Override
	protected void adviceChanged() {
		super.adviceChanged();
		if (this.singleton) {
			logger.debug("Advice has changed; recaching singleton instance");
			synchronized (this) {
				this.singletonInstance = null;
			}
		}
	}



	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
		// Rely on default serialization; just initialize state after deserialization.
		ois.defaultReadObject();

		// Initialize transient fields.
		this.proxyClassLoader = ClassUtils.getDefaultClassLoader();
	}


	/**
	 * Used in the interceptor chain where we need to replace a bean with a prototype
	 * on creating a proxy.
	 */
	private static class PrototypePlaceholderAdvisor implements Advisor, Serializable {

		private final String beanName;

		private final String message;
		
		public PrototypePlaceholderAdvisor(String beanName) {
			this.beanName = beanName;
			this.message = "Placeholder for prototype Advisor/Advice with bean name '" + beanName + "'";
		}
		
		public String getBeanName() {
			return beanName;
		}
		
		public Advice getAdvice() {
			throw new UnsupportedOperationException("Cannot invoke methods: " + this.message);
		}
		
		public boolean isPerInstance() {
			throw new UnsupportedOperationException("Cannot invoke methods: " + this.message);
		}
		
		@Override
		public String toString() {
			return this.message;
		}
	}

}