Spring有很多Scope，比如Singleton，Prototype，Request，Session，SpringCloud又新增了Thread，Refresh。預設的Scope是Singleton，Spring容器內最多的就是Singleton型別的Bean了，但其他不同型別的Scope在特定的場合也有特殊的作用。
Spring對非Singleton的Scode都使用了代理機制，這篇部落格主要是講解針對Scope的代理機制和不同Scope的Bean是如何具備不同的特性的。

Spring在解析標識@Scope註解的Bean時，會執行如下程式碼：

public abstract class ScopedProxyUtils
 
 {

	/** 
	 * 先定義一個ScopedProxyFactoryBean型別的BeanDefinition，其是一個FactoryBean，getObject（） 方法返回的是一個Cglib生成的代理物件
	 * 通過Cglib為Scope的Bean生成代理物件，這個ProxyBean是Singleton型別的Bean，容器內其他Bean依賴得到的就是這個代理物件
	 * 這樣Spring容器內的Bean就能在初始化時就依賴非Singleton型別的Bean了，而不需要每次都用BeanFactory去獲取
	 */
	public static BeanDefinitionHolder createScopedProxy
 
(BeanDefinitionHolder definition,
			BeanDefinitionRegistry registry, boolean proxyTargetClass) {

		String originalBeanName = definition.getBeanName();
		BeanDefinition targetDefinition = definition.getBeanDefinition();
		String targetBeanName = getTargetBeanName(originalBeanName);

		// Create a scoped proxy definition for the original bean name,
 

		// "hiding" the target bean in an internal target definition.
		// 使用ScopedProxyFactoryBean包裝原始的BeanClass
		RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
		......
		// Register the target bean as separate bean in the factory.
		registry.registerBeanDefinition(targetBeanName, targetDefinition);

		// Return the scoped proxy definition as primary bean definition
		// (potentially an inner bean).
		return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
	}

}

下面看看ScopedProxyFactoryBean內部關鍵程式碼：

public class ScopedProxyFactoryBean extends ProxyConfig implements FactoryBean<Object>, BeanFactoryAware {

	/** The TargetSource that manages scoping，關鍵程式碼，AOP動態代理時被代理物件的來源類 */
	private final SimpleBeanTargetSource scopedTargetSource = new SimpleBeanTargetSource();

	/** The cached singleton proxy */
	private Object proxy;
	
	@Override
	public void setBeanFactory(BeanFactory beanFactory) {
		if (!(beanFactory instanceof ConfigurableBeanFactory)) {
			throw new IllegalStateException("Not running in a ConfigurableBeanFactory: " + beanFactory);
		}
		ConfigurableBeanFactory cbf = (ConfigurableBeanFactory) beanFactory;
		
		// 將BeanFactory設定入TargetSource，也就是動態代理時被代理物件的來源
		this.scopedTargetSource.setBeanFactory(beanFactory);

		ProxyFactory pf = new ProxyFactory();
		pf.copyFrom(this);
		pf.setTargetSource(this.scopedTargetSource);
		......
		this.proxy = pf.getProxy(cbf.getBeanClassLoader());
	}


	@Override
	public Object getObject() {
		if (this.proxy == null) {
			throw new FactoryBeanNotInitializedException();
		}
		return this.proxy;  // 其他Bean依賴Scope Bean時得到的是被代理物件
	}

}

通過對一個@RequestScope標識的Class，例項化後生成的Bean格式如下：

targetSource代表這個物件代理的Bean；
advisorArray標識當前代理物件織入了多少個切面，當前Bean只有一個，DefaultIntroductionAdvisor；
這個切面的作用主要是將BeanName設定入Joinpoint中：

public abstract class ExposeBeanNameAdvisors {

	 /**
	 * Create a new advisor that will expose the given bean name, introducing
	 * the NamedBean interface to make the bean name accessible without forcing
	 * the target object to be aware of this Spring IoC concept.
	 * @param beanName the bean name to expose
	 */
	public static Advisor createAdvisorIntroducingNamedBean(String beanName) {
		// 對外暴露BeanName的Advisor
		return new DefaultIntroductionAdvisor(new ExposeBeanNameIntroduction(beanName));
	}

}
 

之後就直接執行被代理物件的方法。

當然我們也可以對非Singleton型別的Bean做AOP代理，這樣advisorArray裡面就會生成額外的切面物件，感興趣的可以自行嘗試。

AOP代理裡還有一個重要元件，TargetSource，也就是被代理物件的來源：

