Use SpringBoot;

1) Create the SpringBoot application and select the module we need;

2) SpringBoot has configured these scenarios by default and only needs to specify a few configurations in the configuration file to run

3) Write business code by myself;

How does automatic configuration work?

What does SpringBoot configure for us in this scenario? Can you change it? What configurations can be modified? Can it be extended? xxx

XxxxAutoConfiguration: help us auto-configure the components in the container; XxxxProperties: configuration class to encapsulate the contents of configuration files;Copy the code

localhost:8080/webjars/jquery/3.51./jquery.js
Copy the code

<! - introduction of jquery - webjar -- -- >Just write the name of the resource under WebJars when accessing it<dependency>
			<groupId>org.webjars</groupId>
			<artifactId>jquery</artifactId>
			<version>3.3.1</version>
		</dependency>
Copy the code

2), “/**” to access any resources of the current project, go to (static resources folder) to find the mapping

"Classpath :/ meta-INF /resources/", "classpath:/resources/", "classpath:/static/", "classpath:/public/" "/" : root path of the current projectCopy the code

• Localhost :8080/ ABC === go to static resources (lasspath:/resources/) folder and find ABC

3) Welcome page; All index.html pages in the static resources folder; Mapped by “/**”;

Localhost :8080/ Find the index page

4) all **/favicon.ico are found under static resource files;

For example, set to replace the default home page and icon

• Note: The default static resource path is the resource under the project. You can also modify the default static resource configuration to specify other folders as the default static resource configuration.
• Under the application. Properties of the project, separate multiple classpath with a colon

spring.resource.static-location=classpath:/hello/,classPath:/xdr630/
Copy the code

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
Copy the code

• You can see the version in the dependency:
  
  
• Switch the thymeleaf version and import thymeleaf 2.1.6 by default. The version is too low and can be imported in POM.xml

<properties>
		<thymeleaf.version>3.0.9. RELEASE</thymeleaf.version>
		<! Support program for layout function Thymeleaf3 main program Layout2 or later -->
		<! -- thymeleaf2 layout1-->
		<thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
</properties>
Copy the code

1), th:text; Change the text content of the current element.

​ Th:Any HTML attribute; To replace the value of the native property

2), expression?

Simple expressions () Variable expressions: ${... } : get the variable value; OGNL;1), get the properties of the object, and call methods2# CTX: The context object. # Vars: the context variables. #locale: the context locale. (only in Web Contexts) the HttpServletRequest object. #response : (only in Web Contexts) the HttpServletResponse object. #session : (only in Web Contexts) the HttpSession object. #servletContext : (only in Web Contexts) the ServletContext object. ${session.foo}3ExecInfo: information about the template being processed. # Messages: MethodsforObtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{... } syntax. #uris : methodsfor escaping parts of URLs/URIs
#conversions : methods for executing the configured conversion service (if any).
#dates : methods for java.util.Date objects: formatting, component extraction, etc.
#calendars : analogous to #dates , but for java.util.Calendar objects.
#numbers : methods for formatting numeric objects.
#strings : methods for String objects: contains, startsWith, prepending/appending, etc.
#objects : methods for objects in general.
#bools : methods for boolean evaluation.
#arrays : methods for arrays.
#lists : methods for lists.
#sets : methods for sets.
#maps : methods for maps.
#aggregates : methods for creating aggregates on arrays or collections.
#ids : methods for dealing with id attributes that might be repeated (for example, as a result of an iteration).

    Selection Variable Expressions: *{... } : select expression: and ${} function is the same; Add: match th:object="${session. User} : < div th: object ="${session.user}"> 
Name: *{firstName}">Sebastian.
 
Surname: *{lastName}">Pepper.
 
Nationality: *{nationality}">Saturn.
  Message Expressions: #{... } : How do I get the URL? } : Define URL; @{/order/process(execId=${execId},execType='FAST')} Fragment Expressions: ~{... } : fragment reference expression ~{commons :: main}">...  Literals Text Literals: 'One Text', 'Another one! ',... Number literals: 0, 34, 3.0, 12.3... Boolean literals: true, false Null literal: Null literal tokens: one, someText, main... Text Operations (Text Manipulation) String concatenation: + Literal substitutions: | | The name is ${name} Arithmetic operations (math) Binary operators: +, -, *, /, % Minus sign (unary operator) : -boolean operators: and, or Boolean negation (unary operator):! Word order: >, <= (gt, lt, GE, le) Equality operators: ==,! = (eq, ne) Conditional Operators: Conditional operators if-then: (If)? (then) If-then-else: (if) ? (then) : (else) Default: (value) ? : (defaultvalue) Special tokens: No-Operation: _Copy the code

