SpringBoot_Web开发(2.2.5version)

痛定思痛。 2023-07-14 05:29 17阅读 0赞

### 文章目录 ###

*   *  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）拦截器进行登陆检查
         *  5）CRUD-员工列表
         *   *  thymeleaf公共页面元素抽取
         *  6）CRUD-员工添加
         *  7）CRUD-员工修改
         *  8）CRUD-员工删除
     *  7. 错误处理机制
     *   *  1）SpringBoot默认的错误处理机制
         *  2）如果定制错误响应：
         *   *  1）如何定制错误的页面；
             *  2）如何定制错误的json数据；
             *  3）将定制数据携带出去；
     *  8. 配置嵌入式Servlet容器
     *   *  1）如何定制和修改Servlet容器的相关配置；
         *  2）注册Servlet三大组件【Servlet、Filter、Listener】
         *  3）替换为其他嵌入式Servlet容器
         *  4）嵌入式Servlet容器自动配置原理；
         *  5）WebServer启动原理；
     *  9. 使用外置的Servlet容器
     *   *  步骤
         *  原理

## 1. 简介 ##

使用SpringBoot；

**1）创建SpringBoot应用，选中我们需要的模块；**

**2）SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来**

**3）自己编写业务代码；**

**自动配置原理**

这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？…

xxxxAutoConfiguration:帮我们给容器中自动配置组件；
    xxxxProperties:配置类来封装配置文件的内容；

## 2. SpringBoot对静态资源的映射规则； ##

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
    public class ResourceProperties {
        
      //可以设置和静态资源有关的参数，缓存时间等

`WebMvcAutoConfigurationAdapter`：

@Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        
        if (!this.resourceProperties.isAddMappings()) {
        
            logger.debug("Default resource handling disabled");
            return;
        }
        Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
        CacheControl cacheControl = this.resourceProperties.getCache().getCachecontrol().toHttpCacheControl();
        if (!registry.hasMappingForPattern("/webjars/**")) {
        
            customizeResourceHandlerRegistration(
                registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/")
                .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
        }
        //private String staticPathPattern = "/**";
        String staticPathPattern = this.mvcProperties.getStaticPathPattern();
        //静态资源文件夹映射
        if (!registry.hasMappingForPattern(staticPathPattern)) {
        
            customizeResourceHandlerRegistration
                (registry.addResourceHandler(staticPathPattern)
                 .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
                                                 .setCachePeriod(getSeconds(cachePeriod)).setCacheControl(cacheControl));
        }
    }

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

webjars：以jar包的方式引入静态资源；  
**WebJars are client-side web libraries (e.g. jQuery & Bootstrap) packaged into JAR (Java Archive) files.**

http://www.webjars.org/

在访问的时候只需要写webjars下面资源的名称即可
    <dependency>
        <groupId>org.webjars</groupId>
        <artifactId>jquery</artifactId>
        <version>3.4.1</version>
    </dependency>

2）"/\*\*" 访问当前项目的任何资源，都去（静态资源的文件夹）找映射

private static final String[] CLASSPATH_RESOURCE_LOCATIONS = 
    {
         
        "classpath:/META-INF/resources/",
     	"classpath:/resources/", 
     	"classpath:/static/", 
     	"classpath:/public/" 
    };

"classpath:/META-INF/resources/", 
    "classpath:/resources/",
    "classpath:/static/", 
    "classpath:/public/" 
    "/"：当前项目的根路径

3）欢迎页； 静态资源文件夹下的所有index.html页面；被"/\*\*"映射；

`EnableWebMvcConfiguration`:

@Bean
    public WelcomePageHandlerMapping welcomePageHandlerMapping(ApplicationContext applicationContext,FormattingConversionService mvcConversionService, ResourceUrlProvider mvcResourceUrlProvider) {
        
        WelcomePageHandlerMapping welcomePageHandlerMapping = new WelcomePageHandlerMapping(
            new TemplateAvailabilityProviders(applicationContext), applicationContext, getWelcomePage(),
            this.mvcProperties.getStaticPathPattern());
        welcomePageHandlerMapping.setInterceptors(getInterceptors(mvcConversionService, mvcResourceUrlProvider));
        return welcomePageHandlerMapping;
    }

## 3. 模板引擎 ##

JSP、Velocity、Freemarker、Thymeleaf  
SpringBoot推荐的Thymeleaf；  
语法更简单，功能更强大；

### 1. 引入thymeleaf； ###

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    如果需要切换thymeleaf版本
    <properties>
        <thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
        
        
        <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 = StandardCharsets.UTF_8;
    
    	public static final String DEFAULT_PREFIX = "classpath:/templates/";
    
    	public static final String DEFAULT_SUFFIX = ".html";

只要把HTML页面放在classpath:/templates/，thymeleaf就能自动渲染；

使用：

1.  导入thymeleaf的名称空间

1.  使用thymeleaf语法；

<!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
        <h1>成功！</h1>
        
        <div th:text="${hello}">这是显示欢迎信息</div>
    </body>
    </html>

### 3. 语法规则 ###

1）th:text；改变当前元素里面的文本内容；

th：任意html属性；来替换原生属性的值

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7iBWermO-1583839873767)(C:\\Users\\83998\\AppData\\Roaming\\Typora\\typora-user-images\\image-20200309165057959.png)\]

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自动配置 ##

### 1. Spring MVC auto-configuration ###

Spring Boot 自动配置好了SpringMVC

以下是SpringBoot对SpringMVC的默认配置:**（WebMvcAutoConfiguration）**

