spring获取profile

撸了一遍明白为什么用封装一个ApplicationContext了, 里面很多的方法继承下来, 要去调用都一脸懵逼.

所以哦豁,又顿悟了一下为什么很多抽象类的那些实现好的方法要包保护了, 只给自己的子类去用, 外部是直接调用不到的.

就需要ApplicationContext去封装,把这些实现的方法开放出去.

先看一下整个流程之间类的关系, 这个也叫 类图

补充一下这些符号的说明

• List item
• -： private
• +： public
• ~： default
• #： protected
• 下划线： static
• 斜体: 抽象类或方法(两个<<尖括号包起来也算)

冒号前有括号是方法名,反之变量名,冒号后是返回值,没有返回值可以直接连冒号一起省略

然后把这些类先创建好,简单归个类

然后上代码

BeanFactory

第一步还是BeanFactory,还是先这么简单

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

BeansException

专门抛Bean工厂中一些异常信息

public class BeansException extends NestedRuntimeException {

    public BeansException(String msg) {
        super(msg);
    }
}

BeanDefinition

然后上一篇我们讲过的, 是通过BeanDefinition只用来存储Bean的信息

@Data
public class BeanDefinition {

    private Class beanClass;

    //这里升级为只传类型,而不是实例 在需要的时候自己去实例
    public BeanDefinition(Class beanClass){
        this.beanClass=beanClass;
    }
}

单例注册接口定义SingletonBeanRegistry

因为上面只是传入了一个class, 所以需要一个能获取实例化对象的方法,开一个接口,让其他人去做实现

public interface SingletonBeanRegistry {

    Object getSingleton(String beanName);
}

单例注册实现DefaultSingletonBeanRegistry

这里就有了一个单例Bean的管理员

这是注册类,补充了一个注册Bean的方法.

public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {

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

    /**
     * 实现获取单例的方法
     * @param beanName
     * @return
     */
    @Override
    public Object getSingleton(String beanName) {
        return singletonObjects.get(beanName);
    }

    /**
     * 提供一个包保护的方法 可以被继承此类的其他类调用
     * @param beanName
     * @param singletonObject
     */
    protected void addSingletonBean(String beanName,Object singletonObject){
        singletonObjects.put(beanName, singletonObject);
    }
}

抽象类定义(模板方法)AbstractBeanFactory

有了个获取类的方法,就可以getBean了?

public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {

    @Override
    public Object getBean(String beanName){
        //继承自DefaultSingletonBeanRegistry 的方法
        Object bean = getSingleton(beanName);
        if (bean != null){
            return bean;
        }
        //获取不到就两个抽象方法 让实现此类的去做实现
        BeanDefinition beanDefinition = getBeanDefinition(beanName);
        return createBean(beanName,beanDefinition);

    }

    protected abstract BeanDefinition getBeanDefinition(String name) throws BeansException;

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

显然还不够,因为前面说了实例化的操作还没整好呢! 所以获取不到类的时候我们就要去实例化类.

但是我不管实现,我只负责获取Bean, 我们分工明确, 我需求提在这里,其他人去帮我实现吧!

这就是模板模式, 我不止定需求,我甚至把这些需求怎么串联起来都定成了一个模板

将核心的调用逻辑在这里定义好, 后续的人不用关心怎么我的方法要怎么去串联, 尽管实现自己的功能就好.

实例化Bean类 AbstractAutowireCapableBeanFactory

这个方法负责创建Bean,另外一个BeanDefinition的事情我就不管了,所以这是一个抽象类,只实现一个抽象方法,上面遗留的另外一个需求,让子类再去实现增强.

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory{

    @Override
    protected Object createBean(String name, BeanDefinition beanDefinition) throws BeansException {
        Object bean;
        try {
            bean = beanDefinition.getBeanClass().newInstance();
        }catch (InstantiationException | IllegalAccessException e) {
            throw new BeansException("In");
        }
        addSingletonBean(name,bean);
        return bean;
    }
}

前面有Bean的管理类了,但是还没有BeanDefinition的管理类

核心实现类 DefaultListableBeanFactory

然后居然是让这个叫BeanFactory的去管理,我不能理解并且大为震惊.

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry{

    private final Map<String,BeanDefinition> beanDefinitionMap =new HashMap<>();

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

    @Override
    protected BeanDefinition getBeanDefinition(String name) throws BeansException {
        BeanDefinition beanDefinition = beanDefinitionMap.get(name);
        if (beanDefinition ==null) throw new BeansException("No bean named '"+name+"' is defined") ;
        return beanDefinition;
    }
}

不过现在都已经好了,包括Bean的定义 注册 获取,上测试代码

@Test
public void testBeanFactory(){
    //初始化 beanFactory
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    //创建 bean信息
    BeanDefinition beanDefinition = new BeanDefinition(UserService.class);
    String beanName = "userService";
    //注册到工厂中
    beanFactory.registerBeanDefinition(beanName,beanDefinition);
    //获取实例
    UserService userService = (UserService) beanFactory.getBean(beanName);
    userService.queryUserInfo();
    //第二次再获取应该走单例
    UserService singletonUserService = (UserService)beanFactory.getBean(beanName);

    singletonUserService.queryUserInfo();
    //是否为单例
    System.out.println(userService);
    System.out.println(singletonUserService);
}