[Java知识库]SpringBoot自学笔记

显示在配置和自动配置类上评估的条件，以及它们匹配或不匹配的原因。 基础入门

环境：

java 8+ ：https://www.oracle.com/cn/java/technologies/javase/javase-jdk8-downloads.html

Maven 3.5+ ：http://maven.apache.org/download.cgi

学习文档：

尚硅谷SpringBoot2：https://www.yuque.com/atguigu/springboot/rmxq85

Maven配置

<mirrors>
      <mirror>
        <id>nexus-aliyun</id>
        <mirrorOf>central</mirrorOf>
        <name>Nexus aliyun</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public</url>
      </mirror>
</mirrors>
 
<profiles>
    <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>
</profiles>

SpringBoot HelloWorld

1、创建maven工程

2、引入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

3、创建主程序

/**
 * 主程序类
 * @SpringBootApplication：这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class,args);
    }
}

4、编写业务

@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(){
        return "Hello, Spring Boot 2!";
    }
}

5、直接运行main方法，访问http://localhost:8080/hello

自动配置原理

依赖管理

<!--依赖管理-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

<!--父项目-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.4.RELEASE</version>
</parent>

几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制,如下图所示

• 开发导入starter场景启动器

1、见到很多 spring-boot-starter-* ： *就某种场景
2、只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景
https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4、见到的  *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

• 无需关注版本号，自动版本仲裁

  • 引入依赖默认都可以不写版本
  • 引入非版本仲裁的jar，要写版本号。

• 可以修改默认版本号

  • 查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
  • 在当前项目里面重写配置

  <properties>        
      <mysql.version>5.1.43</mysql.version>    
  </properties>
  

  最基本的依赖入口spring-boot-starter-*(web)

自动配置

• 自动配好Tomcat

  • 引入Tomcat依赖。
  • 配置Tomcat

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.3.4.RELEASE</version>
      <scope>compile</scope>
  </dependency>
  

• 自动配好SpringMVC

  • 引入SpringMVC全套组件
  • 自动配好SpringMVC常用组件（功能）

• 自动配好Web常见功能，如：字符编码问题

• SpringBoot帮我们配置好了所有web开发的常见场景

• 默认的包结构

  • 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
  • 无需以前的包扫描配置
  • 想要改变扫描路径，@SpringBootApplication(scanBasePackages=“com.ramelon”)
    • 或者@ComponentScan 指定扫描路径

  @SpringBootApplication
  等同于
  @SpringBootConfiguration
  @EnableAutoConfiguration
  @ComponentScan("com.ramelon.boot")
  

• 各种配置拥有默认值

  • 默认配置最终都是映射到某个类上，如：MultipartProperties
  • 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象

• 按需加载所有自动配置项

  • 非常多的starter
  • 引入了哪些场景这个场景的自动配置才会开启
  • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

容器组件

@Configuration

表明一个类中声明一个和多个@Bean标记的方法，并且这些方法被Spring容器管理用于生成Bean定义以及在运行时这些Bean的服务请求。其实相当于原来的声明了多个bean的xml配置文件，而且被@Configuration也相当于一个组件。

/**
 * 1.配置类里面使用@Bean标注在方法上给容器注册组件，默认单例
 * 2.配置类本身也是组件
 * 3.proxyBeanMethods: 代理bean方法
 *  Full(proxyBeanMethods=true)
 *  Life(proxyBeanMethods=false)
 *  组件依赖必须使用Full默认模式，其他默认是否Lite模式
 *  4、@Import(User.class)
 *  给容器中自动创建出这两个类型的组件,默认组件名字就是全类目名
 *  5、@ConditionalOnBean 条件装配 有了这个bean才生效
 *  6、@ConditionalOnMissingBean  没有这个bean才生效
 *  7、@ImportResource("classpath:beans.xml") 导入spring配置文件
 */

@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) // 告诉SpringBoot这是一个配置类==配置文件
@ImportResource("classpath:beans.xml")
// 1.配置绑定功能 2.把指定组件注入到容器中
@EnableConfigurationProperties(Car.class)
public class MyConfig {


    @Bean // 给容器中添加组件。以方法名作为组件的id，返回类型就是组件类型。返回的值，就是组件在容器中的实例。
    public User user01(){
        return new User("Xiaoxi",11, Tomcat());
    }

    @Bean("tom")
    public Cat Tomcat(){
        return new Cat("tomcat");
    }
}

主程序类

/**
 * 主程序类
 * @SpringBootApplication 这是一个springboot应用
 */
@SpringBootApplication
//@SpringBootConfiguration
//@EnableAutoConfiguration
//@ComponentScan("com.ramelon.boot")
public class MainApplication {
    public static void main(String[] args) {
        // 1、返回IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        // 2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        // 3、从容器中获取组件 默认单例
        Cat tom = run.getBean("tom",Cat.class);
        User user01 = run.getBean("user01", User.class);

        System.out.println(tom);

        //4
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        // @Configuration(proxyBeanMethods == true)
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);

        // @Configuration(proxyBeanMethods == false)
        User user011 = run.getBean("user01", User.class);
        Cat tom1 = run.getBean("tom", Cat.class);

        System.out.println("用户的宠物" + (user.getCat()== tom1));

        //5 获取组件
        String[] beanNamesForType = run.getBeanNamesForType(User.class);
        System.out.println("=====");
        for (String s : beanNamesForType) {
            System.out.println(s);
        }

        DBHelper bean1 = run.getBean(DBHelper.class);
        System.out.println(bean1);

        boolean haha = run.containsBean("haha");
        boolean hehe = run.containsBean("hehe");
        System.out.println(haha);
        System.out.println(hehe);
    }
}

注意：@Configuration注解的配置类有如下要求：

1. @Configuration不可以是final类型；
2. @Configuration不可以是匿名类；
3. 嵌套的configuration必须是静态类。

一、用@Configuration加载spring
1.1、@Configuration配置spring并启动spring容器
1.2、@Configuration启动容器+@Bean注册Bean
1.3、@Configuration启动容器+@Component注册Bean
1.4、使用 AnnotationConfigApplicationContext 注册 AppContext 类的两种方法
1.5、配置Web应用程序(web.xml中配置AnnotationConfigApplicationContext)

二、组合多个配置类
2.1、在@configuration中引入spring的xml配置文件
2.2、在@configuration中引入其它注解配置
2.3、@configuration嵌套（嵌套的Configuration必须是静态类）
三、@EnableXXX注解
四、@Profile逻辑组配置
五、使用外部变量

@Bean、@Component、@Controller、@Service、@Repository

• @Bean：表示一个方法实例化、配置或者初始化一个Spring IoC容器管理的新对象。
• @Component: 自动被comonent扫描。 表示被注解的类会自动被component扫描
• @Repository: 用于持久层，主要是数据库存储库。
• @Service: 表示被注解的类是位于业务层的业务component。
• @Controller:表明被注解的类是控制component，主要用于展现层 。

@ComponentScan、@Import

@ComponentScan用于类或接口上主要是指定扫描路径，spring会把指定路径下带有指定注解的类自动装配到bean容器里。会被自动装配的注解包括@Controller、@Service、@Component、@Repository等等。
其作用等同于<context:component-scan base-package=“com.maple.learn” />配置

@Import给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名。

@ComponentScan("com.ramelon.boot")
@Import({User.class, DBHelper.class})

@Conditional

条件装配：满足Conditional指定的条件，则进行组件注入。 ctrl+h打开继承树。