If you want to take complete control of Spring MVC, you can add your own @Configuration annotated with @EnableWebMvc.

The automatic configuration of SpringBoot for SpringMVC is no longer needed, everything is configured by ourselves; All SpringMVC auto-configuration is invalid

We need to add @enableWebMVC to the configuration class;

// The WebMvcConfigurerAdapter can be used to extend the SpringMVC functionality
@EnableWebMvc
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
       // super.addViewControllers(registry);
        // The browser sends /atguigu to success
        registry.addViewController("/atguigu").setViewName("success"); }}Copy the code

Principle:

Why @enableWebMVC auto-configuration is invalid;

1) @enableWebMVC core

@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
Copy the code

2),

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
Copy the code

3),

@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurerAdapter.class })
// The autoconfiguration class takes effect only when the component is not in the container
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
Copy the code

4), @ EnableWebMvc imported WebMvcConfigurationSupport components;

5), import WebMvcConfigurationSupport only the most basic function of for SpringMVC;

1) Write internationalization configuration files;

2), use ResourceBundleMessageSource management internationalization resource files

3) Use FMT :message to retrieve internationalized content

Steps:

1) Write internationalization configuration files and extract the internationalization messages that need to be displayed on the page

2) SpringBoot is automatically configured to manage international resource files;

@ConfigurationProperties(prefix = "spring.messages")
public class MessageSourceAutoConfiguration {
    
    /** * Comma-separated list of basenames (essentially a fully-qualified classpath * location), each following the ResourceBundle convention with relaxed support for * slash based locations. If it doesn't contain a package qualifier (such as * "org.mypackage"), it will be resolved from the classpath root. */
	private String basename = "messages";  
    // Our configuration file can be placed directly in the classpath called messages.properties;
    
    @Bean
	public MessageSource messageSource(a) {
		ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
		if (StringUtils.hasText(this.basename)) {
            // Set the base name of the internationalized resource file (without the language country code)
			messageSource.setBasenames(StringUtils.commaDelimitedListToStringArray(
					StringUtils.trimAllWhitespace(this.basename)));
		}
		if (this.encoding ! =null) {
			messageSource.setDefaultEncoding(this.encoding.name());
		}
		messageSource.setFallbackToSystemLocale(this.fallbackToSystemLocale);
		messageSource.setCacheSeconds(this.cacheSeconds);
		messageSource.setAlwaysUseMessageFormat(this.alwaysUseMessageFormat);
		return messageSource;
	}
Copy the code

3) Go to the page to obtain the value of internationalization;

<! DOCTYPEhtml>
<html lang="en"  xmlns:th="http://www.thymeleaf.org">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
		<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
		<meta name="description" content="">
		<meta name="author" content="">
		<title>Signin Template for Bootstrap</title>
		<! -- Bootstrap core CSS -->
		<link href="asserts/css/bootstrap.min.css" th:href="@ {/ webjars/bootstrap / 4.0.0 / CSS/bootstrap CSS}" rel="stylesheet">
		<! -- Custom styles for this template -->
		<link href="asserts/css/signin.css" th:href="@{/asserts/css/signin.css}" rel="stylesheet">
	</head>

	<body class="text-center">
		<form class="form-signin" action="dashboard.html">
			<img class="mb-4" th:src="@{/asserts/img/bootstrap-solid.svg}" src="asserts/img/bootstrap-solid.svg" alt="" width="72" height="72">
			<h1 class="h3 mb-3 font-weight-normal" th:text="#{login.tip}">Please sign in</h1>
			<label class="sr-only" th:text="#{login.username}">Username</label>
			<input type="text" class="form-control" placeholder="Username" th:placeholder="#{login.username}" required="" autofocus="">
			<label class="sr-only" th:text="#{login.password}">Password</label>
			<input type="password" class="form-control" placeholder="Password" th:placeholder="#{login.password}" required="">
			<div class="checkbox mb-3">
				<label>
          		<input type="checkbox" value="remember-me"/> [[#{login.remember}]]
        </label>
			</div>
			<button class="btn btn-lg btn-primary btn-block" type="submit" th:text="#{login.btn}">Sign in</button>
			<p class="mt-5 mb-3 text-muted">© 2017-2018</p>
			<a class="btn btn-sm">Chinese</a>
			<a class="btn btn-sm">English</a>
		</form>

	</body>

</html>
Copy the code

Effect: Switch internationalization based on the browser language Settings.

Principle:

Internationalized Locale (regional information objects); LocaleResolver (get region information object);

		@Bean
		@ConditionalOnMissingBean
		@ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
		public LocaleResolver localeResolver(a) {
			if (this.mvcProperties
					.getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
				return new FixedLocaleResolver(this.mvcProperties.getLocale());
			}
			AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
			localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
			returnlocaleResolver; } By default, the Locale Locale is retrieved from the request headerCopy the code

4) Click the link to switch to internationalization

/** * can carry region information on the connection */
public class MyLocaleResolver implements LocaleResolver {
    
    @Override
    public Locale resolveLocale(HttpServletRequest request) {
        String l = request.getParameter("l");
        Locale locale = Locale.getDefault();
        if(! StringUtils.isEmpty(l)){ String[] split = l.split("_");
            locale = new Locale(split[0],split[1]);
        }
        return locale;
    }

    @Override
    public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {}}@Bean
    public LocaleResolver localeResolver(a){
        return newMyLocaleResolver(); }}Copy the code

