tl-微服务专题01-Spring Boot快速开始及核心功能介绍

灰太狼 2022-02-24 08:38 158阅读 0赞

**目录**

第一节:springboot快速开始(对三篇)

一:springboot 微服务开发利器

1.1)什么是微服务，微服务和微服务架构的区别?

1.2）什么是微服务架构

1.3微服务的优缺点:

二:springboot快速开始

2.1)(基于maven版本构建)

2.1)配置IDE的环境（maven配置）

2.2)创建一个空的maven工程，然后导入springboot相关的jar包

2.3)通过sts/idea创建 一个springboot项目

三:helloworld的探究，

为啥我只要引入 spring-boot-starter-parent 和 spring-boot-starter-web就可以快速开发mvc的项目

3.1）pom分析

3.2) 我们来分析看下 spring-boot-starter-web（场景启动器）为我项目中导入 web开发需要的jar包依赖

4)多profile切换

4.1)yml支持多模块文档块

4.2) 多yml|properties文件的环境切换

4.3)激活指定环境配置的方法

4.4)设置jvm参数 然后我们看是否设置成功

4.5) springboot关于打包问题总结

6)springboot 的web开发（）

6.1）什么是webJar：以jar包的形式来引入前端资源,比如jquery 或者是BootStraphttps://www.webjars.org/

6.2)springboot是如何整合springmvc功能的（WebMvcAutoConfiguration）

7）如何全面接管springboot的mvc配置(让springboot给我们自动配置的功能失效,自己像如何整合ssm一样的整合springmvc,不推荐)

8)springboot错误处理机制?如何定制错误页面？

8.1）我们来看springboot为我们自动配置的异常处理的一些bean

--------------------

# **第一节:springboot快速开始** #

##    **一:springboot 微服务开发利器** ##

###    **1.1)什么是微服务，微服务和微服务架构的区别?** ###

目前而已，对于微服务业界没有一个统一的标准定义,但是通常而言提倡把一个单一的应用程序划分为一组小  
的服务，  
每个小的服务都会运行在自己的进程中，服务之间通过轻量级的通信机制（http的rest api）进行通信,那么  
一个个的  
小服务就是微服务。  
**①：单体架构与微服务架构图示**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70][]  
传统的的单一电商应用来说，订单，支付，用户，商品，库存等模块都在一个项目中，若某一个模块出  
现线上bug，会导致整个版本发布回退.  
若把单一应用拆分为一个一微服务，比如订单微服务，用户微服务，商品微服务，积分微服务等，若某  
一个微服务出错不会导致整个版本回退。

###    **1.2）什么是微服务架构** ###

微服务架构是一种架构模式（**用于服务管理微服务的**），它把一组小的服务互相协调、互相配合，并且  
完成功能。每个服务运行在其独立的进程中，服务与服务间采用轻量级的通信机制互相协作（通常是基  
于HTTP 协议的RESTfulAPI ）。每个服务都围绕着具体业务进行构建，并且能够被独立的部署到生产环  
境、类生产环境等。另外，应当尽量避免统一的、集中式的服务管理机制，对具体的一个服务而言，应  
根据业务上下文，选择合适的语言、工具对其进行构建。

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 1][]   **1.3微服务的优缺点:** ###

**优点:**  
①:优点每个服务足够内聚，足够小，代码容易理解这样能聚焦一个指定的业务功能或业务需求(职责单  
一)  
②:开发简单、开发效率提高，一个服务可能就是专一的只干一件事,微服务能够被小团队单独开发，这  
个小团队是 2 到 5 人的开发人员组成。  
③:微服务能使用不同的语言开发。  
④:易于和第三方集成，微服务允许容易且灵活的方式集成自动部署，通过持续集成工具，如  
Jenkins,Hudson,bamboo。  
⑤:微服务只是业务逻辑的代码，不会和 HTML,CSS或其他界面组件混合。  
⑥:每个微服务都有自己的存储能力，可以有自己的数据库。也可以有统一数据库。  
.........................................  
.........................................  
**缺点:**  
开发人员要处理分布式系统的复杂性(分布式事务)  
多服务运维难度，随着服务的增加，运维的压力也在增大  
系统部署依赖  
服务间通信成本  
数据一致性  
.................................................  
.................................................

