SpringBoot启动流程及扩展点分析

先来一段经典的SpringBoot启动代码

@SpringBootApplication
public class SpringbootDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootDemoApplication.class, args);
    }
}

SpringBoot应用程序的启动是调用SpringApplication的静态run方法开始的，我们看一下其源代码

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);
}

可以看到，启动程序是先将启动类，即示例代码中的SpringbootDemoApplication类作为参数，构造出一个SpringApplication实例，再调用这个SpringApplication实例的run方法进行启动

getSpringFactoriesInstances

这里我们先了解一下SpringBoot中很常见的getSpringFactoriesInstances方法

// 从各个jar包中的spring.factories中获取到类型为type的类，并将其实例化
private  Collection getSpringFactoriesInstances(Class type) {
    return getSpringFactoriesInstances(type, new Class[] {});
}

/**
 * 从各个jar包中的spring.factories中获取到类型为type的类，并调用其构造函数参数类型为parameterTypes的函数进行初始化
 * type: 从各个jar包中的spring.factories中获取到类型为type的类
 * parameterTypes: 构造函数的参数类型列表
 * args: 构造函数的参数列表
 */
private  Collection getSpringFactoriesInstances(Class type, Class[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // 调用SpringFactoriesLoader，找到其中类型为type的类，返回这些类的全限定名
    Set names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // 构造上面这些类的实例
    List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    // 按照注解排个序，即@Order
    AnnotationAwareOrderComparator.sort(instances);
    // 返回这些实例
    return instances;
}

上面代码中，通过SpringFactoriesLoader加载类型为type的类。这里我们不深入分析了，简单来说，SpringFactoriesLoader就是加载类路径下，所有的META-INF/spring.factories文件，这些文件中是一个properties文件，其中定义了各个类型（即type）及其实现子类，以下是一个文件实例
key就是type的全限定名，value就是我们返回的类名的集合

SpringBoot启动流程及扩展点分析_第1张图片

SpringApplication构造方法

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

/**
* resourceLoader 资源加载器，默认为空
* primarySources 我们的启动类的class
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    // 资源加载器，默认为空
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // 1. 检测Web应用程序类型
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 2. 加载引导上下文的初始化器，引导上下文也是一个容器，主要应用在SpringBoot启动阶段引导应用程序上下文启动
    this.bootstrapRegistryInitializers = new ArrayList<>(
            getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
    // 3. 加载应用程序初始化器
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 4. 加载监听器
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 5. 设置主启动类
    this.mainApplicationClass = deduceMainApplicationClass();
}

我们来挨个分析其中的代码

检测Web应用程序类型

检测Web应用程序类型是由WebApplicationType完成的，以下是WebApplicationType的源代码

public enum WebApplicationType {
    // 说明不是Web应用程序，不应该启动Web服务器
    NONE,
    // 说明应用程序是基于Servlet启动的，会启动内嵌的Web服务器
    SERVLET,
    // 说明应用程序时基于响应式的web应用程序，会启动内嵌的响应式Web服务器
    REACTIVE;

    private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
            "org.springframework.web.context.ConfigurableWebApplicationContext" };

    private static final String WEBMVC_INDICATOR_CLASS = "org.springframework.web.servlet.DispatcherServlet";

    private static final String WEBFLUX_INDICATOR_CLASS = "org.springframework.web.reactive.DispatcherHandler";

    private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";

    static WebApplicationType deduceFromClasspath() {
        // 如果类路径下有DispatcherHandler并且没有DispatcherServlet，也没有ServletContainer，说明是响应式Web应用程序
        if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
                && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
            return WebApplicationType.REACTIVE;
        }
        // 如果类路径下没有Setvlet相关类，则说明不是Web应用程序
        for (String className : SERVLET_INDICATOR_CLASSES) {
            if (!ClassUtils.isPresent(className, null)) {
                return WebApplicationType.NONE;
            }
        }
        // 其余情况表示是普通的Servlet的Web应用程序
        return WebApplicationType.SERVLET;
    }
}

加载引导上下文的初始化器

接下来是加载引导上下文的初始化器，即BootstrapRegistryInitializer的实例，我们可以看一下BootstrapRegistryInitializer的源代码

// BootstrapRegistry的回调接口，在BootstrapRegistry使用之前对BootstrapRegistry进行处理
@FunctionalInterface
public interface BootstrapRegistryInitializer {

    void initialize(BootstrapRegistry registry);

}

在这里就不得不先提到引导上下文BootstrapContext，它是一个小容器，专门在SpringBoot启动过程中引导应用程序容器启动，而BootstrapContext目前只有唯一一个实现类DefaultBootstrapContext，而它同时实现了BootstrapRegistry。BootsstrapRegistryInitializer就是对这个DefaultBootstrapContext做处理的

SpringBoot启动流程及扩展点分析_第2张图片
而默认情况下，SpringBoot并没有定义任何的BootstrapRegistryInitializer

加载应用程序初始化器

应用程序初始化器，对应用程序上下文进行初始化处理的

/**
 * ConfigurableApplicationContext的回调接口，会在refresh方法调用之前对ApplicationContext进行处理
 * 一般用于对ApplicationContext进行一些初始化工作，比如注册一个属性源或者激活某个profile
 *
 * ApplicationContextInitializer会按照Ordered接口或者@Order注解定义的优先级进行排序
 */
@FunctionalInterface
public interface ApplicationContextInitializer {

    void initialize(C applicationContext);

}

以下是SpringBoot默认提供的应用程序上下文的初始化器

SpringBoot启动流程及扩展点分析_第3张图片

加载监听器

// 应用程序监听器，监听ApplicationEvent接口。是基于观察者模式创建的接口
@FunctionalInterface
public interface ApplicationListener extends EventListener {

    void onApplicationEvent(E event);

    /**
     * 静态方法，为消息类型T创建一个监听器
     */
    static  ApplicationListener> forPayload(Consumer consumer) {
        return event -> consumer.accept(event.getPayload());
    }
}

我们再看看SpringBoot默认提供了哪些应用监听器

SpringBoot启动流程及扩展点分析_第4张图片

设置主启动类

private Class deduceMainApplicationClass() {
    try {
        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
        for (StackTraceElement stackTraceElement : stackTrace) {
            if ("main".equals(stackTraceElement.getMethodName())) {
                return Class.forName(stackTraceElement.getClassName());
            }
        }
    }
    catch (ClassNotFoundException ex) {
        // Swallow and continue
    }
    return null;
}

这个代码非常有意思，它是手动创建了一个异常，然后追踪异常堆栈信息，找到main方法所在的类，它就是启动类

run方法解析

看完了SpringApplication的构造方法逻辑，我们接下来看看run方法的实现

// 创建应用程序的ApplicationContext，并进行刷新启动
public ConfigurableApplicationContext run(String... args) {
    long startTime = System.nanoTime();
    // 1. 创建引导上下文
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    // 配置无头模式参数，不做分析
    configureHeadlessProperty(); 
    // 2. 创建SpringBootRunListeners，即启动过程中的监听器。在启动过程中会触发这些监听器
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 触发应用程序开始启动的事件
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
        // 解析命令行参数，封装到ApplicationArguments
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 3. 准备好Environment
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        configureIgnoreBeanInfo(environment);
        // 输出banner，不重要，忽略
        Banner printedBanner = printBanner(environment);
        // 4. 创建应用程序上下文
        context = createApplicationContext();
        context.setApplicationStartup(this.applicationStartup);
        // 5. 准备好应用程序上下文
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        // 6. 刷新应用程序上下文
        refreshContext(context);
        // 刷新后的处理，默认没有实现，这个是交给子类实现的
        afterRefresh(context, applicationArguments);
        Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
        }
        // 触发启动完毕的事件
        listeners.started(context, timeTakenToStartup);
        // 7. 调用SpringRunner
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        // 处理启动失败
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
        // 触发准备完毕的事件
        listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
        // 处理启动失败
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

创建引导上下文createBootstrapContext

SpringApplication会调用createBootstrapContext方法创建引导上下文

private DefaultBootstrapContext createBootstrapContext() {
    DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
    this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
    return bootstrapContext;
}

这里就可以看到，在SpringApplication构造方法中的BootstrapRegistryInitializers就会应用到DefaultBootstrapContext中。这也是SpringBoot提供的扩展点之一

当前扩展点图谱

创建SpringApplicationRunListeners

private SpringApplicationRunListeners getRunListeners(String[] args) {
    Class[] types = new Class[] { SpringApplication.class, String[].class };
    return new SpringApplicationRunListeners(logger,
            getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
            this.applicationStartup);
}

SpringApplicationRunListener

SpringApplicationRunListener监听run方法的各个阶段，在不同的阶段监听不同的事件

// 对run方法中的各个阶段进行监听触发，其实现类必须有一个公共构造参数，其接受的参数为
// SpringApplication和[]String，前者为SpringApplication的实例，后者为启动应用程序输入的参数
public interface SpringApplicationRunListener {

    /**
     * 在run方法开始启动时触发
     * @param bootstrapContext 引导上下文
     */
    default void starting(ConfigurableBootstrapContext bootstrapContext) {
    }

    /**
     * 当Environment准备完毕时触发，此时应用程序上下文ApplicationContext还没有被创建
     * 触发方法为prepareEnvironment
     * @param bootstrapContext 引导上下文
     * @param environment Environment实例
     */
    default void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
            ConfigurableEnvironment environment) {
    }

    /**
     * 在应用程序上下文ApplicationContext创建并准备完成时触发
     * 触发方法为prepareContext
     * @param context 应用程序上下文
     */
    default void contextPrepared(ConfigurableApplicationContext context) {
    }

    /**
     * 在应用程序上下文ApplicationContext载入初始化bean之后触发，此时还未触发上下文的refresh方法
     * 触发方法文prepareContext
     * @param context 应用程序上下文
     */
    default void contextLoaded(ConfigurableApplicationContext context) {
    }

    /**
     * 在应用程序上下文刷新并启动完成之后触发，此时CommandLineRunner和ApplicationRunner还未触发
     * 在run方法内触发
     * @param context 应用程序上下文
     * @param timeTaken 从应用程序启动至触发started事件触发花费的时间，可能为null
     * @since 2.6.0
     */
    default void started(ConfigurableApplicationContext context, Duration timeTaken) {
        started(context);
    }

    /**
     * 早期的started方法，已弃用
     */
    @Deprecated
    default void started(ConfigurableApplicationContext context) {
    }

    /**
     * 在应用程序启动并刷新完成，并且所有的CommandLineRunner和ApplicationRunner都运行完成之后触发
     * 在run方法内触发
     * @param context 应用程序上下文
     * @param timeTaken 从应用程序启动至触发ready事件触发花费的事件，可能为null
     * @since 2.6.0
     */
    default void ready(ConfigurableApplicationContext context, Duration timeTaken) {
        running(context);
    }

    /**
     * 早期的ready方法，已弃用
     */
    @Deprecated
    default void running(ConfigurableApplicationContext context) {
    }

    /**
     * 当启动应用失败时触发
     * @param context 应用程序上下文，可能为null
     * @param exception 导致启动失败的异常
     * @since 2.0.0
     */
    default void failed(ConfigurableApplicationContext context, Throwable exception) {
    }
}

