《手写Spring渐进式源码实践》-第二章 实现Bean对象的定义、注册和获取

本章重点是运用AbstractBeanFactory抽象类，运用模版模式拆分功能，解耦SpringBean容器，处理界限上下文关系，完成BeanFactory接口的实现。

刚开始看这块的时候感觉非常绕，为什么要这么定义，很好奇后面能扩展成什么样子，这块建议多看看模版模式。反复多练几遍，达到看到这几个类就能知道每个类大概做什么事情，这次贴的代码是我写了第4编才顺利的写出来的。另外发现一个秘密，如果一个问题没有搞明白，自己想糊弄自己的意图，那就写一篇博客。
“如果你无法用简单的话解释一件事，说明你还没真正理解它。” —— 理查德·费曼
以下是代码：

public interface BeanFactory {
    Object getBean(String name)throws BeansException;
}

SingletonBeanRegistry是单例对象注册接口的定义和实现。

public interface SingletonBeanRegistry {
    Object getSingleton(String beanName);

    void registrySingletonBean(String name,Object singleton);
}

DefaultSingletonBeanRegistry实现了SingletonBeanRegistry

public abstract class DefauleSingletonBeanRegistry implements SingletonBeanRegistry {
    Map<String,Object> singletonObjects = new HashMap<>();
    @Override
    public Object getSingleton(String beanName) {
        return singletonObjects.get(beanName);
    }

    @Override
    public void registrySingletonBean(String name, Object singleton) {
        singletonObjects.put(name,singleton);
    }
}

AbstractBeanFactory运用模板模式定义了一个流程标准的用于获取对象的AbstractBeanFactory抽象类，并采用职责分离的结构设计，继承DefaultSingletonBeanRegistry类，使用其提供的单例对象注册和获取功能。

public abstract class AbstractoryBeanFactory extends DefauleSingletonBeanRegistry implements BeanFactory{
    @Override
    public Object getBean(String name) throws BeansException {
        Object singleton = super.getSingleton(name);
        if(Objects.nonNull(singleton)){
            return singleton;
        }
        BeanDefinition beanDefinition = getBeanDefinition(name);
        return createBean(name,beanDefinition);
    }

    protected abstract BeanDefinition getBeanDefinition(String beanName);

    protected abstract Object createBean(String beanName, BeanDefinition beanDefinition) throws BeansException;
}

AbstractAutowireCapableBeanFactory用于实现创建对象的具体功能，可以联想到这个注解：@Autowire

public abstract class AbstractAutowireCapableBeanFactory extends AbstractoryBeanFactory {
    @Override
    protected Object createBean(String beanName, BeanDefinition beanDefinition) throws BeansException {
        Object bean;
        try {
            bean = beanDefinition.getBean().newInstance();
        } catch (Exception e) {
            throw  new BeansException("Instantiation of bean failed", e);
        }
        super.registrySingletonBean(beanName,bean);
        return bean;
    }
}

核心实现：DefaultListableBeanFactory

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry{
    private Map<String,BeanDefinition> beanDefinitionMap =  new HashMap<>();
    @Override
    protected BeanDefinition getBeanDefinition(String beanName) {
        try {
            return beanDefinitionMap.get(beanName);
        } catch (Exception e) {
            throw new BeansException( "No bean named "+beanName+" is deined");
        }
    }

    @Override
    public void beanDefinitionRegistry(String name, BeanDefinition beanDefinition) {
        beanDefinitionMap.put(name,beanDefinition);
    }
}

单元测试：

public class UserService {

    public void queryUserInfo(){
        System.out.println("查询用户信息");
    }
}

注意在第一次获取bean对象是singleton=null

注意在第一次获取bean对象是singleton!=null

@SpringBootTest(classes = MyApplication.class)
public class ApiTest {
    @Test
    public void test_BeanFactory(){
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        beanFactory.beanDefinitionRegistry("userService", new BeanDefinition(UserService.class));
        //第一次获取bean对象
        UserService userService = (UserService)beanFactory.getBean("userService");
        userService.queryUserInfo();
        //第二次获取bean对象
        UserService userService1 = (UserService)beanFactory.getBean("userService");
        userService1.queryUserInfo();
    }
}

源码地址：https://github.com/Charlie-pang-sys/WeaponSystem/tree/master/Java/Spring-Tutorials/spring-step-02