## **二:springboot快速开始** ##

###    **2.1)(基于maven版本构建)** ###

2.1)先把maven的配置文件设置为如下配置
    <profile>
        <id>jdk‐1.8</id>
        <activation>
        <activeByDefault>true</activeByDefault>
        <jdk>1.8</jdk>
        </activation>
        <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        </properties>
    </profile>

###    **2.1)配置IDE的环境（maven配置）** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 3][]

###    **2.2)创建一个空的maven工程，然后导入springboot相关的jar包** ###

//父工程依赖
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.8.RELEASE</version>
    </parent>
    spring mvc-web的依赖
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

![20190422235334906.png][]  
**①：编写主入口程序**

/**
    * Created by smlz on 2019/3/18.
    */
    @SpringBootApplication
    public class TulingStartMain {
    
        public static void main(String[] args) {
            SpringApplication.run(TulingStartMain.class,args);
        }
    }

**②:其他业务组件 比如controller service repository compent注解标示的组件**  
**\*\*\*\*\*\*\*\*\*\* 自己写的组件必须放在主启动类(TulingStartMain)在所包的及其子包下???????? 将源码分  
析时候探究原理**

/**
    * Created by smlz on 2019/3/18.
    */
    @RestController
    public class TulingController {
    
        @RequestMapping("/tuling")
        public String tulingHelloWorld() {
            return "tuling,hello";
        }
    }

**③:运行main函数启动程序，访问http://localhost:8080/tuling，或者执行mvn package将项目打成  
jar包，用java -jar XXX.jar直接运行**

### ![20190403174109340.png][]   **2.3)通过sts/idea创建 一个springboot项目** ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 5][]

编写自己的业务代码就maven构建springboot工程版本的一样 这里就不做累赘讲诉.

##    **三:helloworld的探究，** ##

## **为啥我只要引入 spring-boot-starter-parent 和 spring-boot-starter-web就可以快速开发mvc的项目** ##

###    **3.1）pom分析** ###

**SpringBoot项目的父项目是**spring-boot-starter-parent**，而**spring-boot-starter-parent**项目的父项目是**spring-boot-dependencies**，**spring-boot-dependencies**项目是个依赖版本管理项目。**

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.8.RELEASE</version>
        <relativePath/> 
    </parent>
    真正的版本管理仲裁中心 来决定应用的版本
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.0.8.RELEASE</version>
        <relativePath>../../spring-boot-dependencies</relativePath>
    </parent>

以后我们导入依赖默认是不需要写版本；（没有在dependencies里面管理的依赖自然需要声明版本号）

###    **3.2) 我们来分析看下 spring-boot-starter-web（场景启动器）为我项目中导入 web开发需要的jar包依赖** ###

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 6][]   **4)多profile切换** ##

我们在开发应用时，通常一个项目会被部署到不同的环境中，比如：开发、测试、生产等。其中每个环  
境的数据库地址、服务器端口等等配置都会不同，对于多环境的配置，大部分构建工具或是框架解决的  
基本思路是一致的，通过配置多份不同环境的配置文件，再通过打包命令指定需要打包的内容之后进行  
区分打包

###    **4.1)yml支持多模块文档块** ###

server:
        port: 8081
        servlet:
            context-path: /tuling01
    spring:
        profiles:
            active: dev
    ---
    开发环境配置
    spring:
        profiles: dev
    server:
        port: 8082
    ---
    生产环境配置
    spring:
        profiles: prod
    server:
        port: 8083

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 7][]  
从上图看出，我们激活的配置是开发环境的配置,但是现在 我们还看到了 servlet:context-path的配置形成互补配置

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 8][]

**4.1.1)将配置文件中的部分内容直接加载到一个类中。**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 9][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 10][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 11][]

### **4.2) 多yml|properties文件的环境切换** ###

application.yml (用于激活不同环境的配置文件)

spring:
        profiles:
            active: dev

application-dev.yml

server:
        port: 8081
        servlet:
            context-path: /tl_dev

application-prod.yml

server:
        port: 8082
        servlet:
            context-path: /tl_prod

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 12][] ###

###    **4.3)激活指定环境配置的方法** ###

