springboot學習：第二天

阿新 • • 發佈：2021-06-23

三、日誌

1、日誌框架

小張；開發一個大型系統；

　　1、System.out.println("")；前期將關鍵資料列印在控制檯；去掉？寫在一個檔案？

　　2、後來框架來記錄系統的一些執行時資訊；日誌框架； zhanglogging.jar；

　　3、再後來加高大上的幾個功能？非同步模式？自動歸檔？xxxx？ zhanglogging-good.jar？

　　4、再後來將以前框架卸下來？換上新的框架，重新修改之前相關的API；zhanglogging-prefect.jar；

　　5、JDBC---資料庫驅動；

　　寫了一個統一的介面層；日誌門面（日誌的一個抽象層）；logging-abstract.jar；

　　給專案中匯入具體的日誌實現就行了；我們之前的日誌框架都是實現的抽象層；

市面上的日誌框架；

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j....

日誌門面（日誌的抽象層）	日誌實現
~~JCL（Jakarta Commons Logging）~~ SLF4j（Simple Logging Facade for Java） ~~jboss-logging~~	Log4j JUL（java.util.logging） Log4j2 Logback

左邊選一個門面（抽象層）、右邊來選一個實現；

日誌門面： SLF4J；

日誌實現：Logback；

SpringBoot：底層是Spring框架，Spring框架預設是用JCL；

2、SLF4j使用

1、如何在系統中使用SLF4j https://www.slf4j.org

以後開發的時候，日誌記錄方法的呼叫，不應該來直接呼叫日誌的實現類，而是呼叫日誌抽象層裡面的方法；

給系統裡面匯入slf4j的jar和 logback的實現jar

詳細參考：

logger(七)、springBoot的日誌原始碼檢視(LogBack + slf4j)——配置的實際工作類Action

logger(六)、springBoot的日誌原始碼檢視(LogBack + slf4j)—— ContextInitializer

logger(五)、springBoot的日誌原始碼檢視(LogBack + slf4j)——Appender

logger(四)、springBoot的日誌原始碼檢視(LogBack + slf4j)——記錄日誌

logger(三)、springBoot的日誌原始碼檢視(LogBack + slf4j)——建立Logger

logger(二)、springBoot的日誌原始碼檢視(LogBack + slf4j)——建立ILoggerFactory

logger(一)、springBoot的日誌原始碼檢視(LogBack + slf4j)——對接slf4j

springBoot的日誌配置(LogBack+slf4j)簡介 (2021-06-22 10:51)

springboot整合logback日誌快速使用 (2021-06-10 16:22)

四、Web開發

1、簡介

使用SpringBoot；

1）、建立SpringBoot應用，選中我們需要的模組；

2）、SpringBoot已經預設將這些場景配置好了，只需要在配置檔案中指定少量配置就可以執行起來

3）、自己編寫業務程式碼；

自動配置原理？

這個場景SpringBoot幫我們配置了什麼？能不能修改？能修改哪些配置？能不能擴充套件？xxx

xxxxAutoConfiguration：幫我們給容器中自動配置元件；
xxxxProperties:配置類來封裝配置檔案的內容；