=====================测试条件装配==========================
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
//@ConditionalOnBean(name = "tom")
@ConditionalOnMissingBean(name = "tom")
public class MyConfig {


    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */

    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom22")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        boolean tom = run.containsBean("tom");
        System.out.println("容器中Tom组件："+tom);

        boolean user01 = run.containsBean("user01");
        System.out.println("容器中user01组件："+user01);

        boolean tom22 = run.containsBean("tom22");
        System.out.println("容器中tom22组件："+tom22);	
}

原生配置文件引入

@ImportResource

@ImportResource注解用于导入Spring的配置文件，让配置文件里面的内容生效；(就是以前写的springmvc.xml、applicationContext.xml)
Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；
想让Spring的配置文件生效，加载进来；@ImportResource标注在一个配置类上。
注意！这个注解是放在主入口函数的类上，而不是测试类上

======================beans.xml=========================
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="haha" class="com.atguigu.boot.bean.User">
        <property name="name" value="zhangsan"></property>
        <property name="age" value="18"></property>
    </bean>

    <bean id="hehe" class="com.atguigu.boot.bean.Pet">
        <property name="name" value="tomcat"></property>
    </bean>
</beans>

@ImportResource("classpath:beans.xml")
public class MyConfig {}

======================测试=================
        boolean haha = run.containsBean("haha");
        boolean hehe = run.containsBean("hehe");
        System.out.println("haha："+haha);//true
        System.out.println("hehe："+hehe);//true

配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用；

原生写法：

public class getProperties {
     public static void main(String[] args) throws FileNotFoundException, IOException {
         Properties pps = new Properties();
         pps.load(new FileInputStream("a.properties"));
         Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
         while(enum1.hasMoreElements()) {
             String strKey = (String) enum1.nextElement();
             String strValue = pps.getProperty(strKey);
             System.out.println(strKey + "=" + strValue);
             //封装到JavaBean。
         }
     }
 }

@Component + @ConfigurationProperties

/**
 * 只有在容器中的组件，才会拥有SpringBoot提供的强大功能
 */
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {

    private String brand;
    private Integer price;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

application.properties

mycar.brand=BYD
mycar.price=100000

controller

@Autowired
Car car;

@RequestMapping("/car")
public Car car(){
    return car;
}

{"brand":"BYD","price":100000}

@EnableConfigurationProperties + @ConfigurationProperties

@ConfigurationProperties(prefix = "mycar")
public class Car {}


// 1.配置绑定功能 2.把指定组件注入到容器中
@EnableConfigurationProperties(Car.class)
public class MyConfig {}

自动配置原理

引导加载自动配置类

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {}

@SpringBootConfiguration 标注当前类是配置类。

@ComponentScan 指定扫描哪些类。

@EnableAutoConfiguration

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

@AutoConfigurationPackage

// 给容器中导入组件
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {}
//利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来？MainApplication 所在包下。

@Import(AutoConfigurationImportSelector.class)

1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
2、调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
3、利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
4、从META-INF/spring.factories位置来加载一个文件。
  默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
    spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

1、

2、

3、

4、

按需开启自动配置项

虽然我们130个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration 按照条件装配规则（@Conditional），最终会按需配置。

@ConditionalOnClass()

就是说只有在classpath下能找到Advice类才会构建这个bean。下面代码才会生效，否则不生效。

@ConditionalOnMissingClass

bean加载，发现有需求class，优先从已加载里面找，没有就自己找class，找不到class就加载bean。

修改默认配置

@Bean
@ConditionalOnBean(MultipartResolver.class)  //容器中有这个类型组件
@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) //容器中没有这个名字 multipartResolver 的组件
public MultipartResolver multipartResolver(MultipartResolver resolver) {
    //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
    //SpringMVC multipartResolver。防止有些用户配置的文件上传解析器不符合规范
    // Detect if the user has created a MultipartResolver but named it incorrectly
    return resolver;
}
给容器中加入了文件上传解析器；

SpringBoot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先。

@Bean
@ConditionalOnMissingBean
public CharacterEncodingFilter characterEncodingFilter() {
}

总结：

• SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration

• 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定

• 生效的配置类就会给容器中装配很多组件

• 只要容器中有这些组件，相当于这些功能就有了

• 定制化配置

  • 用户直接自己@Bean替换底层的组件

  • 用户去看这个组件是获取的配置文件什么值就去修改。

    server.servlet.encoding.charset=GBK

xxxxxAutoConfiguration —> 组件 —> xxxxProperties里面拿值 ----> application.properties

Lombok简化开发

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {

    private String userName;
    private Boolean boss;
    private Date birth;
    private Integer age;
    private Pet pet;
    private String[] interests;
    private List<String> animal;
    private Map<String, Object> score;
    private Set<Double> salarys;
    private Map<String, List<Pet>>allPets;
}

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

dev-tools

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <optional>true</optional>
</dependency>

JRebel

https://www.jianshu.com/p/704b1164a1c1

Spring Initailizr

https://www.cnblogs.com/libingbin/p/10557739.html

核心功能

配置文件

properties文件

后缀properties是一种属性文件。这种文件以key=value格式存储内容。

yml文件

YAML 是 “YAML Ain’t Markup Language”（YAML 不是一种标记语言）的递归缩写。在开发的这种语言时，YAML 的意思其实是：“Yet Another Markup Language”（仍是一种标记语言）。

@ConfigurationProperties(prefix = "person")
@Component
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    private String userName;
    private Boolean boss;
    private Date birth;
    private Integer age;
    private Pet pet;
    private String[] interests;
    private List<String> animal;
    private Map<String, Object> score;
    private Set<Double> salarys;
    private Map<String, List<Pet>>allPets;
}

person:
  boss: true
  birth: 2019/12/9
  age: 18
#  interests: [篮球,足球]
  interests:
   - 篮球
   - 足球
  animal: [狸猫,小白]
#  score: {english:80,math:90}
  score:
   english: 80
   math: 90
  salarys:
   - 9999.88
   - 999.999
  pet:
   name: 小华
   weight: 99.99
  allPets:
   sick:
    - {name: 小华,weight: 99.99}
    - name: 毛毛
      weight: 88.88
   health:
     - {name: 红红,weight: 99.99}
     - {name: 白白,weight: 99.99}
  user-name: zhangsan

语法

• key: value；kv之间有空格
• 大小写敏感
• 使用缩进表示层级关系
• 缩进不允许使用tab，只允许空格
• 缩进的空格数不重要，只要相同层级的元素左对齐即可
• '#'表示注释
• 字符串无需加引号，如果要加，’'与""表示字符串内容 会被 转义/不转义

配置提示

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

 <build>
     <plugins>
         <plugin>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-maven-plugin</artifactId>
             <configuration>
                 <excludes>
                     <exclude>
                         <groupId>org.springframework.boot</groupId>
                         <artifactId>spring-boot-configuration-processor</artifactId>
                     </exclude>
                 </excludes>
             </configuration>
         </plugin>
     </plugins>
</build>

Web开发

简单功能分析

静态资源访问

静态资源目录：

