//默认扫描当前类所在包和当前子包的所有注解代码
@SpringBootApplication
@EnableAsync
//开启异步执行任务
public class Code04ControllerApplication {
    public static void main(String[] args) {
        SpringApplication.run(Code04ControllerApplication.class, args);
    }
}

    public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
    }

    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }

    public SpringApplication(Class... primarySources) {
        this((ResourceLoader)null, primarySources);
    }

    public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = Collections.emptySet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
        this.applicationStartup = ApplicationStartup.DEFAULT;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = new ArrayList(this.getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

    public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        // 搞一个set容器
        this.sources = new LinkedHashSet();
        
        // 设置banner的模式为console打印
        this.bannerMode = Mode.CONSOLE;
        
        // 设置logStartInfo为true
        this.logStartupInfo = true;
        
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = Collections.emptySet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        
        // 重点，初始化 applicationContextFactory 对象。
        // 从名称就可以看出，该工厂对象专门用来创建spring上下文applicationContex的。
        this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
        
        // 设置ApplicationStartup对象
        this.applicationStartup = ApplicationStartup.DEFAULT;
        
        //设置resourceLoader
        this.resourceLoader = resourceLoader;
        
        // 对primarySources对象做断言校验
        Assert.notNull(primarySources, "PrimarySources must not be null");
        
        // 根据传入的primarySources初始化一个Set容器
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        
        // 遍历classpath下的所有class对象，检查是否包含某些特殊类。
        // 其实就是在扫描是否有webFlux需要的类，如果包含则返回WebApplicationType枚举中的REACTIVE，匹配不到返回NONE，否则返回SERVLET。
        // 这个值决定着springboot启动哪种类型的spring上下文，是Servlet很还是Reactive呢？
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        
        // 初始化bootstrapRegistryInitializers对象，这玩意儿的类型是List<BootstrapRegistryInitializer>，是个集合容器。
        this.bootstrapRegistryInitializers = new ArrayList(this.getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        
        // 初始化initializers对象，这是一个List<ApplicationContextInitializer<?>>类型的集合
        // 和其他钩子接口一样，ApplicationContextInitializer也是个函数式接口，只有一个抽象方法 initialize
        // 该方法接收一个spring applicationContext对象。
        // 可见，该钩子主要是用来操作spring容器对象的。
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        
        // 找出key为类型ApplicationListener的所有实现，反射实例化后聚合为一个集合返回。
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        
        // 遍历当前的方法执行堆栈，找到“main"所在的类，返回其class对象。
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

this.applicationContextFactory = ApplicationContextFactory.DEFAULT;

    ApplicationContextFactory DEFAULT = (webApplicationType) -> {
        try {
            switch(webApplicationType) {
            case SERVLET:
                return new AnnotationConfigServletWebServerApplicationContext();
            case REACTIVE:
                return new AnnotationConfigReactiveWebServerApplicationContext();
            default:
                return new AnnotationConfigApplicationContext();
            }
        } catch (Exception var2) {
            throw new IllegalStateException("Unable create a default ApplicationContext instance, you may need a custom ApplicationContextFactory", var2);
        }
    };

@FunctionalInterface
public interface ApplicationContextFactory {}

ConfigurableApplicationContext create(WebApplicationType webApplicationType);

    ApplicationContextFactory DEFAULT = (webApplicationType) -> {
        try {
            // 根据传入的webApplicationType去做判断
            switch(webApplicationType) {
                
                // 如果是SERVLET则创建AnnotationConfigServletWebServerApplicationContext容器
            case SERVLET:
                return new AnnotationConfigServletWebServerApplicationContext();
                
                // 如果是REACTIVE则创建AnnotationConfigReactiveWebServerApplicationContext容器
            case REACTIVE:
                return new AnnotationConfigReactiveWebServerApplicationContext();
                
                // 如果都不是则创建AnnotationConfigApplicationContext容器
            default:
                return new AnnotationConfigApplicationContext();
            }
        } catch (Exception var2) {
            throw new IllegalStateException("Unable create a default ApplicationContext instance, you may need a custom ApplicationContextFactory", var2);
        }
    };

this.applicationContextFactory = ApplicationContextFactory.DEFAULT;

this.webApplicationType = WebApplicationType.deduceFromClasspath();

    static WebApplicationType deduceFromClasspath() {
        if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", (ClassLoader)null) && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", (ClassLoader)null) && !ClassUtils.isPresent("org.glassfish.jersey.servlet.ServletContainer", (ClassLoader)null)) {
            return REACTIVE;
        } else {
            String[] var0 = SERVLET_INDICATOR_CLASSES;
            int var1 = var0.length;

            for(int var2 = 0; var2 < var1; ++var2) {
                String className = var0[var2];
                if (!ClassUtils.isPresent(className, (ClassLoader)null)) {
                    return NONE;
                }
            }

            return SERVLET;
        }
    }

