java的小粉丝
java的小粉丝

SpringBoot2源码2-核心启动过程和run方法

1. SpringBoot中怎么启动Tomcat?

1.1 ServletWebServerFactoryAutoConfiguration

配置Servlet web容器。

@Configuration(proxyBeanMethods = false)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
      ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
      ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
      ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
}

ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class 导入 WebServerFactoryCustomizerBeanPostProcessor组件，web服务工厂定制器的后置增强

导入了三种不同的web服务器（Tomcat、Jetty、Undertow），默认是Tomcat

我们来看一下 EmbeddedTomcat:

@Configuration(proxyBeanMethods = false)
class ServletWebServerFactoryConfiguration {

   @Configuration(proxyBeanMethods = false)
   @ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
   @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
   static class EmbeddedTomcat {

      @Bean
      TomcatServletWebServerFactory tomcatServletWebServerFactory(
            ObjectProvider connectorCustomizers,
            ObjectProvider contextCustomizers,
            ObjectProvider> protocolHandlerCustomizers) {
         TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
         factory.getTomcatConnectorCustomizers()
               .addAll(connectorCustomizers.orderedStream().collect(Collectors.toList()));
         factory.getTomcatContextCustomizers()
               .addAll(contextCustomizers.orderedStream().collect(Collectors.toList()));
         factory.getTomcatProtocolHandlerCustomizers()
               .addAll(protocolHandlerCustomizers.orderedStream().collect(Collectors.toList()));
         return factory;
      }

   }
}

tomcatServletWebServerFactory()方法中的参数都是从容器中获取，我们可以自定义直接放到容器中。实现ServletWebServerFactory 接口,该接口的getWebServlet()方法就是创建
Tomcat容器。

1.2 DispatcherServletAutoConfiguration

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
public class DispatcherServletAutoConfiguration {

  
   public static final String DEFAULT_DISPATCHER_SERVLET_BEAN_NAME = "dispatcherServlet";

   public static final String DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME = "dispatcherServletRegistration";

   @Configuration(proxyBeanMethods = false)
   @Conditional(DefaultDispatcherServletCondition.class)
   @ConditionalOnClass(ServletRegistration.class)
   @EnableConfigurationProperties(WebMvcProperties.class)
   protected static class DispatcherServletConfiguration {

      @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
      public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
         DispatcherServlet dispatcherServlet = new DispatcherServlet();
         dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
         dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
         dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());
         dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
         dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());
         return dispatcherServlet;
      }

      @Bean
      @ConditionalOnBean(MultipartResolver.class)
      @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
      public MultipartResolver multipartResolver(MultipartResolver resolver) {
         // Detect if the user has created a MultipartResolver but named it incorrectly
         return resolver;
      }

   }

   @Configuration(proxyBeanMethods = false)
   @Conditional(DispatcherServletRegistrationCondition.class)
   @ConditionalOnClass(ServletRegistration.class)
   @EnableConfigurationProperties(WebMvcProperties.class)
   @Import(DispatcherServletConfiguration.class)
   protected static class DispatcherServletRegistrationConfiguration {

      @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
      @ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
      public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet,
            WebMvcProperties webMvcProperties, ObjectProvider multipartConfig) {
         DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet,
               webMvcProperties.getServlet().getPath());
         registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
         registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
         multipartConfig.ifAvailable(registration::setMultipartConfig);
         return registration;
      }

   }
}
  • dispatcherServlet方法就是往容器中注入DispatcherServlet组件。
  • dispatcherServletRegistration() 方法就是将将DispatcherServlet组件添加到Tomcat中（tomcat.addServlet()）

我们来看一下DispatcherServletRegistrationBean继承图：

image.png

在Tomcat启动的时候 会调用 ServletContextInitializer.onStartup() 方法回调，将DispatcherServlet 添加到 Tomcat中，后面的启动流程就跟SpringMVC的启动流程是一样的

2. 核心方法run()

下面是一个简单的项目，我们直接开始看run方法

@SpringBootApplication
public class SpringbootDemoApplication {
    
    public static void main(String[] args) {
        ConfigurableApplicationContext run = SpringApplication.run(SpringbootDemoApplication.class, args);
        Object demoService = run.getBean("demoService");
        System.out.println("demoService = " + demoService);
   }
}

我们这里直接看 SpringApplication#run(java.lang.Class[], java.lang.String[]) 方法:

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

我们这里先看一下 SpringApplication 的构造函数流程:

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        // 保存启动类信息
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        // 初始化环境。环境分为三种 非web环境、web环境、reactive环境三种。其判断逻辑就是判断是否存在指定的类，默认是Servlet 环境，我们这也是Servlet
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        // getSpringFactoriesInstances 方法加载了 spring.factories文件。在这里进行了首次加载spring.factoies文件。设置 ApplicationContextInitializer
        setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
        // 获取监听器，也加载了spring.factories文件
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        // 设置启动类信息
        this.mainApplicationClass = deduceMainApplicationClass();
}

我们下面直接来看 SpringApplication#run(java.lang.String...) 方法的执行流程:

public ConfigurableApplicationContext run(String... args) {
        // 开启关于启动时间的信息监控
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 准备 ApplicationContext
        ConfigurableApplicationContext context = null;
        Collection exceptionReporters = new ArrayList<>();
        //java.awt.headless是J2SE的一种模式用于在缺少显示屏、键盘或者鼠标时的系统配置，很多监控工具如jconsole 需要将该值设置为true，系统变量默认为true
        configureHeadlessProperty();
        // 1. 获取Spring的监听器类，这里是从 spring.factories 中去获取，默认的是以 org.springframework.boot.SpringApplicationRunListener 为key,获取到的监听器类型为 EventPublishingRunListener。
        SpringApplicationRunListeners listeners = getRunListeners(args);
        // 1.1 监听器发送启动事件
        listeners.starting();
        try {
                // 封装参数
                ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
                // 2. 构造容器环境。将容器的一些配置内容加载到 environment  中
                ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
                // 配置BeanInfo的忽略 ：“spring.beaninfo.ignore”，值为“true”表示跳过对BeanInfo类的搜索
                configureIgnoreBeanInfo(environment);
                // 打印信息对象
                Banner printedBanner = printBanner(environment);
                // 3. 创建上下文对象
                context = createApplicationContext();
                // 从 spring.factries 中获取错误报告的类。出错的时候会调用其方法通知
                exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                                new Class[] { ConfigurableApplicationContext.class }, context);
                // 4. 准备刷新上下文
                prepareContext(context, environment, listeners, applicationArguments, printedBanner);
                // 5. 刷新上下文
                refreshContext(context);
                // 结束刷新，留待扩展功能，并未实现什么
                afterRefresh(context, applicationArguments);
                // 停止监听
                stopWatch.stop();
                if (this.logStartupInfo) {
                        new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
                }
                // 监听器发送启动结束时间
                listeners.started(context);
                // 调用 ApplicationRunner 和 CommandLineRunner 对应的方法
                callRunners(context, applicationArguments);
        }
        catch (Throwable ex) {
                handleRunFailure(context, ex, exceptionReporters, listeners);
                throw new IllegalStateException(ex);
        }

        try {
                // 发送容器运行事件
                listeners.running(context);
        }
        catch (Throwable ex) {
                handleRunFailure(context, ex, exceptionReporters, null);
                throw new IllegalStateException(ex);
        }
        return context;
}

3. run()流程步骤详解

下面我们重点分析几个步骤

3.1 获取监听器

这一步是从 spring.factories 文件中获取监听器集合，当有事件发生时调用监听器对应事件的方法。
默认的是以 org.springframework.boot.SpringApplicationRunListener 为key,获取到的监听器类型为 EventPublishingRunListener。

SpringApplicationRunListeners listeners = getRunListeners(args);

其详细代码如下：

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

这里需要注意的是 getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args) 返回的是一个Collection 类型。也就是说明在 SpringApplicationRunListeners并非代表一个监听器，而是保存了监听器集合，在默认情况下，仅有一个 EventPublishingRunListener。在 SpringApplicationRunListeners 类中也能看到，如下：

class SpringApplicationRunListeners {

    private final Log log;

    private final List listeners;

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

总结一下: Spring启动时，通过 spring.factories 文件中获取监听器集合。默认类型为 EventPublishingRunListener。在事件发生时，EventPublishingRunListener 会寻找容器中 ApplicationListener 的bean，并进行事件通知。详见Spring5源码12-监听器原理

3.2 环境变量的构造

这一步的作用就是加载一些配置文件的内容

ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);

其具体实现如下:

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
                ApplicationArguments applicationArguments) {
        // Create and configure the environment
        // 获取或者创建 environment。这里获取类型是 StandardServletEnvironment 
        ConfigurableEnvironment environment = getOrCreateEnvironment();
        // 将入参配置到环境配置中
        configureEnvironment(environment, applicationArguments.getSourceArgs());
        ConfigurationPropertySources.attach(environment);
        // 发布环境准备事件。
        listeners.environmentPrepared(environment);
        bindToSpringApplication(environment);
        if (!this.isCustomEnvironment) {
                environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
                                deduceEnvironmentClass());
        }
        ConfigurationPropertySources.attach(environment);
        return environment;
}

private Class deduceEnvironmentClass() {
        switch (this.webApplicationType) {
        case SERVLET:
                return StandardServletEnvironment.class;
        case REACTIVE:
                return StandardReactiveWebEnvironment.class;
        default:
                return StandardEnvironment.class;
        }
}

关于 webApplicationType 的值，在 org.springframework.boot.SpringApplication#SpringApplication(org.springframework.core.io.ResourceLoader, java.lang.Class...) 构造函数中进行了赋值为Servlet。所以我们这里可以知道 Environment 类型为 StandardServletEnvironment 。
在 listeners.environmentPrepared(environment); 时会发送环境准备事件，环境准备事件要通知监听器如下。对于 Springboot 的配置文件application.yml或者application.properties文件的加载实际上是通过发布环境准备事件完成的，完成这项功能的就是ConfigDataEnvironmentPostProcessor。

3.2.1 application.yml 的加载

SpringBoot在启动时，读取所有的ApplicationListener下的配置类。spring-boot工程下的spring.factories文件：

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.env.EnvironmentPostProcessorApplicationListener

当EnvironmentPostProcessorApplicationListener类接收到ApplicationEnvironmentPreparedEvent的事件时，就会调用EnvironmentPostProcessorsFactory类下的getEnvironmentPostProcessors方法来获取所有的EnvironmentPostProcessor下的配置类，并触发这些类的postProcessEnvironment方法。

public class EnvironmentPostProcessorApplicationListener implements SmartApplicationListener, Ordered {
    ...
   
        public EnvironmentPostProcessorApplicationListener() {
           this(EnvironmentPostProcessorsFactory::fromSpringFactories, new DeferredLogs());
        }

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        if (event instanceof ApplicationEnvironmentPreparedEvent) {
            onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
        }
        ...
    }

    private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
        ...
        for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
                event.getBootstrapContext())) {
            postProcessor.postProcessEnvironment(environment, application);
        }
    }

    List getEnvironmentPostProcessors(ResourceLoader resourceLoader,
            ConfigurableBootstrapContext bootstrapContext) {
        ...
        EnvironmentPostProcessorsFactory postProcessorsFactory = this.postProcessorsFactory.apply(classLoader);
        return postProcessorsFactory.getEnvironmentPostProcessors(this.deferredLogs, bootstrapContext);
    }
}


@FunctionalInterface
public interface EnvironmentPostProcessorsFactory {