只要静态资源放在类路径下： called /static (or /public or /resources or /META-INF/resources
访问 ： 当前项目根路径/ + 静态资源名

原理： 静态映射/**。
请求进来，先去找Controller看能不能处理。不能处理的所有请求又都交给静态资源处理器。静态资源也找不到则响应404页面。

spring:
  mvc:
    static-path-pattern: /res/**

  resources:
    static-locations: "classpath:/haha/"

静态资源访问前缀

spring:
  mvc:
    static-path-pattern: /res/**

当前项目 + static-path-pattern + 静态资源名 = 静态资源文件夹下找

webjars

自动映射 /webjars/**
https://www.webjars.org/

<dependency>
    <groupId>org.webjars</groupId>
    <artifactId>jquery</artifactId>
    <version>3.5.1</version>
</dependency>

访问地址：http://localhost:8080/webjars/jquery/3.5.1/jquery.js 后面地址要按照依赖里面的包路径

欢迎页支持

• 静态资源路径下 index.html
  • 可以配置静态资源路径
  • 但是不可以配置静态资源的访问前缀。否则导致 index.html不能被默认访问

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致welcome page功能失效

  resources:
    static-locations: [classpath:/haha/]

自定义 Favicon

favicon.ico 放在静态资源目录下即可。

spring:
#  mvc:
#    static-path-pattern: /res/**   这个会导致 Favicon 功能失效

静态资源配置原理

• SpringBoot启动默认加载 xxxAutoConfiguration 类（自动配置类）.
• SpringMVC功能的自动配置类 WebMvcAutoConfiguration，生效.

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class, TaskExecutionAutoConfiguration.class,
		ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
}

• 给容器中配了什么。

@Configuration(proxyBeanMethods = false)
@Import(EnableWebMvcConfiguration.class)
@EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
@Order(0)
public static class WebMvcAutoConfigurationAdapter implements WebMvcConfigurer {
}

• 配置文件的相关属性和xxx进行了绑定。WebMvcProperties==spring.mvc、ResourceProperties==spring.resource

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {}
@ConfigurationProperties(prefix = "spring.mvc")
public class WebMvcProperties {}

配置类只有一个有参构造器

//有参构造器所有参数的值都会从容器中确定
//ResourceProperties resourceProperties；获取和spring.resources绑定的所有的值的对象
//WebMvcProperties mvcProperties 获取和spring.mvc绑定的所有的值的对象
//ListableBeanFactory beanFactory Spring的beanFactory
//HttpMessageConverters 找到所有的HttpMessageConverters
//ResourceHandlerRegistrationCustomizer 找到 资源处理器的自定义器。=========
//DispatcherServletPath  
//ServletRegistrationBean   给应用注册Servlet、Filter....

public WebMvcAutoConfigurationAdapter(ResourceProperties resourceProperties, WebMvcProperties mvcProperties,
				ListableBeanFactory beanFactory, ObjectProvider<HttpMessageConverters> messageConvertersProvider,
				ObjectProvider<ResourceHandlerRegistrationCustomizer> resourceHandlerRegistrationCustomizerProvider,
				ObjectProvider<DispatcherServletPath> dispatcherServletPath,
				ObjectProvider<ServletRegistrationBean<?>> servletRegistrations) {
			this.resourceProperties = resourceProperties;
			this.mvcProperties = mvcProperties;
			this.beanFactory = beanFactory;
			this.messageConvertersProvider = messageConvertersProvider;
			this.resourceHandlerRegistrationCustomizer = resourceHandlerRegistrationCustomizerProvider.getIfAvailable();
			this.dispatcherServletPath = dispatcherServletPath;
			this.servletRegistrations = servletRegistrations;
		}

资源处理的默认规则

@Override
public void addResourceHandlers(ResourceHandlerRegistry registry) {
    if (!this.resourceProperties.isAddMappings()) {
        logger.debug("Default resource handling disabled");
        return;
    }
    addResourceHandler(registry, "/webjars/**", "classpath:/META-INF/resources/webjars/");
    addResourceHandler(registry, this.mvcProperties.getStaticPathPattern(),
                       this.resourceProperties.getStaticLocations());
}

spring:
  resources:
    add-mappings: false   禁用所有静态资源规则

默认CLASSPATH_RESOURCE_LOCATIONS

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties {

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

	/**
	 * Locations of static resources. Defaults to classpath:[/META-INF/resources/,
	 * /resources/, /static/, /public/].
	 */
	private String[] staticLocations = CLASSPATH_RESOURCE_LOCATIONS;
}

欢迎页的处理规则

// HandlerMapping：处理器映射。保存了每一个Handler能处理哪些请求。
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));
    welcomePageHandlerMapping.setCorsConfigurations(getCorsConfigurations());
    return welcomePageHandlerMapping;
}

	WelcomePageHandlerMapping(TemplateAvailabilityProviders templateAvailabilityProviders,
			ApplicationContext applicationContext, Resource welcomePage, String staticPathPattern) {
		if (welcomePage != null && "/**".equals(staticPathPattern)) {
            //要用欢迎页功能，必须是/**
			logger.info("Adding welcome page: " + welcomePage);
			setRootViewName("forward:index.html");
		}
		else if (welcomeTemplateExists(templateAvailabilityProviders, applicationContext)) {
			logger.info("Adding welcome page template: index");
			setRootViewName("index");
		}
	}

请求参数处理

请求映射

rest使用与原理

@RequestMapping(value = "/user",method = RequestMethod.GET)
public String getUser(){
    return "GET-张三";
}

@RequestMapping(value = "/user",method = RequestMethod.POST)
public String saveUser(){
    return "POST-张三";
}


@RequestMapping(value = "/user",method = RequestMethod.PUT)
public String putUser(){
    return "PUT-张三";
}

@RequestMapping(value = "/user",method = RequestMethod.DELETE)
public String deleteUser(){
    return "DELETE-张三";
}

@Bean
@ConditionalOnMissingBean(HiddenHttpMethodFilter.class)
@ConditionalOnProperty(prefix = "spring.mvc.hiddenmethod.filter", name = "enabled", matchIfMissing = false)
public OrderedHiddenHttpMethodFilter hiddenHttpMethodFilter() {
    return new OrderedHiddenHttpMethodFilter();
}

/** Default method parameter: {@code _method}. */
public static final String DEFAULT_METHOD_PARAM = "_method";

// 自定义filter
@Bean
public HiddenHttpMethodFilter hiddenHttpMethodFilter(){
    HiddenHttpMethodFilter methodFilter = new HiddenHttpMethodFilter();
    methodFilter.setMethodParam("_m");
    return methodFilter;
}

<form action="/user" method="get">
    <input value="REST-GET提交" type="submit" />
</form>

<form action="/user" method="post">
    <input value="REST-POST提交" type="submit" />
</form>

<form action="/user" method="post">
    <input name="_method" type="hidden" value="DELETE"/>
    <input value="REST-DELETE 提交" type="submit"/>
</form>

<form action="/user" method="post">
    <input name="_method" type="hidden" value="PUT"/>
    <input value="REST-PUT提交" type="submit"/>
</form>

Rest原理（表单提交要使用REST的时候）

• 表单提交会带上**_method=PUT**

• 请求过来被HiddenHttpMethodFilter拦截

• 请求是否正常，并且是POST

• 获取到**_method**的值。

• 兼容以下请求；PUT.DELETE.PATCH

• 原生request（post），包装模式requesWrapper重写了getMethod方法，返回的是传入的值。

• 过滤器链放行的时候用wrapper。以后的方法调用getMethod是调用****requesWrapper的。

Rest使用客户端工具

• 如PostMan直接发送Put、delete等方式请求，无需Filter。

spring:
  mvc:
    hiddenmethod:
      filter:
        enabled: true  # springboot rest风格需要手动开启

@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
    throws ServletException, IOException {

    HttpServletRequest requestToUse = request;

    if ("POST".equals(request.getMethod()) && request.getAttribute(WebUtils.ERROR_EXCEPTION_ATTRIBUTE) == null) {
        String paramValue = request.getParameter(this.methodParam);
        if (StringUtils.hasLength(paramValue)) {
            String method = paramValue.toUpperCase(Locale.ENGLISH);
            if (ALLOWED_METHODS.contains(method)) {
                requestToUse = new HttpMethodRequestWrapper(request, method);
            }
        }
    }

    filterChain.doFilter(requestToUse, response);
}

