spring（三）: 可配置的Spring

ConfigurableBeanFactory

具体代码请查看:litespring_04
我们为了让spring变得可配置，增加了一个ConfigurableBeanFactory接口：

public interface ConfigurableBeanFactory extends BeanFactory {
    //设置classLoader
    void setBeanClassLoader(ClassLoader classLoader);
    //获取classLoader
    ClassLoader getBeanClassLoader();

}

此时ApplicationContext继承ConfigurableBeanFactory，DefaultBeanFactory实现ConfigurableBeanFactory。并实现ConfigurableBeanFactory中的两个方法：

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.beanClassLoader = classLoader;
    }

    @Override
    public ClassLoader getBeanClassLoader() {
        return (this.beanClassLoader != null ? this.beanClassLoader : ClassUtils.getDefaultClassLoader());
    }

同时把之前需要用到classLoader的地方也相应做一些变更。例如ClassPathXmlApplicationContext的getReourceByPath方法等。
做完这些，我们就可以配置spring的classLoader了，此时我们再运行一下测试用例也是可以通过的，证明此时并没有破坏我们的功能。

SingletonBean

实现创建的bean为单例的。首先我们来写一个测试用例：

    @Test
    public void testGetBean(){
        //开始解析xml，并把解析结果存入bean的注册类中
        reader.loadBeanDefinitions( resource );
        //通过beanId获取bean的定义
        BeanDefinition bd = factory.getBeanDefinition("petStore");

        Assert.assertTrue(bd.isSingleton());
        Assert.assertFalse(bd.isPrototype());
        Assert.assertEquals(BeanDefinition.SCOPE_DEFAULT,bd.getScope());

        //断言bean的ClassName正确
        Assert.assertEquals("org.litespring.service.v1.PetStoreService",bd.getBeanClassName());
        //根据bean的id获取Bean
        PetStoreService petStore = (PetStoreService) factory.getBean("petStore");
        //断言获取到bean了。
        Assert.assertNotNull(petStore);

        PetStoreService petStore1 = (PetStoreService) factory.getBean("petStore");
        Assert.assertTrue(petStore.equals(petStore1));
    }

首先为们先消除一下编译错误，把相关方法以及属性加在bean的定义类中。

public interface BeanDefinition {

    public static final String SCOPE_SINGLETON = "singleton";
    public static final String SCOPE_PROTOTYPE = "prototype";
    public static final String SCOPE_DEFAULT = "";

    /**
     * 获取bean定义中的className
     * @return
     */
    String getBeanClassName();

    /**
     * 单例
     * @return
     */
    public boolean isSingleton();

    /**
     * 总是创建一个新的bean
     * @return
     */
    public boolean isPrototype();

    /**
     * 获取scope
     * @return
     */
    String getScope();

    /**
     * 设置scope
     * @param scope
     */
    void setScope(String scope);
}

接下来我们实现这些方法。

public class GenericBeanDefinition implements BeanDefinition{

    private String id;

    private Class<?> beanClass;

    private boolean singleton = true;
    private boolean prototype = false;
    private String scope = SCOPE_DEFAULT;

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

    @Override
    public boolean isPrototype() {
        return this.prototype;
    }

    @Override
    public String getScope() {
        return this.scope;
    }

    @Override
    public void setScope(String scope) {
        this.scope = scope;
        this.singleton = SCOPE_SINGLETON.equals(scope) || SCOPE_DEFAULT.equals(scope);
        this.prototype = SCOPE_PROTOTYPE.equals(scope);
    }

    private String beanClassName;

    public GenericBeanDefinition(String id,String beanClassName) {
        this.id = id;
        this.beanClassName = beanClassName;
    }

    /**
     * 获取bean定义中的className
     * @return className
     */
    public String getBeanClassName() {
        return this.beanClassName;
    }

}

现在我们完成了BeanDefintion的代码。接下来我们需要把xml的scope解析到BeanDefintion中，而xml的解析是在XmlBeanDefintionReader中进行的，所以我们稍微修改一下loadBeanDefintions方法：

public static final String SCOPE_ATTRIBUTE = "scope";