*  Inclusion of `ContentNegotiatingViewResolver` and `BeanNameViewResolver` beans.
    
     *  自动配置了ViewResolver（视图解析器：根据方法的返回值得到视图对象（View），视图对象决定如何渲染（转发？重定向？））
     *  ContentNegotiatingViewResolver：组合所有的视图解析器；
     *  如何定制：我们可以自己给容器中添加一个视图解析器；自动的将其组合进来;
    
    `ContentNegotiatingViewResolver` :
    
        @Bean
        @ConditionalOnBean(ViewResolver.class)
        @ConditionalOnMissingBean(name = "viewResolver", value = ContentNegotiatingViewResolver.class)
        public ContentNegotiatingViewResolver viewResolver(BeanFactory beanFactory) {
              
        ContentNegotiatingViewResolver resolver = new ContentNegotiatingViewResolver();
        resolver.setContentNegotiationManager(beanFactory.getBean(ContentNegotiationManager.class));
        // ContentNegotiatingViewResolver uses all the other view resolvers to locate
        // a view so it should have a high precedence
        resolver.setOrder(Ordered.HIGHEST_PRECEDENCE);
        return resolver;
        }
    
    `initServletContext`：
    
        @Override
        protected void initServletContext(ServletContext servletContext) {
              
            Collection<ViewResolver> matchingBeans =
                BeanFactoryUtils.beansOfTypeIncludingAncestors(obtainApplicationContext(), ViewResolver.class).values();
            if (this.viewResolvers == null) {
              
                this.viewResolvers = new ArrayList<>(matchingBeans.size());
                for (ViewResolver viewResolver : matchingBeans) {
              
                    if (this != viewResolver) {
              
                        this.viewResolvers.add(viewResolver);
                    }
                }
            }
            else {
              
                for (int i = 0; i < this.viewResolvers.size(); i++) {
              
                    ViewResolver vr = this.viewResolvers.get(i);
                    if (matchingBeans.contains(vr)) {
              
                        continue;
                    }
                    String name = vr.getClass().getName() + i;
                    obtainApplicationContext().getAutowireCapableBeanFactory().initializeBean(vr, name);
                }
        
            }
            AnnotationAwareOrderComparator.sort(this.viewResolvers);
            this.cnmFactoryBean.setServletContext(servletContext);
        }
    
    `resolveViewName`：
    
        @Override
        @Nullable
        public View resolveViewName(String viewName, Locale locale) throws Exception {
              
            RequestAttributes attrs = RequestContextHolder.getRequestAttributes();
            Assert.state(attrs instanceof ServletRequestAttributes, "No current ServletRequestAttributes");
            List<MediaType> requestedMediaTypes = getMediaTypes(((ServletRequestAttributes) attrs).getRequest());
            if (requestedMediaTypes != null) {
              
                List<View> candidateViews = getCandidateViews(viewName, locale, requestedMediaTypes);
                View bestView = getBestView(candidateViews, requestedMediaTypes, attrs);
                if (bestView != null) {
              
                    return bestView;
                }
            }
        
            String mediaTypeInfo = logger.isDebugEnabled() && requestedMediaTypes != null ?
                " given " + requestedMediaTypes.toString() : "";
        
            if (this.useNotAcceptableStatusCode) {
              
                if (logger.isDebugEnabled()) {
              
                    logger.debug("Using 406 NOT_ACCEPTABLE" + mediaTypeInfo);
                }
                return NOT_ACCEPTABLE_VIEW;
            }
            else {
              
                logger.debug("View remains unresolved" + mediaTypeInfo);
                return null;
            }
        }
    
    `getCandidateViews`:
    
        private List<View> getCandidateViews(String viewName, Locale locale, List<MediaType> requestedMediaTypes)
            throws Exception {
              
        
            List<View> candidateViews = new ArrayList<>();
            if (this.viewResolvers != null) {
              
                Assert.state(this.contentNegotiationManager != null, "No ContentNegotiationManager set");
                for (ViewResolver viewResolver : this.viewResolvers) {
              
                    View view = viewResolver.resolveViewName(viewName, locale);
                    if (view != null) {
              
                        candidateViews.add(view);
                    }
                    for (MediaType requestedMediaType : requestedMediaTypes) {
              
                        List<String> extensions = this.contentNegotiationManager.resolveFileExtensions(requestedMediaType);
                        for (String extension : extensions) {
              
                            String viewNameWithExtension = viewName + '.' + extension;
                            view = viewResolver.resolveViewName(viewNameWithExtension, locale);
                            if (view != null) {
              
                                candidateViews.add(view);
                            }
                        }
                    }
                }
            }
            if (!CollectionUtils.isEmpty(this.defaultViews)) {
              
                candidateViews.addAll(this.defaultViews);
            }
            return candidateViews;
        }
    
    `getBestView`:
    
        @Nullable
        private View getBestView(List<View> candidateViews, List<MediaType> requestedMediaTypes, RequestAttributes attrs) {
              
            for (View candidateView : candidateViews) {
              
                if (candidateView instanceof SmartView) {
              
                    SmartView smartView = (SmartView) candidateView;
                    if (smartView.isRedirectView()) {
              
                        return candidateView;
                    }
                }
            }
            for (MediaType mediaType : requestedMediaTypes) {
              
                for (View candidateView : candidateViews) {
              
                    if (StringUtils.hasText(candidateView.getContentType())) {
              
                        MediaType candidateContentType = MediaType.parseMediaType(candidateView.getContentType());
                        if (mediaType.isCompatibleWith(candidateContentType)) {
              
                            if (logger.isDebugEnabled()) {
              
                                logger.debug("Selected '" + mediaType + "' given " + requestedMediaTypes);
                            }
                            attrs.setAttribute(View.SELECTED_CONTENT_TYPE, mediaType, RequestAttributes.SCOPE_REQUEST);
                            return candidateView;
                        }
                    }
                }
            }
            return null;
        }
 *  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`, beans.
    
     *  Converter：转换器； public String hello(User user)：类型转换使用Converter

//自己添加的格式化器转换器，只需要放在容器中即可
    @Override
    public void addFormatters(FormatterRegistry registry) {
        
        ApplicationConversionService.addBeans(registry, this.beanFactory);
    }
    
    public static void addBeans(FormatterRegistry registry, ListableBeanFactory beanFactory) {
        
        Set<Object> beans = new LinkedHashSet<>();
        beans.addAll(beanFactory.getBeansOfType(GenericConverter.class).values());
        beans.addAll(beanFactory.getBeansOfType(Converter.class).values());
        beans.addAll(beanFactory.getBeansOfType(Printer.class).values());
        beans.addAll(beanFactory.getBeansOfType(Parser.class).values());
        for (Object bean : beans) {
        
            if (bean instanceof GenericConverter) {
        
                registry.addConverter((GenericConverter) bean);
            }
            else if (bean instanceof Converter) {
        
                registry.addConverter((Converter<?, ?>) bean);
            }
            else if (bean instanceof Formatter) {
        
                registry.addFormatter((Formatter<?>) bean);
            }
            else if (bean instanceof Printer) {
        
                registry.addPrinter((Printer<?>) bean);
            }
            else if (bean instanceof Parser) {
        
                registry.addParser((Parser<?>) bean);
            }
        }
    }

*  Support for `HttpMessageConverters`.
    
     *  HttpMessageConverter：SpringMVC用来转换Http请求和响应的；User—Json；
     *  `HttpMessageConverters` 是从容器中确定；获取所有的HttpMessageConverter；

public HttpMessageConverters(HttpMessageConverter<?>... additionalConverters) {
        
           this(Arrays.asList(additionalConverters));
       }

给容器中添加`HttpMessageConverter`，只需要将自己的组件注册容器中（@Bean,@Component）

*  Automatic registration of `MessageCodesResolver` .定义错误代码生成规则
    
        @Override
        public MessageCodesResolver getMessageCodesResolver() {
              
            if (this.mvcProperties.getMessageCodesResolverFormat() != null) {
              
                DefaultMessageCodesResolver resolver = new DefaultMessageCodesResolver();
                resolver.setMessageCodeFormatter(this.mvcProperties.getMessageCodesResolverFormat());
                return resolver;
            }
            return null;
        }
    
    `this.mvcProperties.getMessageCodesResolverFormat()`\-> `Format`：
    
        public enum Format implements MessageCodeFormatter {
              
        
            /**
        		 * Prefix the error code at the beginning of the generated message code. e.g.:
        		 * {@code errorCode + "." + object name + "." + field}
        		 */
            PREFIX_ERROR_CODE {
              
                @Override
                public String format(String errorCode, @Nullable String objectName, @Nullable String field) {
              
                    return toDelimitedString(errorCode, objectName, field);
                }
            },
        
            /**
        		 * Postfix the error code at the end of the generated message code. e.g.:
        		 * {@code object name + "." + field + "." + errorCode}
        		 */
            POSTFIX_ERROR_CODE {
              
                @Override
                public String format(String errorCode, @Nullable String objectName, @Nullable String field) {
              
                    return toDelimitedString(objectName, field, errorCode);
                }
            };
 *  Automatic use of a `ConfigurableWebBindingInitializer` bean (see below).

@Override
     protected ConfigurableWebBindingInitializer getConfigurableWebBindingInitializer(
         FormattingConversionService mvcConversionService, Validator mvcValidator) {
        
         try {
        
             return this.beanFactory.getBean(ConfigurableWebBindingInitializer.class);
         }
         catch (NoSuchBeanDefinitionException ex) {
        
             return super.getConfigurableWebBindingInitializer(mvcConversionService, mvcValidator);
         }
     }

因为`BeanFactory`从容器中`getBean`，所以可以配置一个ConfigurableWebBindingInitializer来替换默认的；（添加到容器）

`super.getConfigurableWebBindingInitializer(mvcConversionService, mvcValidator);`：

/**
    	 * Return the {@link ConfigurableWebBindingInitializer} to use for
    	 * initializing all {@link WebDataBinder} instances.
    	 */
    protected ConfigurableWebBindingInitializer getConfigurableWebBindingInitializer(
        FormattingConversionService mvcConversionService, Validator mvcValidator) {
        
    
        ConfigurableWebBindingInitializer initializer = new ConfigurableWebBindingInitializer();
        initializer.setConversionService(mvcConversionService);
        initializer.setValidator(mvcValidator);
        MessageCodesResolver messageCodesResolver = getMessageCodesResolver();
        if (messageCodesResolver != null) {
        
            initializer.setMessageCodesResolver(messageCodesResolver);
        }
        return initializer;
    }

初始化WebDataBinder；
    请求数据->JavaBean；

`ConfigurableWebBindingInitializer`:

@Override
    public void initBinder(WebDataBinder binder) {
        
        binder.setAutoGrowNestedPaths(this.autoGrowNestedPaths);
        if (this.directFieldAccess) {
        
            binder.initDirectFieldAccess();
        }
        if (this.messageCodesResolver != null) {
        
            binder.setMessageCodesResolver(this.messageCodesResolver);
        }
        if (this.bindingErrorProcessor != null) {
        
            binder.setBindingErrorProcessor(this.bindingErrorProcessor);
        }
        if (this.validator != null && binder.getTarget() != null &&
            this.validator.supports(binder.getTarget().getClass())) {
        
            binder.setValidator(this.validator);
        }
        if (this.conversionService != null) {
        
            binder.setConversionService(this.conversionService);
        }
        if (this.propertyEditorRegistrars != null) {
        
            for (PropertyEditorRegistrar propertyEditorRegistrar : this.propertyEditorRegistrars) {
        
                propertyEditorRegistrar.registerCustomEditors(binder);
            }
        }
    }

**org.springframework.boot.autoconfigure.web：web的所有自动场景；**

### 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），实现WebMvcConfigurer接口；不能标注@EnableWebMvc**;

既保留了所有的自动配置，也能用我们扩展的配置；

//使用WebMvcConfigurer可以来扩展SpringMVC的功能
    @Configuration
    public class MyMvcConfig implements WebMvcConfigurer {
        
    
    	@Override
    	public void addViewControllers(ViewControllerRegistry registry) {
        
    		//浏览器发送 /atguigu 请求来到 success
    		registry.addViewController("/atguigu").setViewName("success");
    	}
    }

原理：

1）WebMvcAutoConfiguration是SpringMVC的自动配置类

2）在做其他嵌套自动配置时会导入；@Import(**EnableWebMvcConfiguration**.class)

@Configuration(proxyBeanMethods = false)
    public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration implements ResourceLoaderAware {

`DelegatingWebMvcConfiguration`：从容器中获取所有的WebMvcConfigurer

@Configuration(proxyBeanMethods = false)
    public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {
        
    
    	private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
    
        @Autowired(required = false)
        public void setConfigurers(List<WebMvcConfigurer> configurers) {
        
            if (!CollectionUtils.isEmpty(configurers)) {
        
                this.configurers.addWebMvcConfigurers(configurers);
            }
        }

`WebMvcConfigurerComposite`：配置合成器

class WebMvcConfigurerComposite implements WebMvcConfigurer {
        
    
    	private final List<WebMvcConfigurer> delegates = new ArrayList<>();
    
    
    	public void addWebMvcConfigurers(List<WebMvcConfigurer> configurers) {
        
    		if (!CollectionUtils.isEmpty(configurers)) {
        
    			this.delegates.addAll(configurers);
    		}
    	}
    
    	//一个参考实现；将所有的WebMvcConfigurer相关配置都来一起调用；
    	@Override
    	public void configurePathMatch(PathMatchConfigurer configurer) {
        
    		for (WebMvcConfigurer delegate : this.delegates) {
        
    			delegate.configurePathMatch(configurer);
    		}
    	}

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

4）自定义的配置类也会被调用；

效果：SpringMVC的自动配置和自定义扩展配置都会起作用；

### 3. 全面接管SpringMVC； ###

SpringBoot对SpringMVC的自动配置不需要了，所有都是自定义配置；所有的SpringMVC的自动配置都失效了

**需要在配置类中添加@EnableWebMvc即可；**

//使用WebMvcConfigurer可以来扩展SpringMVC的功能
    @EnableWebMvc
    @Configuration
    public class MyMvcConfig implements WebMvcConfigurer {
        
    
    	@Override
    	public void addViewControllers(ViewControllerRegistry 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）默认访问首页 ###

@Configuration
    public class MyMvcConfig implements WebMvcConfigurer {
        
    
    	@Override
    	public void addViewControllers(ViewControllerRegistry registry) {
        
    		registry.addViewController("/").setViewName("login");
    		registry.addViewController("/index.html").setViewName("login");
    	}
    }

### 2）国际化 ###

**1）编写国际化配置文件；**

2）使用ResourceBundleMessageSource管理国际化资源文件

步骤：

1）编写国际化配置文件，抽取页面需要显示的国际化消息  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70]

2）SpringBoot自动配置好了管理国际化资源文件的组件；

@Configuration(proxyBeanMethods = false)
    @ConditionalOnMissingBean(name = AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME, search = SearchStrategy.CURRENT)
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
    @Conditional(ResourceBundleCondition.class)
    @EnableConfigurationProperties
    public class MessageSourceAutoConfiguration {
        
        
        @Bean
    	@ConfigurationProperties(prefix = "spring.messages")
    	public MessageSourceProperties messageSourceProperties() {
        
    		return new MessageSourceProperties();
    	}
        
        @Bean
    	public MessageSource messageSource(MessageSourceProperties properties) {
        
    		ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
            /**
             * 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；
            //或者在配置文件中设置spring.messages.basename
            //设置国际化资源文件的基础名（去掉语言国家代码的）
    		if (StringUtils.hasText(properties.getBasename())) {
        
    			messageSource.setBasenames(StringUtils
    .commaDelimitedListToStringArray(StringUtils.trimAllWhitespace(properties.getBasename())));
    		}
    		if (properties.getEncoding() != null) {
        
    			messageSource.setDefaultEncoding(properties.getEncoding().name());
    		}
    		messageSource.setFallbackToSystemLocale(properties.isFallbackToSystemLocale());
    		Duration cacheDuration = properties.getCacheDuration();
    		if (cacheDuration != null) {
        
    			messageSource.setCacheMillis(cacheDuration.toMillis());
    		}
    		messageSource.setAlwaysUseMessageFormat(properties.isAlwaysUseMessageFormat());
    		messageSource.setUseCodeAsDefaultMessage(properties.isUseCodeAsDefaultMessage());
    		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>
    		
    		<link href="asserts/css/bootstrap.min.css" rel="stylesheet">
    		
    		<link href="asserts/css/signin.css" rel="stylesheet">
    	</head>
    
    	<body class="text-center">
    		<form class="form-signin" action="dashboard.html">
    			<img class="mb-4" 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" th:placeholder="#{login.username}" required="" autofocus="">
    			<label class="sr-only">Password</label>
    			<input type="password" class="form-control" 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;
    }

`AcceptHeaderLocaleResolver`:默认的就是根据请求头带来的区域信息获取Locale进行国际化

@Override
    public Locale resolveLocale(HttpServletRequest request) {
        
        Locale defaultLocale = getDefaultLocale();
        if (defaultLocale != null && request.getHeader("Accept-Language") == null) {
        
            return defaultLocale;
        }
        Locale requestLocale = request.getLocale();
        List<Locale> supportedLocales = getSupportedLocales();
        if (supportedLocales.isEmpty() || supportedLocales.contains(requestLocale)) {
        
            return requestLocale;
        }
        Locale supportedLocale = findSupportedLocale(request, supportedLocales);
        if (supportedLocale != null) {
        
            return supportedLocale;
        }
        return (defaultLocale != null ? defaultLocale : requestLocale);
    }

4）点击链接切换国际化

<a class="btn btn-sm" th:href="@{/index.html(l='zh_CN')}">中文</a>
    <a class="btn btn-sm" th:href="@{/index.html(l='en_US')}">English</a>

/**
     * 可以在链接上携带区域信息
     */
    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) {
        
    
        }
    }

`MyConfig`中配置Bean：

@Bean
    public LocaleResolver localeResolver(){
        
        return new MyLocaleResolver();
    }

### 3）登录 ###

开发期间模板引擎页面修改以后，要实时生效

*  导入DevTools

登陆错误消息的显示

<!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>
    		
    		<link href="/asserts/css/bootstrap.min.css" rel="stylesheet">
    		
    		<link href="/asserts/css/signin.css" rel="stylesheet">
    	</head>
    
    	<body class="text-center">
    		<form class="form-signin" th:action="@{/user/login}" method="post">
    			<img class="mb-4" 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>
    			
    			<p style="color:red;" th:if="${not #strings.isEmpty(msg)}" th:text="${msg}"></p>
    			<label class="sr-only" th:text="#{login.username}">Username</label>
    			<input type="text" name="username" class="form-control" th:placeholder="#{login.username}" required="" autofocus="">
    			<label class="sr-only">Password</label>
    			<input type="password" class="form-control" name="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" th:href="@{/index.html(l='zh_CN')}">中文</a>
    			<a class="btn btn-sm" th:href="@{/index.html(l='en_US')}">English</a>
    		</form>
    	</body>
    </html>

登录成功防止表单重复提交，不要使用请求转发，而使用重定向：

@Controller
    public class LoginController {
        
    	//@RequestMapping(value = "/user/login", method = RequestMethod.POST)
    	@PostMapping(value = "/user/login")
    	public String login(@RequestParam("username") String username, @RequestParam("password") String password,
    	        Map<String, Object> map, HttpSession session) {
        
    		if (!StringUtils.isEmpty(username) && "123456".equals(password)) {
        
    			session.setAttribute("loginUser", username);
    			//登陆成功，防止表单重复提交，重定向到主页
    			return "redirect:/main.html";
    		} else {
        
    			map.put("msg", "用户名密码错误");
    			return "login";
    		}
    	}
    }

同时在配置文件中注册视图控制器

### 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;
    		}
    	}
    }

注册拦截器

public class MyMvcConfig implements WebMvcConfigurer {
        
    
    	@Override
    	public void addInterceptors(InterceptorRegistry registry) {
        
    		registry.addInterceptor(new LoginHandlerInterceptor())
    		        .addPathPatterns("/**").excludePathPatterns("/index.html",
    		                "/user/login", "/webjars/**", "/static/**",
    		                "/asserts/**");
    	}
    }

### 5）CRUD-员工列表 ###

实验要求：

1）RestfulCRUD：CRUD满足Rest风格；

URI： /资源名称/资源标识 HTTP请求方式区分对资源CRUD操作

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>普通CRUD（uri来区分操作）</th> 
   <th>RestfulCRUD</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>查询</td> 
   <td>getEmp</td> 
   <td>emp—GET</td> 
  </tr> 
  <tr> 
   <td>添加</td> 
   <td>addEmp?xxx</td> 
   <td>emp—POST</td> 
  </tr> 
  <tr> 
   <td>修改</td> 
   <td>updateEmp?id=xxx&amp;xxx=xx</td> 
   <td>emp/{id}—PUT</td> 
  </tr> 
  <tr> 
   <td>删除</td> 
   <td>deleteEmp?id=1</td> 
   <td>emp/{id}—DELETE</td> 
  </tr> 
 </tbody> 
</table>

2）实验的请求架构;

<table> 
 <thead> 
  <tr> 
   <th>实验功能</th> 
   <th>请求URI</th> 
   <th>请求方式</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>查询所有员工</td> 
   <td>emps</td> 
   <td>GET</td> 
  </tr> 
  <tr> 
   <td>查询某个员工(来到修改页面)</td> 
   <td>emp/1</td> 
   <td>GET</td> 
  </tr> 
  <tr> 
   <td>来到添加页面</td> 
   <td>emp</td> 
   <td>GET</td> 
  </tr> 
  <tr> 
   <td>添加员工</td> 
   <td>emp</td> 
   <td>POST</td> 
  </tr> 
  <tr> 
   <td>来到修改页面（查出员工进行信息回显）</td> 
   <td>emp/1</td> 
   <td>GET</td> 
  </tr> 
  <tr> 
   <td>修改员工</td> 
   <td>emp</td> 
   <td>PUT</td> 
  </tr> 
  <tr> 
   <td>删除员工</td> 
   <td>emp/1</td> 
   <td>DELETE</td> 
  </tr> 
 </tbody> 
</table>

3）员工列表：

#### thymeleaf公共页面元素抽取 ####

1、抽取公共片段
    <div th:fragment="copy">
    © 2011 The Good Thymes Virtual Grocery
    </div>
    
    2、引入公共片段
    <div th:insert="~{footer :: copy}"></div>
    ~{templatename::selector}：模板名::选择器
    ~{templatename::fragmentname}:模板名::片段名
    
    3、默认效果：
    insert的公共片段在div标签中
    如果使用th:insert等属性进行引入，可以不用写~{}：
    行内写法可以加上：[[~{}]];[(~{})]；

三种引入公共片段的th属性：

**th:insert**：将公共片段整个插入到声明引入的元素中

**th:replace**：将声明引入的元素替换为公共片段

**th:include**：将被引入的片段的内容包含进这个标签中

<footer th:fragment="copy">
    © 2011 The Good Thymes Virtual Grocery
    </footer>
    
    引入方式
    <div th:insert="footer :: copy"></div>
    <div th:replace="footer :: copy"></div>
    <div th:include="footer :: copy"></div>
    
    效果
    <div>
        <footer>
        © 2011 The Good Thymes Virtual Grocery
        </footer>
    </div>
    
    <footer>
    © 2011 The Good Thymes Virtual Grocery
    </footer>
    
    <div>
    © 2011 The Good Thymes Virtual Grocery
    </div>

引入片段的时候传入参数：

<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="0 0 24 24" 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>
    
    
    <div th:replace="commons/bar::#sidebar(activeUri='emps')"></div>

显示员工列表

<button class="btn btn-sm btn-success">ADD</button>
    <div class="table-responsive">
    <table class="table table-striped table-sm">
    	<thead>
    		<tr>
    			<th>#</th>
    			<th>lastName</th>
    			<th>email</th>
    			<th>gender</th>
    			<th>department</th>
    			<th>birth</th>
    			<th>operation</th>
    		</tr>
    	</thead>
    	<tbody>
    		<tr th:each="emp:${emps}">
    			<td th:text="${emp.id}"></td>
    			<td th:text="${emp.lastName}"></td>
    			<td th:text="${emp.email}"></td>
    			<td th:text="${emp.gender}==0?'女':'男'"></td>
    			<td th:text="${emp.department.departmentName}"></td>
    			<td th:text="${#dates.format(emp.birth,'yyyy-MM-dd HH:mm')}"></td>
    			<td>
    				<button class='btn btn-sm btn-primary'>编辑</button>
    				<button class='btn btn-sm btn-danger'>删除</button>
    			</td>
    		</tr>
    	</tbody>

### 6）CRUD-员工添加 ###

添加页面

<form>
        <div class="form-group">
            <label>LastName</label>
            <input type="text" class="form-control" placeholder="zhangsan">
        </div>
        <div class="form-group">
            <label>Email</label>
            <input type="email" class="form-control" placeholder="zhangsan@atguigu.com">
        </div>
        <div class="form-group">
            <label>Gender</label><br/>
            <div class="form-check form-check-inline">
                <input class="form-check-input" type="radio" name="gender"  value="1">
                <label class="form-check-label">男</label>
            </div>
            <div class="form-check form-check-inline">
                <input class="form-check-input" type="radio" name="gender"  value="0">
                <label class="form-check-label">女</label>
            </div>
        </div>
        <div class="form-group">
            <label>department</label>
            <select class="form-control">
                <option>1</option>
                <option>2</option>
                <option>3</option>
                <option>4</option>
                <option>5</option>
            </select>
        </div>
        <div class="form-group">
            <label>Birth</label>
            <input type="text" class="form-control" placeholder="zhangsan">
        </div>
        <button type="submit" class="btn btn-primary">添加</button>
    </form>

提交的数据格式不对：生日：日期；

2017-12-12；2017/12/12；2017.12.12；

日期的格式化；SpringMVC将页面提交的值需要转换为指定的类型;

2017-12-12—Date； 类型转换，格式化;

默认日期是按照/的方式；

*  **建议直接用日期控件**

### 7）CRUD-员工修改 ###

修改添加二合一表单

<form th:action="@{/emp}" method="post">
        
        
        <input type="hidden" name="_method" value="put" th:if="${emp!=null}"/>
        <input type="hidden" name="id" th:if="${emp!=null}" th:value="${emp.id}">
        <div class="form-group">
            <label>LastName</label>
            <input name="lastName" type="text" class="form-control" placeholder="zhangsan" th:value="${emp!=null}?${emp.lastName}">
        </div>
        <div class="form-group">
            <label>Email</label>
            <input name="email" type="email" class="form-control" placeholder="zhangsan@atguigu.com" th:value="${emp!=null}?${emp.email}">
        </div>
        <div class="form-group">
            <label>Gender</label><br/>
            <div class="form-check form-check-inline">
                <input class="form-check-input" type="radio" name="gender" value="1" th:checked="${emp!=null}?${emp.gender==1}">
                <label class="form-check-label">男</label>
            </div>
            <div class="form-check form-check-inline">
                <input class="form-check-input" type="radio" name="gender" value="0" th:checked="${emp!=null}?${emp.gender==0}">
                <label class="form-check-label">女</label>
            </div>
        </div>
        <div class="form-group">
            <label>department</label>
            
            <select class="form-control" name="department.id">
                <option th:selected="${emp!=null}?${dept.id == emp.department.id}" th:value="${dept.id}" th:each="dept:${depts}" th:text="${dept.departmentName}">1</option>
            </select>
        </div>
        <div class="form-group">
            <label>Birth</label>
            <input name="birth" type="text" class="form-control" placeholder="zhangsan" th:value="${emp!=null}?${#dates.format(emp.birth, 'yyyy-MM-dd HH:mm')}">
        </div>
        <button type="submit" class="btn btn-primary" th:text="${emp!=null}?'修改':'添加'">添加</button>
    </form>

### 8）CRUD-员工删除 ###

<tr th:each="emp:${emps}">
        <td th:text="${emp.id}"></td>
        <td>[[${emp.lastName}]]</td>
        <td th:text="${emp.email}"></td>
        <td th:text="${emp.gender}==0?'女':'男'"></td>
        <td th:text="${emp.department.departmentName}"></td>
        <td th:text="${#dates.format(emp.birth, 'yyyy-MM-dd HH:mm')}"></td>
        <td>
            <a class="btn btn-sm btn-primary" th:href="@{/emp/}+${emp.id}">编辑</a>
            <button th:attr="del_uri=@{/emp/}+${emp.id}" class="btn btn-sm btn-danger deleteBtn">删除</button>
        </td>
    </tr>
    
    
    <script>
        $(".deleteBtn").click(function(){
         
            //删除当前员工的
            $("#deleteEmpForm").attr("action",$(this).attr("del_uri")).submit();
            return false;
        });
    </script>

## 7. 错误处理机制 ##

### 1）SpringBoot默认的错误处理机制 ###

默认效果：  
1）浏览器，返回一个默认的错误页面  
浏览器请求头含有信息，优先接收HTML页面，所以在错误页面响应时，采用的是第一种返回HTML页面的方法。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 1]

2）如果是其他客户端，默认响应一个json数据

{
        
        "timestamp": "2020-03-11T06:14:21.092+0000",
        "status": 404,
        "error": "Not Found",
        "message": "No message available",
        "path": "/crud/aaa"
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 2]  
原理：  
可以参照ErrorMvcAutoConfiguration；错误处理的自动配置；  
给容器中添加了以下组件:

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 = MediaType.TEXT_HTML_VALUE)
    	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 modelAndView = resolveErrorView(request, response, status, model);
    		return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
    	}
    
    	/**
        *产生JSON数据
        * 其他客户端请求处理
        */
    	@RequestMapping
    	public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
        
    		HttpStatus status = getStatus(request);
    		if (status == HttpStatus.NO_CONTENT) {
        
    			return new ResponseEntity<>(status);
    		}
    		Map<String, Object> body = getErrorAttributes(request, isIncludeStackTrace(request, MediaType.ALL));
    		return new ResponseEntity<>(body, status);
    	}

`resolveErrorView`:解析错误页面

/**
     * Resolve any specific error views. By default this method delegates to
     * {@link ErrorViewResolver ErrorViewResolvers}.
     * @param request the request
     * @param response the response
     * @param status the HTTP status
     * @param model the suggested model
     * @return a specific {@link ModelAndView} or {@code null} if the default should be
     * used
     * @since 1.4.0
     */
    protected ModelAndView resolveErrorView(HttpServletRequest request, HttpServletResponse response, HttpStatus status,
    		Map<String, Object> model) {
        
    	for (ErrorViewResolver resolver : this.errorViewResolvers) {
        
    		ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
    		if (modelAndView != null) {
        
    			return modelAndView;
    		}
    	}
    	return null;
    }

3. ErrorPageCustomizer：

@Bean
    public ErrorPageCustomizer errorPageCustomizer(DispatcherServletPath dispatcherServletPath) {
        
    	return new ErrorPageCustomizer(this.serverProperties, dispatcherServletPath);
    }

`ErrorPageCustomizer`:注册错误页面

@Override
    public void registerErrorPages(ErrorPageRegistry errorPageRegistry) {
        
    	ErrorPage errorPage = new ErrorPage(
    			this.dispatcherServletPath.getRelativePath(this.properties.getError().getPath()));
    	errorPageRegistry.addErrorPages(errorPage);
    }

`getPath()`：获取错误页面路径，从配置文件中

/**
     * Path of the error controller.
     * 系统出现错误以后来到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`处理；  