接下来看看SpringBoot默认提供的SpringApplicationRunListener

SpringBoot启动流程及扩展点分析_第5张图片

SpringApplicationRunListeners

SpringApplicationRunListeners是一个封装类，其中封装了一个SpringApplicationRunListener的列表，当触发某个事件是，就挨个调用其中的SpringApplicationRunListener的对应方法

class SpringApplicationRunListeners {

    private final Log log;

    private final List listeners;

    private final ApplicationStartup applicationStartup;

    SpringApplicationRunListeners(Log log, Collection listeners,
            ApplicationStartup applicationStartup) {
        this.log = log;
        this.listeners = new ArrayList<>(listeners);
        this.applicationStartup = applicationStartup;
    }

    void starting(ConfigurableBootstrapContext bootstrapContext, Class mainApplicationClass) {
        doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
                (step) -> {
                    if (mainApplicationClass != null) {
                        step.tag("mainApplicationClass", mainApplicationClass.getName());
                    }
                });
    }

    void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
        doWithListeners("spring.boot.application.environment-prepared",
                (listener) -> listener.environmentPrepared(bootstrapContext, environment));
    }

    void contextPrepared(ConfigurableApplicationContext context) {
        doWithListeners("spring.boot.application.context-prepared", (listener) -> listener.contextPrepared(context));
    }

    void contextLoaded(ConfigurableApplicationContext context) {
        doWithListeners("spring.boot.application.context-loaded", (listener) -> listener.contextLoaded(context));
    }

    void started(ConfigurableApplicationContext context, Duration timeTaken) {
        doWithListeners("spring.boot.application.started", (listener) -> listener.started(context, timeTaken));
    }

    void ready(ConfigurableApplicationContext context, Duration timeTaken) {
        doWithListeners("spring.boot.application.ready", (listener) -> listener.ready(context, timeTaken));
    }

    void failed(ConfigurableApplicationContext context, Throwable exception) {
        doWithListeners("spring.boot.application.failed",
                (listener) -> callFailedListener(listener, context, exception), (step) -> {
                    step.tag("exception", exception.getClass().toString());
                    step.tag("message", exception.getMessage());
                });
    }

    private void callFailedListener(SpringApplicationRunListener listener, ConfigurableApplicationContext context,
            Throwable exception) {
        try {
            listener.failed(context, exception);
        }
        catch (Throwable ex) {
            if (exception == null) {
                ReflectionUtils.rethrowRuntimeException(ex);
            }
            if (this.log.isDebugEnabled()) {
                this.log.error("Error handling failed", ex);
            }
            else {
                String message = ex.getMessage();
                message = (message != null) ? message : "no error message";
                this.log.warn("Error handling failed (" + message + ")");
            }
        }
    }

    private void doWithListeners(String stepName, Consumer listenerAction) {
        doWithListeners(stepName, listenerAction, null);
    }

    private void doWithListeners(String stepName, Consumer listenerAction,
            Consumer stepAction) {
        StartupStep step = this.applicationStartup.start(stepName);
        // 调用每个方法
        this.listeners.forEach(listenerAction);
        if (stepAction != null) {
            stepAction.accept(step);
        }
        step.end();
    }

}

EventPublishingRunListener

SpringBoot默认使用EventPublishingRunListener作为run方法的监听者，我们来看看其源代码

/**
 * SpringApplicationRunListener 的实现类，它主要是依赖Spring的事件分发机制来触发事件
 */
public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {

    private final SpringApplication application;

    private final String[] args;

    private final SimpleApplicationEventMulticaster initialMulticaster;

    public EventPublishingRunListener(SpringApplication application, String[] args) {
        this.application = application;
        this.args = args;
        this.initialMulticaster = new SimpleApplicationEventMulticaster();
        for (ApplicationListener listener : application.getListeners()) {
            this.initialMulticaster.addApplicationListener(listener);
        }
    }

    @Override
    public int getOrder() {
        return 0;
    }

    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        this.initialMulticaster
                .multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
    }

    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
            ConfigurableEnvironment environment) {
        this.initialMulticaster.multicastEvent(
                new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        this.initialMulticaster
                .multicastEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        for (ApplicationListener listener : this.application.getListeners()) {
            if (listener instanceof ApplicationContextAware) {
                ((ApplicationContextAware) listener).setApplicationContext(context);
            }
            context.addApplicationListener(listener);
        }
        this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
    }

    @Override
    public void started(ConfigurableApplicationContext context, Duration timeTaken) {
        context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context, timeTaken));
        AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);
    }

    @Override
    public void ready(ConfigurableApplicationContext context, Duration timeTaken) {
        context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context, timeTaken));
        AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC);
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        ApplicationFailedEvent event = new ApplicationFailedEvent(this.application, this.args, context, exception);
        if (context != null && context.isActive()) {
            // Listeners have been registered to the application context so we should
            // use it at this point if we can
            context.publishEvent(event);
        }
        else {
            // An inactive context may not have a multicaster so we use our multicaster to
            // call all the context's listeners instead
            if (context instanceof AbstractApplicationContext) {
                for (ApplicationListener listener : ((AbstractApplicationContext) context)
                        .getApplicationListeners()) {
                    this.initialMulticaster.addApplicationListener(listener);
                }
            }
            this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());
            this.initialMulticaster.multicastEvent(event);
        }
    }

    private static class LoggingErrorHandler implements ErrorHandler {

        private static final Log logger = LogFactory.getLog(EventPublishingRunListener.class);

        @Override
        public void handleError(Throwable throwable) {
            logger.warn("Error calling ApplicationEventListener", throwable);
        }

    }

}

从代码中可以看到，EventPublishingRunListener会从SpringApplication中获取其Listener，即前面我们在构造方法中看到的ApplicationListener实例，在触发事件时，就是利用Spring的事件机制发布事件，触发ApplicationListener进行触发
这里需要注意的是，ApplicationListener的来源是spring.factories，而不是我们平时使用的@EventListener，也就是说，如果不写入到spring.factories，那么ApplicationListener就不会出现在这里的EventPublishingRunListener中

当前扩展点图谱

SpringBoot启动流程及扩展点分析_第6张图片

准备好Environment prepareEnvironment

先看源码

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
        DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    // 1. 创建一个Environment实例
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    // 2. 对Environment进行配置
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    // 对environment增加configurationProperty的属性源
    ConfigurationPropertySources.attach(environment);
    // 3. 触发监听SpringApplicationRunListener的environmentPrepared事件
    listeners.environmentPrepared(bootstrapContext, environment);
    // 将名为defaultProperties的属性源移动到最后
    DefaultPropertiesPropertySource.moveToEnd(environment);
    Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
            "Environment prefix cannot be set via properties.");
    // 将environment的属性设置到SpringApplication中
    bindToSpringApplication(environment);
    // 根据情况对Environment进行一次转换
    if (!this.isCustomEnvironment) {
        EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
        environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
    }
    ConfigurationPropertySources.attach(environment);
    return environment;
}