this.bootstrapRegistryInitializers = new ArrayList(this.getSpringFactoriesInstances(BootstrapRegistryInitializer.class));

    // 传入一个class对象，然后返回一个该对象类型的集合
    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
        return this.getSpringFactoriesInstances(type, new Class[0]);
    }

    private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
        ClassLoader classLoader = this.getClassLoader();
        // 获取classpath下所有的sprig.factories文件中配置的key为type指定类型的所有values
        Set<String> names = new LinkedHashSet(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
        // 根据names中聚合的各个权限定名称反射实例化出对应的对象，重新聚合成一个list。
        List<T> instances = this.createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
        // 对聚合后的对象按照order指定的顺序从小到大排序
        AnnotationAwareOrderComparator.sort(instances);
        return instances;
    }

    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();
        // 通过这个方法加载classpath下所有的META-INF/spring.factories文件中配置的属性k-v，然后返回一个map；
        // 最后在该map中返回key为factoryTypeName指定的values。
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            HashMap result = new HashMap();

            try {
                // 可以看到，通过classLoader去获取当前工程中classpath下的所有META-INF/spring.factories文件。
                // 注意是所有的该文件，包括任意依赖进的jar包里面的。
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));

// 它所属的包是spring的
package org.springframework.context;

// 它是一个函数式接口，只有一个抽象方法
// 该方法只接收一个spring上下文参数，因此，我们可以通过该钩子对象来直接操作spring上下文
@FunctionalInterface
public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext> {
    void initialize(C applicationContext);
}

org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer;
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

// 实现了 ApplicationContextInitializer 接口 和 Ordered 接口
// SharedMetadataReaderFactoryContextInitializer这个实现很重要，spring后期的beanDefinition的加载实际上就是在这个类中为spring容器注册的对应的BeanFactoryPostProcessor。
// 然后这些BeanFactoryPostProcessor在后面做了很多事。这个流程后面再分析，目前只需要记住，这几个实现类很重要！！！
class SharedMetadataReaderFactoryContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext>, Ordered {}

    // 接收一个ConfigurableApplicationContext类型的spring上下文
    public void initialize(ConfigurableApplicationContext applicationContext) {
        // 在这里，拿到spring容器对象后，其实它自己也不干活，而是创建了一个当前内部类 CachingMetadataReaderFactoryPostProcessor 对象。
        // 这个对象是个 BeanFactoryPostProcessor 类型的，然后将其注册到spring容器中。
        // 具体这个对象怎么使用，我们后面再分析，目前只需要清楚，这个ApplicationContextInitializer的该实现，给spring容器中注册了一个BeanFactoryPostProcessor。
        BeanFactoryPostProcessor postProcessor = new SharedMetadataReaderFactoryContextInitializer.CachingMetadataReaderFactoryPostProcessor(applicationContext);
        applicationContext.addBeanFactoryPostProcessor(postProcessor);
    }

public class ConditionEvaluationReportLoggingListener implements ApplicationContextInitializer<ConfigurableApplicationContext> {}

    public void initialize(ConfigurableApplicationContext applicationContext) {
        // 该方法将拿到的容器对象直接初始化成自己的一个属性了，后面人家就能使用自己的这个属性了
        this.applicationContext = applicationContext;
        // 然后为spsirng容器对象注册了一个ApplicationListener 监听器。
        applicationContext.addApplicationListener(new ConditionEvaluationReportLoggingListener.ConditionEvaluationReportListener());
        if (applicationContext instanceof GenericApplicationContext) {
            this.report = ConditionEvaluationReport.get(this.applicationContext.getBeanFactory());
        }

    }

this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));

// 同样属于spring
package org.springframework.context;

import java.util.EventListener;
import java.util.function.Consumer;

// 该接口也是一个函数式接口
@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    // 提供了一个抽象方法
    void onApplicationEvent(E event);

    // 同时还实现了一个静态方法
    static <T> ApplicationListener<PayloadApplicationEvent<T>> forPayload(Consumer<T> consumer) {
        return (event) -> {
            consumer.accept(event.getPayload());
        };
    }
}

