【Spring源码解读】BeanFactory和FactoryBean区别及类装载源码解读

最近读代码读到Bean装载过程,顺带上网搜了下BeanFactory和FactoryBean,发现好多文章都讲的不清不楚,特此自己来整理了一份BeanFactory和FactoryBean的区别及讲下bean的装载和读取过程的源码.

    首先来看下BeanFactory和FactoryBean,借着例子作为入口来进行后面的源码分析.BeanFactory和FactoryBean的定义:

public interface FactoryBean<T> {
    T getObject() throws Exception;
    Class<?> getObjectType();
    boolean isSingleton();
}

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";//此属性后面会讲到
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);
}

    可以看到,二者的定义还比较相似,这里先直接说用法,实现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方法来返回实例.

总结:

1. FactoryBean其实就是一个简单工厂,实现其方法覆写getObject方法可以直接简易的实现工厂模式.
2. BeanFactory是Spring的核心接口,说白了其实也是采用了工厂模式,根据传入的不同bean名字,之后调用容器(如DefaultListableBeanFactory)返回具体的bean实例.我们常用的ClassPathXmlApplicationContext以及FileSystemXmlApplicationContext等都实现了此接口.

---

欢迎关注个人博客:blog.scarlettbai.com