学习笔记-Spring实战-动手实现一个小的spring-Chapter-2

学习笔记-Spring实战-动手实现一个小的spring-Chapter-2

1、思考

上一章节遗留的两个问题：将bean的创建交给容器，处理单例bean

容器要创建bean需要拿到bean的定义即class，因此bean定义类将bean对象换成bean的class

单例 加入容器缓存机制 定义单例注册接口

设计的原则：接口定义行为功能 抽象类继承接口处理非接口功能的通用逻辑 实现类实现接口继承抽象类完成核心功能

2、设计

将接口和实现类中间的部分用抽象类来实现 方便后续扩展

3、实现

AbstractAutowireCapableBeanFactory 负责bean的创建 createBean方法
AbstractBeanFactory 负责判断bean是否存在 分发调用逻辑
BeanDefinition bean定义
BeanDefinitionRegistry bean注册接口 注册bean到容器
BeanFactory bean工厂 提供get Bean方法
BeansException 异常类
DefaultListableBeanFactory 默认bean实现 实现容器的bean注册，实现bean定义的获取（声明在AbstractBeanFactory中）
DefaultSingletonBeanRegistry 单例bean注册实现 添加和获取单例bean
SingletonBeanRegistry 单例bean注册接口

BeanFactory:

/**
 * @author LiWenQiang
 * @description Bean工厂
 * @date 2022-03-02 17:40
 */
public interface BeanFactory {
    Object getBean(String beanName);
}

AbstractBeanFactory

/**
 * @author LiWenQiang
 * @description 抽象Bean工厂-负责 方法调用 具体逻辑由子类实现
 * @date 2022-03-02 17:39
 */
public abstract class AbstractBeanFactory extends  DefaultSingletonBeanRegistry implements BeanFactory{

    @Override
    public Object getBean(String beanName) {

        //判断是否存在bean
        final Object singleton = getSingleton(beanName);
        if(singleton != null){
            return singleton;
        }

        //获取bean定义
        final BeanDefinition beanDefinition = getBeanDefinition(beanName);
        //      //创建bean
        return createBean(beanName,beanDefinition);

    }

    abstract protected  Object createBean(String beanName,BeanDefinition beanDefinition);
    abstract protected BeanDefinition getBeanDefinition(String beanname);


}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author LiWenQiang
 * @description 单例bean注册
 * @date 2022-03-02 17:41
 */
public interface SingletonBeanRegistry {
//    void registSingletonBean(String name,BeanDefinition beanDefinition);

    /**
     * 获取单例对象
     * @param beanName
     * @return
     */
    Object getSingleton(String beanName);
}

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author LiWenQiang
 * @description
 * @date 2022-03-02 17:43
 */
public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {

    Map<String,Object> signletonBeanDefinitionMap = new ConcurrentHashMap<>();

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

    /**
     * 加入单例对象
     * @param beanName
     * @param bean
     */
    protected void adddSingleton(String beanName,Object bean){
        signletonBeanDefinitionMap.put(beanName,bean);
    }

}

/**
 * @author LiWenQiang
 * @description bean定义信息注册接口
 * @date 2022-03-02 17:57
 */
public interface BeanDefinitionRegistry {
    /**
     * 注册bean定义信息
     * @param beanName
     * @param beanDefinition
     */
    void registBeanDefinition(String beanName,BeanDefinition beanDefinition);
}

/**
 * @author LiWenQiang
 * @description 负责createBean方法实现
 * @date 2022-03-02 18:00
 */
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory {


    @Override
    protected Object createBean(String beanName, BeanDefinition beanDefinition) throws BeansException {

        Object bean = null;
        //创建Bean
        try {
            bean = beanDefinition.getBeanDefinition().newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            //转换异常 并把原始异常抛出
            throw new BeansException("bean create fail!",e);
        }
        //加入到容器
        adddSingleton(beanName,bean);
        return bean;
    }
}

import java.util.HashMap;
import java.util.Map;

/**
 * @author LiWenQiang
 * @description 负责bean注册信息的获取
 * @date 2022-03-02 18:07
 */
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry {

    Map<String,BeanDefinition> map = new HashMap<>();

    @Override
    protected BeanDefinition getBeanDefinition(String beanname) throws BeansException {
        final BeanDefinition beanDefinition = map.get(beanname);
        if(beanDefinition == null){
            throw new BeansException("bean definition not exist!");
        }
        return beanDefinition;
    }


    @Override
    public void registBeanDefinition(String beanName, BeanDefinition beanDefinition) {
        map.put(beanName,beanDefinition);
    }
}

/**
 * @author LiWenQiang
 * @description bean定义
 * @date 2022-03-02 17:38
 */
public class BeanDefinition {
    private Class beanDefinition;

    public BeanDefinition(Class beanDefinition) {
        this.beanDefinition = beanDefinition;
    }
    public Class getBeanDefinition() {
        return beanDefinition;
    }

    public void setBeanDefinition(Class beanDefinition) {
        this.beanDefinition = beanDefinition;
    }
}

/**
 * @author LiWenQiang
 * @description
 * @date 2022-03-02 18:04
 */
public class BeansException extends RuntimeException {
    public BeansException(String message) {
        super(message);
    }

    public BeansException(String message, Throwable cause) {
        super(message, cause);
    }
}

4、验证

import org.junit.Test;

/**
 * @author LiWenQiang
 * @description
 * @date 2022-03-02 18:13
 */
public class IOCTest {
    @Test
    public void testIOC1(){
        //创建IOC容器
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

        //注册一个bean进去
        beanFactory.registBeanDefinition("userService",new BeanDefinition(UserService.class));

        //获取bean 多次获取
        final UserService userService = (UserService) beanFactory.getBean("userService");
        final UserService userService2 = (UserService) beanFactory.getBean("userService");
        final UserService userService3 = (UserService) beanFactory.getBean("userService");

        System.out.println(userService);
        System.out.println(userService2);
        System.out.println(userService3);

        //调用方法测试
        userService.queryUserInfo();
    }
}

/**
 * @author LiWenQiang
 * @description
 * @date 2022-03-02 17:04
 */
public class UserService {
    private String name;

    public UserService(String name) {
        this.name = name;
    }

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

多次获取userService 获取的是一个

5、问题

1、目前只能创建无参构造函数的对象，怎么创建带参数的对象？