public void loadBeanDefinitions(Resource resource ){
        InputStream is = null;
        try {
            is = resource.getInputStream();
/*            //获取默认类加载器
            ClassLoader cl = ClassUtils.getDefaultClassLoader();
            //读取文件
            is = cl.getResourceAsStream(configFile);*/
            SAXReader reader = new SAXReader();
            Document doc = null;
            doc = reader.read(is);
            // 获取<beans>
            Element root = doc.getRootElement();
            Iterator<Element> iterator = root.elementIterator();
            //遍历所有<bean>,并把信息注册到registry中
            while (iterator.hasNext()){
                Element element = (Element)iterator.next();
                String id = element.attributeValue(ID_ATTRIBUTE);
                String beanClassName = element.attributeValue(CLASS_ATTRIBUTE);
                BeanDefinition bd = new GenericBeanDefinition(id,beanClassName);
                if (null != element.attribute( SCOPE_ATTRIBUTE )){
                    bd.setScope( element.attributeValue( SCOPE_ATTRIBUTE ) );
                }

                this.registry.registerBeanDefinition(id,bd);
            }
        } catch (DocumentException | IOException e) {
            throw new BeanDefinitionStoreException("IOException parsing XML document",e);
        } finally {
            if (is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

现在我们就完成从xml解析到BeanDefintion的过程。接下来我们就要真正的实现创建SingleBean了。
这里我们提供一个SingletonBeanRegistry接口让它来实现singleton功能，创建DefaultSingletonBeanRegistry去实现接口，并让DefaultBeanFactory继承DefaultSingletonBeanRegistry。
SingletonBeanRegistry如下：

public interface SingletonBeanRegistry {

    /**
     * 注册单例
     * @param beanName
     * @param singletonObject
     */
    void registerSingleton(String beanName,Object singletonObject);

    /**
     * 获取单例的bean
     * @param beanName
     */
    Object getSingleton(String beanName);
}

DefaultSingletonBeanRegistry如下:

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {

    private final Map<String,Object> singletonObjects = new ConcurrentHashMap<String,Object>(64);

    /**
     * 注册单例
     * @param beanName
     * @param singletonObject
     */
    @Override
    public void registerSingleton(String beanName, Object singletonObject) {
        Assert.notNull(beanName," 'beanName' must not be null ");
        Object oldObject = this.singletonObjects.get(beanName);
        if (oldObject != null){
            throw new IllegalStateException("Could not register object [" + singletonObject +
                    "] under bean name '" + beanName + "': there is already object [" + oldObject);
        }
        this.singletonObjects.put(beanName,singletonObject);
    }

    @Override
    public Object getSingleton(String beanName) {
        return this.singletonObjects.get(beanName);
    }
}

DefaultSingletonBeanRegistry完成了单例bean的保存和获取。接下来我们需要稍微改动一下DefaultBeanFactory中的getBean方法，让其当beanDefintion中的scope是single时调用DefaultSingletonBeanRegistry这个类中的方法进行约束。
下面就是变更的代码：

    public Object getBean(String beanId) {
        //获取bean的定义
        BeanDefinition bd = this.getBeanDefinition(beanId);
        if (bd == null){
            return null;
        }
/*        //获取默认类加载器
        ClassLoader cl = this.getBeanClassLoader();
        //获取bean的name
        String beanClassName = bd.getBeanClassName();
        try {
            Class<?> clazz = cl.loadClass(beanClassName);
            //反射出类的实体
            return clazz.newInstance();
        } catch (Exception e) {
            throw new BeanCreationException("create bean for " + beanClassName + " fail");
        }*/
        //判断要创建的bean是不是单例的。
        if (bd.isSingleton()){
            //先从singletonObjects这个map中获取
            Object bean = this.getSingleton( beanId );
            //如果没有获取到则创建一个，同时放进singletonObjects中
            if (null == bean){
                bean = createBean(bd);
                this.registerSingleton( beanId , bean );
            }
            return bean;
        }
        //直接创建一个bean
        return createBean(bd);
    }

    /**
     * 通过BeanDefintion创建bean
     * @param bd
     * @return
     */
    private Object createBean(BeanDefinition bd) {
        //获取默认类加载器
        ClassLoader cl = this.getBeanClassLoader();
        //获取bean的name
        String beanClassName = bd.getBeanClassName();
        try {
            Class<?> clazz = cl.loadClass(beanClassName);
            //反射出类的实体
            return clazz.newInstance();
        } catch (Exception e) {
            throw new BeanCreationException("create bean for " + beanClassName + " fail");
        }
    }

写到这里，我们的测试用例便可以通过了。

---

                                                                                                生活要多点不自量力