允许的请求

private static final List<String> ALLOWED_METHODS =
    Collections.unmodifiableList(Arrays.asList(HttpMethod.PUT.name(),
                                               HttpMethod.DELETE.name(), HttpMethod.PATCH.name()));

请求映射原理

SpringMVC功能分析都从 org.springframework.web.servlet.DispatcherServlet-》doDispatch（）

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
    HandlerExecutionChain mappedHandler = null;
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        ModelAndView mv = null;
        Exception dispatchException = null;

        try {
            processedRequest = checkMultipart(request);
            multipartRequestParsed = (processedRequest != request);

            // Determine handler for the current request.
            // 找到当前请求使用哪个Handler（Controller的方法）处理
            mappedHandler = getHandler(processedRequest);
            
            
        }
    }
}


@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}

所有的请求映射都在HandlerMapping中。

• SpringBoot自动配置欢迎页的 WelcomePageHandlerMapping 。访问 /能访问到index.html；

• SpringBoot自动配置了默认 的 RequestMappingHandlerMapping

• 请求进来，挨个尝试所有的HandlerMapping看是否有请求信息。

• 如果有就找到这个请求对应的handler

• 如果没有就是下一个 HandlerMapping

• 我们需要一些自定义的映射处理，我们也可以自己给容器中放HandlerMapping。自定义 HandlerMapping

@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}

请求处理-常用参数注解使用

@PathVariable 路径变量
@RequestHeader 获取请求头
@RequestParam 获取请求参数
@CookieValue 获取Cookie值
@RequestBody 获取请求体[post]
@RequestAttribute 获取request域属性
@MatrixVariable 矩阵变量

@PathVariable

通过 @PathVariable 可以将URL中占位符参数{xxx}绑定到处理器类的方法形参中@PathVariable(“xxx“)

@GetMapping("car/{id}/owner/{username}")
@ResponseBody
public Map<String,Object> getCar(@PathVariable("id") Integer id,
                                 @PathVariable("username") String name,
                                 @PathVariable Map<String,String> pv){
	HashMap<String, Object> map = new HashMap<>();
	map.put("id",id);
	map.put("name",name);
	map.put("pv",pv);     
    return map;
}

http://localhost:8080/car/3/owner/李四
{pv: {id: "3",username: "李四"},name: "李四",id: 3}

@RequestHeader

用于将请求的头信息区数据映射到功能处理方法的参数上。

@GetMapping("/car")
@ResponseBody
public Map<String,Object> getCar(@RequestHeader("User-Agent") String userAgent,
                                 @RequestHeader Map<String,String> header){
	HashMap<String, Object> map = new HashMap<>();
    map.put("userAgent",userAgent);
    map.put("headers",header);    
    return map;
}


{
headers: {
host: "localhost:8080",
connection: "keep-alive",
sec-ch-ua: "" Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"",
sec-ch-ua-mobile: "?0",
upgrade-insecure-requests: "1",
user-agent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
sec-fetch-site: "same-origin",
sec-fetch-mode: "navigate",
sec-fetch-user: "?1",
sec-fetch-dest: "document",
referer: "http://localhost:8080/",
accept-encoding: "gzip, deflate, br",
accept-language: "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
cookie: ""
},
userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
}

@RequestParam

用于将请求参数区数据映射到功能处理方法的参数上。

@GetMapping("/user")
@ResponseBody
public Map<String,Object> getUser(@RequestParam("age") Integer age,
                                 @RequestParam("inters")List<String> inters,
                                 @RequestParam Map<String,Object> params,
                                 @RequestParam MultiValueMap<String,Object> mparams){
    map.put("age",age);
    map.put("inters",inters);
    map.put("params",params);
    map.put("mparams",mparams);
    return map;
}


/car/3/owner/李四?age=18&inters=basketball&inters=game
    
{"mparams":{"age":["18"],"inters":["basketball","game"]},"inters":["basketball","game"],"params":{"age":"18","inters":"basketball"},"age":18}

@CookieValue

用于将请求的Cookie数据映射到功能处理方法的参数上。

@GetMapping("/cookie")
@ResponseBody
public Map<String,Object> getCookie(@CookieValue("_xsrf") String _ga,
                                    @CookieValue("_xsrf") Cookie cookie){
	 HashMap<String, Object> map = new HashMap<>();
     map.put("_ga",_ga);
     map.put("cookie",cookie);
     return map;
}


{"cookie":{"name":"_xsrf","value":"2|ee9fb6d0|a77da24fe979f6979180a8e0bb273d39|1623077601","version":0,"comment":null,"domain":null,"maxAge":-1,"path":null,"secure":false,"httpOnly":false},"_ga":"2|ee9fb6d0|a77da24fe979f6979180a8e0bb273d39|1623077601"}

@RequestBody

@PostMapping("/save")
public Map PostMethod(@RequestBody String content){
    HashMap<String, Object> map = new HashMap<>();
    map.put("content",content);
    return map;
}

<form action="/save" method="post">
    测试 @RequestBody 获取数据
    用户名：<input name="userName"/>
    邮箱：<input name="email"/>
    <input type="submit" value="提交">
</form>
    
提交之后可以拿到userName的值和email的值。

@RequestAttribute

获取HTTP的请求（request）对象属性值，用来传递给控制器的参数。

@GetMapping("/goto")
public String goToPage(HttpServletRequest request){

    request.setAttribute("msg","success");
    request.setAttribute("code","200");
    return "forward:/success";
}

@ResponseBody
@GetMapping("/success")
public Map success(@RequestAttribute("msg") String msg,
                   @RequestAttribute("code") Integer code,
                   HttpServletRequest request){
    Object msg1 = request.getAttribute("msg");
    request.getAttribute("code");

    HashMap<String, Object> map = new HashMap<>();
    map.put("reqMethod_msg",msg1);
    map.put("annotation_msg",msg);
    return map;
}


访问goto页面；如果成功转发到success页面。
{
    reqMethod_msg: "success",
    annotation_msg: "success"
}

@MatrixVariable

矩阵变量需要在SpringBoot中手动开启
根据RFC3986的规范，矩阵变量应当绑定在路径变量中！
若是有多个矩阵变量，应当使用英文符号**;进行分隔。
若是一个矩阵变量有多个值，应当使用英文符号,**进行分隔，或之命名多个重复的key即可
如:/cars/sell;low=34;brand=byd,audi,yd

spring.mvc.hiddenmethod.filter.enabled=true

/cars/{path}?xxx=xxx&aaa=ccc queryString 查询字符串。@RequestParam;
/cars/{path;low=34;brand=byd,dudi,yd};矩阵变量
页面开发，cookie禁用了，session里面的内容怎么使用;
session.set(a,b)—>jssessionid—>cookie—>每次发请求携带。
uri重写:/abc;jssessionid=xxxx 把cookie的值使用矩阵变量的方式进行传递。

/boss/1;age=20/2;age=20
/boss/1;age=20/

<a href="/cars/sell;low=34;brand=byd,audi,yd">@MatrixVariable</a>
<a href="/cars/sell;low=34;brand=byd;brand=audi;brand=yd">@MatrixVariable</a>
<a href="/boss/1;age=20/2;age=10">@MatrixVariable</a>