响应页面是由`DefaultErrorViewResolver`解析得到的；

### 2）如果定制错误响应： ###

#### 1）如何定制错误的页面； ####

1）有模板引擎的情况下；error/状态码;【将错误页面命名为 错误状态码.html 放在模板引擎文件夹里面的 error文件夹下】，发生此状态码的错误就会来到 对应的页面；

可以使用4xx和5xx作为错误页面的文件名来匹配这种类型的所有错误，精确优先（优先寻找精确的状态码.html）；

页面能获取的信息：

timestamp：时间戳
    status：状态码
    error：错误提示
    exception：异常对象
    message：异常消息
    errors：JSR303数据校验的错误都在这里

2）没有模板引擎（模板引擎找不到这个错误页面），静态资源文件夹下找；

3）以上都没有错误页面，就是默认来到SpringBoot默认的错误提示页面；

@Configuration(proxyBeanMethods = false)
    @ConditionalOnProperty(prefix = "server.error.whitelabel", name = "enabled", matchIfMissing = true)
    @Conditional(ErrorTemplateMissingCondition.class)
    protected static class WhitelabelErrorViewConfiguration {
        
    
    	private final StaticView defaultErrorView = new StaticView();
    
    	@Bean(name = "error")
    	@ConditionalOnMissingBean(name = "error")
    	public View defaultErrorView() {
        
    		return this.defaultErrorView;
    	}

#### 2）如何定制错误的json数据； ####

1）自定义异常处理&返回定制json数据；

@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 {
        
    
    	//返回值的map就是页面和json能获取的所有字段
    	@Override
    	public Map<String, Object> getErrorAttributes(WebRequest webRequest,
    	        boolean includeStackTrace) {
        
    		Map<String, Object> map = super.getErrorAttributes(webRequest,
    		        includeStackTrace);
    		map.put("company", "atguigu");
    
    		//我们的异常处理器携带的数据
    		Map<String, Object> ext = (Map<String, Object>) webRequest
    		        .getAttribute("ext", RequestAttributes.SCOPE_REQUEST);
    		map.put("ext", ext);
    		return map;
    	}
    }

最终的效果：响应是自适应的，可以通过定制ErrorAttributes改变需要返回的内容

{
        
        "timestamp": "2020-03-12T04:31:13.180+0000",
        "status": 500,
        "error": "Internal Server Error",
        "message": "用户不存在",
        "trace": "com.atguigu.springboot.exception.UserNotExistException: 用户不存在\r\n\tat com.atguigu.springboot.controller.HelloController.hello(HelloController.java:25)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)\r\n\tat sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)\r\n\tat sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)\r\n\tat java.lang.reflect.Method.invoke(Method.java:498)\r\n\tat org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:190)\r\n\tat org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:138)\r\n\tat org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:106)\r\n\tat org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:879)\r\n\tat org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:793)\r\n\tat org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87)\r\n\tat org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1040)\r\n\tat org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:943)\r\n\tat org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1006)\r\n\tat org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:898)\r\n\tat javax.servlet.http.HttpServlet.service(HttpServlet.java:634)\r\n\tat org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:883)\r\n\tat javax.servlet.http.HttpServlet.service(HttpServlet.java:741)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:231)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)\r\n\tat org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)\r\n\tat org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100)\r\n\tat org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)\r\n\tat org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93)\r\n\tat org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)\r\n\tat org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201)\r\n\tat org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193)\r\n\tat org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166)\r\n\tat org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:202)\r\n\tat org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:96)\r\n\tat org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:541)\r\n\tat org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:139)\r\n\tat org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92)\r\n\tat org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:74)\r\n\tat org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:343)\r\n\tat org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:367)\r\n\tat org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65)\r\n\tat org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:868)\r\n\tat org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1639)\r\n\tat org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)\r\n\tat java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)\r\n\tat java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)\r\n\tat org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)\r\n\tat java.lang.Thread.run(Thread.java:748)\r\n",
        "path": "/crud/hello",
        "company": "atguigu",
        "ext": {
        
            "code": "user.notexist",
            "message": "用户出错啦"
        }
    }

## 8. 配置嵌入式Servlet容器 ##

SpringBoot默认使用Tomcat作为嵌入式的Servlet容器；

### 1）如何定制和修改Servlet容器的相关配置； ###

1.  修改和server有关的配置（`ServerProperties`【也是`WebServerFactoryCustomizer`】）；

server.port=8081
    server.context-path=/crud
    
    server.tomcat.uri-encoding=UTF-8
    
    //通用的Servlet容器设置
    server.xxx
    //Tomcat的设置
    server.tomcat.xxx

1.  编写一个`WebServerFactoryCustomizer`：嵌入式的Servlet容器的定制器；来修改Servlet容器的配置

//配置嵌入式的Servlet容器
    @Bean
    public WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> webServerFactoryCustomizer() {
        
    	return new WebServerFactoryCustomizer<ConfigurableServletWebServerFactory>() {
        
    
    		/**
    		 * 定制嵌入式的Servlet容器相关的规则
    		 */
    		@Override
    		public void customize(ConfigurableServletWebServerFactory factory) {
        
    			factory.setPort(8080);
    		}
    	};
    }

### 2）注册Servlet三大组件【Servlet、Filter、Listener】 ###

由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用，没有web.xml文件。

注册三大组件用以下方式

`ServletRegistrationBean`:

//注册三大组件
    @Bean
    public ServletRegistrationBean<MyServlet> myServlet() {
        
    	ServletRegistrationBean<MyServlet> registrationBean = new ServletRegistrationBean<MyServlet>(
    	        new MyServlet(), "/myServlet");
    	registrationBean.setLoadOnStartup(1);
    	return registrationBean;
    }

`FilterRegistrationBean`:

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

`ServletListenerRegistrationBean`:

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

SpringBoot自动SpringMVC的时候，自动注册SpringMVC的前端控制器`DIspatcherServlet`；

`DispatcherServletAutoConfiguration`中：

@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<MultipartConfigElement> 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;
    	}
    
    }