// 初始化mainApplicationClass属性，该属性类型为Class<?>
this.mainApplicationClass = this.deduceMainApplicationClass();

    private Class<?> deduceMainApplicationClass() {
        try {
            // 遍历当前的方法执行堆栈，找到“main"所在的类，返回其class对象。
            StackTraceElement[] stackTrace = (new RuntimeException()).getStackTrace();
            StackTraceElement[] var2 = stackTrace;
            int var3 = stackTrace.length;

            for(int var4 = 0; var4 < var3; ++var4) {
                StackTraceElement stackTraceElement = var2[var4];
                if ("main".equals(stackTraceElement.getMethodName())) {
                    return Class.forName(stackTraceElement.getClassName());
                }
            }
        } catch (ClassNotFoundException var6) {
            ;
        }

        return null;
    }

    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }

    public ConfigurableApplicationContext run(String... args) {
        long startTime = System.nanoTime();
        // 创建一个bootstrap上下文对象，里面遍历执行了 BootstrapRegistryInitializer 接口的所有回调实现逻辑。
        DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();
        ConfigurableApplicationContext context = null;
        
        // 将headless的值设置为系统属性 java.awt.headless
        this.configureHeadlessProperty();
        
        // 从sprng.factories中获取SpringApplicationRunListener的所有实现类，然后反射成对象后，封装到一个新的对象SpringApplicationRunListeners中。
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        // 遍历执行 SpringApplicationRunListener 接口的 starting 方法。
        listeners.starting(bootstrapContext, this.mainApplicationClass);

        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            
            // 准备环境，遍历执行 SpringApplicationRunListener 接口的 environmentPrepared 方法。
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            Banner printedBanner = this.printBanner(environment);
            
            // 创建spring容器对象，同时会创建一些内置的beanDefinition注入到beanFactory中，不过这些内置的beanDefinition可以不用关注。
            context = this.createApplicationContext();
            
            // 给容器对象注册applicationStartup
            context.setApplicationStartup(this.applicationStartup);
            
            // 准备上下文，这段逻辑遍历执行了 ApplicationContextInitializer 接口的所有回调逻辑。
            // 同时将传递进来的主资源class转换为beanDefinition后注册到beanFactory中了。
            // 我们在前面大概分析了，ApplicationContextInitializer 接口的 initialize 方法主要用来操作spring容器对象.
            // 比如向容器中注册一些postProcessor等，当然可以对spring容器实施的逻辑有很多。
            this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
            
            // 刷新spring容器，正式启动容器，从springboot正式开始进入spring。核心！！！
            this.refreshContext(context);
            
            // afterRefresh()方法没有实现，留给客户端去实现回调逻辑，当容器启动完成之后需要操作的逻辑   
            this.afterRefresh(context, applicationArguments);
            Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), timeTakenToStartup);
            }

            // 遍历执行 SpringApplicationRunListener 所有实现对象的 started 方法
            listeners.started(context, timeTakenToStartup);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var12) {
            this.handleRunFailure(context, var12, listeners);
            throw new IllegalStateException(var12);
        }

        try {
            Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
            listeners.ready(context, timeTakenToReady);
            return context;
        } catch (Throwable var11) {
            this.handleRunFailure(context, var11, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var11);
        }
    }

DefaultBootstrapContext bootstrapContext = this.createBootstrapContext();

    private DefaultBootstrapContext createBootstrapContext() {
        // 创建一个DefaultBootstrapContext对象
        DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
        // 遍历bootstrapRegistryInitializers集合，执行其中每个对象的initialize方法。
        this.bootstrapRegistryInitializers.forEach((initializer) -> {
            // initialize方法接收一个bootstrapContext，客户端可以使用该对象做一些回调操作
            initializer.initialize(bootstrapContext);
        });
        return bootstrapContext;
    }

SpringApplicationRunListeners listeners = this.getRunListeners(args);

    private SpringApplicationRunListeners getRunListeners(String[] args) {
        // 实例化一个class数组，里面存在两个class元素，第1个元素是SpringApplication的class，第2个元素是一个String数组的class
        Class<?>[] types = new Class[]{SpringApplication.class, String[].class};
        
        // 获取spring,factories文件中配置的key为SpringApplicationRunListener的所有实现子类对象
        // 将所有的SpringApplicationRunListener对象集合封装在一个SpringApplicationRunListeners对象中返回
        return new SpringApplicationRunListeners(logger, this.getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args), this.applicationStartup);
    }

    // 通过创建一个新的对象，将原来的SpringApplicationRunListener集合进行包装
    SpringApplicationRunListeners(Log log, Collection<? extends SpringApplicationRunListener> listeners, ApplicationStartup applicationStartup) {
        this.log = log;
        this.listeners = new ArrayList(listeners);
        this.applicationStartup = applicationStartup;
    }