// 1.语法 cars/sell;low=34;brand=byd,audi,yd
// 2.SpringBoot 默认是禁用了矩阵变量的功能
//  手动开启：原理。对于路径的处理。UriPathHelper进行解析。
// removeSemicolonContent(移除分号内容)支持矩阵变量的
@GetMapping("/cars/{path}")
public Map carsSell(@MatrixVariable("low") Integer low,
                    @MatrixVariable("brand") List<String> brand,
                    @PathVariable("path") String path){
    HashMap<String, Object> map = new HashMap<>();
    map.put("low",low);
    map.put("brand",brand);
    map.put("path",path);
    return map;
}

// /boss/1;age=20/2;age=10
@GetMapping("/boss/{bossId}/{empId}")
public Map Boss(@MatrixVariable(value = "age",pathVar = "bossId") Integer boosAge,
                @MatrixVariable(value = "age",pathVar = "empId")Integer empAge){
    HashMap<String, Object> map = new HashMap<>();

    map.put("bossAge",boosAge);
    map.put("empAge",empAge);
    return map;
}


1、{path: "sell",low: 34,brand: ["byd","audi","yd"]}
2、{"path":"sell","low":34,"brand":["byd","audi","yd"]}
3、{"bossAge":20,"empAge":10}

Servlet API

WebRequest、ServletRequest、MultipartRequest、 HttpSession、javax.servlet.http.PushBuilder、Principal、InputStream、Reader、HttpMethod、Locale、TimeZone、ZoneId

ServletRequestMethodArgumentResolver 以上的部分参数

@Override
public boolean supportsParameter(MethodParameter parameter) {
   Class<?> paramType = parameter.getParameterType();
   return (WebRequest.class.isAssignableFrom(paramType) ||
         ServletRequest.class.isAssignableFrom(paramType) ||
         MultipartRequest.class.isAssignableFrom(paramType) ||
         HttpSession.class.isAssignableFrom(paramType) ||
         (pushBuilder != null && pushBuilder.isAssignableFrom(paramType)) ||
         Principal.class.isAssignableFrom(paramType) ||
         InputStream.class.isAssignableFrom(paramType) ||
         Reader.class.isAssignableFrom(paramType) ||
         HttpMethod.class == paramType ||
         Locale.class == paramType ||
         TimeZone.class == paramType ||
         ZoneId.class == paramType);
}

复杂参数

Map、**Model（map、model里面的数据会被放在request的请求域 request.setAttribute）、**Errors/BindingResult、RedirectAttributes（ 重定向携带数据）、ServletResponse（response）、SessionStatus、UriComponentsBuilder、ServletUriComponentsBuilder

Map<String,Object> map,  Model model, HttpServletRequest request 都是可以给request域中放数据，request.getAttribute();

Map、Model类型的参数，会返回 mavContainer.getModel（）；—> BindingAwareModelMap 是Model 也是Map

mavContainer.getModel(); 获取到值的

自定义对象参数

可以自动类型转换与格式化，可以级联封装

/**
 *     姓名： <input name="userName"/> <br/>
 *     年龄： <input name="age"/> <br/>
 *     生日： <input name="birth"/> <br/>
 *     宠物姓名：<input name="pet.name"/><br/>
 *     宠物年龄：<input name="pet.age"/>
 */
@Data
public class Person {
    
    private String userName;
    private Integer age;
    private Date birth;
    private Pet pet;
    
}

@Data
public class Pet {

    private String name;
    private String age;

}

    <hr/>
    测试原生API
    <a href="testapi">测试原生API</a>
    <hr/>
    测试复杂类型：</hr>
    测试封装POJO：
    <form action="/saveuser" method="post">
        姓名：<input name="userName" value="zhangsan"><br/>
        年龄：<input name="age" value="18"><br/>
        生日：<input name="birth" value="2019/12/10"><br/>
        宠物姓名：<input name="pet.name" value="小花"><br/>
        宠物年龄：<input name="pet.age" value="5"><br/>
        <input type="submit" name="保存">
    </form>

POJO封装过程

• ServletModelAttributeMethodProcessor

参数处理原理

• HandlerMapping中找到能处理请求的Handler（Controller.method()）
• 为当前Handler 找一个适配器 HandlerAdapter； RequestMappingHandlerAdapter
• 适配器执行目标方法并确定方法参数的每一个值

1、handlerAdapters

0 - 支持方法上标注@RequestMapping
1 - 支持函数式编程的

2、执行目标方法

// Actually invoke the handler.
// DispatcherServlet -- doDispatch
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

// 执行目标方法
mav = invokeHandlerMethod(request, response, handlerMethod);

//ServletInvocableHandlerMethod
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
//获取方法的参数值
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);

3、参数解析器-HandlerMethodArgumentResolver

确定将要执行的目标方法的每一个参数的值是什么；

SpringMVC目标方法能写多少种参数类型。取决于参数解析器。

• 当前解析器是否支持解析这种参数
• 支持就调用 resolveArgument

4、返回值处理器

5、如何确定目标方法每一个参数的值

// InvocableHandlerMethod
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
                                           Object... providedArgs) throws Exception {

    MethodParameter[] parameters = getMethodParameters();
    if (ObjectUtils.isEmpty(parameters)) {
        return EMPTY_ARGS;
    }

    Object[] args = new Object[parameters.length];
    for (int i = 0; i < parameters.length; i++) {
        MethodParameter parameter = parameters[i];
        parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
        args[i] = findProvidedArgument(parameter, providedArgs);
        if (args[i] != null) {
            continue;
        }
        if (!this.resolvers.supportsParameter(parameter)) {
            throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
        }
        try {
            args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
        }
        catch (Exception ex) {
            // Leave stack trace for later, exception may actually be resolved and handled...
            if (logger.isDebugEnabled()) {
                String exMsg = ex.getMessage();
                if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
                    logger.debug(formatArgumentError(parameter, exMsg));
                }
            }
            throw ex;
        }
    }
    return args;
}

5.1、挨个判断所有参数解析器那个支持解析这个参数

// HandlerMethodArgumentResolverComposite
@Nullable
private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
    HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
    if (result == null) {
        for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
            if (resolver.supportsParameter(parameter)) {
                result = resolver;
                this.argumentResolverCache.put(parameter, result);
                break;
            }
        }
    }
    return result;
}

5.2、解析这个参数的值

调用各自 HandlerMethodArgumentResolver 的 resolveArgument 方法即可.

5.3、自定义类型参数封装POJO

ServletModelAttributeMethodProcessor 这个参数处理器支持

是否为简单类型。

public static boolean isSimpleValueType(Class<?> type) {
		return (Void.class != type && void.class != type &&
				(ClassUtils.isPrimitiveOrWrapper(type) ||
				Enum.class.isAssignableFrom(type) ||
				CharSequence.class.isAssignableFrom(type) ||
				Number.class.isAssignableFrom(type) ||
				Date.class.isAssignableFrom(type) ||
				Temporal.class.isAssignableFrom(type) ||
				URI.class == type ||
				URL.class == type ||
				Locale.class == type ||
				Class.class == type));
	}