2、SpringBoot對靜態資源的對映規則：

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties implements ResourceLoaderAware {
  //可以設定和靜態資源有關的引數，快取時間等
//預設的路徑
　　private static final String[] CLASSPATH_RESOURCE_LOCATIONS = {
      　　"classpath:/META-INF/resources/", 
　　　　　 "classpath:/resources/",
      　　"classpath:/static/", 
　　　　　 "classpath:/public/" 
　　};

WebMvcAuotConfiguration配置類重要方法：

　　　　　//通過webjars的方式新增靜態檔案   
　　　　 @Override
        public void addResourceHandlers(ResourceHandlerRegistry registry) {
            if (!this.resourceProperties.isAddMappings()) {
                logger.debug("Default resource handling disabled");
                return;
            }
            Integer cachePeriod = this.resourceProperties.getCachePeriod();
            if (!registry.hasMappingForPattern("/webjars/**")) {
                customizeResourceHandlerRegistration(
                        registry.addResourceHandler("/webjars/**")
                                .addResourceLocations(
                                        "classpath:/META-INF/resources/webjars/")
                        .setCachePeriod(cachePeriod));
            }
            String staticPathPattern = this.mvcProperties.getStaticPathPattern();
              //靜態資原始檔夾對映
            if (!registry.hasMappingForPattern(staticPathPattern)) {
                customizeResourceHandlerRegistration(
                        registry.addResourceHandler(staticPathPattern)
                                .addResourceLocations(
                                        this.resourceProperties.getStaticLocations())
                        .setCachePeriod(cachePeriod));
            }
        }

        //配置歡迎頁對映
        @Bean
        public WelcomePageHandlerMapping welcomePageHandlerMapping(
                ResourceProperties resourceProperties) {
            return new WelcomePageHandlerMapping(resourceProperties.getWelcomePage(),
                    this.mvcProperties.getStaticPathPattern());
        }

       //配置喜歡的圖示
        @Configuration
        @ConditionalOnProperty(value = "spring.mvc.favicon.enabled", matchIfMissing = true)
        public static class FaviconConfiguration {

            private final ResourceProperties resourceProperties;

            public FaviconConfiguration(ResourceProperties resourceProperties) {
                this.resourceProperties = resourceProperties;
            }

            @Bean
            public SimpleUrlHandlerMapping faviconHandlerMapping() {
                SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping();
                mapping.setOrder(Ordered.HIGHEST_PRECEDENCE + 1);
                  //所有  **/favicon.ico 
                mapping.setUrlMap(Collections.singletonMap("**/favicon.ico",
                        faviconRequestHandler()));
                return mapping;
            }

            @Bean
            public ResourceHttpRequestHandler faviconRequestHandler() {
                ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
                requestHandler
                        .setLocations(this.resourceProperties.getFaviconLocations());
                return requestHandler;
            }

        }

1）、所有 /webjars/** ，都去 classpath:/META-INF/resources/webjars/ 找資源；

webjars：以jar包的方式引入靜態資源；

請求路徑：

localhost:8080/webjars/jquery/3.3.1/jquery.js

<!--引入jquery-webjar-->在訪問的時候只需要寫webjars下面資源的名稱即可
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>jquery</artifactId>
            <version>3.3.1</version>
        </dependency>

2）、"/**" 訪問當前專案的任何資源，都去（靜態資源的資料夾）找對映

"classpath:/META-INF/resources/", 
"classpath:/resources/",
"classpath:/static/", 
"classpath:/public/" 
"/"：當前專案的根路徑
不包含：templates

localhost:8080/abc === 去靜態資原始檔夾裡面找abc

3）、歡迎頁；靜態資原始檔夾下的所有index.html頁面；被"/**"對映；

localhost:8080/ 找index頁面

踩坑：查詢預設index頁面的時候，是從上面四個預設的地址查詢到

　　　只有請求返回的地址才會預設在classpath:/resources/templates 下查詢

4）、所有的 **/favicon.ico 都是在靜態資原始檔下找；

3、模板引擎

JSP、Velocity、Freemarker、Thymeleaf

SpringBoot推薦的Thymeleaf；

語法更簡單，功能更強大；

1、引入thymeleaf；

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
              2.1.6
        </dependency>
　　　　　　切換thymeleaf版本
　　　　<properties>
        <thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
        <!-- 佈局功能的支援程式  thymeleaf3主程式  layout2以上版本 -->
        <!-- thymeleaf2   layout1-->
        <thymeleaf-layout-dialect.version>2.2.2</thymeleaf-layout-dialect.version>
  　　 </properties>

2、Thymeleaf使用

@ConfigurationProperties(prefix = "spring.thymeleaf")
public class ThymeleafProperties {

    private static final Charset DEFAULT_ENCODING = Charset.forName("UTF-8");

    private static final MimeType DEFAULT_CONTENT_TYPE = MimeType.valueOf("text/html");

    public static final String DEFAULT_PREFIX = "classpath:/templates/";

    public static final String DEFAULT_SUFFIX = ".html";
      //

只要我們把HTML頁面放在classpath:/templates/，thymeleaf就能自動渲染；

使用：

1、匯入thymeleaf的名稱空間

<html lang="en" xmlns:th="http://www.thymeleaf.org">

2、使用thymeleaf語法；

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>成功！</h1>
    <!--th:text 將div裡面的文字內容設定為 -->
    <div th:text="${hello}">這是顯示歡迎資訊</div>
</body>
</html>

@Controller
public class IndexController {
    @RequestMapping("/index")
    public String toIndex(Model model){
        model.addAttribute("hello","hello world!");
        return "index";
    }
}

3、語法規則

1）、th:text；改變當前元素裡面的文字內容；

th：任意html屬性；來替換原生屬性的值

2）、表示式？

Simple expressions:（表示式語法）
    Variable Expressions: ${...}：獲取變數值；OGNL；
            1）、獲取物件的屬性、呼叫方法
            2）、使用內建的基本物件：
                #ctx : the context object.
                #vars: the context variables.
                #locale : the context locale.
                #request : (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}
            3）、內建的一些工具物件：
#execInfo : information about the template being processed.
#messages : methods for obtaining externalized messages inside variables expressions, in the same way as they would be obtained using #{…} syntax.
#uris : methods for 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: *{...}：選擇表示式：和${}在功能上是一樣；
        補充：配合 th:object="${session.user}：
   <div th:object="${session.user}">
    <p>Name: <span th:text="*{firstName}">Sebastian</span>.</p>
    <p>Surname: <span th:text="*{lastName}">Pepper</span>.</p>
    <p>Nationality: <span th:text="*{nationality}">Saturn</span>.</p>
    </div>
    
    Message Expressions: #{...}：獲取國際化內容
    Link URL Expressions: @{...}：定義URL；
            @{/order/process(execId=${execId},execType='FAST')}
    Fragment Expressions: ~{...}：片段引用表示式
            <div th:insert="~{commons :: main}">...</div>
            
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:（文字操作）
    String concatenation: +
    Literal substitutions: |The name is ${name}|
Arithmetic operations:（數學運算）
    Binary operators: + , - , * , / , %
    Minus sign (unary operator): -
Boolean operations:（布林運算）
    Binary operators: and , or
    Boolean negation (unary operator): ! , not
Comparisons and equality:（比較運算）
    Comparators: > , < , >= , <= ( gt , lt , ge , le )
    Equality operators: == , != ( eq , ne )
Conditional operators:條件運算（三元運算子）
    If-then: (if) ? (then)
    If-then-else: (if) ? (then) : (else)
    Default: (value) ?: (defaultvalue)
Special tokens:
    No-Operation: _

4、SpringMVC自動配置

官方連結：https://docs.spring.io/spring-boot/docs/1.5.10.RELEASE/reference/htmlsingle/#boot-features-developing-web-applications

1. Spring MVC auto-configuration

Spring Boot 自動配置好了SpringMVC

以下是SpringBoot對SpringMVC的預設配置:（WebMvcAutoConfiguration）

Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans

　　　　自動配置了ViewResolver（檢視解析器：根據方法的返回值得到檢視物件（View），檢視物件決定如何渲染（轉發？重定向？））

　　　　ContentNegotiatingViewResolver：組合所有的檢視解析器的；

　　　　如何定製：我們可以自己給容器中新增一個檢視解析器；自動的將其組合進來；

Support for serving static resources, including support for WebJars (see below).靜態資原始檔夾路徑,webjars

Static index.html support. 靜態首頁訪問
Custom Favicon support (see below). favicon.ico
自動註冊了 of Converter, GenericConverter, Formatter beans.

　　　　Converter：轉換器； public String hello(User user)：型別轉換使用Converter

　　　　Formatter 格式化器； 2017.12.17===Date；

        @Bean
        @ConditionalOnProperty(prefix = "spring.mvc", name = "date-format")//在檔案中配置日期格式化的規則
        public Formatter<Date> dateFormatter() {
            return new DateFormatter(this.mvcProperties.getDateFormat());//日期格式化元件
        }

自己新增的格式化器轉換器，我們只需要放在容器中即可

Support for HttpMessageConverters (see below).

　　　　HttpMessageConverter：SpringMVC用來轉換Http請求和響應的；User---Json；

　　　　HttpMessageConverters 是從容器中確定；獲取所有的HttpMessageConverter；

　　　　自己給容器中新增HttpMessageConverter，只需要將自己的元件註冊容器中（@Bean,@Component）

Automatic registration of MessageCodesResolver (see below).定義錯誤程式碼生成規則
Automatic use of a ConfigurableWebBindingInitializer bean (see below).

　　我們可以配置一個ConfigurableWebBindingInitializer來替換預設的；（新增到容器）

初始化WebDataBinder；
請求資料=====JavaBean；

org.springframework.boot.autoconfigure.web：web的所有自動場景；

If you want to keep Spring Boot MVC features, and you just want to add additional MVC configuration (interceptors, formatters, view controllers etc.) you can add your own @Configuration class of type WebMvcConfigurerAdapter, but without @EnableWebMvc. If you wish to provide custom instances of RequestMappingHandlerMapping, RequestMappingHandlerAdapter or ExceptionHandlerExceptionResolver you can declare a WebMvcRegistrationsAdapter instance providing such components.

2、擴充套件SpringMVC

 <mvc:view-controller path="/hello" view-name="success"/>
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/hello"/>
            <bean></bean>
        </mvc:interceptor>
    </mvc:interceptors>

編寫一個配置類（@Configuration），是WebMvcConfigurerAdapter型別；不能標註@EnableWebMvc

既保留了所有的自動配置，也能用我們擴充套件的配置；

//使用WebMvcConfigurerAdapter可以來擴充套件SpringMVC的功能
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
       // super.addViewControllers(registry);
        //瀏覽器傳送 /atguigu 請求來到 success
        registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

1）、WebMvcAutoConfiguration是SpringMVC的自動配置類

2）、在做其他自動配置時會匯入；@Import(EnableWebMvcConfiguration.class)

    @Configuration
    public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
      private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

     //從容器中獲取所有的WebMvcConfigurer
      @Autowired(required = false)
      public void setConfigurers(List<WebMvcConfigurer> configurers) {
          if (!CollectionUtils.isEmpty(configurers)) {
              this.configurers.addWebMvcConfigurers(configurers);
                //一個參考實現；將所有的WebMvcConfigurer相關配置都來一起呼叫；  
                @Override
             // public void addViewControllers(ViewControllerRegistry registry) {
              //    for (WebMvcConfigurer delegate : this.delegates) {
               //       delegate.addViewControllers(registry);
               //   }
              }
          }
    }

3）、容器中所有的WebMvcConfigurer都會一起起作用；

4）、我們的配置類也會被呼叫；

效果：SpringMVC的自動配置和我們的擴充套件配置都會起作用；

3、全面接管SpringMVC；

SpringBoot對SpringMVC的自動配置不需要了，所有都是我們自己配置；所有的SpringMVC的自動配置都失效了

我們需要在配置類中新增@EnableWebMvc即可；

//使用WebMvcConfigurerAdapter可以來擴充套件SpringMVC的功能
@EnableWebMvc
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
       // super.addViewControllers(registry);
        //瀏覽器傳送 /atguigu 請求來到 success
        registry.addViewController("/atguigu").setViewName("success");
    }
}