listeners.starting(bootstrapContext, this.mainApplicationClass);

    void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) {
        // 注意这个 doWithListeners 方法
        this.doWithListeners("spring.boot.application.starting", (listener) -> {
            
            // 传入一个lambda表达式
            listener.starting(bootstrapContext);
        }, (step) -> {
            // 传入一个lambda表达式
            if (mainApplicationClass != null) {
                step.tag("mainApplicationClass", mainApplicationClass.getName());
            }

        });
    }

    // listenerAction表示一个消费者对象，函数式接口，表示一段逻辑，stepAction同理
    private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction, Consumer<StartupStep> stepAction) {
        StartupStep step = this.applicationStartup.start(stepName);
        
        // 遍历当前的listeners集合，List<SpringApplicationRunListener> listeners
        // 然后执行传入的回调逻辑，从上可以看出，传入的回调逻辑是 listener.starting(bootstrapContext);
        // 所以此处实际上是遍历执行SpringApplicationRunListener对象中的starting(ConfigurableBootstrapContext bootstrapContext)方法。
        this.listeners.forEach(listenerAction);
        if (stepAction != null) {
            stepAction.accept(step);
        }

        step.end();
    }

ConfigurableEnvironment environment = this.prepareEnvironment(listeners, bootstrapContext, applicationArguments);

    private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
        ConfigurableEnvironment environment = this.getOrCreateEnvironment();
        this.configureEnvironment((ConfigurableEnvironment)environment, applicationArguments.getSourceArgs());
        ConfigurationPropertySources.attach((Environment)environment);
        
        // 遍历执行 SpringApplicationRunListener 集合中的 environmentPrepared 方法
        listeners.environmentPrepared(bootstrapContext, (ConfigurableEnvironment)environment);
        DefaultPropertiesPropertySource.moveToEnd((ConfigurableEnvironment)environment);
        Assert.state(!((ConfigurableEnvironment)environment).containsProperty("spring.main.environment-prefix"), "Environment prefix cannot be set via properties.");
        this.bindToSpringApplication((ConfigurableEnvironment)environment);
        if (!this.isCustomEnvironment) {
            environment = this.convertEnvironment((ConfigurableEnvironment)environment);
        }

        ConfigurationPropertySources.attach((Environment)environment);
        return (ConfigurableEnvironment)environment;
    }

context = this.createApplicationContext();

    protected ConfigurableApplicationContext createApplicationContext() {
        // 使用 SpringApplication 对象的applicationContextFactory根据构造器初始化的webApplicationType去创建对应的spring容器对象
        return this.applicationContextFactory.create(this.webApplicationType);
    }

    static class Factory implements ApplicationContextFactory {
        Factory() {
        }

        // AnnotationConfigServletWebServerApplicationContext类中定义了一个内部类Factory实现了ApplicationContextFactory接口
        // 覆盖了其中的create方法，根据webApplicationType去创建对应的spring容器。
        public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
            return webApplicationType != WebApplicationType.SERVLET ? null : new AnnotationConfigServletWebServerApplicationContext();
        }
    }

    public AnnotationConfigServletWebServerApplicationContext() {
        // 初始化一个缓存注解Class对象的容器
        this.annotatedClasses = new LinkedHashSet();
        // 初始化一个注解的beanDefinition读取器
        this.reader = new AnnotatedBeanDefinitionReader(this);
        // 初始化一个beanDefinition扫描器
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext implements AnnotationConfigRegistry 

public class ServletWebServerApplicationContext extends GenericWebApplicationContext implements ConfigurableWebServerApplicationContext

public class GenericWebApplicationContext extends GenericApplicationContext implements ConfigurableWebApplicationContext, ThemeSource

    public GenericApplicationContext() {
        this.customClassLoader = false;
        this.refreshed = new AtomicBoolean();
        // 这里直接初始化了spring容器中的beanFactory工厂，可以看到该对象是DefaultListableBeanFactory类型
        this.beanFactory = new DefaultListableBeanFactory();
    }

this.prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

    private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        // 为spring容器设置环境
        context.setEnvironment(environment);
        // 为实例化好的spring容器设置一些属性
        this.postProcessApplicationContext(context);
        
        // 传入spring上下文，其中遍历回调了构造器时期注入的所有 ApplicationContextInitializer 对象的initialize方法。
        // 用于对spring上下文插入一些自定义逻辑。
        // 看到了吧，前面springboot时期注册的 ApplicationContextInitializer 的所有实现对象，它们的 initialize 方法就是在这个时候回调执行的。
        // 至于各个实现的initialize方法具体都干了什么事情，由实现者自己决定。
        this.applyInitializers(context);
        
        // 同上面的操作，遍历回调了SpringApplicationRunListener接口的contextPrepared方法。
        listeners.contextPrepared(context);
        
        bootstrapContext.close(context);
        if (this.logStartupInfo) {
            this.logStartupInfo(context.getParent() == null);
            this.logStartupProfileInfo(context);
        }

        // 获取spring容器对象的beanFactory工厂
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        
        // 通过beanFactory工厂注册一个单例bean，名称为 springApplicationArguments
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
            // 如果printedBanner存在，也注册到spring容器中；
            // 注意，此处是直接将一个已经存在的bean对象注册到bean容器中，而不是注册beanDefinition
            beanFactory.registerSingleton("springBootBanner", printedBanner);
        }

        // 设置beanFactory工厂的一些属性
        if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
            ((AbstractAutowireCapableBeanFactory)beanFactory).setAllowCircularReferences(this.allowCircularReferences);
            if (beanFactory instanceof DefaultListableBeanFactory) {
                ((DefaultListableBeanFactory)beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
            }
        }

        // 如果当前spring容器被设置为懒加载，则为spring容器增加一个BeanFactoryPostProcessor处理器。
        // 该处理器用来对beanFactory工厂对象设置一些回调逻辑，即用来改造beanFactory的行为。
        if (this.lazyInitialization) {
            context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
    
        // 获取传入的所有资源类，就是执行run方法时传入的Class对象，一般是main方法所在的主类
        Set<Object> sources = this.getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        
        // 初始化 BeanDefinitionLoader 加载器，同时初始化BeanDefinitionLoader加载器和扫描器等。
        // 同时还将主资源的beanDefinition注入到beanFactory中了，其实就是run方法传递进来的那个class对象。
        this.load(context, sources.toArray(new Object[0]));
        
        // 遍历回调了构造器时期注入的所有SpringApplicationRunListener对象的contextLoaded方法。
        listeners.contextLoaded(context);
    }