   List getEnvironmentPostProcessors(DeferredLogFactory logFactory,
         ConfigurableBootstrapContext bootstrapContext);

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

spring.factories文件中 ：

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.context.config.ConfigDataEnvironmentPostProcessor,\
org.springframework.boot.env.RandomValuePropertySourceEnvironmentPostProcessor,\
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor,\
org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor,\
org.springframework.boot.reactor.DebugAgentEnvironmentPostProcessor

EnvironmentPostProcessor

EnvironmentPostProcessor是处理程序的配置的，不同的子类实现不同的配置，有处理json配置文件的、有处理yaml配置文件的、有替换配置文件中的环境变量的。

SpringBoot 2.4.0之前的版本，处理yaml配置文件的类是ConfigFileApplicationListener类
SpringBoot 2.4.0之后的版本，处理yaml配置文件的类是ConfigDataEnvironmentPostProcessor类,我们重点看这个。

ConfigDataEnvironmentPostProcessor

SpringBoot 2.4.0之后的版本，使用ConfigDataEnvironmentPostProcessor 类来加载yaml文件中的配置。

public class ConfigDataEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        postProcessEnvironment(environment, application.getResourceLoader(), application.getAdditionalProfiles());
    }

    void postProcessEnvironment(ConfigurableEnvironment environment, ResourceLoader resourceLoader,
            Collection additionalProfiles) {
        ...
        getConfigDataEnvironment(environment, resourceLoader, additionalProfiles).processAndApply();
        ...
    }

    ConfigDataEnvironment getConfigDataEnvironment(ConfigurableEnvironment environment, ResourceLoader resourceLoader, Collection additionalProfiles) {
        return new ConfigDataEnvironment(this.logFactory, this.bootstrapContext, environment, resourceLoader, additionalProfiles, this.environmentUpdateListener);
    }
}

ConfigDataEnvironment

ConfigDataEnvironmentPostProcessor 在postProcessEnvironment方法中会实例化一个ConfigDataEnvironment对象，这个对象会加载optional:classpath:/;optional:classpath:/config/;optional:file:./;optional:file:./config/;optional:file:./config/*/路径下的yaml文件。

class ConfigDataEnvironment {
    static final String LOCATION_PROPERTY = "spring.config.location";
    static final String ADDITIONAL_LOCATION_PROPERTY = "spring.config.additional-location";
    static final String IMPORT_PROPERTY = "spring.config.import";
    
    static final ConfigDataLocation[] DEFAULT_SEARCH_LOCATIONS;
    static {
        List locations = new ArrayList<>();
        locations.add(ConfigDataLocation.of("optional:classpath:/;optional:classpath:/config/"));
        locations.add(ConfigDataLocation.of("optional:file:./;optional:file:./config/;optional:file:./config/*/"));
        DEFAULT_SEARCH_LOCATIONS = locations.toArray(new ConfigDataLocation[0]);
    }

    private ConfigDataEnvironmentContributors createContributors(Binder binder) {
        ...
        contributors.addAll(getInitialImportContributors(binder));
        ...
        return createContributors(contributors);
    }

    protected ConfigDataEnvironmentContributors createContributors(
            List contributors) {
        return new ConfigDataEnvironmentContributors(this.logFactory, this.bootstrapContext, contributors);
    }

    private List getInitialImportContributors(Binder binder) {
        List initialContributors = new ArrayList<>();
        addInitialImportContributors(initialContributors, bindLocations(binder, IMPORT_PROPERTY, EMPTY_LOCATIONS));
        addInitialImportContributors(initialContributors,
                bindLocations(binder, ADDITIONAL_LOCATION_PROPERTY, EMPTY_LOCATIONS));
        addInitialImportContributors(initialContributors,
                bindLocations(binder, LOCATION_PROPERTY, DEFAULT_SEARCH_LOCATIONS));
        return initialContributors;
    }
}

spring.factories文件中 ：

# ConfigData Location Resolvers
org.springframework.boot.context.config.ConfigDataLocationResolver=\
org.springframework.boot.context.config.ConfigTreeConfigDataLocationResolver,\
org.springframework.boot.context.config.StandardConfigDataLocationResolver

# ConfigData Loaders
org.springframework.boot.context.config.ConfigDataLoader=\
org.springframework.boot.context.config.ConfigTreeConfigDataLoader,\
org.springframework.boot.context.config.StandardConfigDataLoader

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

processAndApply()

请求路径为：processAndApply() -> ConfigDataEnvironment#processAndApply -> ConfigDataEnvironment#processWithoutProfiles -> ConfigDataEnvironmentContributors#withProcessedImports -> ConfigDataImporter#resolveAndLoad -> ConfigDataImporter#load -> ConfigDataLoaders#load -> StandardConfigDataLoader#load -> YamlPropertySourceLoader#load
我们直接看YamlPropertySourceLoader#load 方法：

在这里加载 application.yml文件。

EnvironmentPostProcessor

如果想处理加载的配置文件，可以在自己的java项目里添加spring.factories，然后实现EnvironmentPostProcessor类。

org.springframework.boot.env.EnvironmentPostProcessor=\
com.camellibby.springboot.component.DemoEnvironmentPostProcessor

public class DemoEnvironmentPostProcessor implements EnvironmentPostProcessor {
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
        System.out.println("DemoEnvironmentPostProcessor is starting");
    }
}

3.3 创建上下文

这一步是创建上下文了:

context = createApplicationContext();

其详细内容如下：

public static final String DEFAULT_CONTEXT_CLASS = "org.springframework.context."
                + "annotation.AnnotationConfigApplicationContext";

public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot."
                + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";

public static final String DEFAULT_REACTIVE_WEB_CONTEXT_CLASS = "org.springframework."
                + "boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext";


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

// org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext.Factory#create
static class Factory implements ApplicationContextFactory {

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

}

public AnnotationConfigServletWebServerApplicationContext() {
   this.reader = new AnnotatedBeanDefinitionReader(this);
   this.scanner = new ClassPathBeanDefinitionScanner(this);
}

很明显，因为我们知道 webApplicationType 值是 servlet，所以这里创建的是 AnnotationConfigServletWebServerApplicationContext 类型的上下文
这里需要注意：AnnotationConfigServletWebServerApplicationContext 构造函数中会创建 AnnotatedBeanDefinitionReader。而在 AnnotatedBeanDefinitionReader 构造函数中会调用 AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);，该方法将一些必要Bean(如ConfigurationClassPostProcessor、AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor 等)注入到了容器中。