The interceptor

/** * login check, */
public class LoginHandlerInterceptor implements HandlerInterceptor {
    // Before the target method is executed
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object user = request.getSession().getAttribute("loginUser");
        if(user == null) {// No login, return to login page
            request.setAttribute("msg"."No permission, please log in first.");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }else{
            // Logged-in, release request
            return true; }}@Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {}@Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {}}Copy the code

Register interceptors

  // All the WebMvcConfigurerAdapter components work together
    @Bean // Register the component in the container
    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(a){
        WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {
                registry.addViewController("/").setViewName("login");
                registry.addViewController("/index.html").setViewName("login");
                registry.addViewController("/main.html").setViewName("dashboard");
            }

            // Register interceptors
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                //super.addInterceptors(registry);
                // Static resources; *.css , *.js
                //SpringBoot has done static resource mapping
                registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/ * *")
                        .excludePathPatterns("/index.html"."/"."/user/login"); }};return adapter;
    }
Copy the code

1. Extract common fragments<div th:fragment="copy">
&copy; 2011 The Good Thymes Virtual Grocery
</div>2. Introduce public fragments<div th:insert="~{footer :: copy}"></div>~ {templatename: : the selector} : template name: : selector ~ {templatename: : fragmentname} : template name: : fragments of 3, the default effect: Insert: [[~{}]]; [[~{}]]; [[~{}]]; [[~{}]]; [(~ {})];Copy the code

Three th attributes introduced into public fragments:

Th: INSERT: Inserts the entire public fragment into the element introduced by the declaration

Th :replace: Replaces the element introduced by the declaration with a public fragment

Th :include: Includes the content of the introduced fragment in this tag

<footer th:fragment="copy">
&copy; 2011 The Good Thymes Virtual Grocery
</footer>Introducing way<div th:insert="footer :: copy"></div>
<div th:replace="footer :: copy"></div>
<div th:include="footer :: copy"></div>The effect<div>
    <footer>
    &copy; 2011 The Good Thymes Virtual Grocery
    </footer>
</div>

<footer>
&copy; 2011 The Good Thymes Virtual Grocery
</footer>

<div>
&copy; 2011 The Good Thymes Virtual Grocery
</div>
Copy the code

To import a fragment, pass in a parameter:

<nav class="col-md-2 d-none d-md-block bg-light sidebar" id="sidebar">
    <div class="sidebar-sticky">
        <ul class="nav flex-column">
            <li class="nav-item">
                <a class="nav-link active"
                   th:class="${activeUri=='main.html'? 'nav-link active':'nav-link'}"
                   href="#" th:href="@{/main.html}">
                    <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox=24 24 "0 0" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="feather feather-home">
                        <path d="M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"></path>
                        <polyline points="9, 22, 9, 12, 15, 12, 15, 22"></polyline>
                    </svg>
                    Dashboard <span class="sr-only">(current)</span>
                </a>
            </li>

<! -- Introduce sidebar; Pass in parameters -->
<div th:replace="commons/bar::#sidebar(activeUri='emps')"></div>
Copy the code

Modified add 2-in-1 form

1) Custom exception handling & return custom JSON data;

@ControllerAdvice
public class MyExceptionHandler {

    @ResponseBody
    @ExceptionHandler(UserNotExistException.class)
    public Map<String,Object> handleException(Exception e){
        Map<String,Object> map = new HashMap<>();
        map.put("code"."user.notexist");
        map.put("message",e.getMessage());
        returnmap; }}// There is no adaptive effect...