// 这一步标志着启动流程正式从springboot的SpringApplication开始进入到spring容器中。
this.refreshContext(context);

    private void refreshContext(ConfigurableApplicationContext context) {
        // 如果允许注册停止钩子，则执行SpringApplicationShutdownHook的registerApplicationContext方法，该方法接收一个spring容器对象
        if (this.registerShutdownHook) {
            shutdownHook.registerApplicationContext(context);
        }

        this.refresh(context);
    }

    void registerApplicationContext(ConfigurableApplicationContext context) {
        this.addRuntimeShutdownHookIfNecessary();
        Class var2 = SpringApplicationShutdownHook.class;
        synchronized(SpringApplicationShutdownHook.class) {
            this.assertNotInProgress();
            // 为spring容器注册了一个ApplicationContextClosedListener类型的监听器
            context.addApplicationListener(this.contextCloseListener);
            this.contexts.add(context);
        }
    }

    // 执行传递进来的spring容器兑现的refresh方法，正式启动spring容器。
    protected void refresh(ConfigurableApplicationContext applicationContext) {
        applicationContext.refresh();
    }

    public final void refresh() throws BeansException, IllegalStateException {
        try {
            // 调用父类的refresh
            super.refresh();
        } catch (RuntimeException var3) {
            WebServer webServer = this.webServer;
            if (webServer != null) {
                webServer.stop();
            }

            throw var3;
        }
    }

    public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
            
            // 刷新前准备动作
            this.prepareRefresh();
            
            // 获取spring容器中的beanFactory工厂
            // 此处获取的就是上面springboot中创建spring容器时已经初始化的DefaultListableBeanFactory对象。
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            
            // 为beanFactory做一些准备工作
            // 提前注册一些内置的 beanDefinition，和一些 BeanPostProcessor 等，比如 ApplicationContextAwareProcessor，LoadTimeWeaverAwareProcessor 等。
            this.prepareBeanFactory(beanFactory);

            try {
                // 对拿到的beanFactory工厂对象的一些后置处理动作
                // 注册一个 BeanPostProcessor - WebApplicationContextServletContextAwareProcessor 等
                this.postProcessBeanFactory(beanFactory);
                
                StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
                
                // 回调执行spring容器中的所有BeanFactoryPostProcessor类型对象的postProcessBeanFactory方法。
                // 这个方法很复杂，底层跟套娃一样，一环套一环。
                // 总的来讲，干了两件事：
                // 1.首先判断前面注册的beanFactoryPostProcessor是否是BeanDefinitionRegistryPostProcessor类型，如果是，则执行其postProcessBeanDefinitionRegistry方法。
                // 2.其次判断如果是 BeanFactoryPostProcessor 类型，则执行其postProcessBeanFactory方法。
                // 我们要注意，BeanDefinitionRegistryPostProcessor接口继承了BeanFactoryPostProcessor接口，对后者进行了扩展，增加了一个postProcessBeanDefinitionRegistry方法。
                // 相当于spring容器在回调执行BeanFactoryPostProcessor的所有实现对象时，默认替我们做了优先级，首先会回调所有实现了BeanDefinitionRegistryPostProcessor类型的对象。
                // 其次才是直接实现BeanFactoryPostProcessor类型的对象。
                // 提前剧透一点：spring容器的beanFactory加载容器中的所有beanDefinition定义，就是在这个方法里面实现的。
                // 当然，肯定是某个实现了BeanDefinitionRegistryPostProcessor或者BeanFactoryPostProcessor接口的子类对象负责干的这事。
                // 其实，就是在上面分析的 SharedMetadataReaderFactoryContextInitializer 的 initialize 方法中注册的 CachingMetadataReaderFactoryPostProcessor 对象负责加载的所有beanDefinition。
                // 详情后面分析。
                this.invokeBeanFactoryPostProcessors(beanFactory);
                
                // 向spring容器中注册BeanPostProcessor对象。
                // BeanPostProcessor 的实现类对象来源主要分为两部分：
                // 1.直接在该方法内部手动实例化现有的 BeanPostProcessor 子类对象并通过 addBeanPostProcessor 方法注册到sprign容器中，比如 BeanPostProcessorChecker 和 ApplicationListenerDetector 等。
                // 2.拉起spring容器，让spring容器优先实例化容器内部类型为 BeanPostProcessor 的beanDefinition，然后通过 addBeanPostProcessor 方法注册到spring容器中。
                // 第2点，会优先获取容器中 beanDefinition 为 BeanPostProcessor 类型的所有bean定义，然后spring容器将优先实例化这些bean；
                // 根据beanDefinition信息，通过反射将其实例化成对象后返回，同时注册到spring容器中。
                // 注册时，会分别判断bean是否实现了Order接口之类的，将beanPostProcessor按照优先级进行排序。
                // 同时，还会注册一个 ApplicationListenerDetector 类型的 BeanPostProcessor，该类是spring自己实现的。
                // 也就是说，到这一步，spring容器已经优先实例化了 BeanPostProcessor 类型的所有bean对象。
                
                // 注意，和上面的BeanFactoryPostProcessor进行区分，主要区别如下：
                // 1.前者 BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 的实现类对象的实例化，以及实例化后注册到spring容器对象中，这些逻辑基本上都是springboot通过spring.factories中倒挂的ApplicationContextInitializer钩子中去实现的。
                // 而 BeanPostProcessor 类型的实现类对象的实例化，很明显是spring容器负责加载的，也就是说，BeanPostProcessor 类型的bean实际上是完全由spring容器管理的，spring容器加载完所有的beanDefinition后，这些beanDefinition中就有 BeanPostProcessor 类型。
                // 2.前者 BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 的实现类对象早就已经通过springboot借助ApplicationContextInitializer的回调方法在回调中向spring容器中注册了，而且在上面的 invokeBeanFactoryPostProcessors()方法中就已经全部回调执行了。
                // 当流程走到这一步，容器中所有的BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor类型的回调逻辑已经全部执行完毕了。
                // 而在当前方法中才正式开始实例化容器中 BeanPostProcessor 类型的对象，实例化后才开始注册，至于啥时候回调执行，后面在分析。
                // 也就是说，前者 BeanFactoryPostProcessor 的回调逻辑在此处都已经被执行完了，spring容器才开始实例化容器中 BeanPostProcessor 类型的对象。
                // 所以， BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 的回调实际要远远早于 BeanPostProcessor。
                // 其实从源码中也可以看出，spring容器注册bean定义本身就是通过容器上下文中注册的 BeanDefinitionRegistryPostProcessor 回调器进行的，因此它的执行必然优先；
                // 只有它执行了，spring容器中才会有普通bean的定义存在，接着才能拿到bean定义去做下一步的动作。
                // 而所有实现 BeanPostProcessor 钩子的普通bean定义这个时候才能拿到，才能从容器中获取所有类型为BeanPostProcessor的bean，拿到bean才能将这些BeanPostProcessor注册到spring容器中。
                // 因此：BeanFactoryPostProcessor 和 BeanDefinitionRegistryPostProcessor 的回调逻辑远远早于 BeanPostProcessor 钩子。
                this.registerBeanPostProcessors(beanFactory);
                beanPostProcess.end();
                
                // 初始化 messageSource 对象。
                // messageSource 对象是用来处理消息的，说白了就是用来读取国际化资源文件的一个bean。
                // 这个后续单独写一篇文章分析。
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                
                // 在spring容器正式利用beanFactory工厂根据beanDefinition去实例化bean前，做一些其他工作
                // 主要是创建web运行环境，即将servlet容器（Servlet、Filter、Listener等）纳入到spring容器中来。
                // 我们知道，spring的web容器其实是Servlet容器内部的一个子容器，它没法管理Servlet容器中的对象；
                // 比如Servlet容器中的servlet、filter、listener等。
                // 传统的Servlet规范，要想向Servlet容器中注册servlet、filter、listener对象等，比如配置web.xml。
                // 然后实现Servlet规范的web服务器厂商（比如tomcat），会遵守Servlet规范，去解析web.xml，拿到web.xml中配置的serlvet，filter等，进行反射，然后将其注册到tomcat容器中。
                // Servlet3.x规范废弃了web.xml，提供了api侵入式来向Servlet容器中注册servlet、filter、listener对象等。
                // springboot依靠Servlet3.x的规范，内置了tomcat容器，并依靠Servlet3.x提供的api来显式的通过代码向Servlet容器中注册serlvet、filter等。
                // 这个方法后面单独写一篇文章分析。
                this.onRefresh();
                
                // 注册springboot传进来的所有 ApplicationListener 对象
                this.registerListeners();
                
                // 完成spring beanFactory工厂对象的初始化工作，注意，真正根据beanDefinition去反射创建bean对象就是在这一步进行的。
                // 前面磨磨唧唧的，都是在向springboot容器中注册钩子，然后回调钩子；
                // 回调钩子时又向spring容器中注册钩子，然后回调钩子....
                // 这一系列操作下来，spring容器中现在已经有了所有内置的bean定义和普通的业务bean定义了（其中一些特殊钩子类型的bean已经被优先创建并回调执行了其钩子逻辑了）
                // 那么剩下的普通bean，就是在下面这个方法里面根据bean定义反射创建并注册到spring容器中的。
                this.finishBeanFactoryInitialization(beanFactory);
                
                // 完成spring容器的启动
                this.finishRefresh();
            } catch (BeansException var10) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var10);
                }

                this.destroyBeans();
                this.cancelRefresh(var10);
                throw var10;
            } finally {
                this.resetCommonCaches();
                contextRefresh.end();
            }
        }
    }

ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();

    protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
        // 为beanFactory工厂设置一些属性，不重要
        this.refreshBeanFactory();
        // 获取当前spring容器中的beanFactory工厂并返回
        return this.getBeanFactory();
    }

    public final ConfigurableListableBeanFactory getBeanFactory() {
        // 直接返回beanFactory
        return this.beanFactory;
    }