原理：

為什麼@EnableWebMvc自動配置就失效了；

1）@EnableWebMvc的核心

@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {

2）、

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

3）、

@Configuration
@ConditionalOnWebApplication
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class,
        WebMvcConfigurerAdapter.class })
//容器中沒有這個元件的時候，這個自動配置類才生效
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
        ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {

4）、@EnableWebMvc將WebMvcConfigurationSupport元件匯入進來；

5）、匯入的WebMvcConfigurationSupport只是SpringMVC最基本的功能；

5、如何修改SpringBoot的預設配置

模式：

1）、SpringBoot在自動配置很多元件的時候，先看容器中有沒有使用者自己配置的（@Bean、@Component）如果有就用使用者配置的，如果沒有，才自動配置；如果有些元件可以有多個（ViewResolver）將使用者配置的和自己預設的組合起來；

2）、在SpringBoot中會有非常多的xxxConfigurer幫助我們進行擴充套件配置

3）、在SpringBoot中會有很多的xxxCustomizer幫助我們進行定製配置

6、RestfulCRUD

1）、預設訪問首頁

//使用WebMvcConfigurerAdapter可以來擴充套件SpringMVC的功能
//@EnableWebMvc   不要接管SpringMVC
@Configuration
public class MyMvcConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
       // super.addViewControllers(registry);
        //瀏覽器傳送 /atguigu 請求來到 success
        registry.addViewController("/success").setViewName("success");
    }

    //所有的WebMvcConfigurerAdapter元件都會一起起作用
    @Bean //將元件註冊在容器
    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
        WebMvcConfigurerAdapter adapter = new WebMvcConfigurerAdapter() {
            @Override
            public void addViewControllers(ViewControllerRegistry registry) {
                registry.addViewController("/").setViewName("login");
                registry.addViewController("/index.html").setViewName("login");
            }
        };
        return adapter;
    }
}