@Override
@Nullable
public final Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
                                    NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

    Assert.state(mavContainer != null, "ModelAttributeMethodProcessor requires ModelAndViewContainer");
    Assert.state(binderFactory != null, "ModelAttributeMethodProcessor requires WebDataBinderFactory");

    String name = ModelFactory.getNameForParameter(parameter);
    ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
    if (ann != null) {
        mavContainer.setBinding(name, ann.binding());
    }

    Object attribute = null;
    BindingResult bindingResult = null;

    if (mavContainer.containsAttribute(name)) {
        attribute = mavContainer.getModel().get(name);
    }
    else {
        // Create attribute instance
        try {
            attribute = createAttribute(name, parameter, binderFactory, webRequest);
        }
        catch (BindException ex) {
            if (isBindExceptionRequired(parameter)) {
                // No BindingResult parameter -> fail with BindException
                throw ex;
            }
            // Otherwise, expose null/empty value and associated BindingResult
            if (parameter.getParameterType() == Optional.class) {
                attribute = Optional.empty();
            }
            bindingResult = ex.getBindingResult();
        }
    }

    if (bindingResult == null) {
        // Bean property binding and validation;
        // skipped in case of binding failure on construction.
        WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
        if (binder.getTarget() != null) {
            if (!mavContainer.isBindingDisabled(name)) {
                bindRequestParameters(binder, webRequest);
            }
            validateIfApplicable(binder, parameter);
            if (binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
                throw new BindException(binder.getBindingResult());
            }
        }
        // Value type adaptation, also covering java.util.Optional
        if (!parameter.getParameterType().isInstance(attribute)) {
            attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
        }
        bindingResult = binder.getBindingResult();
    }

    // Add resolved attribute and BindingResult at the end of the model
    Map<String, Object> bindingResultModel = bindingResult.getModel();
    mavContainer.removeAttributes(bindingResultModel);
    mavContainer.addAllAttributes(bindingResultModel);

    return attribute;
}

WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);

WebDataBinder :web数据绑定器，将请求参数的值绑定到指定的JavaBean里面

WebDataBinder 利用它里面的 Converters 将请求数据转成指定的数据类型。再次封装到JavaBean中

GenericConversionService：在设置每一个值的时候，找它里面的所有converter那个可以将这个数据类型（request带来参数的字符串）转换到指定的类型（JavaBean – Integer）

byte – > file

@FunctionalInterfacepublic interface Converter<S, T>

未来我们可以给WebDataBinder里面放自己的Converter；

private static final class StringToNumber<T extends Number> implements Converter<String, T>

自定义 Converter

//1、WebMvcConfigurer定制化SpringMVC的功能
@Bean
public WebMvcConfigurer webMvcConfigurer(){
    return new WebMvcConfigurer() {
        @Override
        public void configurePathMatch(PathMatchConfigurer configurer) {
            UrlPathHelper urlPathHelper = new UrlPathHelper();
            // 不移除；后面的内容。矩阵变量功能就可以生效
            urlPathHelper.setRemoveSemicolonContent(false);
            configurer.setUrlPathHelper(urlPathHelper);
        }

        @Override
        public void addFormatters(FormatterRegistry registry) {
            registry.addConverter(new Converter<String, Pet>() {

                @Override
                public Pet convert(String source) {
                    // 啊猫,3
                    if(!StringUtils.isEmpty(source)){
                        Pet pet = new Pet();
                        String[] split = source.split(",");
                        pet.setName(split[0]);
                        pet.setAge(Integer.parseInt(split[1]));
                        return pet;
                    }
                    return null;
                }
            });
        }
    };
}

6、目标方法执行完成时

将所有的数据都放在ModelAndViewContainer；包含要去的页面地址View。还包含Model数据。

7、处理派发结果

processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);

InternalResourceView：
@Override
	protected void renderMergedOutputModel(
			Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

		// Expose the model object as request attributes.
    	// 暴露模型作为请求域属性
		exposeModelAsRequestAttributes(model, request);

		// Expose helpers as request attributes, if any.
		exposeHelpers(request);

		// Determine the path for the request dispatcher.
		String dispatcherPath = prepareForRendering(request, response);

		// Obtain a RequestDispatcher for the target resource (typically a JSP).
		RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);
		if (rd == null) {
			throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
					"]: Check that the corresponding file exists within your web application archive!");
		}

		// If already included or response already committed, perform include, else forward.
		if (useInclude(request, response)) {
			response.setContentType(getContentType());
			if (logger.isDebugEnabled()) {
				logger.debug("Including [" + getUrl() + "]");
			}
			rd.include(request, response);
		}

		else {
			// Note: The forwarded resource is supposed to determine the content type itself.
			if (logger.isDebugEnabled()) {
				logger.debug("Forwarding to [" + getUrl() + "]");
			}
			rd.forward(request, response);
		}
	}

protected void exposeModelAsRequestAttributes(Map<String, Object> model,
			HttpServletRequest request) throws Exception {

    //model中的所有数据遍历挨个放在请求域中
		model.forEach((name, value) -> {
			if (value != null) {
				request.setAttribute(name, value);
			}
			else {
				request.removeAttribute(name);
			}
		});
	}

数据响应与内容协商

响应JSON

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--web场景自动引入了json场景-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-json</artifactId>
    <version>2.3.4.RELEASE</version>
    <scope>compile</scope>
</dependency>

返回值解析器

try {
			this.returnValueHandlers.handleReturnValue(
					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
		}



@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
                              ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

    HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
    if (handler == null) {
        throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
    }
    handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}



RequestResponseBodyMethodProcessor  	
@Override
	public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
			ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
			throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

		mavContainer.setRequestHandled(true);
		ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
		ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

		// Try even with null return value. ResponseBodyAdvice could get involved.
        // 使用消息转换器进行写出操作
		writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
	}

返回值解析原理

• 1、返回值处理器判断是否支持这种类型返回值 supportsReturnType

• 2、返回值处理器调用 handleReturnValue 进行处理

• 3、RequestResponseBodyMethodProcessor 可以处理返回值标了@ResponseBody 注解的。

  • \1. 利用 MessageConverters 进行处理 将数据写为json
    • 1、内容协商（浏览器默认会以请求头的方式告诉服务器他能接受什么样的内容类型）
    • 2、服务器最终根据自己自身的能力，决定服务器能生产出什么样内容类型的数据，
    • 3、SpringMVC会挨个遍历所有容器底层的 HttpMessageConverter ，看谁能处理？
      • 1、得到MappingJackson2HttpMessageConverter可以将对象写为json
      • 2、利用MappingJackson2HttpMessageConverter将对象转为json再写出去

SpringMVC到底支持哪些返回值

ModelAndView
Model
View
ResponseEntity 
ResponseBodyEmitter
StreamingResponseBody
HttpEntity
HttpHeaders
Callable
DeferredResult
ListenableFuture
CompletionStage
WebAsyncTask
有 @ModelAttribute 且为对象类型的
@ResponseBody 注解 ---> RequestResponseBodyMethodProcessor；

HTTPMessageConverter原理

HttpMessageConverter: 看是否支持将 此 Class类型的对象，转为MediaType类型的数据。
例子：Person对象转为JSON。或者 JSON转为Person

默认的MessageConverter

0 - 只支持Byte类型的
1 - String
2 - String
3 - Resource
4 - ResourceRegion
5 - DOMSource.class \ SAXSource.class \ StAXSource.class \StreamSource.class \Source.class
6 - MultiValueMap
7 - true
8 - true
9 - 支持注解方式xml处理的

内容协商

根据客户端接收能力不同，返回不同媒体类型的数据

引入xml依赖

 <dependency>
     <groupId>com.fasterxml.jackson.dataformat</groupId>
     <artifactId>jackson-dataformat-xml</artifactId>
</dependency>

postman分别测试返回json和xml

只需要改变请求头中Accept字段。Http协议中规定的，告诉服务器本客户端可以接收的数据类型。

开启浏览器参数方式内容协商功能

为了方便内容协商，开启基于请求参数的内容协商功能。

spring:
    contentnegotiation:
      favor-parameter: true  #开启请求参数内容协商模式

发请求： http://localhost:8080/test/person?format=json