创建Environment实例，getOrCreateEnvironment

private ConfigurableEnvironment getOrCreateEnvironment() {
    // 如果当前environment不为空，直接返回
    if (this.environment != null) {
        return this.environment;
    }
    // 根据应用类型创建Environment
    ConfigurableEnvironment environment = this.applicationContextFactory.createEnvironment(this.webApplicationType);
    // 如果用户自己通过编程方式定制了applicationContextFactory，且其自定义的applicationContextFactory没有成功创建Environment
    // 则采用默认的方式创建一个environment
    if (environment == null && this.applicationContextFactory != ApplicationContextFactory.DEFAULT) {
        environment = ApplicationContextFactory.DEFAULT.createEnvironment(this.webApplicationType);
    }
    // 反正最后肯定会返回一个不为空的Environment
    return (environment != null) ? environment : new ApplicationEnvironment();
}

这里会使用成员属性applicationContextFactory创建Environment，其是一个ApplicationContextFactory接口类型。默认情况下SpringApplication中applicationContextFactory是DefaultApplicationContextFactory类型的

// SpringApplication中对applicationContextFactory的定义
private ApplicationContextFactory applicationContextFactory = ApplicationContextFactory.DEFAULT;

// ApplicationContextFactory 中对DEFAULT的定义
ApplicationContextFactory DEFAULT = new DefaultApplicationContextFactory();
ApplicationContextFactory

我们先来看看ApplicationContextFactory是做啥的

// 是提供给SpringApplication用来创建ConfigurableApplicationContext的策略接口
// 创建上下文时不应该改变其初始的内容，而是交给SpringApplication负责进行配置和刷新
@FunctionalInterface
public interface ApplicationContextFactory {

    // 定义了ApplicationContextFactory的默认实现DEFAULT
    ApplicationContextFactory DEFAULT = new DefaultApplicationContextFactory();

    /**
     * 根据传入的应用类型WebApplicationType返回其期望的Environment的类型
     * 该方法主要用在转换已有的Environment
     * @param webApplicationType 应用类型
     * @since 2.6.14
     */
    default Class getEnvironmentType(WebApplicationType webApplicationType) {
        return null;
    }

    /**
     * 根据应用类型WebApplicationType创建Environment，这个Environment随后会被设置到应用程序上下文中
     * 请注意，这个方法的返回值必须和getEnvironmentType方法的保持一致
     * @param webApplicationType 应用类型
     * @since 2.6.14
     */
    default ConfigurableEnvironment createEnvironment(WebApplicationType webApplicationType) {
        return null;
    }

    /**
     * 创建应用程序上下文
     * @param webApplicationType 应用类型
     */
    ConfigurableApplicationContext create(WebApplicationType webApplicationType);

    /**
     * 传入一个应用程序上下文类型，创建一个会使用该类型创建上下文的ApplicationContextFactory
     * @param contextClass 应用程序上下文类型
     * @return the factory that will instantiate the context class
     * @see BeanUtils#instantiateClass(Class)
     */
    static ApplicationContextFactory ofContextClass(Class contextClass) {
        return of(() -> BeanUtils.instantiateClass(contextClass));
    }

    //工具方法，与ofContextClass配套使用
    static ApplicationContextFactory of(Supplier supplier) {
        return (webApplicationType) -> supplier.get();
    }

}

总的来说，ApplicationContextFactory正如其名，主要负责创建应用程序上下文，附带会创建所需的Environment

DefaultApplicationContextFactory

因此，接下来我们看一下默认的DefaultApplicationContextFactory是如何创建Environment的

class DefaultApplicationContextFactory implements ApplicationContextFactory {
    // 省略无关代码

    @Override
    public Class getEnvironmentType(WebApplicationType webApplicationType) {
        return getFromSpringFactories(webApplicationType, ApplicationContextFactory::getEnvironmentType, null);
    }
    
    @Override
    public ConfigurableEnvironment createEnvironment(WebApplicationType webApplicationType) {
        return getFromSpringFactories(webApplicationType, ApplicationContextFactory::createEnvironment, null);
    }

    @Override
    public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
        try {
            return getFromSpringFactories(webApplicationType, ApplicationContextFactory::create,
                    AnnotationConfigApplicationContext::new);
        }
        catch (Exception ex) {
            throw new IllegalStateException("Unable create a default ApplicationContext instance, "
                    + "you may need a custom ApplicationContextFactory", ex);
        }
    }

    /**
     * 从spring.factories中获取ApplicationContextFactory类型的实例，遍历这些实例创建Environment
     * @param webApplicationType 应用类型，即前面提到的NONE，SERLVET，REACTIVE
     * @param action 函数，定义对每个ApplicationContextFactory调用哪个方法进行处理
     * @param defaultResult 定义默认值
     */
    private  T getFromSpringFactories(WebApplicationType webApplicationType,
            BiFunction action, Supplier defaultResult) {
        for (ApplicationContextFactory candidate : SpringFactoriesLoader.loadFactories(ApplicationContextFactory.class,
                getClass().getClassLoader())) {
            T result = action.apply(candidate, webApplicationType);
            if (result != null) {
                return result;
            }
        }
        return (defaultResult != null) ? defaultResult.get() : null;
    }
}

DefaultApplicationContextFactory的设计采用了组合模式，它本身没有太多逻辑，它的职责是通过SpringFactoriesLoader加载spring.factories中定义的ApplicationContextFactory，然后将相关逻辑交给这些spring.factories中的ApplicationContextFactory进行处理

其他ApplicationContextFactory

这里又看到了熟悉的SpringFactoriesLoader，因此我们继续看看默认情况下SpringBoot提供了哪些ApplicationContextFactory

SpringBoot启动流程及扩展点分析_第7张图片

简单看看SpringBoot默认提供的这些ApplicationContextFactory

// 对应响应式应用程序
public class AnnotationConfigReactiveWebServerApplicationContext extends ReactiveWebServerApplicationContext
        implements AnnotationConfigRegistry {
    // 省略无关代码
            
    static class Factory implements ApplicationContextFactory {

        @Override
        public Class getEnvironmentType(WebApplicationType webApplicationType) {
            return (webApplicationType != WebApplicationType.REACTIVE) ? null : ApplicationReactiveWebEnvironment.class;
        }

        @Override
        public ConfigurableEnvironment createEnvironment(WebApplicationType webApplicationType) {
            return (webApplicationType != WebApplicationType.REACTIVE) ? null : new ApplicationReactiveWebEnvironment();
        }

        @Override
        public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
            return (webApplicationType != WebApplicationType.REACTIVE) ? null
                    : new AnnotationConfigReactiveWebServerApplicationContext();
        }

    }
}

// 对应普通Web应用程序
public class AnnotationConfigServletWebServerApplicationContext extends ServletWebServerApplicationContext
        implements AnnotationConfigRegistry {
    // 省略无关代码

    static class Factory implements ApplicationContextFactory {

        @Override
        public Class getEnvironmentType(WebApplicationType webApplicationType) {
            return (webApplicationType != WebApplicationType.SERVLET) ? null : ApplicationServletEnvironment.class;
        }

        @Override
        public ConfigurableEnvironment createEnvironment(WebApplicationType webApplicationType) {
            return (webApplicationType != WebApplicationType.SERVLET) ? null : new ApplicationServletEnvironment();
        }

        @Override
        public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
            return (webApplicationType != WebApplicationType.SERVLET) ? null
                    : new AnnotationConfigServletWebServerApplicationContext();
        }

    }
}

这里两个ApplicationContextFactory就分别对应SERVLET和REACTIVE两种应用类型。
我们经常使用SpringBoot开发Web应用程序，基本上都是SERVLET类型的，所以，在创建Environment时就是ApplicationServletEnvironment。本文的重点不是Environment，因此不做深入的解析了

对Environment进行配置，configureEnvironment

/**
 * 模板方法，主要逻辑委托给configurePropertySources和configureProfiles进行处理
 * 可以覆写本方法实现对environment的完全控制
 * 或者覆写configurePropertySources和configureProfiles实现局部的控制
 * @param environment 应用程序的Environment
 * @param args 传递给run方法的参数列表
 */
protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    // 1. 为environment设置上转换服务ConversionService
    if (this.addConversionService) {
        environment.setConversionService(new ApplicationConversionService());
    }
    // 2. 配置属性源
    configurePropertySources(environment, args);
    // 3. 配置profiles
    configureProfiles(environment, args);
}
设置转换服务ConversionService

这里我们简单看一下ConversionService是做啥的

/**
 * 用于类型转换的服务接口，ConversionService是Spring类型转换系统的入口
 * 调用convert(Object, class)可以进行一个线程安全的转换
 * @since 3.0
 */
public interface ConversionService {