2）、國際化

1）、編寫國際化配置檔案；

2）、使用ResourceBundleMessageSource管理國際化資原始檔

3）、在頁面使用fmt:message取出國際化內容

步驟：

1）、編寫國際化配置檔案，抽取頁面需要顯示的國際化訊息

2）、SpringBoot自動配置好了管理國際化資原始檔的元件；

@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";  
    //我們的配置檔案可以直接放在類路徑下叫messages.properties；
    
    @Bean
    public MessageSource messageSource() {
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        if (StringUtils.hasText(this.basename)) {
            //設定國際化資原始檔的基礎名（去掉語言國家程式碼的）
            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;
    }

3）、去頁面獲取國際化的值；

<!DOCTYPE html>
<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">中文</a>
            <a class="btn btn-sm">English</a>
        </form>

    </body>

</html>

效果：根據瀏覽器語言設定的資訊切換了國際化；

原理：

國際化Locale（區域資訊物件）；LocaleResolver（獲取區域資訊物件）；

        @Bean
        @ConditionalOnMissingBean
        @ConditionalOnProperty(prefix = "spring.mvc", name = "locale")
        public LocaleResolver localeResolver() {
            if (this.mvcProperties
                    .getLocaleResolver() == WebMvcProperties.LocaleResolver.FIXED) {
                return new FixedLocaleResolver(this.mvcProperties.getLocale());
            }
            AcceptHeaderLocaleResolver localeResolver = new AcceptHeaderLocaleResolver();
            localeResolver.setDefaultLocale(this.mvcProperties.getLocale());
            return localeResolver;
        }
//預設的就是根據請求頭帶來的區域資訊獲取Locale進行國際化

4）、點選連結切換國際化

/**
 * 可以在連線上攜帶區域資訊
 */
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(){
        return new MyLocaleResolver();
    }
}

3）、登陸

開發期間模板引擎頁面修改以後，要實時生效

1）、禁用模板引擎的快取

# 禁用快取
spring.thymeleaf.cache=false

2）、頁面修改完成以後ctrl+f9：重新編譯；

登陸錯誤訊息的顯示

<p style="color: red" th:text="${msg}" th:if="${not #strings.isEmpty(msg)}"></p>

4）、攔截器進行登陸檢查

攔截器：

/**
 * 登陸檢查，
 */
public class LoginHandlerInterceptor implements HandlerInterceptor {
    //目標方法執行之前
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Object user = request.getSession().getAttribute("loginUser");
        if(user == null){
            //未登陸，返回登陸頁面
            request.setAttribute("msg","沒有許可權請先登陸");
            request.getRequestDispatcher("/index.html").forward(request,response);
            return false;
        }else{
            //已登陸，放行請求
            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 {

    }
}

註冊攔截器

//所有的WebMvcConfigurerAdapter元件都會一起起作用
    @Bean //將元件註冊在容器
    public WebMvcConfigurerAdapter webMvcConfigurerAdapter(){
        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");
            }

            //註冊攔截器
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                //super.addInterceptors(registry);
                //靜態資源；  *.css , *.js
                //SpringBoot已經做好了靜態資源對映
                registry.addInterceptor(new LoginHandlerInterceptor()).addPathPatterns("/**")
                        .excludePathPatterns("/index.html","/","/user/login");
            }
        };
        return adapter;
    }

7、錯誤處理機制

1）、SpringBoot預設的錯誤處理機制

預設效果：

1）、瀏覽器，返回一個預設的錯誤頁面

瀏覽器傳送請求的請求頭：

2）、如果是其他客戶端，預設響應一個json資料

原理：

可以參照ErrorMvcAutoConfiguration；錯誤處理的自動配置；

給容器中添加了以下元件：

1、DefaultErrorAttributes：幫我們在頁面共享資訊；

2、BasicErrorController：處理預設/error請求

3、ErrorPageCustomizer：

4、DefaultErrorViewResolver：

1、DefaultErrorAttributes：

