java_lujj
java_lujj

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继承图：

SpringBoot2源码2-核心启动过程和run方法_第1张图片

在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 方法：

public class YamlPropertySourceLoader implements PropertySourceLoader {

	@Override
	public String[] getFileExtensions() {
		return new String[] { "yml", "yaml" };
	}

	@Override
	public List> load(String name, Resource resource) throws IOException {
		if (!ClassUtils.isPresent("org.yaml.snakeyaml.Yaml", getClass().getClassLoader())) {
			throw new IllegalStateException(
					"Attempted to load " + name + " but snakeyaml was not found on the classpath");
		}
		List> loaded = new OriginTrackedYamlLoader(resource).load();
		if (loaded.isEmpty()) {
			return Collections.emptyList();
		}
		List> propertySources = new ArrayList<>(loaded.size());
		for (int i = 0; i < loaded.size(); i++) {
			String documentNumber = (loaded.size() != 1) ? " (document #" + i + ")" : "";
			propertySources.add(new OriginTrackedMapPropertySource(name + documentNumber,
					Collections.unmodifiableMap(loaded.get(i)), true));
		}
		return propertySources;
	}

}

在这里加载 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 方法在之前的文章中有过介绍
 
  
@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，如下图所示：
 
  
 
  
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方法: 
 
  
 
 
  
SpringBoot2源码2-核心启动过程和run方法_第2张图片
 
  
 核心代码如下：
 
  
// 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 流程框图
 
  
SpringBoot2源码2-核心启动过程和run方法_第3张图片
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,spring,spring,boot)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                                
  • java短路运算符和逻辑运算符的区别
                                    3213213333332132
java基础
                                    
    
/*
		 * 逻辑运算符——不论是什么条件都要执行左右两边代码
		 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的
		 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。
		 * 
		 * 并联电路两个开关只要有一个开关闭合，电路就会通。
		 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
    
                                
    • 
                                
  • Java异常那些不得不说的事
                                    白糖_
javaexception
                                    
    一、在finally块中做数据回收操作 
比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 
JDBCAgent jdbc = new JDBCAgent();
try{
jdbc.excute("select * from ctp_log");
}catch(SQLException e){
...
}finally{
jdbc.close();

    
                                
    • 
                                
  • utf-8与utf-8(无BOM)的区别
                                    dcj3sjt126com
PHP
                                    
    BOM——Byte Order Mark，就是字节序标记       在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
    
                                
    • 
                                
  • JAVA Annotation之定义篇
                                    周凡杨
java注解annotation入门注释
                                    
        Annotation: 译为注释或注解 
An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
    
                                
    • 
                                
  • tomcat的多域名、虚拟主机配置
                                    g21121
tomcat
                                    
    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。 
很多朋友搜索的内容基本是告诉我们这么配置： 
在Engine标签下增面积Host标签，如下： 
<Host name="www.site1.com"  appBase="webapps"
    
                                
    • 
                                
  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ）
                                    510888780
linuxcapistrano
                                    
     
1.ssh -v [email protected] 出现 
Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 
错误 
 
运行状况如下： 
 
 
OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013
debug1: Reading configuratio
    
                                
    • 
                                
  • log4j的用法
                                    Harry642
javalog4j
                                    
    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
    
                                
    • 
                                
  • mysql、sqlserver、oracle分页，java分页统一接口实现
                                    aijuans
oraclejave
                                    
      
定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 
oracle分页： 
　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart 
sqlServer分页： 
 
    
                                
    • 
                                
  • Hessian 简单例子
                                    antlove
javaWebservicehessian
                                    
    hello.hessian.MyCar.java 
package hessian.pojo;

import java.io.Serializable;


public class MyCar implements Serializable {

    private static final long serialVersionUID = 473690540190845543
    
                                
    • 
                                
  • 数据库对象的同义词和序列
                                    百合不是茶
sql序列同义词ORACLE权限
                                    
    回顾简单的数据库权限等命令; 
解锁用户和锁定用户
alter user scott account lock/unlock;
//system下查看系统中的用户
select * dba_users;

//创建用户名和密码
create user wj identified by wj;
identified by 
//授予连接权和建表权
grant connect to 
    
                                
    • 
                                
  • 使用Powermock和mockito测试静态方法
                                    bijian1013
持续集成单元测试mockitoPowermock
                                    
            实例： 
package com.bijian.study;

import static org.junit.Assert.assertEquals;

import java.io.IOException;

import org.junit.Before;
import org.junit.Test;
import or
    
                                
    • 
                                
  • 精通Oracle10编程SQL(6)访问ORACLE
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *访问ORACLE
*/

--检索单行数据
--使用标量变量接收数据
DECLARE
  v_ename emp.ename%TYPE;
  v_sal emp.sal%TYPE;