**①:直接在application.yml的配置文件中使用 spring.profiles.active=dev|prod|test  
②:设置虚拟机参数 -Dspring.profiles.active=dev|prod|test  
③:命令行参数启动(打成Jar包时候) java -jar tuling-vip-springboot-02-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod**

###    **4.4)设置jvm参数 然后我们看是否设置成功** ###

java -Xms128m -Xmx128m -jar tuling-vip-springboot-02-0.0.1-SNAPSHOT.jar --server.port=8888  
第一步:在cmd窗口中使用jps来看我们主进程的

![20190403175857597.png][]

![20190427191324456.png][]  
第二步:使用jinfo命令 +进程号来查看具体信息

### ![20190403175936645.png][]   **4.5) springboot关于打包问题总结** ###

**4.5.1):打成指定的jar名称的**

<build>
        指定打包的文件名称
        <finalName>tulingVipSpringboot</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 13][]  
**4.5.2)若出现工程中出现多个mainclass的时候需要指定主启动类**

<build>
        <finalName>tulingVipSpringboot</finalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.tuling.TulingVipSpringboot02Application</mainClass>
                </configuration>
                <goals>
                    <goal>repackage</goal>
                </goals>
            </plugin>
        </plugins>
    </build>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 14][]  
**4.5.3）如何打出一个war包**  
第一步:指定springboot pom中的打包方式 由jar改为war

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 15][]  
第二步:在spring-boot-starter-web模块打包比依赖与 tomcat（即要打成war包的那个模块加此tomcat依赖，并设置provided。只在要打成war包给tomcat使用的时候才加此依赖，否则不要。）（是为了排除掉tomcat。springboot**程序是**jar**的方式**,**是通过**IOC**容器启动，带动了**tomcat**的启动。****打成**war**的时候，是**tomcat**启动带动**IOC**容器的启动**)

![20190403180617301.png][]  
第三步:主启动类上 实现SpringBootServletInitializer 从写confiure方法(原理第三节课节讲)

@SpringBootApplication
    public class TulingVipSpringboot03Application extends SpringBootServletInitializer {
    
        public static void main(String[] args) {
            SpringApplication.run(TulingVipSpringboot03Application.class, args);
        }
    
        @Override
        protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
            return application.sources(TulingVipSpringboot03Application.class);
        }
    }

第四步:打成war包 放在tomcat上运行.

##    **6)springboot 的web开发（）** ##

###    **6.1）什么是webJar：以jar包的形式来引入前端资源,比如jquery 或者是BootStrap**   [https://www.webjars.org/][https_www.webjars.org] ###

**6.1.1）引入对应的jar包**

<dependency>
    	<groupId>org.webjars</groupId>
    	<artifactId>jquery</artifactId>
    	<version>3.3.1-2</version>
    </dependency>
    
    <dependency>
    	<groupId>org.webjars</groupId>
    	<artifactId>bootstrap</artifactId>
    	<version>4.3.1</version>
    </dependency>

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 16][]

**6.1.2)映射规则 /webjars/\*\* 都会被映射到classpath:/META-INF/resources/webjars/ 目录下去处理**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 17][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 18][]  
**6.1.3)前端资源映射规则 核心源代码:**

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

源码里的原文
    @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));
    			}
    			String staticPathPattern = this.mvcProperties.getStaticPathPattern();
    			if (!registry.hasMappingForPattern(staticPathPattern)) {
    				customizeResourceHandlerRegistration(
    						registry.addResourceHandler(staticPathPattern)
    								.addResourceLocations(getResourceLocations(
    										this.resourceProperties.getStaticLocations()))
    								.setCachePeriod(getSeconds(cachePeriod))
    								.setCacheControl(cacheControl));
    			}
    		}

**6.1.4）**[http://localhost:8080/webjars/jquery/3.3.1-2/jquery.js][http_localhost_8080_webjars_jquery_3.3.1-2_jquery.js] **请求如何拦截处理请求的**  
①根据日志打印，我们发现如下突破口

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 19][]  
②:第二步:  
org.springframework.web.servlet.resource.ResourceHttpRequestHandler\#handleRequest方法  
>org.springframework.web.servlet.resource.ResourceHttpRequestHandler\#getResource  
>org.springframework.web.servlet.resource.ResourceResolverChain\#resolveResource  
>org.springframework.web.servlet.resource.PathResourceResolver\#resolveResourceInternal  
>org.springframework.web.servlet.resource.PathResourceResolver\#getResource(**真正的资源映射  
处理逻辑**)