http://localhost:8080/test/person?format=xml

确定客户端接收什么样的内容类型；

1、Parameter策略优先确定是要返回json数据（获取请求头中的format的值）

2、最终进行内容协商返回给客户端json即可。

内容协商原理

• 1、判断当前响应头中是否已经有确定的媒体类型。MediaType

• 2、获取客户端（PostMan、浏览器）支持接收的内容类型。（获取客户端Accept请求头字段）【application/xml】

• contentNegotiationManager 内容协商管理器 默认使用基于请求头的策略

  

• HeaderContentNegotiationStrategy 确定客户端可以接收的内容类型

  

• 3、遍历循环所有当前系统的 MessageConverter，看谁支持操作这个对象（Person）

• 4、找到支持操作Person的converter，把converter支持的媒体类型统计出来。

• 5、客户端需要【application/xml】。服务端能力【10种、json、xml】

  

• 6、进行内容协商的最佳匹配媒体类型

• 7、用 支持 将对象转为 最佳匹配媒体类型 的converter。调用它进行转化 。

导入了jackson处理xml的包，xml的converter就会自动进来

WebMvcConfigurationSupport
jackson2XmlPresent = ClassUtils.isPresent("com.fasterxml.jackson.dataformat.xml.XmlMapper", classLoader);

if (jackson2XmlPresent) {
			Jackson2ObjectMapperBuilder builder = Jackson2ObjectMapperBuilder.xml();
			if (this.applicationContext != null) {
				builder.applicationContext(this.applicationContext);
			}
			messageConverters.add(new MappingJackson2XmlHttpMessageConverter(builder.build()));
		}

自定义 MessageConverter

实现多协议数据兼容。json、xml、x-guigu

0、@ResponseBody 响应数据出去 调用 RequestResponseBodyMethodProcessor 处理

1、Processor 处理方法返回值。通过 MessageConverter 处理

2、所有 MessageConverter 合起来可以支持各种媒体类型数据的操作（读、写）

3、内容协商找到最终的 messageConverter；

SpringMVC的什么功能。一个入口给容器中添加一个 WebMvcConfigurer

 @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {

            @Override
            public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
				converters.add(new RaMessageConverter());
            }
        }
    }

/**
 * 自动以Converter
 */
public class RaMessageConverter implements HttpMessageConverter<Person> {
    @Override
    public boolean canRead(Class<?> clazz, MediaType mediaType) {
        return false;
    }

    @Override
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
        return clazz.isAssignableFrom(Person.class);
    }

    /**
     * 服务器要统计所有MessageConverter都能写出哪些内容类型
     * @return
     */
    @Override
    public List<MediaType> getSupportedMediaTypes() {
        return MediaType.parseMediaTypes("application/x-ramelon");
    }

    @Override
    public Person read(Class<? extends Person> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        return null;
    }

    @Override
    public void write(Person person, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        // 自定义协议数据的写出
        String data = person.getUserName() + ";" + person.getAge() + ";" + person.getBirth();

        OutputStream body = outputMessage.getBody();
        body.write(data.getBytes());
    }
}

/**
 * 自定义协商策略
 * @param configurer
*/
@Override
public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {

    // Map<String, MediaType> mediaTypes
    Map<String, MediaType> mediaTypes = new HashMap<>();
    mediaTypes.put("json",MediaType.APPLICATION_JSON);
    mediaTypes.put("xml",MediaType.APPLICATION_XML);
    mediaTypes.put("gg",MediaType.parseMediaType("application/x-ramelon"));
    // 指定支持解析哪些参数对应的哪些媒体类型
    ParameterContentNegotiationStrategy strategy = new ParameterContentNegotiationStrategy(mediaTypes);

    configurer.strategies(Arrays.asList(strategy));

}

有可能我们添加的自定义的功能会覆盖默认很多功能，导致一些默认的功能失效。

大家考虑，上述功能除了我们完全自定义外？SpringBoot有没有为我们提供基于配置文件的快速修改媒体类型功能？怎么配置呢？【提示：参照SpringBoot官方文档web开发内容协商章节】

视图解析与模板引擎

视图解析：SpringBoot默认不支持 JSP，需要引入第三方模板引擎技术实现页面渲染。

1、视图解析

1、目标方法处理的过程中，所有数据都会被放在 ModelAndViewContainer 里面。包括数据和视图地址

2、方法的参数是一个自定义类型对象（从请求参数中确定的），把他重新放在 ModelAndViewContainer

3、任何目标方法执行完成以后都会返回 ModelAndView（数据和视图地址）。

4、processDispatchResult 处理派发结果（页面改如何响应）

• 1、render(mv, request, response); 进行页面渲染逻辑

  • 1、根据方法的String返回值得到 View 对象【定义了页面的渲染逻辑】
  • 1、所有的视图解析器尝试是否能根据当前返回值得到View对象
  • 2、得到了 redirect:/main.html --> Thymeleaf new RedirectView()
  • 3、ContentNegotiationViewResolver 里面包含了下面所有的视图解析器，内部还是利用下面所有视图解析器得到视图对象。
  • 4、view.render(mv.getModelInternal(), request, response); 视图对象调用自定义的render进行页面渲染工作

• RedirectView 如何渲染【重定向到一个页面】

  • 1、获取目标url地址
  • 2、response.sendRedirect(encodedURL);

视图解析：

• 返回值以 forward: 开始： new InternalResourceView(forwardUrl); --> 转发request.getRequestDispatcher(path).forward(request, response);

• 返回值以 redirect: 开始： new RedirectView() --》 render就是重定向

• 返回值是普通字符串： new ThymeleafView（）—>

2、基本语法

1、表达式

2、字面量

文本值: ‘one text’ , ‘Another one!’ **,…**数字: 0 , 34 , 3.0 , 12.3 **,…**布尔值: true , false

空值: null

变量： one，two，… 变量不能有空格

3、文本操作

字符串拼接: +

变量替换: |The name is ${name}|

4、数学运算

运算符: + , - , * , / , %

5、布尔运算

运算符: and , or

一元运算: ! , not

6、比较运算

比较: > , < , >= , <= ( gt , lt , ge , le **)**等式: == , != ( eq , ne )

7、条件运算

If-then: (if) ? (then)

If-then-else: (if) ? (then) : (else)

Default: (value) ?: (defaultvalue)

8、特殊操作

无操作： _

3、设置属性值-th:attr

设置单个值

<form action="subscribe.html" th:attr="action=@{/subscribe}">
  <fieldset>
    <input type="text" name="email" />
    <input type="submit" value="Subscribe!" th:attr="value=#{subscribe.submit}"/>
  </fieldset>
</form>

设置多个值

<img src="../../images/gtvglogo.png"  th:attr="src=@{/images/gtvglogo.png},title=#{logo},alt=#{logo}" />

以上两个的代替写法 th:xxxx

<input type="submit" value="Subscribe!" th:value="#{subscribe.submit}"/>
<form action="subscribe.html" th:action="@{/subscribe}">

所有h5兼容的标签写法

https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#setting-value-to-specific-attributes

4、迭代

<tr th:each="prod : ${prods}">
        <td th:text="${prod.name}">Onions</td>
        <td th:text="${prod.price}">2.41</td>
        <td th:text="${prod.inStock}? #{true} : #{false}">yes</td>
</tr>

<tr th:each="prod,iterStat : ${prods}" th:class="${iterStat.odd}? 'odd'">
  <td th:text="${prod.name}">Onions</td>
  <td th:text="${prod.price}">2.41</td>
  <td th:text="${prod.inStock}? #{true} : #{false}">yes</td>