3.4 上下文准备工作

上面一步，仅仅是将上下文创建出来了，并没有对上下文进行操作。这一步开始对上下文的准备操作。

prepareContext(context, environment, listeners, applicationArguments, printedBanner);

其详细内容如下：

private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
                SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
        // 设置上下文的环境变量
        context.setEnvironment(environment);
        // 执行容器后置处理 ： 可以注册beanName策略生成器、设置资源加载器，设置转换服务等。但这里默认是没有做任何处理。目的是留给后续可以扩展
        postProcessApplicationContext(context);
        // 处理所有的初始化类的初始化方法。即 spring.factories 中key 为 org.springframework.context.ApplicationContextInitializer 指向的类，调用其 initialize 方法
        applyInitializers(context);
        // 向监听器发送容器准备事件
        listeners.contextPrepared(context);
        if (this.logStartupInfo) {
                logStartupInfo(context.getParent() == null);
                logStartupProfileInfo(context);
        }
        // Add boot specific singleton beans
        // 获取上下文中的 BeanFactory。这里的BeanFactory 实际类型是  DefaultListableBeanFactory。BeanFactory 在初始化的时候，直接在构造函数里创建为 DefaultListableBeanFactory
        ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 注册 springApplicationArguments等一系列bean
        beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
        if (printedBanner != null) {
                beanFactory.registerSingleton("springBootBanner", printedBanner);
        }
        if (beanFactory instanceof DefaultListableBeanFactory) {
                // 设置是否允许bean定义覆盖
                ((DefaultListableBeanFactory) beanFactory)
                                .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
        // 如果允许懒加载，则添加对应的BeanFactory后置处理器
        if (this.lazyInitialization) {
                context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
        }
        // Load the sources
        // 这里加载的实际上是启动类
        Set sources = getAllSources();
        Assert.notEmpty(sources, "Sources must not be empty");
        // 这里将启动类加入到 beanDefinitionMap 中，为后续的自动化配置做好了基础
        load(context, sources.toArray(new Object[0]));
        // 发送容器加载完成事件
        listeners.contextLoaded(context);
}

....

// 需要注意这里的 sources参数实际上是 启动类的 Class
protected void load(ApplicationContext context, Object[] sources) {
        if (logger.isDebugEnabled()) {
                logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
        }
        // 从上下文中获取 BeanDefinitionRegistry并依次创建出 BeanDefinitionLoader 。这里将sources作为参数保存到了 loader  中。也就是 loader  中保存了 启动类的Class信息
        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();
}
 
 
我们这里比较关键的方法是 loader.load(); 方法 其中 loader.load(); 不管怎么跳转，最后都会跳转到 BeanDefinitionLoader#load(java.lang.Class) 方法中。如下:
 
 
private int load(Class source) {
        // 判断是否存在 groovy 加载方式
        if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
                // Any GroovyLoaders added in beans{} DSL can contribute beans here
                GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class);
                load(loader);
        }
        // 判断 source 是否 需要被加载到Spring容器中。实际上是根据判断是否存在 @Component 
        if (isComponent(source)) {
                // 将source 就是启动类的 class，注册到 annotatedReader 中。annotatedReader  类型是AnnotatedBeanDefinitionReader。
                this.annotatedReader.register(source);
                return 1;
        }
        return 0;
}

 
 
this.annotatedReader.register(source); 后续会跳转到 AnnotatedBeanDefinitionReader#doRegisterBean 方法中，看名字就知道是这个方法的工作是 注册 Bean。实际上，在这个方法中完成了对@Qualifier 以及一些其他注解的处理。具体如下：
 
 
// 这里的 beanClass 其实就是启动类的 beanClass 
private  void doRegisterBean(Class beanClass, @Nullable String name,
                @Nullable Class[] qualifiers, @Nullable Supplier supplier,
                @Nullable BeanDefinitionCustomizer[] customizers) {
        // 将Class 转换成一个 BeanDefinition 类
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
        // 判断是否应该跳过
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
                return;
        }

        abd.setInstanceSupplier(supplier);
        // 保存其作用域信息。这里默认是 singleton
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        abd.setScope(scopeMetadata.getScopeName());
        // 获取 beanName
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
        // 处理一些通用的注解信息，包括Lazy、Primary、DependsOn、Role、Description 注解。获取其value值并保存到 abd 中
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        // 处理  @Qualifier 
        if (qualifiers != null) {
                for (Class qualifier : qualifiers) {
                        if (Primary.class == qualifier) {
                                abd.setPrimary(true);
                        }
                        else if (Lazy.class == qualifier) {
                                abd.setLazyInit(true);
                        }
                        else {
                                abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                        }
                }
        }
        if (customizers != null) {
                for (BeanDefinitionCustomizer customizer : customizers) {
                        customizer.customize(abd);
                }
        }

        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        // 判断是否需要创建代理，需要则创建
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        // 将 BeanDefinitionHolder  注册到 容器中。此时的 registry 就是 AnnotationConfigServletWebServerApplicationContext。在BeanDefinitionLoader 初始化的时候保存的
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

 
 
3.5 SpringApplication#refreshContext
 
 
对容器进行一个刷新工作。在此进行了大量的工作。这里的处理工作就由Springboot交给 Spring来处理了
 
 
refreshContext(context);

 
 
详细如下:
 
 
private void refreshContext(ConfigurableApplicationContext context) {
        refresh(context);
        if (this.registerShutdownHook) {
                try {
                        context.registerShutdownHook();
                }
                catch (AccessControlException ex) {
                        // Not allowed in some environments.
                }
        }
}

 
 
最终会跳转到 AbstractApplicationContext#refresh 中。而关于 AbstractApplicationContext#refresh 方法在之前的文章中有过介绍，参见Spring5源码11-容器刷新refresh方法(注解版)。我们重点看一下Tomcat的启动过程，着重看onRefresh()方法：
 
 
@Override
public void refresh() throws BeansException, IllegalStateException {

         // Initialize other special beans in specific context subclasses.
         onRefresh();

         // Check for listener beans and register them.
         registerListeners();      
}

 
 