Copy the code

2) Forward to /error for adaptive response effect processing

 @ExceptionHandler(UserNotExistException.class)
    public String handleException(Exception e, HttpServletRequest request){
        Map<String,Object> map = new HashMap<>();
        // Pass in our own error status code 4xx 5xx, otherwise we will not enter the custom error page parsing process
        /** * Integer statusCode = (Integer) request .getAttribute("javax.servlet.error.status_code"); * /
        request.setAttribute("javax.servlet.error.status_code".500);
        map.put("code"."user.notexist");
        map.put("message",e.getMessage());
        // Forward to /error
        return "forward:/error";
    }
Copy the code

SpringBoot uses Tomcat as the embedded Servlet container by default;

The problem?

Because SpringBoot starts the embedded Servlet container as a JAR package by default to start SpringBoot Web applications, there is no web.xml file.

Register the three components in the following way

ServletRegistrationBean

// Register three components
@Bean
public ServletRegistrationBean myServlet(a){
    ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
    return registrationBean;
}
Copy the code

FilterRegistrationBean

@Bean
public FilterRegistrationBean myFilter(a){
    FilterRegistrationBean registrationBean = new FilterRegistrationBean();
    registrationBean.setFilter(new MyFilter());
    registrationBean.setUrlPatterns(Arrays.asList("/hello"."/myServlet"));
    return registrationBean;
}
Copy the code

ServletListenerRegistrationBean

@Bean
public ServletListenerRegistrationBean myListener(a){
    ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
    return registrationBean;
}
Copy the code

SpringBoot automatically registers the front-end controller of SpringMVC when we automate SpringMVC. The DIspatcherServlet;

DispatcherServletAutoConfiguration:

@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public ServletRegistrationBean dispatcherServletRegistration( DispatcherServlet dispatcherServlet) {
   ServletRegistrationBean registration = new ServletRegistrationBean(
         dispatcherServlet, this.serverProperties.getServletMapping());
    // Default interception: / all requests; Package static resources, but do not intercept JSP requests; /* Intercepts JSPS
    Server.servletpath can be used to change the request path intercepted by SpringMVC's front-end controller by default
    
   registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
   registration.setLoadOnStartup(
         this.webMvcProperties.getServlet().getLoadOnStartup());
   if (this.multipartConfig ! =null) {
      registration.setMultipartConfig(this.multipartConfig);
   }
   return registration;
}
Copy the code

2) SpringBoot can support other Servlet containers;

EmbeddedServletContainerAutoConfiguration: embedded Servlet container configuration automatically?

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
/ / import BeanPostProcessorsRegistrar: Spring annotations; Import some components into the container
/ / import EmbeddedServletContainerCustomizerBeanPostProcessor:
// Post-handler: The bean is initialized before and after the object is created
public class EmbeddedServletContainerAutoConfiguration {
    
    @Configuration
	@ConditionalOnClass({ Servlet.class, Tomcat.class })// Determine whether Tomcat dependencies are currently introduced;
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)/ / determine the current container no user self-defining EmbeddedServletContainerFactory: embedded Servlet container factory. Creates an embedded Servlet container
	public static class EmbeddedTomcat {

		@Bean
		public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory(a) {
			return newTomcatEmbeddedServletContainerFactory(); }}/** * Nested configuration if Jetty is being used. */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Server.class, Loader.class, WebAppContext.class })
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedJetty {

		@Bean
		public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory(a) {
			return newJettyEmbeddedServletContainerFactory(); }}/** * Nested configuration if Undertow is being used. */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedUndertow {

		@Bean
		public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory(a) {
			return newUndertowEmbeddedServletContainerFactory(); }}Copy the code

1), EmbeddedServletContainerFactory (embedded Servlet container factory)

public interface EmbeddedServletContainerFactory {

   // Get the embedded Servlet container
   EmbeddedServletContainer getEmbeddedServletContainer( ServletContextInitializer... initializers);

}
Copy the code

2) EmbeddedServletContainer :(EmbeddedServletContainer)

3), TomcatEmbeddedServletContainerFactory, for example

