zoukankan      html  css  js  c++  java
  • springboot启动流程(六)ioc容器刷新前prepareContext

    所有文章

    https://www.cnblogs.com/lay2017/p/11478237.html

    prepareContext方法核心逻辑

    上一篇文章中,我们通过createApplicationContext方法创建了一个ApplicationContext的实例对象。本文将阅读一下在ApplicationContext在refresh之前的prepareContext中做了哪些事情。

    我们跟进prepareContext方法

    private void prepareContext(
            ConfigurableApplicationContext context, 
            ConfigurableEnvironment environment,
            SpringApplicationRunListeners listeners, 
            ApplicationArguments applicationArguments, 
            Banner printedBanner
            ) {
        // 设置Environment
        context.setEnvironment(environment);
        // 后置处理
        postProcessApplicationContext(context);
        // 调用ApplicationContextInitializer接口的实现
        applyInitializers(context);
        // 发布ApplicationContext准备事件
        listeners.contextPrepared(context);
        
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 注册args参数为单例bean
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            // 注册banner为单例bean
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
        if (beanFactory instanceof DefaultListableBeanFactory) {
            // 设置beanFactory中是否允许重复bean覆盖
            ((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
    
        // 加载main方法所在类
        Set<Object> sources = getAllSources();
        // 注册main方法所在类到beanFactory
        load(context, sources.toArray(new Object[0]));
        // 发布Context加载事件
        listeners.contextLoaded(context);
    }

    我们看到prepareContext方法主要逻辑包含了三块内容

    1)基本的初始化,如设置Environment,调用ApplicationContextInitializer接口的实现类

    2)注册现有的对象为单例bean,如args、banner

    3)加载main方法所在的主类

    load方法加载主类

    很显然,加载main方法的主类是我们关注的重点。我们先看看getAllSources方法返回

    public Set<Object> getAllSources() {
        Set<Object> allSources = new LinkedHashSet<>();
        // 添加主类
        if (!CollectionUtils.isEmpty(this.primarySources)) {
            allSources.addAll(this.primarySources);
        }
        // 添加附加资源类
        if (!CollectionUtils.isEmpty(this.sources)) {
            allSources.addAll(this.sources);
        }
        return Collections.unmodifiableSet(allSources);
    }

    primarySources是在SpringApplication初始化的时候设置的,而sources默认是没有的。所在getAllSoures方法将返回main方法所在的主类。

    下面,我们跟进load方法,阅读一下加载main所在主类的逻辑

    protected void load(ApplicationContext context, Object[] sources) {
        // 获取BeanDefinition加载器
        BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
        if (this.beanNameGenerator != null) {
            loader.setBeanNameGenerator(this.beanNameGenerator);
        }
        if (this.resourceLoader != null) {
            loader.setResourceLoader(this.resourceLoader);
        }
        if (this.environment != null) {
            loader.setEnvironment(this.environment);
        }
        // 加载资源
        loader.load();
    }

    load方法中,先是获得了BeanDefinitionLoader,然后去加载资源。这里要注意!为什么是BeanDefinitionLoader呢?

    首先,我们得知道Spring的bean资源来自各种地方,如xml、annotation等,那么这些bean在配置的时候也就是对bean进行定义,而这些定义映射到内存中的对象就是BeanDefinition的对象,Spring后续会根据BeanDefinition再获取具体的bean。

    简单来说就是:配置 --> BeanDefinition --> Bean 这样一个逻辑

    所以,后续我们会看到BeanDefinitionLoader会将主类加载成BeanDefinition,然后注册到ApplicationContext当中。

    先跟进getBeanDefinitionRegistry方法,看看BeanDefinition会被注册到哪里去

    private BeanDefinitionRegistry getBeanDefinitionRegistry(ApplicationContext context) {
        // 返回当前ApplicationContext
        if (context instanceof BeanDefinitionRegistry) {
            return (BeanDefinitionRegistry) context;
        }
        if (context instanceof AbstractApplicationContext) {
            return (BeanDefinitionRegistry) ((AbstractApplicationContext) context).getBeanFactory();
        }
        throw new IllegalStateException("Could not locate BeanDefinitionRegistry");
    }

    我们注意,springboot的AnnotationConfigServletWebServerApplicationContext这个ApplicationContext的实现类,随着继承链路向上走是继承自GenericApplicationContext的,而GenericApplicationContext实现了BeanDefinitionRegistry。

    所以,getBeanDefinitionRegistry将最终返回强转过的ApplicationContext。也就是说BeanDefinition将被注册到ApplicationContext里面。

    回到load方法中,我们再跟进createBeanDefinitionLoader方法

    protected BeanDefinitionLoader createBeanDefinitionLoader(BeanDefinitionRegistry registry, Object[] sources) {
        return new BeanDefinitionLoader(registry, sources);
    }

    再跟进构造方法

    BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
        this.sources = sources;
        // 注解方式的读取器
        this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
        // xml方式的读取器
        this.xmlReader = new XmlBeanDefinitionReader(registry);
    
        // 类路径下的扫描器
        this.scanner = new ClassPathBeanDefinitionScanner(registry);
        // 扫描排除当前main方法的主类
        this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));
    }

    我们看到加载器支持注解、xml两种方式。类路径下的扫描器排除了当前的主类

    回到load方法

    protected void load(ApplicationContext context, Object[] sources) {
        // 获取BeanDefinition加载器
        BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
        if (this.beanNameGenerator != null) {
            loader.setBeanNameGenerator(this.beanNameGenerator);
        }
        if (this.resourceLoader != null) {
            loader.setResourceLoader(this.resourceLoader);
        }
        if (this.environment != null) {
            loader.setEnvironment(this.environment);
        }
        // 加载资源
        loader.load();
    }

    此时,我们已经获取了BeanDefinitionLoader,下面调用该loader的load方法开始加载

    跟进第二个load方法

    public int load() {
        int count = 0;
        for (Object source : this.sources) {
            count += load(source);
        }
        return count;
    }

    再跟进第三个load方法

    private int load(Object source) {
        if (source instanceof Class<?>) {
            return load((Class<?>) source);
        }
        if (source instanceof Resource) {
            return load((Resource) source);
        }
        if (source instanceof Package) {
            return load((Package) source);
        }
        if (source instanceof CharSequence) {
            return load((CharSequence) source);
        }
        throw new IllegalArgumentException("Invalid source type " + source.getClass());
    }

    由于我们的主类是一个class,所以进入第一个if分支的load方法

    继续跟进

    private int load(Class<?> source) {
        // 省略
        if (isComponent(source)) {
            this.annotatedReader.register(source);
            return 1;
        }
        return 0;
    }

    该方法先通过isComponent方法判断了主类是不是被@Component注解,如果是,那么调用注解方式的阅读器,注册该资源。

    跟进isComponent方法,看看怎么判断的

    private boolean isComponent(Class<?> type) {
        // 找到是否匹配@Component注解
        if (AnnotationUtils.findAnnotation(type, Component.class) != null) {
            return true;
        }
        // 省略
    }

    其实就是找这个类是否有@Component注解,但请注意我们通常都使用@SpringBootApplication这个注解,并没有直接注解@Component。而@SpringBootApplication是一个组合注解,其中就组合了@Component

    而AnnotationUtils.findAnnotation方法将会递归遍历注解,最终找到@Component。

    isComponent判断为true以后,我们再跟进annotationReader.register(source)阅读一下读取主类的过程

    public void register(Class<?>... annotatedClasses) {
        for (Class<?> annotatedClass : annotatedClasses) {
            registerBean(annotatedClass);
        }
    }

    继续跟进registerBean方法

    public void registerBean(Class<?> annotatedClass) {
        doRegisterBean(annotatedClass, null, null, null);
    }

    再跟进doRegisterBean方法,该方法比较长,我们省略掉一些次要的部分

    <T> void doRegisterBean(
            Class<T> annotatedClass, 
            @Nullable Supplier<T> instanceSupplier, 
            @Nullable String name,
            @Nullable Class<? extends Annotation>[] qualifiers, 
            BeanDefinitionCustomizer... definitionCustomizers
            ) {
        // 先包装成BeanDefinition
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
        
        // 解析scope元数据
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
    
        // 生成bean的名
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
    
        // 解析一些常见的注解元数据
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
    
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        // 注册BeanDefinition到ApplicationContext
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }

    可以看到,doRegisterBean方法的主要逻辑就是包装并解析出一个BeanDefinition,然后调用registerBeanDefinition方法把BeanDefinition给注册到ApplicationContext中。

    注册相关的本文就不再继续展开了,后续的文章会跟进这些内容。

    总结

    总的来说,prepareContext方法主要就是为了加载并注册主类的BeanDefinition到ApplicationContext。这里注意!我们一直都在说注册到ApplicationContext,但熟悉spring的都会知道无论是Bean还是BeanDefinition都是注册到BeanFactory中的。但我们一直没有严格区分它,后续的文章我们将会把ApplicationContext和BeanFactory进行区分。

  • 相关阅读:
    System.arraycopy()的用法?
    Java当中“+=”和“=+”的区别
    jsp FN 标签库的使用方法
    手作编辑画面处理
    mpfu 位编辑处理?
    5/14 自动跟新 位数编集 百分号添加 手作部品。
    jsp 4-14 知识总结
    jstl split 分割字符串?
    aws vpc 知识总结(助理级)
    典型的软件自动化测试框架
  • 原文地址:https://www.cnblogs.com/lay2017/p/11487463.html
Copyright © 2011-2022 走看看