private Resource getResource(String resourcePath, @Nullable HttpServletRequest request,List<? extends Resource> locations) {
        for (Resource location : locations) {
            try {
                if (logger.isTraceEnabled()) {
                    logger.trace("Checking location: " + location);
                }
                String pathToUse = encodeIfNecessary(resourcePath, request, location);
                //真正的处理逻辑 把jquery/3.3.1-2/jquery.js 映射到
                Resource resource = getResource(pathToUse, location);
                if (resource != null) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Found match: " + resource);
                    }
                    return resource;
                }
                else if (logger.isTraceEnabled()) {
                    logger.trace("No match for location: " + location);
                }
            }
            catch (IOException ex) {
                logger.trace("Failure checking for relative resource - trying next location", ex);
            }
        }
        return null;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 20][]  
  
**6.1.5)访问静态html页面 我们直接把静态页面放在static的目录下，直接可以在路径直接访问**

![20190404110344577.png][]  
**6.1.6)映射原理 /\*\*请求都会被映射到**

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

public void addResourceHandlers(ResourceHandlerRegistry registry) {
        .....
        ......
        ......
        String staticPathPattern = this.mvcProperties.getStaticPathPattern();
        if (!registry.hasMappingForPattern(staticPathPattern)) {
            customizeResourceHandlerRegistration(
                registry.addResourceHandler(staticPathPattern)
                    .addResourceLocations(getResourceLocations(
                        this.resourceProperties.getStaticLocations()))
                    .setCachePeriod(getSeconds(cachePeriod))
                    .setCacheControl(cacheControl));
        }
    }

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 21][]  
**6.1.8) 使用webjar的方式修前端页面修改引用路径**

![20190404110833924.png][]

![20190404110854634.png][]

### **6.2)springboot是如何整合springmvc功能的（WebMvcAutoConfiguration）** ###

**6.2.1）自动装配的组件**  
**①**:ContentNegotiatingViewResolver 和 BeanNameViewResolver 视图解析器  
视图解析器的作用:根据方法的值找到对应的视图  
**②**:Support for serving static resources, including support for WebJars 支持静态资源和webJars  
**③**:Converter ,日期格式化器 Formatter  
**④**:消息装换器: HttpMessageConverters  
**⑤**:首页设置index.html  
**⑥**:图标支持 Favicon  
**6.2.2)如何扩展springmvc的配置（springboot提我们自己配置的springmvc的功能不丢失的情况  
下） 比如我需要使用自己定义的拦截器**  
我们需要自己写一个配置类 继承 WebMvcConfigurerAdapter 需要什么组件 就注册什么组件  
**A:如何往容器中添加一个拦截器**  
**第一步:创建一个拦截器**

@Component
    public class TulingInterceptor implements HandlerInterceptor {
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)throws Exception {
            System.out.println("我是TulingInterceptor的preHandle方法");
            return true;
        }
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable ModelAndView modelAndView) throws Exception {
            System.out.println("我是TulingInterceptor的postHandle方法");
        }
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,@Nullable Exception ex) throws Exception {
            System.out.println("我是TulingInterceptor的afterCompletion方法");
        }
    }

**第二步:注册拦截器**

@Configuration
    public class TulingConfig extends WebMvcConfigurerAdapter {
        @Autowired
        private TulingInterceptor tulingInterceptor;
    
        /**
        * 注册拦截器
        * @param registry
        */
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(tulingInterceptor).addPathPatterns("/**").excludePathPatterns("/index.html","/");
        }
    }

**B:往容器中增加一个过滤器**

public class TulingFilter implements Filter {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
        
        }
        
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("TulingFilter的doFilter方法");
            filterChain.doFilter(servletRequest,servletResponse);
        }
        
        @Override
        public void destroy() {
    
        }
    }

/**
    * 注册一个filter
    * @return
    */
    @Bean
    public FilterRegistrationBean tulingFilter(){
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new TulingFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        return filterRegistrationBean;
    }

**C:往容器中增加一个servlet**