SpringBoot使用ServletWebServerApplicationContext#onRefresh：
 
 
@Override
protected void onRefresh() {
   super.onRefresh();
   try {
      createWebServer();
   }
   catch (Throwable ex) {
      throw new ApplicationContextException("Unable to start web server", ex);
   }
}

 
 
直接看createWebServer()方法：
 
 
private void createWebServer() {
   WebServer webServer = this.webServer;
   ServletContext servletContext = getServletContext();
   if (webServer == null && servletContext == null) {
      StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
      // 本文环境获取的是tomcatServletWebServerFactory，默认的
      ServletWebServerFactory factory = getWebServerFactory();
      createWebServer.tag("factory", factory.getClass().toString());
      this.webServer = factory.getWebServer(getSelfInitializer());
      createWebServer.end();
      getBeanFactory().registerSingleton("webServerGracefulShutdown",
            new WebServerGracefulShutdownLifecycle(this.webServer));
      getBeanFactory().registerSingleton("webServerStartStop",
            new WebServerStartStopLifecycle(this, this.webServer));
   }
   else if (servletContext != null) {
      try {
         getSelfInitializer().onStartup(servletContext);
      }
      catch (ServletException ex) {
         throw new ApplicationContextException("Cannot initialize servlet context", ex);
      }
   }
   initPropertySources();
}

 
 
3.5.1 getWebServerFactory()
 
 
如下所示，从容器中获取ServletWebServerFactory类型的bean，唯一一个，否则抛出异常。本文环境获取的是tomcatServletWebServerFactory。
 
 
protected ServletWebServerFactory getWebServerFactory() {
   // Use bean names so that we don't consider the hierarchy
   String[] beanNames = getBeanFactory().getBeanNamesForType(ServletWebServerFactory.class);
   if (beanNames.length == 0) {
      throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to missing "
            + "ServletWebServerFactory bean.");
   }
   if (beanNames.length > 1) {
      throw new ApplicationContextException("Unable to start ServletWebServerApplicationContext due to multiple "
            + "ServletWebServerFactory beans : " + StringUtils.arrayToCommaDelimitedString(beanNames));
   }
   return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

 
 
3.5.2 getSelfInitializer()
 
 
ServletWebServerApplicationContext的getSelfInitializer方法，返回的是ServletContextInitializer。
 
 
private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
    return this::selfInitialize;
}

 
 
看到this::selfInitialize是不是比较迷糊？典型的java8的lambda写法。我们看一下ServletContextInitializer 可能就明白了。
 如下所示，其是一个函数式接口，只有一个onStartup方法。函数式接口(有且仅有一个抽象方法的接口)可以使用lambda式的写法。
 
 
@FunctionalInterface
public interface ServletContextInitializer {
     // 初始化过程中，使用给定的servlets、filters、listeners
     //context-params and attributes necessary配置ServletContext
    void onStartup(ServletContext servletContext) throws ServletException;

}

 
 
我们这里获取到的本质是一个lambda，参数则是当前this，如下图所示：
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
this::selfInitialize中的selfInitialize则指的是ServletWebServerApplicationContext的selfInitialize方法。this指的是AnnotationConfigServletWebServerApplicationContext，其继承于ServletWebServerApplicationContext
 
 
private void selfInitialize(ServletContext servletContext) throws ServletException {
    prepareWebApplicationContext(servletContext);
    registerApplicationScope(servletContext);
    WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
    for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
        beans.onStartup(servletContext);
    }
}

 
 
其实换成匿名类的写法则是：
 
 
new ServletContextInitializer() {
      @Override
      public void onStartup(ServletContext servletContext) throws ServletException {
        selfInitialize(servletContext);
      }
};

 
 
3.5.3 getWebServer(）
 
 
本文这里是TomcatServletWebServerFactory#getWebServer方法。
 
 
@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
    if (this.disableMBeanRegistry) {
    // registry = new NoDescriptorRegistry();
        Registry.disableRegistry();
    }
    //实例化Tomcat
    Tomcat tomcat = new Tomcat();

    //获取临时路径 
    File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
    //设置基础路径
    tomcat.setBaseDir(baseDir.getAbsolutePath());

    //实例化Connector 并进行配置
    Connector connector = new Connector(this.protocol);
    connector.setThrowOnFailure(true);

    //这里会实例化server  service
    tomcat.getService().addConnector(connector);
    customizeConnector(connector);

    //对Connector做配置比如Protocol、URIEncoding
    tomcat.setConnector(connector);

    //这里会实例化Engine、Host
    tomcat.getHost().setAutoDeploy(false);
    configureEngine(tomcat.getEngine());
    for (Connector additionalConnector : this.additionalTomcatConnectors) {
                // todo
        tomcat.getService().addConnector(additionalConnector);
    }
    prepareContext(tomcat.getHost(), initializers);
    return getTomcatWebServer(tomcat);
}

 
 
getService
 
 
getService首先会触发getServer然后获取service。getServer如下所示会实例化Server并对其进行配置。
 
 
public Service getService() {
    return getServer().findServices()[0];
}
public Server getServer() {
   if (server != null) {
       return server;
   }
   System.setProperty("catalina.useNaming", "false");
    // 实例化 server
   server = new StandardServer();

    // 对basedir做处理
   initBaseDir();

   // Set configuration source
   ConfigFileLoader.setSource(new CatalinaBaseConfigurationSource(new File(basedir), null));
   // 为server设置port和service
   server.setPort( -1 );
   //实例化service
   Service service = new StandardService();
   service.setName("Tomcat");
   server.addService(service);
   return server;
}

 
 
