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多平台发布
     

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(程序员)
    
        
    
            
    
                
      
                    
    • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
      目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
      
                    
      • 
                    
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      
                    
      • 
                    
    • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
      利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
      
                    
      • 
                    
    • 人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
      随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
      
                    
      • 
                    
    • 如何自学软件编程？零基础自学编程入门指南
                        _pangzi

                        
      前言零基础自学编程的动力是什么?在开启学习编程之路的时候必须搞清楚自己为什么要学编程?是因为工资高?还是对编程有浓厚的兴趣？还有自己有一定的编程基础想要继续提升自己？其实对于这个问题需要具体分析，如果是单纯看到程序员工资高，而自己本身并没有什么兴趣，那我不建议自学，可以选择参加培训或者不要进入编程领域不然自己学不会没有获得高薪，反而浪费了大把的时间，如果方法不对，反而会打击自信心。下面小编针对学习
      
                    
      • 
                    
    • ChatGPT 高效学习套路揭秘：让知识获取事半功倍的秘诀
                        kkai人工智能
chatgpt人工智能学习媒体ai
                        
      最近这段时间，AI热潮因ChatGPT的火爆再次掀起。如今，网上大部分内容都在调侃AI，但很少有人探讨如何正经使用ChatGPT做事情。作为一名靠搜索引擎和GitHub自学编程的开发者，第一次和ChatGPT深度交流后，我就确信：ChatGPT能够极大提高程序员学习新技术的效率。使用ChatGPT一个月后，我越发感受到它的颠覆性。因此，我想从工作和学习的角度，分享它的优势及我的一些使用技巧，而非娱
      
                    
      • 
                    
    • 程序员如何在AI时代保持核心竞争力
                        nfgo
chatgpt人工智能
                        
      程序员如何在AI时代保持核心竞争力随着AIGC（如ChatGPT、MidJourney、Claude等）大语言模型的相继涌现，AI辅助编程工具逐渐普及，程序员的工作方式正在发生深刻的变革。AI不仅能够自动生成代码，还能优化、调试、甚至提出解决方案。这一趋势让许多人担心：AI会不会最终取代部分编程工作？然而，也有人认为AI是提升效率的得力助手。那么，程序员在这个AI崛起的时代该如何应对？是专注某个领
      
                    
      • 
                    
    • 程序员架构师主要是做什么_程序员架构师：职责、技能与挑战
                        绿色小猪

                        
      免费备考资料（2024年11月软考）：历年试题+视频课合集+电子讲义点击领取>>>免费刷题：2024年11月软考备考刷题点此进入>>>程序员架构师的角色定位在软件开发领域，程序员架构师是一个至关重要的角色。他们不仅需要深入理解业务需求，还要将其转化为技术上的解决方案。程序员架构师是项目中的技术领航者，负责制定和维护软件系统的整体架构，确保系统的可扩展性、可维护性和性能。他们的工作涉及从概念化到实现
      
                    
      • 
                    
    • 2020年最新程序员职业发展路线指南，超详细！
                        编程流川枫
11编程语言程序员互联网IT职业
                        
      【文章来源微信公众号：每天学编程】01、程序员的特性技术出身的职场人特性很明显，与做市场、业务出身的职场人区别尤其明显。IT行业中常见的一些职场角色：老板、项目经理、产品经理、需求分析师、设计师、开发工程师、运维工程师等。开发工程师具有如下特征：1、逻辑思维清晰、严谨和细腻；但是有时不容易转弯，有些程序员容易较劲、钻牛角尖。2、性格偏内向、不善于沟通、表达和交际；但是在网络聊天工具上，有些显为幽默
      
                    
      • 
                    
    • 40岁的java程序员，还有出路吗？
                        cesske