BEGIN
  select ename,sal into v_ename,v_sal
  from emp where empno=&no;
  dbms_output.pu
    
                                
    • 
                                
  • 【Nginx四】Nginx作为HTTP负载均衡服务器
                                    bit1129
nginx
                                    
     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处： 
  负载均衡的好处 
 
 增加可用资源 
 增加吞吐量 
 加快响应速度，降低延时 
 出错的重试验机制 
 Nginx主要支持三种均衡算法： 
 
 round-robin 
 l
    
                                
    • 
                                
  • jquery-validation备忘
                                    白糖_
jquerycssF#Firebug
                                    
    留点学习jquery validation总结的代码： 
  
function checkForm(){
	validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID
		errorElement :"span",// 使用"div"标签标记错误， 默认:&
    
                                
    • 
                                
  • solr限制admin界面访问（端口限制和http授权限制）
                                    ronin47
限定Ip访问
                                    
    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。 
可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。 
我们先看如何通过tomcat配置http授权限制。 
第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： 
<userusername="ad
    
                                
    • 
                                
  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1
                                    bylijinnan
java多线程
                                    
    

public class IncDecThread {

	private int j=10;
	
	/*
	 * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1
	 * 两个问题：
	 * 1、线程同步--synchronized
	 * 2、线程之间如何共享同一个j变量--内部类
	 */
	public static 
    
                                
    • 
                                
  • 买房历程
                                    cfyme

                                    
      
  
2015-06-21: 万科未来城，看房子 
  
2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675 
  
2015-06-27: 房子首付,签完合同 
  
2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。 
  
首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
    
                                
    • 
                                
  • [军事与科技]制造大型太空战舰的前奏
                                    comsci
制造
                                    
     
 
       天气热了........空调和电扇要准备好.......... 
 
       最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界.......... 
 
 
       所以,我们不得不关
    
                                
    • 
                                
  • dateformat
                                    dai_lm
DateFormat
                                    
    
"Symbol  Meaning             Presentation   Ex."
"------  -------             ------------   ----"
"G       era designator      (Text)         AD"
"y       year
    
                                
    • 
                                
  • Hadoop如何实现关联计算
                                    datamachine
mapreducehadoop关联计算
                                    
        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。 
    以关联计算为例。 
    假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？ 
  &nbs
    
                                
    • 
                                
  • 用户模型中修改用户信息时，密码是如何处理的
                                    dcj3sjt126com
yii
                                    
    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。 
场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。 
面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
    
                                
    • 
                                
  • 中文 iOS/Mac 开发博客列表
                                    dcj3sjt126com
Blog
                                    
      
本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。 
本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。 
本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。   
    
                                
    • 
                                
  • js去除空格，去除左右两端的空格
                                    蕃薯耀
去除左右两端的空格js去掉所有空格js去除空格
                                    
    js去除空格，去除左右两端的空格 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
    
                                
    • 
                                
  • SpringMVC4零配置--web.xml
                                    hanqunfeng
springmvc4
                                    
    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 
ServletContainerInitializer：启动容器时负责加载相关配置 
package javax.servlet;
import java.util.Set;
public interface ServletContainer
    
                                
    • 
                                
  • 《开源框架那些事儿21》：巧借力与借巧力
                                    j2eetop
框架UI
                                    
    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。 
故事1：巧借力，乌鸦也可以吃核桃 
有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。 
核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
    
                                
    • 
                                
  • JQuery EasyUI 验证扩展
                                    可怜的猫
jqueryeasyui验证
                                    
      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。 
  以下内容只需要在公用js中添加即可。 
  使用类似于如下： 
 <input class="easyui-textbox" name="mobile" id="mobile&
    
                                
    • 
                                
  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类)
                                    nannan408

                                    
    1.前言. 
   如题. 
2.代码. 
 

/* 
 * Copyright (c) 2015, S.F. Express Inc. All rights reserved.
 */
package com.test.test.test.send;

import java.io.IOException;
import java.io.InputStream
    
                                
    • 
                                
  • Jquery性能优化
                                    r361251
JavaScriptjquery
                                    
    一、注意定义jQuery变量的时候添加var关键字 
这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： 
$loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的 
二、请使用一个var来定义变量 
如果你使用多个变量的话，请如下方式定义： 
. 代码如下: 
 
var page 
    
                                
    • 
                                
  • 在eclipse项目中使用maven管理依赖
                                    tjj006
eclipsemaven
                                    
    概览: 
 
 如何导入maven项目至eclipse中 
 
 
 建立自有Maven  Java类库服务器 
 
 
 建立符合maven代码库标准的自定义类库 
 
Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。 
我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
    
                                
    • 
                                
  • 中国天气网省市级联页面
                                    x125858805
级联
                                    
    1、页面及级联js 
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
&l
    
                                
    •