this.prepareBeanFactory(beanFactory);

    protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 为beanFactory设置classLoader
        beanFactory.setBeanClassLoader(this.getClassLoader());
        if (!shouldIgnoreSpel) {
            beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        }

        beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
        
        // 重点，为beanFactory注册一个BeanPostProcessor钩子,ApplicationContextAwareProcessor
        beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
        
        beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
        beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
        beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
        beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
        beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);
        beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
        beanFactory.registerResolvableDependency(ResourceLoader.class, this);
        beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
        beanFactory.registerResolvableDependency(ApplicationContext.class, this);
        
        // 注册一个 BeanPostProcessor 钩子，ApplicationListenerDetector
        beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
        
        if (!NativeDetector.inNativeImage() && beanFactory.containsBean("loadTimeWeaver")) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

        if (!beanFactory.containsLocalBean("environment")) {
            beanFactory.registerSingleton("environment", this.getEnvironment());
        }

        if (!beanFactory.containsLocalBean("systemProperties")) {
            beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
        }

        if (!beanFactory.containsLocalBean("systemEnvironment")) {
            beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
        }

        if (!beanFactory.containsLocalBean("applicationStartup")) {
            beanFactory.registerSingleton("applicationStartup", this.getApplicationStartup());
        }

    }

class ApplicationContextAwareProcessor implements BeanPostProcessor

    @Nullable
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 判断传入的bean是否是指定的类型，如果不是，则直接返回原始bean，如果是则做处理。
        if (!(bean instanceof EnvironmentAware) && !(bean instanceof EmbeddedValueResolverAware) && !(bean instanceof ResourceLoaderAware) && !(bean instanceof ApplicationEventPublisherAware) && !(bean instanceof MessageSourceAware) && !(bean instanceof ApplicationContextAware) && !(bean instanceof ApplicationStartupAware)) {
            return bean;
        } else {
            AccessControlContext acc = null;
            if (System.getSecurityManager() != null) {
                acc = this.applicationContext.getBeanFactory().getAccessControlContext();
            }

            if (acc != null) {
                AccessController.doPrivileged(() -> {
                    this.invokeAwareInterfaces(bean);
                    return null;
                }, acc);
            } else {
                // 对原始bean做处理
                this.invokeAwareInterfaces(bean);
            }

            return bean;
        }
    }

  private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof EnvironmentAware) {
            // 如果bean是EnvironmentAware类型，则回调执行setEnvironment方法
            ((EnvironmentAware)bean).setEnvironment(this.applicationContext.getEnvironment());
        }

        if (bean instanceof EmbeddedValueResolverAware) {
            ((EmbeddedValueResolverAware)bean).setEmbeddedValueResolver(this.embeddedValueResolver);
        }

        if (bean instanceof ResourceLoaderAware) {
            ((ResourceLoaderAware)bean).setResourceLoader(this.applicationContext);
        }

        if (bean instanceof ApplicationEventPublisherAware) {
            ((ApplicationEventPublisherAware)bean).setApplicationEventPublisher(this.applicationContext);
        }

        if (bean instanceof MessageSourceAware) {
            ((MessageSourceAware)bean).setMessageSource(this.applicationContext);
        }

        if (bean instanceof ApplicationStartupAware) {
            ((ApplicationStartupAware)bean).setApplicationStartup(this.applicationContext.getApplicationStartup());
        }

        if (bean instanceof ApplicationContextAware) {
            // 最常用的 ApplicationContextAware 钩子，就是在这个注册的
            ((ApplicationContextAware)bean).setApplicationContext(this.applicationContext);
        }

    }