java开发语言
                        
      目录前言一、现状与挑战二、出路与机遇三、案例分析与启示四、结语前言40岁Java程序员的出路：挑战与机遇并存在科技日新月异的今天，IT行业始终保持着高速的发展态势，而Java作为其中的重要一员，其地位依然稳固且充满挑战。对于一位40岁的Java程序员而言，面对职业生涯的“中年危机”，是否还有出路？本文将从多个维度探讨这一问题，旨在为这一群体提供思考和启示。一、现状与挑战职场竞争加剧随着技术的不断发
      
                    
      • 
                    
    • 程序员单身
                        单身总动员

                        
      如何判断一个男人会不会出轨?容易知足的男人，相对靠谱。他们不会想要通过征服很多异性来证明自己的魅力，他觉得有你一个就够了，多了他也没精力去讨好；他们也特别踏实，只会用行动来向你证明自己。专注于某项兴趣的男人，相对靠谱。比如小编的朋友，是个程序员，世人眼中的闷骚男，他专注于编程，每天24小时除了吃饭睡觉，脑子里想的都是代码，空间、微博也全是代码，最大的业余爱好就是打打游戏，他对老婆就特别专一。综上所
      
                    
      • 
                    
    • Python开发游戏？也太好用了吧
                        七步编程
工具Githubpythonpython游戏开发语言
                        
      程序员宝藏库：https://gitee.com/sharetech_lee/CS-Books-Store当然可以啦！现在日常能够用到和想到的场景，绝大多数都可以用Python实现。效果怎么样暂且不提，但是得益于丰富的第三方工具包，的确让Python能够很容易处理各种各样的场景。对于游戏开发也是这样，如果真的要想商业化，Python在游戏开发方面肯定没办法和C++相提并论，但是如果用于日常学习和自
      
                    
      • 
                    
    • 超级无敌详细的Mysql数据库笔记（基础篇版）
                        当大哥爱上学习
mysql数据库笔记
                        
      注：本篇笔记根据黑马程序员MySQL数据库入门到精通的内容所创建，适合复习和结合该视频学习使用。一.基础1.关系型数据库(RDBMS)概念:建立在关系模型基础上，由多张相互连接的二维表组成的数据库。特点:使用表存储数据，格式统一，便于维护使用SQL语言操作，标准统一，使用方便。2.SQLSQL通用语法SQL语句可以单行或多行书写，以分号结尾.SQL语句可以使用空格/缩进来增强语句的可读性。MySQ
      
                    
      • 
                    
    • 函数可以返回数组吗？有哪3种返回方法呢？如代码种的func2、func3、func4都可以返回数组。func1为什么会报错呢？关于返回数组需要注意哪些呢？
                        神笔馬良
java算法数据结构
                        
      问题描述：根据下列代码回答下列问题。//Createdby黑马程序员.#include"iostream"usingnamespacestd;/**函数返回数组，就是返回指针，要注意：*-不可返回局部数组（在函数内创建的数组），如果要返回需要*-static修饰*-动态内存创建（new[]、delete[]）*-返回全局（在函数外创建的对象）**不推荐函数返回数组，因为要么手动delete、要么s
      
                    
      • 
                    
    • 有个程序员的老公是种什么体验，嫁给程序员，我超级后悔！
                        前端小芳

                        
      1：在我还没长开的时候，就常听人说，有两种男人不能嫁：一种是兵哥哥，另一种是程序员。前者见不着，后者死的早。一想到不等头发花白，就要踟蹰独行，我就害怕的厉害。所以，很长一段时间，都对身边的程序员们避而远之。甚至做梦也没有想到，自己会成为程序员的老婆，而且一做就是好多年。2：那天全市停水，为了给部门同事解渴。我气喘吁吁地从超市搬来10瓶矿泉水。“注意性价比啊，一瓶500毫升的水3块，你30块买了5升
      
                    
      • 
                    
    • Github官方桌面客户端
                        zwb_jianshu

                        
      GitHub是一个面向开源及私有软件项目的托管平台，因为只支持git作为唯一的版本库格式进行托管，故名gitHub。如果你是一名程序员，那么一定会听过或用过现在最流行的版本控制工具GIT！而GitHub.com则是目前全球最热门的公共代码仓库网站，多到数不清的知名开源项目源代码都是托管在它上面。GitHubDesktop免费的Github官方桌面客户端首先，我先对GitHub来一个简单的介绍，Gi
      
                    
      • 
                    
    • 一文搞懂应用架构的3个核心概念
                        公众号-架构师汤师爷