@Override
public EmbeddedServletContainer getEmbeddedServletContainer( ServletContextInitializer... initializers) {
    // Create a Tomcat
   Tomcat tomcat = new Tomcat();
    
    // Configure the basic steps of Tomcat
   File baseDir = (this.baseDirectory ! =null ? this.baseDirectory
         : createTempDir("tomcat"));
   tomcat.setBaseDir(baseDir.getAbsolutePath());
   Connector connector = new Connector(this.protocol);
   tomcat.getService().addConnector(connector);
   customizeConnector(connector);
   tomcat.setConnector(connector);
   tomcat.getHost().setAutoDeploy(false);
   configureEngine(tomcat.getEngine());
   for (Connector additionalConnector : this.additionalTomcatConnectors) {
      tomcat.getService().addConnector(additionalConnector);
   }
   prepareContext(tomcat.getHost(), initializers);
    
    // Pass in the configured Tomcat and return an EmbeddedServletContainer; And start the Tomcat server
   return getTomcatEmbeddedServletContainer(tomcat);
}
Copy the code

4) How do our configuration changes to embedded containers take effect?

ServerProperties, EmbeddedServletContainerCustomizerCopy the code

EmbeddedServletContainerCustomizer: customizer, help us to modify the configuration of the Servlet container?

How to modify the principle?

5), the container import EmbeddedServletContainerCustomizerBeanPostProcessor

// before initialization
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
      throws BeansException {
    / / if the current initialization is a ConfigurableEmbeddedServletContainer type of component
   if (bean instanceof ConfigurableEmbeddedServletContainer) {
       //
      postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
   }
   return bean;
}

private void postProcessBeforeInitialization( ConfigurableEmbeddedServletContainer bean) {
    // Get all the customizers and call each one's customize method to assign attributes to the Servlet container;
    for(EmbeddedServletContainerCustomizer customizer : getCustomizers()) { customizer.customize(bean); }}private Collection<EmbeddedServletContainerCustomizer> getCustomizers(a) {
    if (this.customizers == null) {
        // Look up does not include the parent context
        this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
            this.beanFactory
            / / from the container for all the ge types of components: EmbeddedServletContainerCustomizer
            / / custom Servlet containers, containers can be added to a EmbeddedServletContainerCustomizer types of components
            .getBeansOfType(EmbeddedServletContainerCustomizer.class,
                            false.false)
            .values());
        Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
        this.customizers = Collections.unmodifiableList(this.customizers);
    }
    return this.customizers; } ServerProperties is also a customizerCopy the code

Steps:

1), SpringBoot according to the dependence on import situation, add the corresponding to the container EmbeddedServletContainerFactory TomcatEmbeddedServletContainerFactory 】 【

When a component in the container wants to create an object, it will alert the post-processor; EmbeddedServletContainerCustomizerBeanPostProcessor;

The backend processor works as long as it is an embedded Servlet container factory;

3), rear processor, from the container get all EmbeddedServletContainerCustomizer, call custom custom methods

###5) Embedded Servlet container startup principle;

When do you create an embedded Servlet container factory? When to get the embedded Servlet container and start Tomcat;

Get the embedded Servlet container factory:

1) The SpringBoot application starts and runs the Run method

2), refreshContext (context); SpringBoot flushes the IOC container [create IOC container objects, initialize the container, and create every component in the container]; If it is a web application to create AnnotationConfigEmbeddedWebApplicationContext, otherwise: AnnotationConfigApplicationContext

3), refresh (context); Refresh the ioc container you just created;

public void refresh(a) throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         initMessageSource();

         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();

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

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

         // Instantiate all remaining (non-lazy-init) singletons.
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }

      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...resetCommonCaches(); }}}Copy the code

4), onRefresh (); The Web’s IOC container overrides the onRefresh method

5) The Webioc container creates an embedded Servlet container; createEmbeddedServletContainer();

Get the embedded Servlet container factory:

EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();

Obtained from the ioc container EmbeddedServletContainerFactory components; TomcatEmbeddedServletContainerFactory object creation, post processor is a look at the object, to obtain all of custom custom first Servlet container of related configuration;

Use the container factory to get the embedded Servlet container: this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());

8) The embedded Servlet container creates objects and starts the Servlet container;

Start the embedded Servlet container first, then fetch the remaining uncreated objects from the IOC container;

The IOC container initiates the creation of an embedded Servlet container

1) You must create a WAR project; (Use IDEA to create a directory structure)

2) Specify embedded Tomcat as provided;

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-tomcat</artifactId>
   <scope>provided</scope>
</dependency>
Copy the code

3), you must write a SpringBootServletInitializer subclasses, and call the configure method

public class ServletInitializer extends SpringBootServletInitializer {

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
       // Pass in the main program of the SpringBoot application
      returnapplication.sources(SpringBoot04WebJspApplication.class); }}Copy the code

4) Start the server and it can be used;