幫我們在頁面共享資訊

    @Override
    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
            boolean includeStackTrace) {
        Map<String, Object> errorAttributes = new LinkedHashMap<String, Object>();
        errorAttributes.put("timestamp", new Date());
        addStatus(errorAttributes, requestAttributes);
        addErrorDetails(errorAttributes, requestAttributes, includeStackTrace);
        addPath(errorAttributes, requestAttributes);
        return errorAttributes;
    }

2、BasicErrorController：

處理預設/error請求

@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {
　　 //產生html型別的資料；瀏覽器傳送的請求來到這個方法處理
    @RequestMapping(produces = "text/html")
    public ModelAndView errorHtml(HttpServletRequest request,
            HttpServletResponse response) {
        HttpStatus status = getStatus(request);
        Map<String, Object> model = Collections.unmodifiableMap(getErrorAttributes(
                request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
        response.setStatus(status.value());
　　　　 //去哪個頁面作為錯誤頁面；包含頁面地址和頁面內容
        ModelAndView modelAndView = resolveErrorView(request, response, status, model);
        return (modelAndView == null ? new ModelAndView("error", model) : modelAndView);
    }
　　 //產生json資料，其他客戶端來到這個方法處理；
    @RequestMapping
    @ResponseBody
    public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        Map<String, Object> body = getErrorAttributes(request,
                isIncludeStackTrace(request, MediaType.ALL));
        HttpStatus status = getStatus(request);
        return new ResponseEntity<Map<String, Object>>(body, status);
    }
...
}

3、ErrorPageCustomizer：

    //系統出現錯誤以後來到error請求進行處理；（web.xml註冊的錯誤頁面規則）
    @Value("${error.path:/error}")
    private String path = "/error";

4、DefaultErrorViewResolver：

@Override
    public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,
            Map<String, Object> model) {
        ModelAndView modelAndView = resolve(String.valueOf(status), model);
        if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
            modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
        }
        return modelAndView;
    }

    private ModelAndView resolve(String viewName, Map<String, Object> model) {
        //預設SpringBoot可以去找到一個頁面？  error/404
        String errorViewName = "error/" + viewName;
        
        //模板引擎可以解析這個頁面地址就用模板引擎解析
        TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
                .getProvider(errorViewName, this.applicationContext);
        if (provider != null) {
            //模板引擎可用的情況下返回到errorViewName指定的檢視地址
            return new ModelAndView(errorViewName, model);
        }
        //模板引擎不可用，就在靜態資原始檔夾下找errorViewName對應的頁面   error/404.html
        return resolveResource(errorViewName, model);
    }

步驟：

一但系統出現4xx或者5xx之類的錯誤；ErrorPageCustomizer就會生效（定製錯誤的響應規則）；

就會來到/error請求；就會被BasicErrorController處理；

1）響應頁面；去哪個頁面是由DefaultErrorViewResolver解析得到的；

protected ModelAndView resolveErrorView(HttpServletRequest request,
      HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
    //所有的ErrorViewResolver得到ModelAndView
   for (ErrorViewResolver resolver : this.errorViewResolvers) {
      ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
      if (modelAndView != null) {
         return modelAndView;
      }
   }
   return null;
}

2）、如果定製錯誤響應：

　　1）、如何定製錯誤的頁面；

　　　　1）、有模板引擎的情況下；error/狀態碼;

　　　　　　【將錯誤頁面命名為錯誤狀態碼.html 放在模板引擎資料夾裡面的 error資料夾下】，發生此狀態碼的錯誤就會來到對應的頁面；

　　　　　　我們可以使用4xx和5xx作為錯誤頁面的檔名來匹配這種型別的所有錯誤，精確優先（優先尋找精確的狀態碼.html）；

　　　　　　頁面能獲取的資訊；

　　　　　　timestamp：時間戳

　　　　　　status：狀態碼

　　　　　　error：錯誤提示

　　　　　　exception：異常物件

　　　　　　message：異常訊息

　　　　　　errors：JSR303資料校驗的錯誤都在這裡

　　　　2）、沒有模板引擎（模板引擎找不到這個錯誤頁面），靜態資原始檔夾下找；

　　　　3）、以上都沒有錯誤頁面，就是預設來到SpringBoot預設的錯誤提示頁面；

2）、如何定製錯誤的json資料；

　　1）、自定義異常處理&返回定製json資料；

//自定義異常
public class UserNotExistException extends RuntimeException {
    public UserNotExistException(){super("使用者不存在");}
}

@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());
        return map;
    }
}
//沒有自適應效果...