后端架构设计JavaSaaS
                        
      如果你是一名业务开发，你可能要说，我整天就是做CRUD（增删改查），哪里需要了解什么应用架构设计？经常有人说，程序员35岁之后很容易陷入瓶颈，被行业淘汰，我觉得原因其实就在此。有些朋友在写代码的时候，可能没有太多考虑非功能性的需求、扩展性，只是完成功能，觉得能用就好。做事情的时候，也没有长远的规划，只是把眼前的事情做好就满足了。我面试过很多大龄候选人，他们的简历长达十几页，项目经历有几十个。然而，
      
                    
      • 
                    
    • oracle数据库安装和配置详细讲解
                        程序员小羊！
运维数据库oracle
                        
      大家好，我是程序员小羊！前言：Oracle数据库是全球广泛使用的关系型数据库管理系统(RDBMS)，提供高性能、可靠性、安全性和可扩展性，广泛应用于企业关键任务系统。下面详细介绍如何在CentOS系统上安装和配置Oracle数据库。1.前提条件1.1硬件要求内存：最小1GB，推荐2GB以上。硬盘：至少10GB的可用空间，视具体应用需求而定。1.2软件要求操作系统：CentOS7或CentOS8（确
      
                    
      • 
                    
    • 切换淘宝最新镜像源npm详细讲解
                        程序员小羊！
杂文npm前端node.js
                        
      大家好，我是程序员小羊！前言：在中国大陆，npm（NodePackageManager）的默认源由于网络限制，速度可能较慢。为了解决这个问题，淘宝提供了一个镜像源，它同步了npm的官方仓库，并显著提升了访问速度。切换到淘宝的镜像源可以加快npm包的下载速度。下面是详细的切换步骤及相关说明。1.查看当前npm源在更改npm源之前，查看当前npm使用的源地址：npmconfiggetregistry默
      
                    
      • 
                    
    • 一文理解 Python 中的环境变量
                        简讯Alfred
和我一起零基础学Python简明python教程零基础学pythonpython环境变量
                        
      你好，我是简讯！一枚野生程序员。热爱编程，但目前的工作与编程毫无关系。正在尝试各种副业，目前有做：红包封面商城：如何利用红包封面打造副业购物平台赚取佣金：利用淘宝京东等平台优惠券赚取佣金编辑器使用Neovim多一点，如果你也喜欢使用Nvim，我们可以一起交流。我的Nvim配置：https://github.com/alpha87/nvim。个人公众号经常会分享一些编程相关的文章，还有一些我已经操作
      
                    
      • 
                    
    • Java中的垃圾回收机制是如何工作的？
                        Good_tea_h
javajvm算法
                        
      Java中的垃圾回收机制（GarbageCollection,GC）是Java虚拟机（JVM）的一个重要组成部分，它负责自动管理内存的分配和释放，以减轻程序员在内存管理方面的负担，并防止内存泄漏和内存溢出等问题。一、垃圾回收机制的核心思想Java的垃圾回收机制主要基于两个核心思想：标记和回收。标记：垃圾收集器会定期自动扫描内存中的对象，根据特定的算法（如可达性分析法）来判断哪些对象已经不再被程序使
      
                    
      • 
                    
    • Android app后台运行休眠仍然可以运行的方法（确保一直运行)
                        2401_84102689
2024年程序员学习android
                        
      先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！因此收集整理了一份《2024年最新Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
      
                    
      • 
                    
    • 我们都是小小发明家
                        蜻蜓之旅

                        
      说到健康码，相信大家都再熟悉不过了。让人惊奇的是，发明它的并不是程序员而是杭州民警钟毅带着他的团队研发出来的。以前只要听到发明家，就觉得特别高大上，好像离我们普通人比较遥远。以前我也这么认为，直到看到了这本《超能编程队4：我是发明家》，才明白原来发明家就在我们身边，就像那位民警一样，他并不是那么遥不可及的。他可以是我们生活中的每一个人，只要你肯创造、肯想象、肯实践，愿意为大家服务、愿意为社会创造价
      
                    
      • 
                    
    • 程序员35岁会失业吗？
                        Good kid.
经验分享笔记
                        
      35岁被认为是程序员职业生涯的分水岭，许多程序员开始担忧自己的职业发展是否会受到年龄的限制。有人担心随着年龄的增长，技术更新换代的速度会使得资深程序员难以跟上；而另一些人则认为，丰富的经验和深厚的技术积累是年轻程序员无法比拟的宝贵财富。那么，让我们来探讨一下这个话题。技术更新与个人适应性确实，技术的快速发展对程序员的职业技能有一定的影响。新的编程语言、框架和工具不断涌现，程序员需要不断学习和适应这
      
                    
      • 
                    
    • 关于Echarts的一些设置总结
                        夏之小星星
