【Spring原始碼解讀】BeanFactory和FactoryBean區別及類裝載原始碼解讀
阿新 • • 發佈：2019-01-23
最近讀程式碼讀到Bean裝載過程,順帶上網搜了下BeanFactory和FactoryBean,發現好多文章都講的不清不楚,特此自己來整理了一份BeanFactory和FactoryBean的區別及講下bean的裝載和讀取過程的原始碼.
首先來看下BeanFactory和FactoryBean,藉著例子作為入口來進行後面的原始碼分析.BeanFactory和FactoryBean的定義:
public interface FactoryBean<T> {
T getObject() throws Exception;
Class<?> getObjectType();
boolean 可以看到,二者的定義還比較相似,這裡先直接說用法,實現FactoryBean的類,在初始入容器後,通過BeanFactory的getBean方法呼叫時,會呼叫FactoryBean的getObject方法返回對應的類,而不是像普通的bean一樣直接返回bean例項.BeanFactory的常量&的作用是在獲取bean的時候直接返回FactoryBean的例項,而不是呼叫器的getObject方法返回對應的類,後面會有原始碼分析.
首先來看一個例子:
首先是具體物件:
public interface ICar {
void automaker();
}
public class Benz implements ICar {
public void automaker() {
System.out.println("I'm Benz");
}
}
public class VOLVO implements ICar {
public void automaker() {
System.out.println("I'm VOLVO");
}
}這裡就是定義物件,不多講,下面在applicationContext.xml中新增配置:
<bean id="carFactoryBean" class="org.white.test.web.test.CarFactoryBean" P:carEnum="BENZ"></bean>下面來看測試程式碼:
public class CarFactoryBeanTest {
private static final ApplicationContext CONTEXT = new ClassPathXmlApplicationContext(
"/META-INF/applicationContext.xml");
@Test
public void testFactoryBean() throws Exception {
ICar car = (ICar) CONTEXT.getBean("carFactoryBean");
car.automaker();
CarFactoryBean carFactoryBean = (CarFactoryBean) CONTEXT.getBean("&carFactoryBean");
carFactoryBean.getObject();
}
}執行結果:
I'm Benz
class org.white.test.web.test.CarFactoryBean通過例子可以看到結果就如上面所說.老子說,知其然並要知其所以然.下面我們就來通讀原始碼分析下bean的裝載和讀取.首先來看類圖:
這裡只講部分核心程式碼,其他過程就省略掉了,我們直接來看DefaultBeanDefinitionDocumentReader,此類實現自BeanDefinitionDocumentReader,負責從傳入的Element中解析出bean.Element的載入過程此處就不過多分析了,讀者可以看上面類圖,PathMatchingResourcePatternResolver負責根據我們傳入的xml路徑解析為Resource,之後由DefaultDocumentLoader獲取Document,讀者可以找程式碼看看.
//根據解析到的Element解析並註冊具體bean
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
NodeList nl = root.getChildNodes();
for (int i = 0; i < nl.getLength(); i++) {
Node node = nl.item(i);
if (node instanceof Element) {
Element ele = (Element) node;
if (delegate.isDefaultNamespace(ele)) {
//解析預設標籤
parseDefaultElement(ele, delegate);
}
else {
//解析自定義標籤
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}上述程式碼中的parseCustomElement()方法是解析自定義標籤,比如我們配置中的標籤,就是spring擴充套件的自定義標籤,會根據它的namespace即http://www.springframework.org/schema/context獲取對應的處理器處理,這個今天就不展開了,留著下次專門寫一篇自定義標籤的文章詳細給大家分析.
下面來看該類的另一個方法:
這裡根據ele的不同型別做不同處理
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//解析<import />屬性並載入匯入的xml裡的bean
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
//註冊bean別名
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
//註冊具體bean
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
//註冊beans
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
} 上面的方法解析出bean後要放入容器中,下面就是最核心的容器類DefaultListableBeanFactory
//bean容器,xml中的bean解析後會放入這裡
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);
//方法程式碼很多,其實很簡單,就是將bean放入容器中
//實現自BeanDefinitionRegistry,註冊具體bean,即將bean放入容器beanDefinitionMap中,後續取值從這裡取
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Validation of bean definition failed", ex);
}
}
BeanDefinition oldBeanDefinition;
oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
if (!isAllowBeanDefinitionOverriding()) {
throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
"': There is already [" + oldBeanDefinition + "] bound.");
}
else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
if (this.logger.isWarnEnabled()) {
this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
"' with a framework-generated bean definition: replacing [" +
oldBeanDefinition + "] with [" + beanDefinition + "]");
}
}
else if (!beanDefinition.equals(oldBeanDefinition)) {
if (this.logger.isInfoEnabled()) {
this.logger.info("Overriding bean definition for bean '" + beanName +
"' with a different definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
else {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Overriding bean definition for bean '" + beanName +
"' with an equivalent definition: replacing [" + oldBeanDefinition +
"] with [" + beanDefinition + "]");
}
}
this.beanDefinitionMap.put(beanName, beanDefinition);
}
else {
if (hasBeanCreationStarted()) {
// Cannot modify startup-time collection elements anymore (for stable iteration)
synchronized (this.beanDefinitionMap) {
this.beanDefinitionMap.put(beanName, beanDefinition);
List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
else {
// Still in startup registration phase
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
resetBeanDefinition(beanName);
}
}上面就是初始化的bean裝載過程.
下面來看bean的例項化:
看AbstractBeanFactory類中如下程式碼:
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
//注意這裡,如果我們的bean滿足:
//1.沒有實現FactoryBean 2.isFactoryDereference方法是判定是否以&符號開頭
//滿足則直接返回例項.否則則會走下面的邏輯 所以這裡就是BeanFactory中常量&的用法
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}上面方法會繼續呼叫到下面方法:
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
//呼叫FactoryBean的getObject方法來返回例項
return factory.getObject();
}
}, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
//呼叫FactoryBean的getObject方法來返回例項
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
if (object == null && isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
return object;
}上面註釋已經說明了,最終其實會呼叫FactoryBean的getObject方法來返回例項.
總結:
- FactoryBean其實就是一個簡單工廠,實現其方法覆寫getObject方法可以直接簡易的實現工廠模式.
- BeanFactory是Spring的核心介面,說白了其實也是採用了工廠模式,根據傳入的不同bean名字,之後呼叫容器(如DefaultListableBeanFactory)返回具體的bean例項.我們常用的
ClassPathXmlApplicationContext以及FileSystemXmlApplicationContext等都實現了此介面.
歡迎關注個人部落格:blog.scarlettbai.com