public class TulingServlet extends HttpServlet {
    
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.getWriter().write("hello......");
        }
    
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }
    }

## **7）如何全面接管springboot的mvc配置(让springboot给我们自动配置的功能失效,自己像如   何整合ssm一样的整合springmvc,不推荐)** ##

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

![20190404112343281.png][]  
大概意思说，在配置文件中使用一个@EnableWebMvc来标识到配置类上,就会导致配置失效 why?为什么会失  
效?????????????????  
原理: @EnableWebMvc 为容器中导入了DelegatingWebMvcConfiguration的组件

@Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @Documented
    @Import(DelegatingWebMvcConfiguration.class)
    public @interface EnableWebMvc {
    }

1)我们来分析一下DelegatingWebMvcConfiguration是一个什么东西？？？？？  
我们发现DelegatingWebMvcConfiguration是WebMvcConfiurationSupport（只保证了springmvc的基本功能）类  
型的

@Configuration
    public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport

2)我们来看下WebMvcAutoConfiguration上的注解

@Configuration
    @ConditionalOnWebApplication(type = Type.SERVLET)
    @ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
    
    //容器中 没有WebMvcConfigurationSupport 该配置文件才生生效,但是我们使用了 @EnableWebMvc 导入了WebMvcConfiurationSupport的配置,所以导致该配置类失效，
    //只保存了springmvc的最基本的功能
    @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
    @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
    @AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
    ValidationAutoConfiguration.class })
    public class WebMvcAutoConfiguration

3)我们的webJar 欢迎页 等全部失效

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 22][]

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 23][]   **8)springboot错误处理机制?如何定制错误页面？** ##

案例:浏览器模拟发送的错误请求 http://localhost:8080/aaaaaaaaaaaaaa

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 24][]  
案例2:通过postman 或者restlet 发送的请求 http://localhost:8080/testTuling/dddd

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 25][]  
我们可以看出 不同的终端发送的请求 会返回不同的错误异常类容 是根据什么原理？  
原理: 是根据不同客户端发送的请求的请求头来区分是 返回页面还是json数据

![20190404113038970.png][]

### ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 26][]   **8.1）我们来看springboot为我们自动配置的异常处理的一些bean** ###

org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration

@Bean
    @ConditionalOnMissingBean(value = ErrorAttributes.class, search = SearchStrategy.CURRENT)
    public DefaultErrorAttributes errorAttributes() {
        return new DefaultErrorAttributes(this.serverProperties.getError().isIncludeException());
    }
    @Bean
    @ConditionalOnMissingBean(value = ErrorController.class, search = SearchStrategy.CURRENT)
    public BasicErrorController basicErrorController(ErrorAttributes errorAttributes) {
        return new BasicErrorController(errorAttributes, this.serverProperties.getError(),this.errorViewResolvers);
    }
    @Bean
    public ErrorPageCustomizer errorPageCustomizer() {
        return new ErrorPageCustomizer(this.serverProperties, this.dispatcherServletPath);
    }
    @Bean
    @ConditionalOnBean(DispatcherServlet.class)
    @ConditionalOnMissingBean
    public DefaultErrorViewResolver conventionErrorViewResolver() {
        return new DefaultErrorViewResolver(this.applicationContext,this.resourceProperties);
    }
    
    @Configuration
    @ConditionalOnProperty(prefix = "server.error.whitelabel", name = "enabled", matchIfMissing = true)
    @Conditional(ErrorTemplateMissingCondition.class)
    protected static class WhitelabelErrorViewConfiguration {
        private final SpelView defaultErrorView = new SpelView(
            "<html><body><h1>Whitelabel Error Page</h1>"
                + "<p>This application has no explicit mapping for /error, so you are seeing this as a fallback.</p>"
                + "<div id='created'>${timestamp}</div>"
                + "<div>There was an unexpected error (type=${error}, status=${status}).</div>"
                + "<div>${message}</div></body></html>");
    @Bean(name = "error")
    @ConditionalOnMissingBean(name = "error")
    public View defaultErrorView() {
        return this.defaultErrorView;
    }

我们具体来分析上诉源代码的组件  
A:  
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration.ErrorPageCustomizer（错  
误页面定制器）  
作用：系统出现错误以后来到/error请求进行处理；

/**
    * Path of the error controller.
    */
    @Value("${error.path:/error}")
    private String path = "/error";

那么当我们 发生错误，需要/error 的请求映射来请求 接下来就会引出另外一个组件 来处理/error请求  
B：org.springframework.boot.autoconfigure.web.servlet.error.BasicErrorController （基础错误控制器）

@Controller
    @RequestMapping("${server.error.path:${error.path:/error}}")
    public class BasicErrorController extends AbstractErrorController {
    
        //处理浏览器页面异常
        @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) ? modelAndView : new ModelAndView("error", model);
        }
    
        //处理postman 请求的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<>(body, status);
        }
    }