    /**
     * 判断类型sourceType是否可以转换为targetType类型
     * 如果返回true，说明可以通过convert(Object, Class)进行转换
     * 
     * 对于集合，数组，map这些容器类型需要特别注意：
     * 对于这几个类型之间的相互转换，这个方法将总是返回true，即使其元素类型的转换会产生异常，也会返回true
     * 这就需要调用者自行处理ConversionException异常了
     * @param sourceType 源类型，如果source本身就是null，则传入null
     * @param targetType 目标类型
     * @throws 如果targetType为空，则会抛出非法参数异常
     */
    boolean canConvert(@Nullable Class sourceType, Class targetType);

    // 和前一个函数功能一样，只是参数不一样了
    boolean canConvert(@Nullable TypeDescriptor sourceType, TypeDescriptor targetType);

    /**
     * 将指定的source转换为目标类型target
     * @param source 数据源，可为null
     * @param targetType 目标类型，不可为null
     * @return 转换结果，targetType的实例
     * @throws ConversionException 转换异常
     * @throws IllegalArgumentException 如果targetType为null，抛出该异常
     */
    @Nullable
     T convert(@Nullable Object source, Class targetType);

    // 和前一个函数功能一样，只是参数不一样了
    @Nullable
    Object convert(@Nullable Object source, @Nullable TypeDescriptor sourceType, TypeDescriptor targetType);

}

简单来说，ConversionService负责转换类型，将某个source转成目标类型。因为Environment接口实现了PropertyResolver，其中有一个方法为

// 获取key的属性值，并按照targetType进行返回
@Nullable
 T getProperty(String key, Class targetType);

因此，Environment借助了ConversionService来实现将属性值转换成targetType的功能

配置属性源 configurePropertySources
/**
 * 添加，删除或者重排序environment中的PropertySource的顺序
 * @param environment 应用程序的Environment实例
 * @param args 传递给run方法的参数
 */
protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
    MutablePropertySources sources = environment.getPropertySources();
    if (!CollectionUtils.isEmpty(this.defaultProperties)) {
        DefaultPropertiesPropertySource.addOrMerge(this.defaultProperties, sources);
    }
    // addConmandLineProperties: 是否要将命令行参数作为属性源添加到Environment中，默认为true
    if (this.addCommandLineProperties && args.length > 0) {
        // 将命令行参数作为属性源添加到Environment中
        String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
        if (sources.contains(name)) {
            // 如果Environment中已经包含了同名的属性源，则将这两个属性源合并后替换到原来的
            PropertySource source = sources.get(name);
            CompositePropertySource composite = new CompositePropertySource(name);
            composite.addPropertySource(
                    new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
            composite.addPropertySource(source);
            sources.replace(name, composite);
        }
        else {
            // 将命令行参数放到第一优先级
            sources.addFirst(new SimpleCommandLinePropertySource(args));
        }
    }
}
配置profiles configureProfiles
/**
 * 可以在这里配置激活哪个profile，这和spring.profiles.active并不冲突。默认不激活任何profile
 * @param environment Environment实例
 * @param args 传递给run方法的参数
 */
protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
}

触发监听SpringApplicationRunListener的environmentPrepared事件

这里对environmentPrepared事件需要特殊介绍的原因是这里面还包括一个扩展点，我们来分析一下
前面分析中提到，ApplicationListener也是SpringBoot提供的一个特殊扩展点，他是由默认的EventPublishingRunListener（SpringApplicationRunListener的实现）并结合事件机制完成的。而SpringBoot默认提供的ApplicationListener中有一个EnvironmentPostProcessorApplicationListener，我们来分析这个EnvironmentPostProcessorApplicationListener

SpringBoot启动流程及扩展点分析_第8张图片

EnvironmentPostProcessorApplicationListener
public class EnvironmentPostProcessorApplicationListener implements SmartApplicationListener, Ordered {
    public static final int DEFAULT_ORDER = Ordered.HIGHEST_PRECEDENCE + 10;

    private final DeferredLogs deferredLogs;

    private int order = DEFAULT_ORDER;

    private final Function postProcessorsFactory;

    // 可以回到前面的章节，在SpringApplication构造函数中创建ApplicationListener时，调用的是无参构造方法
    public EnvironmentPostProcessorApplicationListener() {
        this(EnvironmentPostProcessorsFactory::fromSpringFactories, new DeferredLogs());
    }
    public EnvironmentPostProcessorApplicationListener(EnvironmentPostProcessorsFactory postProcessorsFactory) {
        this((classloader) -> postProcessorsFactory, new DeferredLogs());
    }
    EnvironmentPostProcessorApplicationListener(
            Function postProcessorsFactory, DeferredLogs deferredLogs) {
        this.postProcessorsFactory = postProcessorsFactory;
        this.deferredLogs = deferredLogs;
    }

    // 返回监听的事件类型，主要有三类事件
    // 1. ApplicationEnvironmentPreparedEvent
    // 2. ApplicationPreparedEvent
    // 3. ApplicationFailedEvent
    @Override
    public boolean supportsEventType(Class eventType) {
        return ApplicationEnvironmentPreparedEvent.class.isAssignableFrom(eventType)
                || ApplicationPreparedEvent.class.isAssignableFrom(eventType)
                || ApplicationFailedEvent.class.isAssignableFrom(eventType);
    }

    // 监听入口，可以看到最后会调用onApplicationEnvironmentPreparedEvent进行处理
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationEnvironmentPreparedEvent) {
            onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
        }
        if (event instanceof ApplicationPreparedEvent) {
            onApplicationPreparedEvent();
        }
        if (event instanceof ApplicationFailedEvent) {
            onApplicationFailedEvent();
        }
    }

    // 最后是遍历成员属性postProcessorsFactory获取到EnvironmentPostProcessor
    private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
        ConfigurableEnvironment environment = event.getEnvironment();
        SpringApplication application = event.getSpringApplication();
        for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
                event.getBootstrapContext())) {
            postProcessor.postProcessEnvironment(environment, application);
        }
    }

    private void onApplicationPreparedEvent() {
        finish();
    }

    private void onApplicationFailedEvent() {
        finish();
    }

    private void finish() {
        this.deferredLogs.switchOverAll();
    }

    List getEnvironmentPostProcessors(ResourceLoader resourceLoader,
            ConfigurableBootstrapContext bootstrapContext) {
        ClassLoader classLoader = (resourceLoader != null) ? resourceLoader.getClassLoader() : null;
        EnvironmentPostProcessorsFactory postProcessorsFactory = this.postProcessorsFactory.apply(classLoader);
        return postProcessorsFactory.getEnvironmentPostProcessors(this.deferredLogs, bootstrapContext);
    }

    @Override
    public int getOrder() {
        return this.order;
    }

    public void setOrder(int order) {
        this.order = order;
    }

}

这里可以看到EnvironmentPostProcessorApplicationListener的事件处理逻辑是调用内部的EnvironmentPostProcessor进行处理，而EnvironmentPostProcessor则是通过成员属性postProcessorsFactory获取到的。默认情况下，SpringBoot会调用EnvironmentPostProcessorApplicationListener的无参构造方法创建对应的监听请，而其无参构造方法中则是通过EnvironmentPostProcessorsFactory静态方法fromSpringFactories获取，对应源代码为：

static EnvironmentPostProcessorsFactory fromSpringFactories(ClassLoader classLoader) {
    return new ReflectionEnvironmentPostProcessorsFactory(classLoader,
            SpringFactoriesLoader.loadFactoryNames(EnvironmentPostProcessor.class, classLoader));
}

该代码会返回一个ReflectionEnvironmentPostProcessorsFactory，同时这里也看到了熟悉的SpringFactoriesLoader
我们挨个来分析

ReflectionEnvironmentPostProcessorsFactory
class ReflectionEnvironmentPostProcessorsFactory implements EnvironmentPostProcessorsFactory {

    private final List> classes;

    private ClassLoader classLoader;

    private final List classNames;

    ReflectionEnvironmentPostProcessorsFactory(Class... classes) {
        this.classes = new ArrayList<>(Arrays.asList(classes));
        this.classNames = null;
    }

    ReflectionEnvironmentPostProcessorsFactory(ClassLoader classLoader, String... classNames) {
        this(classLoader, Arrays.asList(classNames));
    }

    // EnvironmentPostProcessorsFactory.fromSpringFactories调用的构造函数
    ReflectionEnvironmentPostProcessorsFactory(ClassLoader classLoader, List classNames) {
        this.classes = null;
        this.classLoader = classLoader;
        this.classNames = classNames;
    }

    // 核心代码，EnvironmentPostProcessorApplicationListener 会调用这个方法来获取到
    // EnvironmentPostProcessor
    @Override
    public List getEnvironmentPostProcessors(DeferredLogFactory logFactory,
            ConfigurableBootstrapContext bootstrapContext) {
        Instantiator instantiator = new Instantiator<>(EnvironmentPostProcessor.class,
                (parameters) -> {
                    parameters.add(DeferredLogFactory.class, logFactory);
                    parameters.add(Log.class, logFactory::getLog);
                    parameters.add(ConfigurableBootstrapContext.class, bootstrapContext);
                    parameters.add(BootstrapContext.class, bootstrapContext);
                    parameters.add(BootstrapRegistry.class, bootstrapContext);
                });
        return (this.classes != null) ? instantiator.instantiateTypes(this.classes)
                : instantiator.instantiate(this.classLoader, this.classNames);
    }

}