prepareContext
 
 
这里会实例化TomcatEmbeddedContext并对其进行配置。
 
 
protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
    File documentRoot = getValidDocumentRoot();
    TomcatEmbeddedContext context = new TomcatEmbeddedContext();
    if (documentRoot != null) {
        context.setResources(new LoaderHidingResourceRoot(context));
    }
    context.setName(getContextPath());
    context.setDisplayName(getDisplayName());
    context.setPath(getContextPath());
    File docBase = (documentRoot != null) ? documentRoot : createTempDir("tomcat-docbase");
    context.setDocBase(docBase.getAbsolutePath());
    context.addLifecycleListener(new FixContextListener());
    context.setParentClassLoader((this.resourceLoader != null) ? this.resourceLoader.getClassLoader()
            : ClassUtils.getDefaultClassLoader());
    resetDefaultLocaleMapping(context);
    addLocaleMappings(context);
    context.setUseRelativeRedirects(false);
    try {
        context.setCreateUploadTargets(true);
    }
    catch (NoSuchMethodError ex) {
        // Tomcat is < 8.5.39. Continue.
    }
    configureTldSkipPatterns(context);
    WebappLoader loader = new WebappLoader(context.getParentClassLoader());
    loader.setLoaderClass(TomcatEmbeddedWebappClassLoader.class.getName());
    loader.setDelegate(true);
    context.setLoader(loader);
    if (isRegisterDefaultServlet()) {
        addDefaultServlet(context);
    }
    if (shouldRegisterJspServlet()) {
        addJspServlet(context);
        addJasperInitializer(context);
    }
    context.addLifecycleListener(new StaticResourceConfigurer(context));
    ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);
    host.addChild(context);
    configureContext(context, initializersToUse);
    postProcessContext(context);
}

 
 
getTomcatWebServer
 
 
这个方法很简单，只是直接实例化了TomcatWebServer返回。其构造方法触发了initialize，这会引起后续一系列动作，包括tomcat.start()。
 
 
protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
    return new TomcatWebServer(tomcat, getPort() >= 0);
}
public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
    Assert.notNull(tomcat, "Tomcat Server must not be null");
    this.tomcat = tomcat;
    this.autoStart = autoStart;
        // todo
    initialize();
}

 
 
initialize()
 
 
我们回过头来，看一下initialize()方法：
 
 
private void initialize() throws WebServerException {
   logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
   synchronized (this.monitor) {
      try {
         ...
         // Start the server to trigger initialization listeners
         this.tomcat.start();

        ...
      }
   }
}

 
 
在这里将嵌入式Tomcat启动。
 
 
selfInitialize
 
 
获取到TomcatWebServer后，Tomcat启动之后就触发了selfInitialize方法。这里servletContext其实是获取了ApplicationContext的一个门面/外观–ApplicationContextCade。
 
 
// ServletWebServerApplicationContext
private void selfInitialize(ServletContext servletContext) throws ServletException {
        // todo
    prepareWebApplicationContext(servletContext);
        // todo
    registerApplicationScope(servletContext);
        // todo
    WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
        // todo
    for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
        beans.onStartup(servletContext);
    }
}

 
 
prepareWebApplicationContext
 ServletWebServerApplicationContext的prepareWebApplicationContext方法如下所示，简单来讲就是为servletContext设置根容器属性并为当前应用上下文ApplicationContext设置servletContext引用。
 
 
protected void prepareWebApplicationContext(ServletContext servletContext) {
//尝试从servletContext中获取rootContext 
        Object rootContext = servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
        if (rootContext != null) {
                if (rootContext == this) {
                        throw new IllegalStateException(
                                        "Cannot initialize context because there is already a root application context present - "
                                                        + "check whether you have multiple ServletContextInitializers!");
                }
                return;
        }
        Log logger = LogFactory.getLog(ContextLoader.class);
        // 这个日志是不是很熟悉？！
        servletContext.log("Initializing Spring embedded WebApplicationContext");
        try {

//向servletContext设置属性 ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE
                servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this);
                if (logger.isDebugEnabled()) {
                        logger.debug("Published root WebApplicationContext as ServletContext attribute with name ["
                                        + WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
                }
                // 为ApplicationContext设置servletContext引用
                setServletContext(servletContext);
                if (logger.isInfoEnabled()) {
                        long elapsedTime = System.currentTimeMillis() - getStartupDate();
                        logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
                }
        }
        catch (RuntimeException | Error ex) {
                logger.error("Context initialization failed", ex);
                servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
                throw ex;
        }
}

 
 
registerApplicationScope:
 ServletWebServerApplicationContext的registerApplicationScope方法如下所示，简单来讲就是(扩展)注册scope-application。这里会实例化一个ServletContextScope (包装了servletContext)，然后注册到BeanFactory中并为servletContext设置属性。
 
 
private void registerApplicationScope(ServletContext servletContext) {
        ServletContextScope appScope = new ServletContextScope(servletContext);
        // application
        getBeanFactory().registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
        // Register as ServletContext attribute, for ContextCleanupListener to detect it.
        servletContext.setAttribute(ServletContextScope.class.getName(), appScope);
}

 
 
我们在Spring中refresh分析之postProcessBeanFactory方法详解提到了request-RequestScope，session–SessionScope的注册，本文这里注册了application-ServletContextScope注册。
 
 
registerEnvironmentBeans:
 WebApplicationContextUtils的registerEnvironmentBeans方法。
 
 
public static void registerEnvironmentBeans(ConfigurableListableBeanFactory bf, @Nullable ServletContext sc) {
        registerEnvironmentBeans(bf, sc, null);
}