2）、轉發到/error進行自適應響應效果處理

 @ExceptionHandler(UserNotExistException.class)
    public String handleException(Exception e, HttpServletRequest request){
        Map<String,Object> map = new HashMap<>();
        //傳入我們自己的錯誤狀態碼  4xx 5xx，否則就不會進入定製錯誤頁面的解析流程
        /**
         * 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());
        //轉發到/error
        return "forward:/error";
    }

3）、將我們的定製資料攜帶出去；

出現錯誤以後，會來到/error請求，會被BasicErrorController處理，響應出去可以獲取的資料是由getErrorAttributes得到的（是AbstractErrorController（ErrorController）規定的方法）；

1、完全來編寫一個ErrorController的實現類【或者是編寫AbstractErrorController的子類】，放在容器中；

2、頁面上能用的資料，或者是json返回能用的資料都是通過errorAttributes.getErrorAttributes得到；

容器中DefaultErrorAttributes.getErrorAttributes()；預設進行資料處理的；

自定義ErrorAttributes

//給容器中加入我們自己定義的ErrorAttributes
@Component
public class MyErrorAttributes extends DefaultErrorAttributes {

    @Override
    public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes, boolean includeStackTrace) {
        Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);
        map.put("company","atguigu");
        return map;
    }
}

最終的效果：響應是自適應的，可以通過定製ErrorAttributes改變需要返回的內容，

8、配置嵌入式Servlet容器

SpringBoot預設使用Tomcat作為嵌入式的Servlet容器；

1）、如何定製和修改Servlet容器的相關配置；

1、修改和server有關的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）；

server.port=8081
server.context-path=/crud

server.tomcat.uri-encoding=UTF-8

//通用的Servlet容器設定
server.xxx
//Tomcat的設定
server.tomcat.xxx

2、編寫一個EmbeddedServletContainerCustomizer：嵌入式的Servlet容器的定製器；來修改Servlet容器的配置

@Bean  //一定要將這個定製器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
    return new EmbeddedServletContainerCustomizer() {

        //定製嵌入式的Servlet容器相關的規則
        @Override
        public void customize(ConfigurableEmbeddedServletContainer container) {
            container.setPort(8083);
        }
    };
}

2）、註冊Servlet三大元件【Servlet、Filter、Listener】

由於SpringBoot預設是以jar包的方式啟動嵌入式的Servlet容器來啟動SpringBoot的web應用，沒有web.xml檔案。

註冊三大元件用以下方式:

public class MyServlet extends HttpServlet {

    //處理get請求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("Hello MyServlet");
    }
}

public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("MyFilter process...");
        chain.doFilter(request,response);

    }

    @Override
    public void destroy() {

    }
}

public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("contextInitialized...web應用啟動");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("contextDestroyed...當前web專案銷燬");
    }
}

ServletRegistrationBean

FilterRegistrationBean

ServletListenerRegistrationBean

@Configuration
public class MyServerConfig {

    //註冊三大元件
    @Bean
    public ServletRegistrationBean myServlet(){
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
        registrationBean.setLoadOnStartup(1);
        return registrationBean;
    }

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

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


    //配置嵌入式的Servlet容器
    @Bean
    public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
        return new EmbeddedServletContainerCustomizer() {

            //定製嵌入式的Servlet容器相關的規則
            @Override
            public void customize(ConfigurableEmbeddedServletContainer container) {
                container.setPort(8083);
            }
        };
    }

}

SpringBoot幫我們自動配置SpringMVC的時候，自動的註冊SpringMVC的前端控制器；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());
    //預設攔截： /  所有請求；包靜態資源，但是不攔截jsp請求；   /*會攔截jsp
    //可以通過server.servletPath來修改SpringMVC前端控制器預設攔截的請求路徑
    
   registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
   registration.setLoadOnStartup(
         this.webMvcProperties.getServlet().getLoadOnStartup());
   if (this.multipartConfig != null) {
      registration.setMultipartConfig(this.multipartConfig);
   }
   return registration;
}

3）、替換為其他嵌入式Servlet容器

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   引入web模組預設就是使用嵌入式的Tomcat作為Servlet容器；
</dependency>

jetty

<!-- 引入web模組 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
      <exclusion>
         <artifactId>spring-boot-starter-tomcat</artifactId>
         <groupId>org.springframework.boot</groupId>
      </exclusion>
   </exclusions>
</dependency>

<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-jetty</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

Undertow

<!-- 引入web模組 -->
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <exclusions>
      <exclusion>
         <artifactId>spring-boot-starter-tomcat</artifactId>
         <groupId>org.springframework.boot</groupId>
      </exclusion>
   </exclusions>
</dependency>

<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-undertow</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

4）、嵌入式Servlet容器自動配置原理；

EmbeddedServletContainerAutoConfiguration：嵌入式的Servlet容器自動配置？

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//匯入BeanPostProcessorsRegistrar：Spring註解版；給容器中匯入一些元件
//匯入了EmbeddedServletContainerCustomizerBeanPostProcessor：
//後置處理器：bean初始化前後（建立完物件，還沒賦值賦值）執行初始化工作
public class EmbeddedServletContainerAutoConfiguration {
    
    @Configuration
    @ConditionalOnClass({ Servlet.class, Tomcat.class })//判斷當前是否引入了Tomcat依賴；
    @ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
    //判斷當前容器沒有使用者自己定義EmbeddedServletContainerFactory：嵌入式的Servlet容器工廠；作用：建立嵌入式的Servlet容器
    public static class EmbeddedTomcat {

        @Bean
        public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
            return new TomcatEmbeddedServletContainerFactory();
        }

    }
    
    /**
     * 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() {
            return new JettyEmbeddedServletContainerFactory();
        }

    }

    /**
     * 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() {
            return new UndertowEmbeddedServletContainerFactory();
        }

    }

1）、EmbeddedServletContainerFactory（嵌入式Servlet容器工廠）

public interface EmbeddedServletContainerFactory {

   //獲取嵌入式的Servlet容器
   EmbeddedServletContainer getEmbeddedServletContainer(
         ServletContextInitializer... initializers);

}

2）、EmbeddedServletContainer：（嵌入式的Servlet容器）

3）、以TomcatEmbeddedServletContainerFactory為例

@Override
public EmbeddedServletContainer getEmbeddedServletContainer(
      ServletContextInitializer... initializers) {
    //建立一個Tomcat
   Tomcat tomcat = new Tomcat();
    
    //配置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);
    
    //將配置好的Tomcat傳入進去，返回一個EmbeddedServletContainer；並且啟動Tomcat伺服器
   return getTomcatEmbeddedServletContainer(tomcat);
}

4）、我們對嵌入式容器的配置修改是怎麼生效？

ServerProperties、EmbeddedServletContainerCustomizer

EmbeddedServletContainerCustomizer：定製器幫我們修改了Servlet容器的配置？

怎麼修改的原理？

5）、容器中匯入了EmbeddedServletContainerCustomizerBeanPostProcessor

//初始化之前
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
      throws BeansException {
    //如果當前初始化的是一個ConfigurableEmbeddedServletContainer型別的元件
   if (bean instanceof ConfigurableEmbeddedServletContainer) {
       //
      postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
   }
   return bean;
}

private void postProcessBeforeInitialization(
            ConfigurableEmbeddedServletContainer bean) {
    //獲取所有的定製器，呼叫每一個定製器的customize方法來給Servlet容器進行屬性賦值；
    for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
        customizer.customize(bean);
    }
}

private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
    if (this.customizers == null) {
        // Look up does not include the parent context
        this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
            this.beanFactory
            //從容器中獲取所有這型別的元件：EmbeddedServletContainerCustomizer
            //定製Servlet容器，給容器中可以新增一個EmbeddedServletContainerCustomizer型別的元件
            .getBeansOfType(EmbeddedServletContainerCustomizer.class,
                            false, false)
            .values());
        Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
        this.customizers = Collections.unmodifiableList(this.customizers);
    }
    return this.customizers;
}

//ServerProperties也是定製器

步驟：

1）、SpringBoot根據匯入的依賴情況，給容器中新增相應的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

2）、容器中某個元件要建立物件就會驚動後置處理器；EmbeddedServletContainerCustomizerBeanPostProcessor；

　　只要是嵌入式的Servlet容器工廠，後置處理器就工作；

3）、後置處理器，從容器中獲取所有的EmbeddedServletContainerCustomizer，呼叫定製器的定製方法

5）、嵌入式Servlet容器啟動原理；

什麼時候建立嵌入式的Servlet容器工廠？什麼時候獲取嵌入式的Servlet容器並啟動Tomcat；

獲取嵌入式的Servlet容器工廠：

1）、SpringBoot應用啟動執行run方法

2）、refreshContext(context);SpringBoot重新整理IOC容器【建立IOC容器物件，並初始化容器，建立容器中的每一個元件】；如果是web應用建立AnnotationConfigEmbeddedWebApplicationContext，否則：AnnotationConfigApplicationContext

3）、refresh(context);重新整理剛才建立好的ioc容器；

public void refresh() 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();
      }
   }
}

4）、 onRefresh(); web的ioc容器重寫了onRefresh方法

5）、webioc容器會建立嵌入式的Servlet容器；createEmbeddedServletContainer();

6）、獲取嵌入式的Servlet容器工廠：

EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();

從ioc容器中獲取EmbeddedServletContainerFactory 元件；TomcatEmbeddedServletContainerFactory建立物件，後置處理器一看是這個物件，就獲取所有的定製器來先定製Servlet容器的相關配置；

7）、使用容器工廠獲取嵌入式的Servlet容器：this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());

8）、嵌入式的Servlet容器建立物件並啟動Servlet容器；

先啟動嵌入式的Servlet容器，再將ioc容器中剩下沒有創建出的物件獲取出來；

IOC容器啟動建立嵌入式的Servlet容器

9、使用外接的Servlet容器

嵌入式Servlet容器：應用打成可執行的jar

優點：簡單、便攜；

缺點：預設不支援JSP、優化定製比較複雜（使用定製器【ServerProperties、自定義EmbeddedServletContainerCustomizer】，自己編寫嵌入式Servlet容器的建立工廠【EmbeddedServletContainerFactory】）；

外接的Servlet容器：外面安裝Tomcat---應用war包的方式打包；

步驟

1）、必須建立一個war專案；（利用idea建立好目錄結構）

2）、將嵌入式的Tomcat指定為provided；

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

3）、必須編寫一個SpringBootServletInitializer的子類，並呼叫configure方法

public class ServletInitializer extends SpringBootServletInitializer {

   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
       //傳入SpringBoot應用的主程式
      return application.sources(SpringBoot04WebJspApplication.class);
   }

}

4）、啟動伺服器就可以使用；

原理

jar包：執行SpringBoot主類的main方法，啟動ioc容器，建立嵌入式的Servlet容器；

war包：啟動伺服器，伺服器啟動SpringBoot應用【SpringBootServletInitializer】，啟動ioc容器；

servlet3.0（Spring註解版）：

8.2.4 Shared libraries / runtimes pluggability：

規則：

1）、伺服器啟動（web應用啟動）會建立當前web應用裡面每一個jar包裡面ServletContainerInitializer例項：

2）、ServletContainerInitializer的實現放在jar包的META-INF/services資料夾下，有一個名為javax.servlet.ServletContainerInitializer的檔案，內容就是ServletContainerInitializer的實現類的全類名

3）、還可以使用@HandlesTypes，在應用啟動的時候載入我們感興趣的類；

流程：

1）、啟動Tomcat

2）、org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\META-INF\services\javax.servlet.ServletContainerInitializer：

Spring的web模組裡面有這個檔案：org.springframework.web.SpringServletContainerInitializer

3）、SpringServletContainerInitializer將@HandlesTypes(WebApplicationInitializer.class)標註的所有這個型別的類都傳入到onStartup方法的Set<Class<?>>；為這些WebApplicationInitializer型別的類建立例項；

4）、每一個WebApplicationInitializer都呼叫自己的onStartup；

5）、相當於我們的SpringBootServletInitializer的類會被建立物件，並執行onStartup方法

6）、SpringBootServletInitializer例項執行onStartup的時候會createRootApplicationContext；建立容器

protected WebApplicationContext createRootApplicationContext(
      ServletContext servletContext) {
    //1、建立SpringApplicationBuilder
   SpringApplicationBuilder builder = createSpringApplicationBuilder();
   StandardServletEnvironment environment = new StandardServletEnvironment();
   environment.initPropertySources(servletContext, null);
   builder.environment(environment);
   builder.main(getClass());
   ApplicationContext parent = getExistingRootWebApplicationContext(servletContext);
   if (parent != null) {
      this.logger.info("Root context already created (using as parent).");
      servletContext.setAttribute(
            WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, null);
      builder.initializers(new ParentContextApplicationContextInitializer(parent));
   }
   builder.initializers(
         new ServletContextApplicationContextInitializer(servletContext));
   builder.contextClass(AnnotationConfigEmbeddedWebApplicationContext.class);
    
    //呼叫configure方法，子類重寫了這個方法，將SpringBoot的主程式類傳入了進來
   builder = configure(builder);
    
    //使用builder建立一個Spring應用
   SpringApplication application = builder.build();
   if (application.getSources().isEmpty() && AnnotationUtils
         .findAnnotation(getClass(), Configuration.class) != null) {
      application.getSources().add(getClass());
   }
   Assert.state(!application.getSources().isEmpty(),
         "No SpringApplication sources have been defined. Either override the "
               + "configure method or add an @Configuration annotation");
   // Ensure error pages are registered
   if (this.registerErrorPageFilter) {
      application.getSources().add(ErrorPageFilterConfiguration.class);
   }
    //啟動Spring應用
   return run(application);

7）、Spring的應用就啟動並且建立IOC容器

public ConfigurableApplicationContext run(String... args) {
   StopWatch stopWatch = new StopWatch();
   stopWatch.start();
   ConfigurableApplicationContext context = null;
   FailureAnalyzers analyzers = null;
   configureHeadlessProperty();
   SpringApplicationRunListeners listeners = getRunListeners(args);
   listeners.starting();
   try {
      ApplicationArguments applicationArguments = new DefaultApplicationArguments(
            args);
      ConfigurableEnvironment environment = prepareEnvironment(listeners,
            applicationArguments);
      Banner printedBanner = printBanner(environment);
      context = createApplicationContext();
      analyzers = new FailureAnalyzers(context);
      prepareContext(context, environment, listeners, applicationArguments,
            printedBanner);
       
       //重新整理IOC容器
      refreshContext(context);
      afterRefresh(context, applicationArguments);
      listeners.finished(context, null);
      stopWatch.stop();
      if (this.logStartupInfo) {
         new StartupInfoLogger(this.mainApplicationClass)
               .logStarted(getApplicationLog(), stopWatch);
      }
      return context;
   }
   catch (Throwable ex) {
      handleRunFailure(context, listeners, analyzers, ex);
      throw new IllegalStateException(ex);
   }
}

啟動Servlet容器，再啟動SpringBoot應用

springboot學習：第二天

三、日誌

1、日誌框架

2、SLF4j使用

1、如何在系統中使用SLF4j https://www.slf4j.org

四、Web開發

1、簡介

2、SpringBoot對靜態資源的對映規則：

3、模板引擎

1、引入thymeleaf；

2、Thymeleaf使用

3、語法規則

4、SpringMVC自動配置

1. Spring MVC auto-configuration

2、擴充套件SpringMVC

3、全面接管SpringMVC；

5、如何修改SpringBoot的預設配置

6、RestfulCRUD

1）、預設訪問首頁

2）、國際化

3）、登陸

4）、攔截器進行登陸檢查

7、錯誤處理機制

1）、SpringBoot預設的錯誤處理機制

1、DefaultErrorAttributes：

2、BasicErrorController：

3、ErrorPageCustomizer：

4、DefaultErrorViewResolver：

步驟：

2）、如果定製錯誤響應：

1）、如何定製錯誤的頁面；

2）、如何定製錯誤的json資料；

3）、將我們的定製資料攜帶出去；

8、配置嵌入式Servlet容器

1）、如何定製和修改Servlet容器的相關配置；

2）、註冊Servlet三大元件【Servlet、Filter、Listener】

3）、替換為其他嵌入式Servlet容器

4）、嵌入式Servlet容器自動配置原理；

5）、嵌入式Servlet容器啟動原理；

9、使用外接的Servlet容器

步驟

原理

相關推薦

　　1）、如何定製錯誤的頁面；