`webMvcProperties.getServlet().getPath()`：前端控制器拦截路径

//默认拦截：/ 包括静态资源，但是不包括jsp请求
    // /*会拦截jsp资源
    //可以通过spring.mvc.servlet.path修改前端控制器默认拦截路径
    private String path = "/";

### 3）替换为其他嵌入式Servlet容器 ###

![在这里插入图片描述][20200312152130726.png]

默认支持：

Tomcat（默认使用）

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
       引入web模块默认就是使用嵌入式的Tomcat作为Servlet容器；
    </dependency>

Jetty

<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>
    
    
    <dependency>
       <artifactId>spring-boot-starter-jetty</artifactId>
       <groupId>org.springframework.boot</groupId>
    </dependency>

Undertow

<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>
    
    
    <dependency>
       <artifactId>spring-boot-starter-undertow</artifactId>
       <groupId>org.springframework.boot</groupId>
    </dependency>

### 4）嵌入式Servlet容器自动配置原理； ###

`ServletWebServerFactoryConfiguration`：嵌入式的Servlet容器自动配置

@Configuration(proxyBeanMethods = false)
    class ServletWebServerFactoryConfiguration {
        
    
    	@Configuration(proxyBeanMethods = false)
    	//判断是否引入Tomcat依赖
    	@ConditionalOnClass({
         Servlet.class, Tomcat.class, UpgradeProtocol.class })
    	//判断当前容器没有用户自定义的Servlet服务工厂 
    	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
    	static class EmbeddedTomcat {
        
    
    		@Bean
    		TomcatServletWebServerFactory tomcatServletWebServerFactory(
    				ObjectProvider<TomcatConnectorCustomizer> connectorCustomizers,
    				ObjectProvider<TomcatContextCustomizer> contextCustomizers,
    				ObjectProvider<TomcatProtocolHandlerCustomizer<?>> 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;
    		}
    
    	}
    
    	/**
    	 * Nested configuration if Jetty is being used.
    	 */
    	@Configuration(proxyBeanMethods = false)
    	@ConditionalOnClass({
         Servlet.class, Server.class, Loader.class, WebAppContext.class })
    	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
    	static class EmbeddedJetty {
        
    
    		@Bean
    		JettyServletWebServerFactory JettyServletWebServerFactory(
    				ObjectProvider<JettyServerCustomizer> serverCustomizers) {
        
    			JettyServletWebServerFactory factory = new JettyServletWebServerFactory();
    			factory.getServerCustomizers().addAll(serverCustomizers.orderedStream().collect(Collectors.toList()));
    			return factory;
    		}
    
    	}
    
    	/**
    	 * Nested configuration if Undertow is being used.
    	 */
    	@Configuration(proxyBeanMethods = false)
    	@ConditionalOnClass({
         Servlet.class, Undertow.class, SslClientAuthMode.class })
    	@ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
    	static class EmbeddedUndertow {
        
    
    		@Bean
    		UndertowServletWebServerFactory undertowServletWebServerFactory(
    				ObjectProvider<UndertowDeploymentInfoCustomizer> deploymentInfoCustomizers,
    				ObjectProvider<UndertowBuilderCustomizer> builderCustomizers) {
        
    			UndertowServletWebServerFactory factory = new UndertowServletWebServerFactory();
    			factory.getDeploymentInfoCustomizers()
    					.addAll(deploymentInfoCustomizers.orderedStream().collect(Collectors.toList()));
    			factory.getBuilderCustomizers().addAll(builderCustomizers.orderedStream().collect(Collectors.toList()));
    			return factory;
    		}
    	}
    }