public static void registerEnvironmentBeans(ConfigurableListableBeanFactory bf,
                @Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {

//将servletContext作为单例注册容器
        if (servletContext != null && !bf.containsBean(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME)) {
                bf.registerSingleton(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME, servletContext);
        }

// 将servletConfig 作为单例注册容器本文这里没有触发
        if (servletConfig != null && !bf.containsBean(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME)) {
                bf.registerSingleton(ConfigurableWebApplicationContext.SERVLET_CONFIG_BEAN_NAME, servletConfig);
        }
// String CONTEXT_PARAMETERS_BEAN_NAME = "contextParameters";
        if (!bf.containsBean(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME)) {
                Map parameterMap = new HashMap<>();
                if (servletContext != null) {
                // 获取servletContextd的初始化参数
                        Enumeration paramNameEnum = servletContext.getInitParameterNames();
                        while (paramNameEnum.hasMoreElements()) {
                                String paramName = (String) paramNameEnum.nextElement();
                                parameterMap.put(paramName, servletContext.getInitParameter(paramName));
                        }
                }
                // 本文这里servletConfig 为null
                if (servletConfig != null) {
                // // 获取servletConfig的初始化参数
                        Enumeration paramNameEnum = servletConfig.getInitParameterNames();
                        while (paramNameEnum.hasMoreElements()) {
                                String paramName = (String) paramNameEnum.nextElement();
                                parameterMap.put(paramName, servletConfig.getInitParameter(paramName));
                        }
                }
                // 将contextParameters作为单例注册到容器
                bf.registerSingleton(WebApplicationContext.CONTEXT_PARAMETERS_BEAN_NAME,
                                Collections.unmodifiableMap(parameterMap));
        }

// String CONTEXT_ATTRIBUTES_BEAN_NAME = "contextAttributes";
        if (!bf.containsBean(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME)) {
                Map attributeMap = new HashMap<>();
                if (servletContext != null) {
                        Enumeration attrNameEnum = servletContext.getAttributeNames();
                        while (attrNameEnum.hasMoreElements()) {
                                String attrName = (String) attrNameEnum.nextElement();
                                attributeMap.put(attrName, servletContext.getAttribute(attrName));
                        }
                }
                // 将contextAttributes作为单例注册到容器
                bf.registerSingleton(WebApplicationContext.CONTEXT_ATTRIBUTES_BEAN_NAME,
                                Collections.unmodifiableMap(attributeMap));
        }
}

 
 
触发ServletContextInitializer的onStartup:如下所示，这里会获取ServletContextInitializer的所有实例，遍历触发其onStartup方法。
 
 
for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
        beans.onStartup(servletContext);
}

 
 
如下所示，将会挨个触发这5个的onStartup方法:
 
 
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 
 
核心代码如下：
 
 
// org.springframework.boot.web.servlet.RegistrationBean#onStartup
@Override
public final void onStartup(ServletContext servletContext) throws ServletException {
   String description = getDescription();
   if (!isEnabled()) {
      logger.info(StringUtils.capitalize(description) + " was not registered (disabled)");
      return;
   }
   register(description, servletContext);
}
// org.springframework.boot.web.servlet.DynamicRegistrationBean#register
@Override
protected final void register(String description, ServletContext servletContext) {
   D registration = addRegistration(description, servletContext);
   if (registration == null) {
      logger.info(StringUtils.capitalize(description) + " was not registered (possibly already registered?)");
      return;
   }
   configure(registration);
}
// org.springframework.boot.web.servlet.ServletRegistrationBean#addRegistration
@Override
protected ServletRegistration.Dynamic addRegistration(String description, ServletContext servletContext) {
   String name = getServletName();
   return servletContext.addServlet(name, this.servlet);
}

 
 
在这里，会将Dispatcher加入到Tomcat中，之后就是Tomcat的启动流程，跟之前启动SpringMVC流程一样
 
 
3.6 afterRefresh
 
 
进入org.springframework.boot.SpringApplication#afterRefresh方法中
 
 
protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) {
}

 
 
这里啥也没做，就是一个模板方法，可能使用于扩展性的吧
 
 
3.7 callRunners
 
 
进入org.springframework.boot.SpringApplication#callRunners方法中
 
 
private void callRunners(ApplicationContext context, ApplicationArguments args) {
   List runners = new ArrayList<>();
   runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
   runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
   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);
   }
}
 
 
可以看到这里主要就是从容器中获取runner对象并调用对应的run方法。
 
 
3.8 流程框图
 
 
 
  
 
   
  
   
 
  
 
  

    image.png 
  
 
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(SpringBoot2源码2-核心启动过程和run方法)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》
                        1784e22615e0

                        
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • html 中如何使用 uniapp 的部分方法
                        某公司摸鱼前端
htmluni-app前端
                        
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么
                        测评君高省

                        
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
    
                    
    • 
                    
  • 水平垂直居中的几种方法（总结）
                        LJ小番茄
CSS_玄学语言htmljavascript前端csscss3
                        
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
    
                    
    • 
                    
  • 本周第二次约练
                        2cfbdfe28a51

                        
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
    
                    
    • 
                    
  • 放下是一段成长的修行
                        小莳玥

                        
    人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                                
  • java数字签名三种方式
                                    知了ing
javajdk
                                    
    以下3钟数字签名都是基于jdk7的 
1，RSA 
 