this.postProcessBeanFactory(beanFactory);

    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 执行父类的方法
        super.postProcessBeanFactory(beanFactory);
        
        // 如果指定了basePackages扫描包路径，则对目标包进行扫描
        if (this.basePackages != null && this.basePackages.length > 0) {
            this.scanner.scan(this.basePackages);
        }

        // 如果注解容器不为空则注册
        if (!this.annotatedClasses.isEmpty()) {
            this.reader.register(ClassUtils.toClassArray(this.annotatedClasses));
        }

    }

    protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
        // 向beanFactory对象注册一个BeanPostProcessor对象->WebApplicationContextServletContextAwareProcessor
        beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
        beanFactory.ignoreDependencyInterface(ServletContextAware.class);
        this.registerWebApplicationScopes();
    }

public class WebApplicationContextServletContextAwareProcessor extends ServletContextAwareProcessor

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (this.getServletContext() != null && bean instanceof ServletContextAware) {
            ((ServletContextAware)bean).setServletContext(this.getServletContext());
        }

        if (this.getServletConfig() != null && bean instanceof ServletConfigAware) {
            ((ServletConfigAware)bean).setServletConfig(this.getServletConfig());
        }

        return bean;
    }

    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
        if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
            // 注册一个 BeanPostProcessor - LoadTimeWeaverAwareProcessor
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }

    }

    // 这个方法是扫描bean定义并注册beanDefinition的核心方法。
    public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        Set<String> processedBeans = new HashSet();
        ArrayList regularPostProcessors;
        ArrayList registryProcessors;
        int var9;
        ArrayList currentRegistryProcessors;
        String[] postProcessorNames;
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
            regularPostProcessors = new ArrayList();
            registryProcessors = new ArrayList();
            Iterator var6 = beanFactoryPostProcessors.iterator();

            while(var6.hasNext()) {
                BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                } else {
                    regularPostProcessors.add(postProcessor);
                }
            }

            currentRegistryProcessors = new ArrayList();
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            String[] var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            int var10;
            String ppName;
            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }

            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            var16 = postProcessorNames;
            var9 = postProcessorNames.length;

            for(var10 = 0; var10 < var9; ++var10) {
                ppName = var16[var10];
                if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    processedBeans.add(ppName);
                }
            }

            sortPostProcessors(currentRegistryProcessors, beanFactory);
            registryProcessors.addAll(currentRegistryProcessors);
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
            currentRegistryProcessors.clear();
            boolean reiterate = true;

            while(reiterate) {
                reiterate = false;
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                String[] var19 = postProcessorNames;
                var10 = postProcessorNames.length;

                for(int var26 = 0; var26 < var10; ++var26) {
                    String ppName = var19[var26];
                    if (!processedBeans.contains(ppName)) {
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                        reiterate = true;
                    }
                }

                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
                currentRegistryProcessors.clear();
            }

            invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
            invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        } else {
            invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        }

        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
        regularPostProcessors = new ArrayList();
        registryProcessors = new ArrayList();
        currentRegistryProcessors = new ArrayList();
        postProcessorNames = postProcessorNames;
        int var20 = postProcessorNames.length;

        String ppName;
        for(var9 = 0; var9 < var20; ++var9) {
            ppName = postProcessorNames[var9];
            if (!processedBeans.contains(ppName)) {
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
                } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                    registryProcessors.add(ppName);
                } else {
                    currentRegistryProcessors.add(ppName);
                }
            }
        }

        sortPostProcessors(regularPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList(registryProcessors.size());
        Iterator var21 = registryProcessors.iterator();

        while(var21.hasNext()) {
            String postProcessorName = (String)var21.next();
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }

        sortPostProcessors(orderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList(currentRegistryProcessors.size());
        Iterator var24 = currentRegistryProcessors.iterator();

        while(var24.hasNext()) {
            ppName = (String)var24.next();
            nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
        }

        invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
        beanFactory.clearMetadataCache();
    }