B1:我们来看下浏览器的响应过程怎么来处理请求异常信息的？

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) ? modelAndView : new ModelAndView("error", model);
    }
    
    protected ModelAndView resolveErrorView(HttpServletRequest request,HttpServletResponse response, HttpStatus status, Map<String, Object> model) {
        //获取容器中的所有错误视图解析器 DefaultErrorViewResolver
        for (ErrorViewResolver resolver : this.errorViewResolvers) {
            ModelAndView modelAndView = resolver.resolveErrorView(request, status, model);
            if (modelAndView != null) {
                return modelAndView;
            }
        }
        return null;
    }

B2:我们接着分析  
org.springframework.boot.autoconfigure.web.servlet.error.DefaultErrorViewResolver\#DefaultErrorViewResolver  
错误视图解析器

@Override
    public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status,Map<String, Object> model) {
        //解析视图
        ModelAndView modelAndView = resolve(String.valueOf(status), model);
    
        //没有对应的解析精确匹配的状态码 使用模糊匹配比如4XX 5XX
        if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
            //返回4XX 5XX的页面
            modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
        }
        return modelAndView;
    }
    
    private ModelAndView resolve(String viewName, Map<String, Object> model) {
        // error/404
        String errorViewName = "error/" + viewName;
        //视图是否有模版引擎解析
        TemplateAvailabilityProvider provider = this.templateAvailabilityProviders.getProvider(errorViewName, this.applicationContext);
        //有模版引擎解析直接返回
        if (provider != null) {
            return new ModelAndView(errorViewName, model);
        }
        //静态html的页面解析
        return resolveResource(errorViewName, model);
    }
    
    private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
        for (String location : this.resourceProperties.getStaticLocations()) {
            try {
                //在static模版下需要创建一个error/404.html
                Resource resource = this.applicationContext.getResource(location);
                resource = resource.createRelative(viewName + ".html");
                //存在该页面 直接返回
                if (resource.exists()) {
                    return new ModelAndView(new HtmlResourceView(resource), model);
                }
            }
            catch (Exception ex) {
            }
        }
        return null;
    }

浏览器模拟发送异常请求的流程 视图解析过程  
org.springframework.boot.autoconfigure.web.servlet.error.AbstractErrorController\#resolveErrorView  
开始解析视图，获取所有的异常错误视图解析器  
>org.springframework.boot.autoconfigure.web.servlet.error.DefaultErrorViewResolver\#resolveErrorView  
默认错误视图解析器解析视图  
>org.springframework.boot.autoconfigure.web.servlet.error.DefaultErrorViewResolver\#resolve  
响应码精准匹配视图  
1)判断模版引擎是否能够处理错误视图,能处理就处理，不能处理交给静态页面解析处理  
>org.springframework.boot.autoconfigure.web.servlet.error.DefaultErrorViewResolver\#resolveResource  
html资源视图  
>若不能精准匹配，那么就进行4XX 5XX模糊匹配  
>若不能精准匹配(error/状态码.html)的错误页面，也没有（error/状态码开头xx.html错误页面那  
就使用默认的错误空白页面）

private final SpelView defaultErrorView = new SpelView(
        "<html><body><h1>Whitelabel Error Page</h1>"
            + "<p>This application has no explicit mapping for /error, so you are seeing this as a fallback.</p>"
            + "<div id='created'>${timestamp}</div>"
            + "<div>There was an unexpected error (type=${error}, status=${status}).</div>"
            + "<div>${message}</div></body></html>");
    @Bean(name = "error")
    @ConditionalOnMissingBean(name = "error")
    public View defaultErrorView() {
        return this.defaultErrorView;
    }

