TinySpring学习(Step2)

今天总结一下上一篇的进化版，主要更改的地方在于：如何让BeanDefinition得到注入类的对象，在step1中，是直接实例化，然后丢到BeanDefinition中就可以了，但是实际情况中，bean的创建过程最好还是通过容器来管理，所以我们将这一过程放到了registerBeanDefinition中：

类图如下：（setBean这一过程就藏在图中标出的框框里）

BeanDefinition:（如何想要通过类名来得到对象，就要根据类名得到类，然后才能实例化出对象，所以需要3个私有成员：bean、beanClass、beanClassName）

this.beanClass = Class.forName(beanClassName);

上一段代码的含义就是通过类名得到类，这是Class类的静态方法，底层通过反射来实现

public class BeanDefinition {

    private Object bean;

    private Class beanClass;

    private String beanClassName;

    public BeanDefinition() {
    }

    public void setBean(Object bean) {
        this.bean = bean;
    }

    public Object getBean() {
        return bean;
    }

    public Class getBeanClass() {
        return beanClass;
    }

    public void setBeanClass(Class beanClass) {
        this.beanClass = beanClass;
    }

    public String getBeanClassName() {
        return beanClassName;
    }

    public void setBeanClassName(String beanClassName) {
        this.beanClassName = beanClassName;
        try {
            this.beanClass = Class.forName(beanClassName);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

BeanFactory:

public interface BeanFactory {

    Object getBean(String name);

    void registerBeanDefinition(String name, BeanDefinition beanDefinition);
}

AbstractBeanFactory :（setBean的过程就是在registerBeanDefinition中完成的）

public abstract class AbstractBeanFactory implements BeanFactory {
    private Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>();

    @Override
    public Object getBean(String name) {
        return beanDefinitionMap.get(name).getBean();
    }
    @Override
    public void registerBeanDefinition(String name, BeanDefinition beanDefinition) {
        Object bean = doCreateBean(beanDefinition);
        beanDefinition.setBean(bean);
        beanDefinitionMap.put(name, beanDefinition);
    }
    protected abstract Object doCreateBean(BeanDefinition beanDefinition);

}

AutowireCapableBeanFactory:

public class AutowireCapableBeanFactory extends AbstractBeanFactory {

    @Override
    protected Object doCreateBean(BeanDefinition beanDefinition) {
        try {
            Object bean = beanDefinition.getBeanClass().newInstance();
            return bean;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

测试类：

@Test
    public void test() {
        // 1.初始化beanfactory
        BeanFactory beanFactory = new AutowireCapableBeanFactory();

        // 2.注入bean
        BeanDefinition beanDefinition = new BeanDefinition();
        beanDefinition.setBeanClassName("us.codecraft.tinyioc.HelloWorldService");
        beanFactory.registerBeanDefinition("helloWorldService", beanDefinition);

        // 3.获取bean
        HelloWorldService helloWorldService = (HelloWorldService) beanFactory.getBean("helloWorldService");
        helloWorldService.helloWorld();

    }

小结：

做完step2,我们发现和step1唯一不同的地方就是bean的注入，step1是通过new关键字实例化好对象，丢到BeanDefinition当中的，而改进版的是将这一过程交给BeanFactory去做，利用反射，来进行动态的类加载。为了系统的可扩展性，我们将BeanFactory做成了接口，有一个实现类是AbstractBeanFactory，还有一个类继承自AbstractBeanFactory，叫做AutowireCapableBeanFactory，这个类实现的功能就是获得类的对象，也就是类的实例化这一重要步骤。