可以看到，ReflectionEnvironmentPostProcessorsFactory的功能就是接收spring.factories中指定的EnvironmentPostProcessor类型，并实例化后交给EnvironmentPostProcessorApplicationListener来触发

关系图

下面是整理的关系图，可以帮助理清相关关系
SpringBoot启动流程及扩展点分析_第9张图片

扩展点

SpringBoot启动流程及扩展点分析_第10张图片

创建应用程序上下文 createApplicationContext

protected ConfigurableApplicationContext createApplicationContext() {
    return this.applicationContextFactory.create(this.webApplicationType);
}

这里就是调用ApplicationContextFactory进行创建Context
根据前文的源码分析我们可以知道，对于我们常用的Web应用程序来说，其ApplicationContextFactory是AnnotationConfigServletWebServerApplicationContext.Factory。其相关源码在前文可以查阅

准备应用程序上下文 preparedContext

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    // 设置Environment
    context.setEnvironment(environment);
    // 1. 对context进行后置处理
    postProcessApplicationContext(context);
    // 2. 应用初始化器
    applyInitializers(context);
    // 触发ContextPreparedEvent事件
    listeners.contextPrepared(context);
    // 在引导上下文中触发BootstrapContextClosedEvent事件
    bootstrapContext.close(context);
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null);
        logStartupProfileInfo(context);
    }
    // 添加SpringBoot特有的一些单例bean到应用程序上下文中
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
        ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
        if (beanFactory instanceof DefaultListableBeanFactory) {
            ((DefaultListableBeanFactory) beanFactory)
                    .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
    }
    // 添加懒加载相关的BeanFactoryPostProcessor
    if (this.lazyInitialization) {
        context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    }
    context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
    // 3. 对source进行处理，在这里我们可以提前注册一些bean到应用程序上下文中
    Set sources = getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    load(context, sources.toArray(new Object[0]));
    listeners.contextLoaded(context);
}

对context进行后置处理 postProcessApplicationContext


protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
    // 注册单例的beanNameGenerator，它的功能是生成bean的名称
    if (this.beanNameGenerator != null) {
        context.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                this.beanNameGenerator);
    }
    // 设置资源加载器
    if (this.resourceLoader != null) {
        if (context instanceof GenericApplicationContext) {
            ((GenericApplicationContext) context).setResourceLoader(this.resourceLoader);
        }
        if (context instanceof DefaultResourceLoader) {
            ((DefaultResourceLoader) context).setClassLoader(this.resourceLoader.getClassLoader());
        }
    }
    // 设置转换服务
    if (this.addConversionService) {
        context.getBeanFactory().setConversionService(context.getEnvironment().getConversionService());
    }
}


这个后置处理就是增加一些bean，设置一些字段到context中


应用初始化器 applyInitializers


protected void applyInitializers(ConfigurableApplicationContext context) {
    for (ApplicationContextInitializer initializer : getInitializers()) {
        Class requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
                ApplicationContextInitializer.class);
        Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
        initializer.initialize(context);
    }
}



可以看到，这里是获取了SpringApplication内部的初始化器，对context进行初始化操作。而这里的initializers是在SpringApplication构造函数中完成加载的，可以回到前面看一下，它也是从spring.factories中获取的


对source进行处理


source是SpringBoot提供的一种注册bean的方式，souce可以是一个class，可以是一个包Package，可以是一个XML文件或者Groovy脚本的Resource，可以是上述三种的字符串描述
SpringApplication中用成员属性sources来保存这些资源


protected void load(ApplicationContext context, Object[] sources) {
    if (logger.isDebugEnabled()) {
        logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
    }
    // 构造一个BeanDefinitionLoader，用于从sources中加载BeanDefinition，将其注册到context中去
    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();
}


这里就不进行深入的源码解析了，总结一下source情况


    

  • 如果source是一个Class类型，或者其是一个Class的全限定名字符串，则会将其对应的类注册到context中，特殊情况是Groovy脚本（这种情况没见到过，但是BeanDefinitionLoader确实会进行特殊处理）
    • 

  • 如果source是一个Package类型，或者其是一个包名的字符串，则会进行扫描，类似于ComponentScan
    • 

  • 如果source是一个Resource类型，或者是一个资源的字符串表达，则会尝试将其作为XML配置文件，或者Groovy脚本文件进行加载注册
    扩展点
    某种意义上，source也是一个扩展点，但考虑到很少用，暂不加入

    SpringBoot启动流程及扩展点分析_第11张图片
    刷新应用程序上下文 refreshContext
    private void refreshContext(ConfigurableApplicationContext context) {
  if (this.registerShutdownHook) {
      shutdownHook.registerApplicationContext(context);
  }
  refresh(context);
}

protected void refresh(ConfigurableApplicationContext applicationContext) {
  applicationContext.refresh();
}
    这里的代码比较简单，仅仅是调用applicationContext的刷新函数refresh即可。其内部是AbastactApplicationContext的刷新流程，本文暂不涉略其中
    调用SpringRunner callRunners
    
private void callRunners(ApplicationContext context, ApplicationArguments args) {
  List runners = new ArrayList<>();
  // 从应用程序上下文中获取所有ApplicationRunner的实例
  runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
  // 从应用程序上下文中获取所有CommandLineRunner的实例
  runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
  // 按照Ordered接口或者Order注解排序
  AnnotationAwareOrderComparator.sort(runners);
  // 遍历，调用方法
  for (Object runner : new LinkedHashSet<>(runners)) {
      if (runner instanceof ApplicationRunner) {
          callRunner((ApplicationRunner) runner, args);
      }
      if (runner instanceof CommandLineRunner) {
          callRunner((CommandLineRunner) runner, args);
      }
  }
}

private void callRunner(ApplicationRunner runner, ApplicationArguments args) {
  try {
      (runner).run(args);
  }
  catch (Exception ex) {
      throw new IllegalStateException("Failed to execute ApplicationRunner", ex);
  }
}