我们怎么包含一个自己的错误异常信息的 自适应的效果  
浏览器效果:(需要返回自己定义的错误页面 包含了自定义的错误异常信息)

![20190404114848752.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 27][]

其他客户端的效果:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 28][]

第一步:我们定义一个全局异常处理器，然后返回看执行效果

@ControllerAdvice
    public class TulingExceptionHanlder {
    
        /**
        * 浏览器和其他客户端都返回了json 数组，不满足自适应
        * @param e
        * @param request
        * @return
        */
        @ExceptionHandler(value= TulingException.class)
        @ResponseBody
        public Map<String,Object> dealException(TulingException e, HttpServletRequest request){
            Map<String,Object> retInfo = new HashMap<>();
            retInfo.put("code",e.getCode());
            retInfo.put("msg",e.getMsg());
            return retInfo;
        }
    }

效果: 浏览器不满足 自适应效果返回的是一个json字符串,而不是一个页面

![20190404115107989.png][]

其他客户端满足要求，返回自己定义的错误异常信息

![20190404115157312.png][]

第二步:在异常处理器中 进行重定向  
根据第一步的效果来看 浏览器不能满足自适应效果 ,那么我们看下BasicErrorController的类

@Controller
    @RequestMapping("${server.error.path:${error.path:/error}}")
    public class BasicErrorController extends AbstractErrorController

他处理的请求是/error的请求，那么我们就想到 在全局异常处理器进行重定向

@ControllerAdvice
    public class TulingExceptionHanlder {
    
        @ExceptionHandler(value= TulingException.class)
        public String dealException(TulingException e, HttpServletRequest request){
            Map<String,Object> retInfo = new HashMap<>();
            retInfo.put("code",e.getCode());
            retInfo.put("msg",e.getMsg());
            //重定向，把请求转发到BasicErrorController来处理 /error
            return "forward:/error";
        }

执行效果:

![20190404115531471.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 29][]

分析过程  
①:根据上述执行效果我们发现 进行转发后 他的http状态码变为200 那么错误异常处理就不能进行正常  
流程的处理  
②:那么我们需要分析 错误异常处理器 看下是如何获取异常状态码的.  
org.springframework.boot.autoconfigure.web.servlet.error.AbstractErrorController\#getStatus  
很明显，BasicErrorController 的getStatus的过程中，都是从request中获取  
javax.servlet.error.status\_code属性

protected HttpStatus getStatus(HttpServletRequest request) {
        Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
        if (statusCode == null) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        try {
            return HttpStatus.valueOf(statusCode);
        }
        catch (Exception ex) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
    }

那么我们需要在我们的全局异常处理器中request中设置该属性

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 30][]

页面返回的属性字段是在哪里配置的？？？

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 31][]

那我们来着重分析一下  
org.springframework.boot.web.servlet.error.DefaultErrorAttributes\#getErrorAttributes

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 32][]

疑问:我们来看下这个类的自动装配原理,发现容器中有ErrorAttributes主键，那么就不进行自动装配,我  
们可以来自己写一个类来继承他

![20190404115931403.png][]