String password="test";
			// 1.初始化密钥
			KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
			keyPairGenerator.initialize(51
    
                                
    • 
                                
  • Hibernate学习笔记
                                    caoyong
Hibernate
                                    
    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 
2>、搭建Hibernate的开发环境 
     a>、添加jar包: 
      aa>、hibernatte开发包中/lib/required/所
    
                                
    • 
                                
  • 设计模式之装饰器模式Decorator（结构型）
                                    漂泊一剑客
Decorator
                                    
    1. 概述 
 
 
       若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。 
 
      
    
                                
    • 
                                
  • 读取磁盘文件txt，并输入String
                                    一炮送你回车库
String
                                    
    public static void main(String[] args) throws IOException { 
  
 String fileContent = readFileContent("d:/aaa.txt"); 
  
 System.out.println(fileContent); 
   

    
                                
    • 
                                
  • js三级联动下拉框
                                    3213213333332132
三级联动
                                    
    
//三级联动  
   省/直辖市<select id="province"></select>  
   市/省直辖<select id="city"></select>  
   县/区 <select id="area"></select>  
  
    
                                
    • 
                                
  • erlang之parse_transform编译选项的应用
                                    616050468
parse_transform游戏服务器属性同步abstract_code
                                    
             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
    
                                
    • 
                                
  • JAVA JSON的解析
                                    darkranger
java
                                    
    
 
//		{
//			“Total”：“条数”，
//			 Code: 1,
//
//			“PaymentItems”:[
//			{
//			“PaymentItemID”:”支款单ID”,
//			“PaymentCode”:”支款单编号”,
//			“PaymentTime”:”支款日期”,
//			”ContractNo”:”合同号”，
//	
    
                                
    • 
                                
  • POJ-1273-Drainage Ditches
                                    aijuans
ACM_POJ
                                    
    POJ-1273-Drainage Ditches 
http://poj.org/problem?id=1273 
基本的最大流，按LRJ的白书写的 
 
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;
#define INF 0x7fffffff
int ma
    
                                
    • 
                                
  • 工作流Activiti5表的命名及含义
                                    atongyeye
工作流Activiti
                                    
    activiti5 - http://activiti.org/designer/update在线插件安装 
 
activiti5一共23张表 
 
 
Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 
 
ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 
 
A
    
                                
    • 
                                
  • android的广播机制和广播的简单使用
                                    百合不是茶
android广播机制广播的注册
                                    
          Android广播机制简介  在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
    
                                
    • 
                                
  • Spring事务传播行为详解
                                    bijian1013
javaspring事务传播行为
                                    
            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。 
        Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
    
                                
    • 
                                
  • eidtplus operate
                                    征客丶
eidtplus
                                    
    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 
列模式替换或复制内容(多行): 
右键-->格式-->填充所选内容-->选择相应操作 
OR 
Ctrl+Shift+V(复制多行数据,必须行数一致) 
 
-------------------------------------------------------
    
                                
    • 
                                
  • 【Kafka一】Kafka入门
                                    bit1129
kafka
                                    
    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧 
  下载Kafka 
 http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 
 2.10表示Scala的版本，而0.8.1.1表示Kafka
    
                                
    • 
                                
  • Spring 事务实现机制
                                    BlueSkator
spring代理事务
                                    
    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口 
    
                                
    • 
                                
  • bootstrap源码学习与示例：bootstrap-dropdown（转帖）
                                    BreakingBad
bootstrapdropdown
                                    
    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 
一个下拉开菜单的设计： 
                  <ul class="nav pull-right">
                        <li id="fat-menu" class="dropdown">

    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/*
 * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。
 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
 * 
 * 在我看来，Mediator模式是把多个对象（
    
                                
    • 
                                
  • 常用代码记录
                                    chenjunt3
UIExcelJ#
                                    
      
1、单据设置某行或某字段不能修改

//i是行号,"cash"是字段名称
getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false);
//取得单据表体所有项用以上语句做循环就能设置整行了
getBillC
    
                                
    • 
                                
  • 搜索引擎与工作流引擎
                                    comsci
算法工作搜索引擎网络应用
                                    
      
 
    最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想) 
  -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
    
                                
    • 
                                
  • oracle Health Monitor
                                    daizj
oracleHealth Monitor
                                    
    About Health Monitor 
 
Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. 
 
About Health Monitor Checks 
 
Health M
    
                                
    • 
                                
  • JSON字符串转换为对象
                                    dieslrae
javajson
                                    
        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了. 
  
    
                                
    • 
                                
  • C语言学习八结构体，综合应用，学生管理系统
                                    dcj3sjt126com
C语言
                                    
    实现功能的代码： 
# include <stdio.h>
# include <malloc.h>

struct Student
{
	int age;
	float score;
	char name[100];
};


int main(void)
{
	int len;
	struct Student * pArr;
	int i,
    
                                
    • 
                                
  • vagrant学习笔记
                                    dcj3sjt126com
vagrant
                                    
    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant 
  
1. vagrant virtualbox 下载安装 
https://www.vagrantup.com/downloads.html 
https://www.virtualbox.org/wiki/Downloads 
  
查看安装在命令行输入vagrant 
  
  
2.
    
                                
    • 
                                
  • 14.性能优化-优化-软件配置优化
                                    frank1234
软件配置性能优化
                                    
    1.Tomcat线程池 
 
修改tomcat的server.xml文件： 
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
    
                                
    • 
                                
  • 一个不错的shell 脚本教程 入门级
                                    HarborChung
linuxshell
                                    
    一个不错的shell 脚本教程 入门级 
建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
    
                                
    • 
                                
  • Spring4新特性——核心容器的其他改进
                                    jinnianshilongnian
spring动态代理spring4依赖注入
                                    
    Spring4新特性——泛型限定式依赖注入 
Spring4新特性——核心容器的其他改进 
Spring4新特性——Web开发的增强 
Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  
Spring4新特性——Groovy Bean定义DSL 
Spring4新特性——更好的Java泛型操作API  
Spring4新
    
                                
    • 
                                
  • Linux设置tomcat开机启动
                                    liuxingguome
tomcatlinux开机自启动
                                    
    执行命令sudo gedit /etc/init.d/tomcat6 
 
然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 
 
#!/bin/bash 
 
# 
 
# /etc/rc.d/init.d/tomcat 
 
# init script for tomcat precesses
    
                                
    • 
                                
  • 第13章 Ajax进阶（下）
                                    onestopweb
Ajax
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • Troubleshooting Crystal Reports off BW
                                    blueoxygen
BO
                                    
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE 
  
Quite useful, especially this part:  
SAP BW connectivity 
For t
    
                                
    • 
                                
  • Java开发熟手该当心的11个错误
                                    tomcat_oracle
javajvm多线程单元测试
                                    
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 
测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
    
                                
    • 
                                
  • 正则表达式大全
                                    yang852220741
html编程正则表达式
                                    
    今天向大家分享正则表达式大全，它可以大提高你的工作效率 
正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 
一、校验数字的表达式 
 
数字：^[0-9]*$ 
n位的数字：^\d{n}$ 
至少n位的数字：^\d{n,}$ 
m-n位的数字：^\d{m,n}$
    
                                
    •