1）`ServletWebServerFactory`（ServletWeb服务工厂）

/**
     * Factory interface that can be used to create a {@link WebServer}.
     */
    @FunctionalInterface
    public interface ServletWebServerFactory {
        
    	WebServer getWebServer(ServletContextInitializer... initializers);
    }

![在这里插入图片描述][20200312155224122.png]  
2）`WebServer`：（Servlet容器）

/**
     * Simple interface that represents a fully configured web server (for example Tomcat,
     * Jetty, Netty). Allows the server to be {@link #start() started} and {@link #stop()
     * stopped}.
    */
    public interface WebServer {

3）、以`TomcatServletWebServerFactory`的`getWebServer`为例

@Override
    public WebServer getWebServer(ServletContextInitializer... initializers) {
        
    	if (this.disableMBeanRegistry) {
        
    		Registry.disableRegistry();
    	}
    	//创建一个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);
    	connector.setThrowOnFailure(true);
    	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);
    	//配置好后传入返回
    	return getTomcatWebServer(tomcat);
    }

`getTomcatWebServer`：配置好后传入，并自动启动

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;
    	initialize();
    }
    
    private void initialize() throws WebServerException {
        
    	...
    	// Start the server to trigger initialization listeners
    	this.tomcat.start();
    	...

4）对嵌入式容器的配置修改是如何生效

/** Beware: calls to this interface are usually made from a
     * {@link WebServerFactoryCustomizerBeanPostProcessor} which is a
     * {@link BeanPostProcessor} (so called very early in the ApplicationContext lifecycle).
     * */
    WebServerFactoryCustomizer

`WebServerFactoryCustomizer`：定制器修改了Servlet容器的配置  
5）`WebServerFactoryCustomizerBeanPostProcessor`

@Override
    //初始化之前
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
    	//如果当前bean是一个WebServerFactory
    	if (bean instanceof WebServerFactory) {
        
    		postProcessBeforeInitialization((WebServerFactory) bean);
    	}
    	return bean;
    }
    
    @SuppressWarnings("unchecked")
    private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
        
    	//调用每一个定制器赋值
    	LambdaSafe.callbacks(WebServerFactoryCustomizer.class, getCustomizers(), webServerFactory)
    			.withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)
    			.invoke((customizer) -> customizer.customize(webServerFactory));
    }
    /**
    *获得所有定制器
    */
    private Collection<WebServerFactoryCustomizer<?>> getCustomizers() {
        
    	if (this.customizers == null) {
        
    		// Look up does not include the parent context
    		this.customizers = new ArrayList<>(getWebServerFactoryCustomizerBeans());
    		this.customizers.sort(AnnotationAwareOrderComparator.INSTANCE);
    		this.customizers = Collections.unmodifiableList(this.customizers);
    	}
    	return this.customizers;
    }
    /**
    *从容器中获得所有WebServerFactoryCustomizer类型的定制器
    *所以自定义servlet容器就创建一个WebServerFactoryCustomizer组件
    */
    @SuppressWarnings({
         "unchecked", "rawtypes" })
    private Collection<WebServerFactoryCustomizer<?>> getWebServerFactoryCustomizerBeans() {
        
    	return (Collection) this.beanFactory.getBeansOfType(WebServerFactoryCustomizer.class, false, false).values();
    }