@Component
    public class TulingErrorAttribute extends DefaultErrorAttributes {
    
        public Map<String, Object> getErrorAttributes(WebRequest webRequest, boolean includeStackTrace) {
            //获取父类的封装字段结果
            Map<String, Object> retInfo = super.getErrorAttributes(webRequest,includeStackTrace);
            //获取全局异常自定义的结果
            Map<String,Object> ext = (Map<String, Object>) webRequest.getAttribute("ext",0);
            //封装自定义的错误信息
            retInfo.put("company","tuling");
            retInfo.put("ext",ext);
            return retInfo;
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70]: /images/20220224/7f0f9dd126cf44a28d2da6d022961726.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 1]: /images/20220224/1838290301ae44c9b005ca0598d23cd4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 2]: /images/20220224/377c01302a4e48bf82f8af707b45d436.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 3]: /images/20220224/5492225d885f4a94a80eacff7227fa0c.png
[20190422235334906.png]: /images/20220224/5043824d526742bf8f9e17c85e67c8b0.png
[20190403174109340.png]: /images/20220224/5c01d596eebb453d82f9987806c17f3e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 4]: /images/20220224/ca81a7f003ee44a59109af8d2d70f403.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 5]: /images/20220224/1ae33df3fd8740faa68dbdca7d3623a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 6]: /images/20220224/c66ed31bdc5641fb90f3b920b2f4a984.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 7]: /images/20220224/9a5bd84e0ee34735a1c3b001aadd132f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 8]: /images/20220224/e53f57846c474069a858e13311a06950.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 9]: /images/20220224/9caab4b4f71440298ae434abdcccd084.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 10]: /images/20220224/5b139b3bbec74eeaa7fec6165c35bc1e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 11]: /images/20220224/31d513efd0804de0831370a5dd2f8a06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 12]: /images/20220224/d06164c5b3c542979f54ff3df4c7fd15.png
[20190403175857597.png]: /images/20220224/374756da2a994e2ca17b5a6a61f184e8.png
[20190427191324456.png]: /images/20220224/c83664563c104a3a8664a8b9ba38f5af.png
[20190403175936645.png]: /images/20220224/160aa0cb29264e3296fcaabbacd5db7f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 13]: /images/20220224/9b56ac9207414df6b1ac2e6043dc7527.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 14]: /images/20220224/08c7caf516e949418bc4573fcd2bc00a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 15]: /images/20220224/1f5b34ef4362418c982df8689c06a584.png
[20190403180617301.png]: /images/20220224/8b93fd82919346dd9f834c88976f702a.png
[https_www.webjars.org]: https://www.webjars.org/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 16]: /images/20220224/714833908f404634909750d230c69722.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 17]: /images/20220224/b17df9de176247cd842107c4ab73cca1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 18]: /images/20220224/bff91c321716493a82dff97c0277af45.png
[http_localhost_8080_webjars_jquery_3.3.1-2_jquery.js]: http://localhost:8080/webjars/jquery/3.3.1-2/jquery.js
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 19]: /images/20220224/ba731f86c37e48218cacfbcdf443312b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 20]: /images/20220224/2d351783967641eab105d643ec65a7ed.png
[20190404110344577.png]: /images/20220224/efb24092ae06443ebeb35750ff835354.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 21]: /images/20220224/4649faadfd3e4d2496c69c13bf93dbc8.png
[20190404110833924.png]: /images/20220224/db3c8d5f8b3a44e8969e047fa709d7a1.png
[20190404110854634.png]: /images/20220224/f9237699ed194c82b7c0da8b96472f22.png
[20190404112343281.png]: /images/20220224/529e5d8470bd401a90652dadb5787047.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 22]: /images/20220224/92782e864889412386d9f169e56c1731.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 23]: /images/20220224/bc4b938eb03e4cb2b62e95d4480b6303.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 24]: /images/20220224/f5c91b79852245e2a4631d95f4a92fdd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 25]: /images/20220224/d2beb615605a45ce8859c1c5a0a2a8d0.png
[20190404113038970.png]: /images/20220224/7ed82c2ae8be446ba2a575b118617f37.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 26]: /images/20220224/92e38044d4784e35a6ca90edf426a8e5.png
[20190404114848752.png]: /images/20220224/c04cd9dc617c402d8672c3e9b5d77c80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 27]: /images/20220224/f3a1ccae0aa44e2f84b3887afe6c1530.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 28]: /images/20220224/9777cf83631f41129bb5bb9b1795af50.png
[20190404115107989.png]: /images/20220224/1032504909c34d0490896e5102ddd893.png
[20190404115157312.png]: /images/20220224/e9a75d5d03cf4281bc631e392f181999.png
[20190404115531471.png]: /images/20220224/c353af5dbbec4e14857f152f465c5ec8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 29]: /images/20220224/8739533dbfe24ab5b3c0579eb2f82743.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 30]: /images/20220224/037ddd5328e242cfafff91e406cd8e7e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 31]: /images/20220224/d66652b7c10646c6a5e2005974fd718a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2l0d3htaW5n_size_16_color_FFFFFF_t_70 32]: /images/20220224/3762e708b1bb40f8952fdded18044567.png
[20190404115931403.png]: /images/20220224/15c866b1c5ab43f5a0a6a4d5b8887a67.png