</tr>

5、条件运算

<a href="comments.html"
th:href="@{/product/comments(prodId=${prod.id})}"
th:if="${not #lists.isEmpty(prod.comments)}">view</a>

<div th:switch="${user.role}">
  <p th:case="'admin'">User is an administrator</p>
  <p th:case="#{roles.manager}">User is a manager</p>
  <p th:case="*">User is some other thing</p>
</div>

6、属性优先级

3、thymeleaf使用

引入start

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

自动配置thymeleaf

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(ThymeleafProperties.class)
@ConditionalOnClass({ TemplateMode.class, SpringTemplateEngine.class })
@AutoConfigureAfter({ WebMvcAutoConfiguration.class, WebFluxAutoConfiguration.class })
public class ThymeleafAutoConfiguration {}

自动配好的策略

• 1、所有thymeleaf的配置值都在 ThymeleafProperties

• 2、配置好了 SpringTemplateEngine

• 3、配好了 ThymeleafViewResolver

• 4、我们只需要直接开发页面

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

public static final String DEFAULT_SUFFIX = ".html";

直接开发

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
 <h1 th:text="${msg}">哈哈</h1>
 <h2>
     <a href="www.baidu.com" th:href="${link}">百度</a>
     <a href="www.baidu.com" th:href="@{link}">百度</a>
 </h2>
</body>
</html>

4、构建后台管理系统

项目创建

thymeleaf、web-starter、devtools、lombok

静态资源处理

自动配置好，我们只需要把所有静态资源放到 static 文件夹下

路径构建

th:action="@{/login}

模板抽取

th:insert/replace/include

页面跳转 数据渲染

@Controller
public class IndexController {

    /**
     * 来登录页
     *
     * @return
     */
    @GetMapping(value = {"/", "/login"})
    public String loginPage() {

        return "login";
    }

    @PostMapping("/login")
    public String main(User user, HttpSession session, Model model) {
        if (StringUtils.hasLength(user.getUserName()) && StringUtils.hasLength(user.getPassWord())) {
            // 把登录成功的用户保存起来
            session.setAttribute("loginUser", user);
            return "redirect:/main.html";
        }else {
            model.addAttribute("msg","账号密码错误");
            return "login";
        }
    }

    @GetMapping("/main.html")
    public String mianPage(HttpSession session, Model model) {

        Object loginUser = session.getAttribute("loginUser");
        if(loginUser != null){
            return "main";
        }else {
            model.addAttribute("msg","请重新登录");
            return "login";
        }
    }
}


@Controller
public class TableController {

    @GetMapping("/basic_table")
    public String basic_table(){

        return "table/basic_table";
    }

    @GetMapping("/dynamic_table")
    public String dynamic_table(Model model){

        List<User> users = Arrays.asList(new User("zhangsan","123456"),
                new User("lisi","111222"),
                new User("haha","145632"),
                new User("小溪","888888"));

        model.addAttribute("users",users);
        return "table/dynamic_table";
    }

    @GetMapping("/responsive_table")
    public String responsive_table(){

        return "table/responsive_table";
    }

    @GetMapping("/editable_table")
    public String editable_table(){

        return "table/editable_table";
    }
}

<table class="display table table-bordered" id="hidden-table-info">
    <thead>
        <tr>
            <th>#</th>
            <th>用户名</th>
            <th>密码</th>
        </tr>
    </thead>
    <tbody>
        <tr class="gradeX" th:each="user,stats:${users}">
            <td th:text="${stats.count}">Trident</td>
            <td th:text="${user.userName}">Internet</td>
            <td >[[${user.password}]]</td>
        </tr>
    </tbody>
</table>

拦截器

HandlerInterceptor接口

/**
 * 拦截器
 * 登录检查
 * 1、配置好拦截器要拦截哪些请求
 * 2、把这些配置放在容器中
 */
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 目标方法执行之前
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String requestURI = request.getRequestURI();

        log.info("拦截的请求路径是{}",requestURI);


        HttpSession session = request.getSession();

        Object loginUser = session.getAttribute("loginUser");

        if(loginUser != null){
            return true;
        }

        request.setAttribute("msg","请先登录");
        // response.sendRedirect("/");
        request.getRequestDispatcher("/").forward(request,response);
        return false;
    }

    /**
     * 目标方法执行以后
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

    /**
     * 页面渲染以后
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

配置拦截器

/**
 *  1、编写一个拦截器实现HandlerInterceptor接口
 *  2、拦截器注册到容器中（实现WebMvcConfigurer的addInterceptors）
 *  3、指定拦截规则【如果是拦截所有，静态资源也会被拦截】
 */
@Configuration
public class AdminWebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**") // 所有请求都被拦截器拦截包括静态资源
                .excludePathPatterns("/","/login","/css/**","/fonts/**","/images/**","/js/**","/favicon.ico"); // 需要放行的请求
    }
}

拦截器原理

• 根据当前的请求，找到HandlerExecutionChain【可以处理请求的handler以及handler的所有拦截器】

• 先来顺序执行所有的拦截器的preHandle方法

  • 如果当前拦截器preHandler返回为true。则执行下一个拦截器的preHandler
  • 如果当前拦截器返回为false。直接倒叙执行所有已经执行了的拦截器afterCompletion

• 如果有一个拦截器返回false。直接跳出不执行目标方法

• 所有拦截器都要返回true。执行目标方法。

• 倒叙执行所有拦截器的postHandle方法

• 前面的步骤有异常都会直接出发afterCompletion

• 页面成功渲染完成以后，也会倒叙出发afterHandler

文件上传

<form method="post" action="/upload" enctype="multipart/form-data">
    <input type="file" name="file"><br>
    <input type="submit" value="提交">
</form>

@PostMapping("/upload")
public String upload(@RequestParam("email") String email,
                     @RequestParam("username") String username,
                     @RequestParam("headerImg") MultipartFile headerImg,
                     @RequestParam("photos") MultipartFile[] photos) throws IOException {

    log.info("上传的信息：email={}，username={}，headerImg={}，photos={}",
             email,username,headerImg.getSize(),photos.length);

    if(!headerImg.isEmpty()){
        String filename = headerImg.getOriginalFilename();
        headerImg.transferTo(new File("F:\\IMG\\"+filename));
    }

    if (photos.length > 0){
        for (MultipartFile photo : photos) {
            if(!photo.isEmpty()){
                photo.transferTo(new File("F:\\IMG\\"+photo.getOriginalFilename()));
            }
        }
    }
    return "main";
}

自动配置原理

文件上传自动配置类-MultipartAutoConfiguration-MultipartProperties

• 自动配置好了 StandardServletMultipartResolver 【文件上传解析器】
• 原理步骤
  • 1、请求进来使用文件上传解析器判断（isMultipart）并封装（resolveMultipart，返回MultipartHttpServletRequest**）文件上传请求
  • 2、参数解析器来解析请求中的文件内容封装成MultipartFile
  • 3、将request中文件信息封装为一个Map；MultiValueMap<String, MultipartFile>

FileCopyUtils。实现文件流的拷贝

异常处理

1、默认规则

• 默认情况下，Spring Boot提供/error处理所有错误的映射
• 对于机器客户端，它将生成JSON响应，其中包含错误，HTTP状态和异常消息的详细信息。对于浏览器客户端，响应一个“ whitelabel”错误视图，以HTML格式呈现相同的数据

{
  "timestamp": "2021-07-09T09:54:46.263+00:00",
  "status": 404,
  "error": "Not Found",
  "message": "No message available",
  "path": "/main.htmls"
}