echarts前端javascript
                        
      最近领导让我一个偏后端程序员画各种数据展示echarts页面，遇到好多问题在此记录一下，未完待续。。。ps：不喜欢画页面啊啊啊啊啊，以前公司这些都是ui的活啊啊啊啊，折磨死我啦啊啊啊啊一、柱形图1、echarts如何设置柱形颜色渐变在option加color属性option={color:{type:'linear',//x=0,y=1,柱子的颜色在垂直方向渐变x:0,y:1,colorStops
      
                    
      • 
                    
    • Python教程：面向对象
                        无敌开心
python开发语言
                        
      模块3：Python高级模块概述本课程旨在介绍Python编程语言中的面向对象编程（OOP）概念和技术。学生将学习如何使用类、对象、继承、多态等OOP的关键要素来构建灵活、可重用和可扩展的代码。通过实际编程练习和项目，学生将提高他们的编程技能，学会设计和实现面向对象的解决方案。面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性。面向对象编程是程序员发展的分水岭，
      
                    
      • 
                    
    • 如果面试官问你CAS，你还这么答，可能就要回去等通知了
                        爱玛士
程序员面试Javajava面试开发语言程序员架构
                        
      前言大家好，我是JAVA高级开发之路，一个总在为粉丝解决面试题的程序员。最近有几个粉丝说在面试面试中遇到了CAS的问题，连着几次面试都没有让面试官满意，区区CAS底层源码，怎能难倒咱们这届程序员们呢？都支棱起来，跟我一起来搞定CAS底层源码。什么是CASCAS的全称是Compare-And-Swap，它是CPU并发原语。它的功能是判断内存某个位置的值是否为预期值，如果是则更改为新的值，这个过程是原
      
                    
      • 
                    
    • 程序员被公司开除，隔阵子领导命令回公司讲解代码，网友纷纷支招
                        编程彭于晏

                        
      对于很多已经步入社会已经开始上班的人来说，离职是一件很常见的事情。有的是员工自己要求离职，可能是有更好的就业机会，也可能是有私事处理，不能继续工作；有的则是企业开除员工，或者是因为员工工作不努力，划水，或者是公司结构调整，需要裁员。但是不管是哪种原因吧，员工在离职前都需要和后来接任的同事将自己手上负责的工作进行交接，包括财务信息、已完成工作、未完成工作等，一方面是给曾经的公司和同事留下一个好印象，
      
                    
      • 
                    
    • 编程小技巧
                        风的低语

                        
      40条真言，希望对进阶中的程序朋友有所帮助。1、重构是程序员的主力技能。2、工作日志能提升脑容量。3、先用profiler调查，才有脸谈优化。4、注释贵精不贵多。杜绝大姨妈般的“例注”。漫山遍野的碎碎念注释，实际就是背景噪音。5、普通程序员+google=超级程序员。6、单元测试总是合算的。7、不要先写框架再写实现。最好反过来，从原型中提炼框架。8、代码结构清晰，其它问题都不算事儿。9、好的项目作
      
                    
      • 
                    
    • 基于nodejs+vue的美妆彩妆网站的设计与实现(源码+LW+调试文档+讲解等)
                        程序员gelei
nodejs毕业设计项目vue.js前端javascript
                        
      目录：博主介绍：完整视频演示：系统技术介绍：后端Java介绍前端框架Vue介绍具体功能截图：部分代码参考：Mysql表设计参考：项目测试：项目论文：为什么选择我：源码获取：博主介绍：博主：程序员gelei：全网拥有20W+粉丝、CSDN作者、博客专家、全栈领域优质创作者、平台优质Java创作者、专注于Java、小程序、python、安卓技术领域和毕业项目实战✌Java精品实战案例《1000套》20
      
                    
      • 
                                
    • 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 
 
作者在进入大学前是一个不折不扣的计算机白痴，曾经被人笑话过不懂鼠标是什么，
      
                                
      •