// 動態的切面攔截器，AOP代理物件都會走進其 #intercept 方法，織入Advisor
private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {
	private final AdvisedSupport advised;
	
	//  獲取被代理物件
	protected Object getTarget() throws Exception {
		return this.advised.getTargetSource().getTarget();
	}

}

之前在看ScopedProxyFactoryBean原始碼時，其內部的TargetSource例項是：SimpleBeanTargetSource，看其原始碼：

public class SimpleBeanTargetSource extends AbstractBeanFactoryBasedTargetSource {

	@Override
	public Object getTarget() throws Exception {
		// 每次執行代理物件的方法時，都從BeanFactory處獲取指定名稱的Scope Bean
		return getBeanFactory().getBean(getTargetBeanName());
	}

}

每次通過代理物件執行原始Bean的方法時，都會從BeanFactory處獲取Scope Bean（注意不是Scope Bean 內部呼叫），接下來看看BeanFactory對非Singleton型別的Bean的獲取方式程式碼：

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

	protected <T> T doGetBean(final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
				......
				// Create bean instance.
				if (mbd.isSingleton()) {
					......
				}

				else if (mbd.isPrototype()) {     // 如果是Prototype型別的Bean，每次getBean( ) 都new一個
					// It's a prototype -> create a new instance.
					Object prototypeInstance = null;
					try {
						beforePrototypeCreation(beanName);
						prototypeInstance = createBean(beanName, mbd, args);
					}
					finally {
						afterPrototypeCreation(beanName);
					}
					bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
				}

				else {       // 非Singleton，Prototype型別的Bean
					String scopeName = mbd.getScope();
					final Scope scope = this.scopes.get(scopeName);    // 獲取對應Scope的處理器
					if (scope == null) {
						throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
					}
					try {
						// 通過Scope處理器的get( ) 方法獲取Bean例項，同時將new Bean的操作封裝成一個回撥函式，
						// 由Scope處理器來決定是否建立一個新的Bean
						Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
							@Override
							public Object getObject() throws BeansException {
								beforePrototypeCreation(beanName);
								try {
									return createBean(beanName, mbd, args);
								}
								finally {
									afterPrototypeCreation(beanName);
								}
							}
						});
						bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
					}
				}
		......
}

到了這裡，結合之前的程式碼和講解，應該能很容易的看明白不同非Singleton型別的Bean的代理機制和內部實現了，Scope型別有不少，我就不一一去詳細的解釋原始碼了， 接下來我針對每個Scope做個總結：

• Request：從RequestContextHolder獲取ThreadLocal型別的RequestAttributes，正常情況下返回ServletRequestAttributes型別的物件，裡面封裝了HttpServletRequest，HttpServletResponse等Http請求相關的物件。當Spring接收到一個Http請求時，會將請求相關物件封裝成一個ServletRequestAttributes，設定到RequestContextHolder裡。如果獲取ServletRequestAttributes時返回null，也就是Spring還沒有接收到Http請求，比如Spring容器初始化時。那麼就會丟擲異常。如果獲取ServletRequestAttributes，但是沒有獲取到此Bean，那麼通過ObjectFactory的回撥函式new一個Bean，然後設定到ServletRequestAttributes裡，實際就是設定到HttpServletRequest裡。也就是說Request Scope 型別的物件不能在容器初始化時呼叫其方法，但是能引用到Scope的代理物件；不要非同步的獲取Request Scope型別的Bean；在一次Http請求中，多次獲取到的相同名稱的Request Scope Bean是同一個物件。
• Session：作用機制與Request類似，也是從ServletRequestAttributes裡獲取的，當不存在時new一個，設定到Session中，注意事項與Request也一致。
• Thread：通過ThreadLocalScopeCache 來管理Thread型別的Bean，每個執行緒都持有一個ConcurrentMap<String, Object>用於儲存Thread Bean，key就是BeanName，value就是Thread Bean，當不存在時通過ObjectFactory new 一個。對於執行緒複用情況下，記得手動清理之前的ThreadLocalCache。
• Refresh：也提供了Cache機制，當第一次get時，通過ObjectFactory建立一個，然後快取起來，之後每次獲取都先從快取中獲取，如果不存在，再通過ObjectFactory建立。同時可以通過ContextRefresher 清空所有快取，這樣下次獲取的Refresh Bean就是重新生成的。當一個Bean裡的持有Spring Environment的一些資訊，且這些資料是可配置，動態重新整理的，那麼使用@RefreshScope標識Bean，同時搭配ContextRefresher就能在配置更新後動態的更新這些物件，保證配置資訊能夠實時的起作用。