ServerProperties中的设置是在具体定制器定制过程中读取的，其本身并不是一个定制器，以`TomcatWebServerFactoryCustomizer`为例

public class TomcatWebServerFactoryCustomizer
    		implements WebServerFactoryCustomizer<ConfigurableTomcatWebServerFactory>, Ordered {
        	
    	...
    	private final ServerProperties serverProperties;
    	public TomcatWebServerFactoryCustomizer(Environment environment, ServerProperties serverProperties) {
        
    		this.environment = environment;
    		this.serverProperties = serverProperties;
    	}

步骤：

1）SpringBoot根据导入的依赖情况，`ServletWebServerFactoryConfiguration`给容器中添加相应的`ServletWebServerFactory`【`TomcatServletWebServerFactory`】

2）容器中某个组件要创建对象就会惊动后置处理器；`WebServerFactoryCustomizerBeanPostProcessor`；  
只要是嵌入式的Servlet容器工厂，后置处理器就工作；

3）后置处理器，从容器中获取所有的`WebServerFactoryCustomizer`，调用定制器的定制方法

4） 定制器的定制方法并结合ServerProperties中的设置进行配置

### 5）WebServer启动原理； ###

获取`WebServerFactory`：

1）SpringBoot应用启动运行run方法

2）refreshContext(context);SpringBoot刷新IOC容器【创建IOC容器对象，并初始化容器，创建容器中的每一个组件】

protected ConfigurableApplicationContext createApplicationContext() {
        
    	Class<?> contextClass = this.applicationContextClass;
    	if (contextClass == null) {
        
    		try {
        
    			switch (this.webApplicationType) {
        
    			case SERVLET:
    			//"org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext"
    				contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
    				break;
    			case REACTIVE:
    				contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
    				break;
    			default:
    				contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
    			}
    		}
    		...
    }

3）**刷新刚才创建好的ioc容器；**

private void refreshContext(ConfigurableApplicationContext context) {
        
    	refresh(context);
    	...

@Override
    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）web ioc容器会创建WebServer；

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

**6）、获取`WebServerFactory`：**

private void createWebServer() {
        
    	WebServer webServer = this.webServer;
    	ServletContext servletContext = getServletContext();
    	if (webServer == null && servletContext == null) {
        
    		ServletWebServerFactory factory = getWebServerFactory();
    		this.webServer = factory.getWebServer(getSelfInitializer());
    	}
    	else if (servletContext != null) {
        
    		try {
        
    			getSelfInitializer().onStartup(servletContext);
    		}
    		catch (ServletException ex) {
        
    			throw new ApplicationContextException("Cannot initialize servlet context", ex);
    		}
    	}
    	initPropertySources();
    }

从ioc容器中获取`WebServerFactory`组件；`TomcatServletWebServerFactory`创建对象，后置处理器一看是这个对象，就获取所有的定制器来先定制Servlet容器的相关配置；

7）**使用`WebServerFactory`获取嵌入式的`WebServer`**：

this.webServer = factory.getWebServer(getSelfInitializer());

8）`WebServer`创建对象并启动；

public WebServer getWebServer(ServletContextInitializer... initializers) {
        
    	if (this.disableMBeanRegistry) {
        
    		Registry.disableRegistry();
    	}
    	Tomcat tomcat = new Tomcat();
    	...
    	//在这个方法中启动
    	return getTomcatWebServer(tomcat);

**先启动嵌入式的Servlet容器，再将ioc容器中剩下没有创建出的对象获取出来；**

// 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();

**IOC容器启动创建WebServer**

## 9. 使用外置的Servlet容器 ##

嵌入式Servlet容器：应用打成可执行的jar

优点：简单、便携；  
缺点：默认不支持JSP、优化定制比较复杂（ServerProperties,使用定制器【自定义`WebServerFactoryCustomizer`】，自己编写嵌入式Servlet容器的创建工厂【`WebServerFactory`】）；

外置的Servlet容器：外面安装Tomcat—应用war包的方式打包；

### 步骤 ###

1）必须创建一个war项目；

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：  
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）\\maven\\org\\springframework\\spring-web\\5.2.4.RELEASE\\spring-web-5.2.4.RELEASE.jar/META-INF/services/javax.servlet.ServletContainerInitializer

Spring的web模块里面有这个文件：`org.springframework.web.SpringServletContainerInitializer`  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 3]

3）SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到onStartup方法的Set<Class<?>>；为这些WebApplicationInitializer类型的类创建实例；

@HandlesTypes(WebApplicationInitializer.class)
    public class SpringServletContainerInitializer implements ServletContainerInitializer {
        
    
    @Override
    public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
    		throws ServletException {
        
    
    	List<WebApplicationInitializer> initializers = new LinkedList<>();
    
    	if (webAppInitializerClasses != null) {
        
    		for (Class<?> waiClass : webAppInitializerClasses) {
        
    			// Be defensive: Some servlet containers provide us with invalid classes,
    			// no matter what @HandlesTypes says...
    			if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
    					WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
        
    				try {
        
    					initializers.add((WebApplicationInitializer)
    							ReflectionUtils.accessibleConstructor(waiClass).newInstance());
    				}
    				catch (Throwable ex) {
        
    					throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
    				}
    			}
    		}
    	}
    	...

4）每一个`WebApplicationInitializer`都调用自己的`onStartup`；  
![\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HuoeZPi6-1583649601434)(images/搜狗截图20180302221835.png)\]][img-HuoeZPi6-1583649601434_images_20180302221835.png]  
5）相当于自定义继承`SpringBootServletInitializer`的类会被创建对象，并执行`onStartup`方法

6）`SpringBootServletInitializer`实例执行`onStartup`的时候会`createRootApplicationContext`创建容器

protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
        
    	//创建SpringApplicationBuilder 
    	SpringApplicationBuilder builder = createSpringApplicationBuilder();
    	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(AnnotationConfigServletWebServerApplicationContext.class);
    	//调用configure，子类重写了该方法将springboot主程序类传进来
    	builder = configure(builder);
    	builder.listeners(new WebEnvironmentPropertySourceInitializer(servletContext));
    	//创建一个spring应用
    	SpringApplication application = builder.build();
    	if (application.getAllSources().isEmpty()
    			&& MergedAnnotations.from(getClass(), SearchStrategy.TYPE_HIERARCHY).isPresent(Configuration.class)) {
        
    		application.addPrimarySources(Collections.singleton(getClass()));
    	}
    	Assert.state(!application.getAllSources().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.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
    	}
    	//启动
    	return run(application);
    }

7）Spring的应用就启动并且创建IOC容器

public ConfigurableApplicationContext run(String... args) {
        
    	StopWatch stopWatch = new StopWatch();
    	stopWatch.start();
    	ConfigurableApplicationContext context = null;
    	Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    	configureHeadlessProperty();
    	SpringApplicationRunListeners listeners = getRunListeners(args);
    	listeners.starting();
    	try {
        
    		ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
    		ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
    		configureIgnoreBeanInfo(environment);
    		Banner printedBanner = printBanner(environment);
    		context = createApplicationContext();
    		exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
    				new Class[] {
         ConfigurableApplicationContext.class }, context);
    		prepareContext(context, environment, listeners, applicationArguments, printedBanner);
    		//刷新IOC容器
    		refreshContext(context);
    		afterRefresh(context, applicationArguments);
    		stopWatch.stop();
    		if (this.logStartupInfo) {
        
    			new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
    		}
    		listeners.started(context);
    		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;
    }

**启动Servlet容器，再启动SpringBoot应用**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70]: /images/20230529/52b26968adee4f3f95df208a6829691b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 1]: /images/20230529/2439f54e927344ad9c7cf9c55684305f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 2]: /images/20230529/f9c65a9dee224eecbfea25cdc330d97b.png
[20200312152130726.png]: /images/20230529/f26336730d674dd78a63748e953751d4.png
[20200312155224122.png]: /images/20230529/edd8e1deca2d44c59439e7e2fcde1f9f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NoaWxsX0x5bg_size_16_color_FFFFFF_t_70 3]: /images/20230529/b4049cd520544b71b76bbc3226e34557.png
[img-HuoeZPi6-1583649601434_images_20180302221835.png]: /images/20230529/15699d9edb7b4b79a7188db470223e54.png