private void callRunner(CommandLineRunner runner, ApplicationArguments args) {
  try {
      (runner).run(args.getSourceArgs());
  }
  catch (Exception ex) {
      throw new IllegalStateException("Failed to execute CommandLineRunner", ex);
  }
}
    callRunners的方法比较简单，就是从容器中获取到ApplicationRunner和CommandLineRunner，调用其run方法
    这也算一个扩展点
    扩展点
    SpringBoot启动流程及扩展点分析_第12张图片
    总结
    SpringBoot的启动是一个非常复杂的流程，本文仅仅对SpringBoot的启动做了一些简要的梳理，同时总结了一些比较常见的SpringBoot的扩展点
    


    本文由mdnice多平台发布
    






    



    


    


    




    

    你可能感兴趣的:(程序员)
    

    

    

      

    • SQLite版本3中的文件锁定和并发(七）
代码工匠云
数据库SQLiteC与c++sqlitec++数据库

      返回：SQLite—系列文章目录上一篇：自己编译SQLite或将SQLite移植到新的操作系统（六）下一篇：SQLite—系列文章目录正文：1.0SQLite版本3中的文件锁定和并发SQLite版本3.0.0引入了新的锁定和日志功能旨在提高SQLite版本2的并发性的机制并减少作家的饥饿问题。新机制还允许交易的原子提交涉及多个数据库文件。本文档介绍新的锁定机制。目标受众是想要理解和/或修改的程序员
      

      • 

    • 程序员开发技术整理
laizhixue
学习前端框架

      前端技术：vue-前端框架element-前端框架bootstrap-前端框架echarts-图标组件C#后端技术：webservice：soap架构：简单的通信协议，用于服务通信ORM框架：对象关系映射，如EF：对象实体模型，是ado.net中的应用技术soap服务通讯：xml通讯ado.net：OAuth2:登录授权认证：Token认证：JWT：jsonwebtokenJava后端技术：便捷工
      

      • 

    • C++ 如何去认识模板
SuhyOvO
C++c++开发语言

      引言:C++模板是泛型编程的基石,允许程序员定义可与任何数据类型协作的函数和类。这种机制极大地增加了代码的灵活性和复用性,是C++最强大的特性之一。本文将深入探讨C++模板的概念、优势以及使用方法,帮助读者掌握这一重要的编程工具。文章目录模板简介模板的优势一、模板基础1.1模板的概念1.2函数模板1.3类模板二、模板进阶2.1模板的实例化2.2模板的特化2.3模板的默认参数2.4模板的嵌套三、模板
      

      • 

    • C++面试题
虾仁A
面试c++

      目录一、堆和栈的区别二、C++中new、delte和malloc的区别三、什么是源对象四、C++有哪些设计模式五，你使用过C++哪些类型的指针一、堆和栈的区别特性堆栈申请方式由程序员显式申请和释放由系统自动分配和释放分配方式动态分配自动分配分配效率相对较慢，需要遍历内存链表寻找合适空间相对较快，系统直接分配内存地址不连续的内存区域连续的内存区域大小限制大小灵活，上限取决于虚拟内存大小固定，通常较小
      

      • 

    • 老实的我，难道就注定找不到女朋友吗？
智慧同同

      老实如我，内向不爱说话不会幽默，30好几了，没有女朋友，连女生的手都没牵过，难道老实也是一种错？活该单身吗？事业没起色，感情也特失败，感觉我的前半生写满了悲剧，单身久了也会寂寞，可是现在感觉女朋友不好找，每天反思这自己为什么单身。1、嘴笨，不会说甜言蜜语老实如我，每天的工作就是对着电脑，以前是当程序员对着电脑敲代码，现在是做淘宝运营，天天对着电脑看数据，和人交流少，性格本来就内向，不爱说话也变得不
      

      • 

    • Java | 如何利用AI给编程提效
程序员影子
AI+编程实践java开发语言AI编程ai语言模型

      大家可以关注一下专栏，方便大家需要的时候直接查找，专栏将持续更新~大家好，我是程序员影子|全网同名一名致力于帮助更多朋友快速入门编程的程序猿一、引言AI已经频繁的出现在我们的生活中，那我们该如何更好的玩转AI+编程，提升自己的开发效率呢？本篇文章影子将为大家分享AI在编程开发中的提效，并以三大国产模型和Java语言作为例子，为大家带来实践分享。1.1AI编程助手的发展背景随着AI的快速发展，尤其是
      

      • 

    • 强大的文本编辑器：Sublime Text for Mac注册激活版
macw_q
后端

      SublimeTextforMac是一款功能强大的文本编辑器，特别适合程序员和开发者使用。它提供了丰富的功能，如智能代码补全、语法高亮、自定义快捷键、项目管理、多行选择、自动保存等，以提高代码编写效率和舒适度。此外，SublimeText还支持插件扩展，用户可以根据自己的需求安装各种插件，进一步增强编辑器的功能。软件下载：SublimeTextforMac注册激活版下载在Mac上使用Sublime
      

      • 

    • 我的RUST学习——【第九章 9-1】panic! 与不可恢复的错误
swallowblank
rustrust

      突然有一天，代码出问题了，而你对此束手无策。对于这种情况，Rust有panic!宏。当执行这个宏时，程序会打印出一个错误信息，展开并清理栈数据，然后接着退出。出现这种情况的场景通常是检测到一些类型的bug，而且程序员并不清楚该如何处理它。发生panic时的展开或终止当出现panic时，程序默认会开始展开（unwinding），这意味着Rust会回溯栈并清理它遇到的每一个函数的数据，不过这个回溯并清
      

      • 

    • 【创作纪念日】1024回忆录
风巽·剑染春水
创作纪念日1024

        不知不觉中，从创作第一篇文章到现在，已经1024天了，两年多的时间里，已经从硕士到博士了，1024，对于程序员来说，是个特别的数字吧，在此回忆与记录一下这些美好的经历吧。缘起  很早以前，我从来也没想过我会了解计算机，了解代码的世界，那时候少年心中的梦想是当一名医生，想要悬壶济世，想要治病救人。后来因为种种原因，我没能成为一名临床医学生，学习了生物医学工程专业。  这个专业说实话很杂，什么都学
      

      • 

    • 突破编程_C++_C++11新特性（type_traits的概念以及核心类型特性）
breakthrough_01
c++开发语言

      1type_traits的概述type_traits是C++标准模板库（STL）中的一个头文件，它定义了一系列模板类，这些模板类在编译期获取某一参数、某一变量、某一个类等的类型信息，主要用于进行静态检查。通过使用type_traits，程序员可以在编译时就获得关于类型的详细信息，从而可以在不实际运行程序的情况下进行类型相关的优化和检查。type_traits中的内容主要可以分为以下几类：辅助基类：
      

      • 

    • Rust字符串深入理解
Hello.Reader
rustrust开发语言后端

      一、概述Rust是一种系统级语言，进行操作系统等底层应用开发，同时又具合理的抽象处理能力。在进行Rust编程时，字符串处理是程序员经常碰到的工作。本文深入解析Rust语言中字符串的使用，包括staticstring，String与&str的区别，转换等等。二、Rust的字符串类型Rust主要提供了两种类型的字符串。一种是固定的Unicode字符串片段，称为’StringLiteral’或’str’
      

      • 

    • 13个可能未使用过的Python特性
千锋教育官方
Pythonpython开发语言

      大多数程序员不知道的令人难以置信的功能列表。Python是顶级编程语言之一，它具有许多程序员从未使用过的许多隐藏功能。在这篇文章中，我将分享你可能从未使用过的13个Python特性。1.列表Stepping这是一个step参数，可以通过采取几个步骤来分割你的列表。此外，你可以使用step参数来反转整数。看看下面的代码示例：# 列表Steppingdata = [10, 20, 30, 40, 50
      

      • 

    • 逃不过衣服的坑，程序员：不许笑！都给我憋着，不然不做需求了
程序员小伙伴

      程序员说好的避开格子衫，却逃不过条纹的坑...心里憋了很久的话...其实我一直很好奇一个问题，为什么大部分理工科男生穿的都一样，都对格子衬衫、冲锋衣等情有独钟？上班的时候，如果只看程序员小哥的背景，反正我是认不出谁是谁......看完有人在网上这样说身边的程序员，有网友不禁表示，抬头一看，我们公司的程序员果然一半多都在穿条纹。有个百度程序员还带着自嘲的语气说道：不许笑！都给我憋着！不然不做需求了。
      

      • 

    • 2019Java程序员就业前景比以往怎么样
心空如大海

      一直以来Java程序员都非常火,那么现今做Java程序员还依然有前途吗？Java编程在互联网方向的应用非常多，当然这也有更多的细分。目前采用Java开发互联网网站及应用的IT企业越来越多，这也增加了Java程序员的需求。众多行业中，程序员当然属于高薪职业。无论是国内还是国外，IT行业的程序员，工程师，甚至连码农都要比其他行业的从业者的收入高很多。Java行业市场需求存在巨大的缺口这几年中国在移动互
      

      • 

    • 有关程序员的幽默，你懂多少？,有关程序员的礼品
Java程序员笔记

      先上一副对联：上联：一个项目两部电脑三餐盒饭只为四千工资搞得五脏俱损六神无主仍然七点起床八点开会处理九个漏洞十分辛苦；下联：十年编码九年加班八面无光忙的七窍生烟到头六亲不认五体投地依旧四肢酸软三更加班只为二个臭钱一生孤苦；横批：苦逼程序员。warmingorerror某假日，一名男程开车带朋友出去玩。突然前方出现路标：警告！前方危险！但是程序员司机一点减速的趋势都没有。朋友大呼：“你没看到前面有警
      

      • 

    • JDBC的概念
2301_79744036
数据库java

      一.JDBC概念：其实JDBC就像是翻译官，就像是你去到国外是不是听不懂当地人再讲什么？Java就相当于是你，数据库就是本地人，然后JDBC就是那个翻译官，它提供了一套标准的方法和工具，让Java程序可以与各种不同类型的数据库进行交流，无论是MySQL、Oracle、SQLServer还是其他类型的数据库。它隐藏了与具体数据库相关的细节，使得Java程序员可以用相同的方式来访问不同的数据库，而不需
      

      • 

    • 第二章《有故事的程序员》跨行转IT入行原因及背景 探索思想的转变 初步关注IT行业
IT帮
有故事的程序员改行学it程序人生职场发展

      本故事是作者亲身经历外包阿里全栈工程师，去过富士康，送过外卖，卖过保险，进过传销......跨行转IT,github做过开源项目，发布过npm包，创过业，分享生活、技术交流、交友、兴趣爱好学习等，让大家轻松愉快边学习技术边畅谈人生...《有故事的程序员》转IT入行原因及背景探索思想的转变初步关注IT行第2集第二章入行原因及背景第1节悲催的往事之前是在郑州那个城市，租了一个很小的单间，这是一段路好多
      

      • 

    • 十年高级程序员从阿里离职，分享这些年的面试经验——offer篇
Java机械师

      时隔两年再一次的面临离职找工作，这一次换工作有些许的不舍，也有些许的无奈。个人所在的技术团队不错，两年时间成长了很多，也很不舍这个团队。但是，由于公司的某些原因和对于自身未来发展的综合考虑，又不得不得离去，去寻找更合适的地方成长和发展。相比于两年前，现在找工作没有那么的着急，也没有那么的迫切，也没有特别想去的公司，反正去大厂互联网公司基本都是加班加点的。也许，这是工作十年的我即将面临的一个坎吧。对
      

      • 

    • 【C/C++ 学习笔记】内存
糠帅傅蓝烧牛肉面
C/C++学习笔记c++学习笔记

      【C/C++学习笔记】内存视频地址:Bilibili内存分区模型代码区:存放函数体的二进制代码，由操作系统进行管理全局区:存放全局变量和静态变量以及常量栈区:由编译器自动分配释放，存放函数的参数值、局部变量等堆区:由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活性可执行程序在程序编译后，生成了exe可执行程序，为执行该程序前分为两
      

      • 

    • 二进制 （小白进军程序员）
没有女朋友的程序员
补码cpu

      1.人为什么使用十进制？人有10个手指头。2.计算机为什么用二进制？因为CPU的引脚是为了通电用的。有时候是高电频，有的是低电频。为了区分，就用0和1表示，0表示低点频。1表示高点频。二进制就是冯2进1.十进制就是冯10进1.3.十进制和二进制表数的共通点就是基数（radix）十进制的基数为10二进制的基数为24.二进制和十进制的转换口诀基数*位次幂+比如0101转为十进制0101=1*2的零次方
      

      • 

    • 3.1_3_覆盖与交换
LaVine
操作系统

      内存空间的扩充覆盖技术将程序分为多个段一个固定区，若干个覆盖区常驻内存的段放在固定区，调入后不再调出，不常用的段放在覆盖区，需要时调入内存，用不到的时候调出内存覆盖区采用最大的覆盖区覆盖结构需要程序员声明对用户不透明交换技术：当内存吃紧的时候将一些进程调出内存中级调度（内存调度）把某些进程换入换出内存，进程PCB常驻内存就绪挂起，阻塞挂起交换技术的几个问题调出的内存放在磁盘中的哪里？将磁盘划分为文
      

      • 

    • 主流开发语言和开发环境、程序员如何选择职业赛道？
洛可可白
程序员开发语言

      前言欢迎来到我的技术小宇宙！这里不仅是我记录技术点滴的后花园，也是我分享学习心得和项目经验的乐园。无论你是技术小白还是资深大牛，这里总有一些内容能触动你的好奇心。洛可可白：个人主页个人专栏：✅前端技术✅后端技术个人博客：洛可可白博客代码获取：bestwishes0203封面壁纸：洛可可白wallpaper文章目录主流开发语言和开发环境、程序员如何选择职业赛道？主流开发语言开发环境程序员如何选择职业
      

      • 

    • 2016年收入最高的5个编程语言
qq_34281962
编程语言调查报告数据语言大数据薪酬

      电子书网站Packt公布了其2016年技术提高报告。它提供的统计数据基于超过11,000名IT专业人士参与的关于2016年收入最高的编程语言的调研。它同时还介绍了流行的web框架和主题。高效的程序员是基于IT的企业结构的中坚力量。企业雇用擅长于不同编程语言的人，并支付他们薪水，这样人员才不会被竞争对手撬走。现在有许许多多的编程语言，数以千计的开发人员在用这些编程语言工作。但是，在薪水方面，学习有些
      

      • 

    • Java判断s1中出现s2的次数_java查找字符出现次数
李祥JasonLee

      Java第14次上机要求(2015年6月2日字符串第4次)_IT认证_资格考试/认证_教育专区。Java上机要求(第十四次上机)请大家将自己的垃圾自行带走,不要在机房吃东西,......Perl与Java字符串查找时的性能实验及分析_信息与通信_工程科技_专业资料。Perl和Java在处理字符串方面的强大功能,使得程序员们常常不知道如何选择他们。首先对Perl......发学生第3次java测试题
      

      • 

    • 面试 Java 并发编程八股文十问十答第四期
程序员小白条
面试八股文系列面试java职场和发展八股文面试基础项目实战

      面试Java并发编程八股文十问十答第四期作者：程序员小白条，个人博客相信看了本文后，对你的面试是有一定帮助的！关注专栏后就能收到持续更新！⭐点赞⭐收藏⭐不迷路！⭐1）线程优先级的理解线程优先级是操作系统调度线程时考虑的一个因素，用于确定线程在竞争CPU时间时的优先级顺序。Java中的线程优先级范围是从1到10，其中1是最低优先级，10是最高优先级。线程优先级的设置可以影响线程获取CPU时间片的概率
      

      • 

    • 借助ChatGPT提高编程效率指南
AI臻蚌
chatgptchatgpt人工智能

      PS:ChatGPT无限次数，无需魔法，登录即可使用,网页打开下面一、借助ChatGPT提高编程效率指南随着计算机技术的飞速发展，编程已经成为了现代社会中一个非常重要的技能。对于许多人来说，编程不仅是一项工作技能，而且是一种生活方式。然而，即使是最有经验的程序员，也会在编写代码时遇到困难和挑战。幸运的是，我们可以利用现代技术来提高编程效率，并使我们的工作更加轻松。ChatGPT是一种基于GPT-3
      

      • 

    • load与viewDidLoad的调用时机
要加油啊小和尚

      简单总结一些，等到底层原理都理解的时候，一切都会恍然大悟+(void)loadload这个类方法，在程序运行时，Runtime会将所有的Class和Category加载到内存中，如果实现了load方法，这时，会调用类的load方法，通知我们Class或Category已经被加载到内存中。为什么要自动调用load方法呢？目的当然是两个：1.告诉我们程序员你要在里面写一些代码啦，我调用的时候，顺便帮你
      

      • 

    • 2万字系统总结，帮你实现 Linux 命令自由
zy_zeros
elkspringboot后端

      前言Linux的学习对于一个程序员的重要性是不言而喻的。前端开发相比后端开发，接触Linux机会相对较少，因此往往容易忽视它。但是学好它却是程序员必备修养之一。Linux基础操作系统操作系统OperatingSystem简称OS，是软件的一部分，它是硬件基础上的第一层软件，是硬件和其它软件沟通的桥梁。操作系统会控制其他程序运行，管理系统资源，提供最基本的计算功能，如管理及配置内存、决定系统资源供需
      

      • 

    • HTML—基本介绍
Black—slience
html前端

      HTML是一种超文本标记语言(HyperTextMarkupLanguage)，用于创建网页的标记语言超文本：是指页面内可以包含图片、链接、声音、视频等内容标记：HTML富含大量的标签供程序员使用，通过标记符号来规定指定内容的样式浏览器最终根据不同的HTML标签，解析成日常中所看到的网页HTML文件基本格式(HTML5版本)网页标题标签体闭合标签(封闭的区间)②自闭合标签，没有修饰的内容-->加粗
      

      • 

    • Spring技术内幕：设计理念和整体架构概述
各自安好吧
spring架构java后端

      程序员都很崇拜技术大神，很大一部分是因为他们发现和解决问题的能力，特别是线上出现紧急问题时，总是能够快速定位和解决。一方面，他们有深厚的技术基础，对应用的技术知其所以然，另一方面，在采坑的过程中不断总结，积累了很多经验。相信大家都使用过Spring，有些人了解它的核心：IOC和AOP，但只是了解它们的基本概念、使用了反射和动态代理，关于如何管理对象、代理的具体实现了解的比较浅。有些人使用Sprin
      

      • 

    • JVM StackMapTable 属性的作用及理解
lijingyao8206
jvm字节码Class文件StackMapTable

       
      在Java 6版本之后JVM引入了栈图(Stack Map Table)概念。为了提高验证过程的效率，在字节码规范中添加了Stack Map Table属性，以下简称栈图，其方法的code属性中存储了局部变量和操作数的类型验证以及字节码的偏移量。也就是一个method需要且仅对应一个Stack Map Table。在Java 7版
      

      • 

    • 回调函数调用方法
百合不是茶
java

      最近在看大神写的代码时,.发现其中使用了很多的回调 ,以前只是在学习的时候经常用到 ,现在写个笔记 记录一下
 
代码很简单:
   
      MainDemo  :调用方法  得到方法的返回结果
  
     
      

      • 

    • [时间机器]制造时间机器需要一些材料
comsci
制造

            根据我的计算和推测,要完全实现制造一台时间机器,需要某些我们这个世界不存在的物质
    和材料...
      甚至可以这样说,这种材料和物质,我们在反应堆中也无法获得......
     
      

      • 

    • 开口埋怨不如闭口做事
邓集海
邓集海 做人 做事 工作

      “开口埋怨，不如闭口做事。”不是名人名言，而是一个普通父亲对儿子的训导。但是，因为这句训导，这位普通父亲却造就了一个名人儿子。这位普通父亲造就的名人儿子，叫张明正。 　　 　　张明正出身贫寒，读书时成绩差，常挨老师批评。高中毕业，张明正连普通大学的分数线都没上。高考成绩出来后，平时开口怨这怨那的张明正，不从自身找原因，而是不停地埋怨自己家庭条件不好、埋怨父母没有给他创造良好的学习环境。 　　 　　
      

      • 

    • jQuery插件开发全解析，类级别与对象级别开发
IT独行者
jquery开发插件　函数

      jQuery插件的开发包括两种： 一种是类级别的插件开发，即给
jQuery添加新的全局函数，相当于给
jQuery类本身添加方法。
jQuery的全局函数就是属于
jQuery命名空间的函数，另一种是对象级别的插件开发，即给
jQuery对象添加方法。下面就两种函数的开发做详细的说明。
 
1
、类级别的插件开发 类级别的插件开发最直接的理解就是给jQuer
      

      • 

    • Rome解析Rss
413277409
Rome解析Rss

      import java.net.URL; 
import java.util.List; 
 
import org.junit.Test; 
 
import com.sun.syndication.feed.synd.SyndCategory; 
import com.sun.syndication.feed.synd.S
      

      • 

    • RSA加密解密
无量
加密解密rsa

      RSA加密解密代码
代码有待整理
package com.tongbanjie.commons.util;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerat
      

      • 

    • linux 软件安装遇到的问题
aichenglong
linux遇到的问题ftp

      1 ftp配置中遇到的问题
   500 OOPS: cannot change directory
  出现该问题的原因:是SELinux安装机制的问题.只要disable SELinux就可以了
  修改方法:1 修改/etc/selinux/config 中SELINUX=disabled
   2 source /etc
      

      • 

    • 面试心得
alafqq
面试

      最近面试了好几家公司。记录下；
支付宝，面试我的人胖胖的，看着人挺好的；博彦外包的职位，面试失败；
阿里金融，面试官人也挺和善，只不过我让他吐血了。。。
由于印象比较深，记录下；
1，自我介绍
2，说下八种基本类型；（算上string。楼主才答了3种，哈哈，string其实不是基本类型，是引用类型）
3，什么是包装类，包装类的优点；
4，平时看过什么书？NND，什么书都没看过。。照样
      

      • 

    • java的多态性探讨
百合不是茶
java

      java的多态性是指main方法在调用属性的时候类可以对这一属性做出反应的情况
//package 1;
class A{
public void test(){
System.out.println("A");
}
}
class D extends A{
public void test(){
S
      

      • 

    • 网络编程基础篇之JavaScript-学习笔记
bijian1013
JavaScript

      1.documentWrite
<html>
<head>
<script language="JavaScript">
document.write("这是电脑网络学校");
document.close();
</script>
</h
      

      • 

    • 探索JUnit4扩展：深入Rule
bijian1013
JUnitRule单元测试

              本文将进一步探究Rule的应用，展示如何使用Rule来替代@BeforeClass，@AfterClass，@Before和@After的功能。
        在上一篇中提到，可以使用Rule替代现有的大部分Runner扩展，而且也不提倡对Runner中的withBefores()，withAfte
      

      • 

    • [CSS]CSS浮动十五条规则
bit1129
css

      这些浮动规则，主要是参考CSS权威指南关于浮动规则的总结，然后添加一些简单的例子以验证和理解这些规则。
 
1. 所有的页面元素都可以浮动 2. 一个元素浮动后，会成为块级元素，比如<span>,a, strong等都会变成块级元素 3.一个元素左浮动，会向最近的块级父元素的左上角移动，直到浮动元素的左外边界碰到块级父元素的左内边界；如果这个块级父元素已经有浮动元素停靠了
      

      • 

    • 【Kafka六】Kafka Producer和Consumer多Broker、多Partition场景
bit1129
partition

      0.Kafka服务器配置
3个broker
1个topic，6个partition，副本因子是2
2个consumer，每个consumer三个线程并发读取
  1. Producer
package kafka.examples.multibrokers.producers;
import java.util.Properties;
import java.util.
      

      • 

    • zabbix_agentd.conf配置文件详解
ronin47
zabbix 配置文件

      Aliaskey的别名，例如 Alias=ttlsa.userid:vfs.file.regexp[/etc/passwd,^ttlsa:.:([0-9]+),,,,\1]， 或者ttlsa的用户ID。你可以使用key：vfs.file.regexp[/etc/passwd,^ttlsa:.: ([0-9]+),,,,\1]，也可以使用ttlsa.userid。备注: 别名不能重复，但是可以有多个
      

      • 

    • java--19.用矩阵求Fibonacci数列的第N项
bylijinnan
fibonacci

      参考了网上的思路，写了个Java版的：
public class Fibonacci {
final static int[] A={1,1,1,0};
public static void main(String[] args) {
int n=7;
for(int i=0;i<=n;i++){
int f=fibonac
      

      • 

    • Netty源码学习-LengthFieldBasedFrameDecoder
bylijinnan
javanetty

      先看看LengthFieldBasedFrameDecoder的官方API
http://docs.jboss.org/netty/3.1/api/org/jboss/netty/handler/codec/frame/LengthFieldBasedFrameDecoder.html
API举例说明了LengthFieldBasedFrameDecoder的解析机制，如下：
实
      

      • 

    • AES加密解密
chicony
加密解密

      AES加解密算法，使用Base64做转码以及辅助加密：
package com.wintv.common;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decod
      

      • 

    • 文件编码格式转换
ctrain
编码格式

      
package com.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

      

      • 

    • mysql 在linux客户端插入数据中文乱码
daizj
mysql中文乱码

      1、查看系统客户端，数据库，连接层的编码
 查看方法： http://daizj.iteye.com/blog/2174993
进入mysql，通过如下命令查看数据库编码方式： mysql>  show variables like 'character_set_%'; +--------------------------+------
      

      • 

    • 好代码是廉价的代码
dcj3sjt126com
程序员读书

       
长久以来我一直主张：好代码是廉价的代码。
当我跟做开发的同事说出这话时，他们的第一反应是一种惊愕，然后是将近一个星期的嘲笑，把它当作一个笑话来讲。 当他们走近看我的表情、知道我是认真的时，才收敛一点。
当最初的惊愕消退后，他们会用一些这样的话来反驳： “好代码不廉价，好代码是采用经过数十年计算机科学研究和积累得出的最佳实践设计模式和方法论建立起来的精心制作的程序代码。”
我只
      

      • 

    • Android网络请求库——android-async-http
dcj3sjt126com
android

      在iOS开发中有大名鼎鼎的ASIHttpRequest库，用来处理网络请求操作，今天要介绍的是一个在Android上同样强大的网络请求库android-async-http，目前非常火的应用Instagram和Pinterest的Android版就是用的这个网络请求库。这个网络请求库是基于Apache HttpClient库之上的一个异步网络请求处理库，网络处理均基于Android的非UI线程，通
      

      • 

    • ORACLE 复习笔记之SQL语句的优化
eksliang
SQL优化Oracle sql语句优化SQL语句的优化

      转载请出自出处：http://eksliang.iteye.com/blog/2097999
  SQL语句的优化总结如下
 
sql语句的优化可以按照如下六个步骤进行：
合理使用索引
避免或者简化排序
消除对大表的扫描
避免复杂的通配符匹配
调整子查询的性能
EXISTS和IN运算符
下面我就按照上面这六个步骤分别进行总结： 
      

      • 

    • 浅析：Android 嵌套滑动机制（NestedScrolling）
gg163
android移动开发滑动机制嵌套

      谷歌在发布安卓 Lollipop版本之后，为了更好的用户体验，Google为Android的滑动机制提供了NestedScrolling特性
NestedScrolling的特性可以体现在哪里呢？<!--[if !supportLineBreakNewLine]--><!--[endif]-->
比如你使用了Toolbar，下面一个ScrollView，向上滚
      

      • 

    • 使用hovertree菜单作为后台导航
hvt
JavaScriptjquery.nethovertreeasp.net

       
hovertree是一个jquery菜单插件，官方网址：http://keleyi.com/jq/hovertree/ ，可以登录该网址体验效果。
0.1.3版本：http://keleyi.com/jq/hovertree/demo/demo.0.1.3.htm
hovertree插件包含文件：
http://keleyi.com/jq/hovertree/css
      

      • 

    • SVG 教程 （二）矩形
天梯梦
svg

      SVG <rect> SVG Shapes
SVG有一些预定义的形状元素，可被开发者使用和操作：
矩形 <rect>
圆形 <circle>
椭圆 <ellipse>
线 <line>
折线 <polyline>
多边形 <polygon>
路径 <path>

      

      • 

    • 一个简单的队列
luyulong
java数据结构队列

      
public class MyQueue {
private long[] arr;
private int front;
private int end;
// 有效数据的大小
private int elements;
public MyQueue() {
arr = new long[10];
elements = 0;
front 
      

      • 

    • 基础数据结构和算法九：Binary Search Tree
sunwinner
Algorithm

       
A binary search tree (BST) is a binary tree where each node has a Comparable key (and an associated value) and satisfies the restriction that the key in any node is larger than the keys in all
      

      • 

    • 项目出现的一些问题和体会
Steven-Walker
DAOWebservlet

           第一篇博客不知道要写点什么，就先来点近阶段的感悟吧。
    这几天学了servlet和数据库等知识，就参照老方的视频写了一个简单的增删改查的，完成了最简单的一些功能，使用了三层架构。
dao层完成的是对数据库具体的功能实现，service层调用了dao层的实现方法，具体对servlet提供支持。
 &
      

      • 

    • 高手问答：Java老A带你全面提升Java单兵作战能力！
ITeye管理员
java

      本期特邀《Java特种兵》作者：谢宇，CSDN论坛ID: xieyuooo 针对JAVA问题给予大家解答，欢迎网友积极提问，与专家一起讨论!
作者简介：
淘宝网资深Java工程师，CSDN超人气博主，人称“胖哥”。
CSDN博客地址：
http://blog.csdn.net/xieyuooo
作者在进入大学前是一个不折不扣的计算机白痴，曾经被人笑话过不懂鼠标是什么，
      

      •