springboot

一、SpringBoot入门

1、SpringBoot简介

简化Spring应用开发的一个框架；
整个Spring技术栈的一个大整合；
J2EE开发的一站式解决方案；
复制代码

2、SpringBoot的优点

快速创建独立运行的Spring项目以及与主流框架集成
使用嵌入式的Servlet容器，应用无需打成WAR包
starters自动依赖与版本控制
大量的自动配置，简化开发，也可修改默认值
无需配置XML，无代码生成，开箱即用
准生产环境的运行时应用监控
与云计算的天然集成
复制代码

3、微服务

微服务：架构风格（服务微化）
一个应用应该是一组小型服务；可以通过HTTP的方式进行互通；
单体应用：ALL IN ONE
微服务：每一个功能元素最终都是一个可独立替换和独立升级的软件单元；
复制代码

详细参照微服务文档

4、环境准备

springBoot2.x用JDK8, 因为底层是Spring framework5
jdk1.8：java -version
maven3.x：maven3.2以上版本
复制代码

maven下载地址

翻译工具

springbootGitHub地址

springboot官方文档

5、SpringBoot Helloworld

1、创建一个maven工程
2、导入SpringBoot相关的依赖(starters)
复制代码

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

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
复制代码

3、编写一个主程序，启动SpringBoot应用
复制代码

/**
 * @SpringBootApplication 来标注一个注程序类，说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {

    //Spring应用启动
    public static void main(String[] args) {
        SpringApplication.run(HelloWorldMainApplication.class,args);
    }
}
复制代码

4、编写相关的Controller、Service
复制代码

@Controller
public class HelloController {

    @ResponseBody
    @RequestMapping("/hello")
    public String Hello(){
        return "Hello World!";
    }
}
复制代码

5、运行主程序测试
6、简化部署
复制代码

<!-- 这个插件，可以将应用打包成一个可执行的jar包 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
复制代码

6、Hello World探究

1、POM文件：
    springboot将所有的功能场景都抽取出来，做成一个个的starters（启动器）
    只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。
复制代码

<!-- 父项目 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.0.RELEASE</version>
</parent>
<!-- 它的父项目是： -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.1.0.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
</parent>
<!-- 它来真正管理SpringBoot应用里面的所有依赖版本 -->
<!-- Spring Boot的版本仲裁中心 -->
<!-- 注意：没有在dependencies里面管理的依赖需要声明版本号 -->

<!-- 启动器 -->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
<!-- spring-boot-start:spring-boot场景启动器 -->
<!-- web:导入了web模块正常运行所依赖的组件 -->
复制代码

2、主程序类，主入口类
复制代码

/**
 * @SpringBootApplication 来标注一个注程序类，说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {
    //Spring应用启动
    public static void main(String[] args) {
        SpringApplication.run(HelloWorldMainApplication.class,args);
    }
}
复制代码

@SpringBootApplication:标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用
复制代码

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

@SpringBootConfiguration:SpringBoot的配置类，标注在某个类上，表示这是一个Spring Boot的配置类
    @Configuration:配置类上来标注这个注解
        @Component配置类也是容器中的一个组件
        
@EnableAutoConfiguration：开启自动配置功能
    @AutoConfigurationPackage：自动配置包
        @Import(AutoConfigurationPackages.Registrar.class)：Spring的底层注解，给容器中导入一个组件；导入的组件由AutoConfigurationPackages.Registrar.class指定
        将主配置类(@SpringBootApplication标注的类)的所在包及下面所有子包里面的所有组件扫描到Spring容器；
    @Import(AutoConfigurationImportSelector.class)：给容器中导入组件，将所有需要导入的组件以全类名的方式返回

Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，
将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作
复制代码

7、使用Spring Initializer快速创建Spring Boot项目

默认生成的Spring Boot项目
    主程序已经生成好了，我们只需要我们自己的逻辑
    resources文件夹中目录结构
        static：保存所有的静态资源； js css images；
        templates：保存所有的模板页面；（SpringBoot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面）;可以使用模板引擎（freemarker、thymeleaf）；
        application.properties：SpringBoot应用的配置文件；可以修改一些默认设置
复制代码

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.bjlemon</groupId>
    <artifactId>springboot01helloworld-quick</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboot01helloworld-quick</name>
    <description>Demo project for Spring Boot</description>

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

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

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

        <!-- Spring Boot进行单元测试的模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>
复制代码

Springboot01helloworldQuickApplication.java

@SpringBootApplication
public class Springboot01helloworldQuickApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot01helloworldQuickApplication.class, args);
    }
}
复制代码

HelloController.java

//这个类的所有方法返回的数据直接写给浏览器，（如果是对象转为json数据）
//@ResponseBody
//@Controller
@RestController
public class HelloController {
    @RequestMapping(name="/hello")
    public String hello(){
        return "hello world quick!";
    }
}
复制代码

二、配置文件

1、配置文件

SpringBoot使用一个全局的配置文件，配置文件名是固定的
    application.properties
    application.yml
配置文件的作用：修改SpringBoot自动配置的默认值
YAML（YAML Ain't Markup Language）
YAML A Markup Language：是一个标记语言
YAML isn't Markup Language：不是一个标记语言
以前的配置文件；大多都使用的是 xxxx.xml文件；
YAML：以数据为中心，比json、xml等更适合做配置文件；
复制代码

YAML：配置例子(application.yaml)

server:
  port: 8081
复制代码

XML：配置例子

<server>
    <port>8081</port>
</server>
复制代码

2、yaml语法

1、基本语法
    k:(空格)v：表示一对键值对（空格必须有）；属性和值也是大小写敏感；
    以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的
复制代码

server:
  port: 8081
  servlet:
    context-path: /springboot
复制代码

2、值的写法
    字面量：普通的值（数字，字符串，布尔）
        k: v：字面直接来写；
        字符串默认不用加上单引号或者双引号；
        ""：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思
            name: "zhangsan \n lisi"；输出：zhangsan 换行 lisi
        ''：单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据
            name: 'zhangsan \n lisi'；输出：zhangsan \n lisi
    
    对象、Map(属性和值)(键值对)：
        k: v:在下一行来写对象的属性和值的关系；注意缩进
        对象还是k: v方式
复制代码

friends:
    lastName: zhangsan
    age: 20
#行内写法
friends: {lastName: zhangsan,age: 18}
复制代码

    数组(List、Set)：
        用- 值表示数组中的一个元素
复制代码

pets:
    ‐ cat
    ‐ dog
    ‐ pig
#行内写法
pets: [cat,dog,pig]
复制代码

3、配置文件值注入

yaml配置文件：

person:
  last-name: 青
  age: 16
  boss: true
  birth: 2017/02/16
  maps:
    k1: v1
    k2: v2
  lists:
    - 柚子
    - 灵棋
  dog:
    name: 雪儿
    age: 15
复制代码

properties配置文件：

person.last-name=灵棋
person.age=20
person.boss=false
person.birth=2017/02/16
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c
person.dog.name=欢欢
person.dog.age=10
复制代码

javaBean：

/**
 * 将配置文件中配置的每一个属性的值，映射到这个组件中
 * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
 *      prefix = "person"：与配置文件中person下面的所有属性进行一一映射
 *      只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
 *  @ConfigurationProperties(prefix = "person")默认从全局配置文件中获取值；
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
    ......
}
复制代码

导入配置文件处理器，编写配置就会有提示了

<!--导入配置文件处理器，配置文件进行绑定就会有提示-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>
复制代码

1、properties配置文件在idea中默认utf-8可能会乱码
    调整Settings--File Encodings--properties Files设置成UTF-8并且后面打上勾
2、@Value获取值和@ConfigurationProperties获取值比较
    @ConfigurationProperties：
        批量注入配置文件中的属性
        支持松散绑定（松散语法）
        不支持spEL
        支持JSR303数据校验
        支持复杂类型封装
    @Value：
        一个个指定
        不支持松散绑定（松散语法）
        支持spEL
        不支持JSR303数据校验
        不支持复杂类型封装
    如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value；
    如果说，我们专门编写了一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties；
复制代码

@Component
public class Person {
    @Value("${person.lastName}")
    private String lastName;
    @Value("#{11*2}")
    private Integer age;
    @Value("true")
    private Boolean boss;
    ......
}
复制代码

3、配置文件注入值数据校验
复制代码

@Component
@ConfigurationProperties(prefix = "person")
@Validated
public class Person {
    @Email
    private String lastName;
}
复制代码

4、@PropertySource&@ImportResource&@Bean
    @PropertySource：加载指定的配置文件
复制代码

@Component
@ConfigurationProperties(prefix = "person")
@PropertySource(value = {"classpath:person.properties"})
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
}
复制代码

    @ImportResource：导入Spring的配置文件，让配置文件里面的内容生效
        Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别；
        想让Spring的配置文件生效，加载进来；@ImportResource标注在一个配置类上
复制代码

@SpringBootApplication
//导入Spring的配置文件让其生效
@ImportResource(locations = {"classpath:beans.xml"})
public class Springboot02configApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot02configApplication.class, args);
    }
}
复制代码

    SpringBoot推荐给容器中添加组件的方式；推荐使用全注解的方式
        1、配置类@Configuration------>Spring配置文件
        2、使用@Bean给容器中添加组件
复制代码

/**
 * @Configuration，指明当前类是一个配置类，就是来替代之前的spring配置文件
 * 在配置文件中用<bean></bean>标签添加组件
 */
@Configuration
public class MyAppConfig {
    //将方法的返回值添加到容器中，容器中这个组件默认的id就是方法名
    @Bean
    public HelloService helloService(){
        return new HelloService();
    }
}
复制代码

4、配置文件占位符

1、随机数
复制代码

${random.value}
${random.uuid}
${random.int}
${random.long}
${random.int(value,[max])}
${random.long(value,[max])}
复制代码

2、占位符获取之前配置的值，如果没有可以是用:指定默认值
复制代码

person.lastName=灵棋${random.uuid}
person.age=${random.int}
#person.dog.name=${person.lastName}_dog
person.dog.name=${person.hello:hello}_dog
person.dog.age=10
复制代码

5、Profile

1、多Profile文件
    我们在主配置文件编写的时候，文件名可以是 application-{profile}.properties/yml
    默认使用application.properties的配置；
2、yml支持多文档块方式
复制代码

server:
  port: 8081
  servlet:
    context-path: /springboot
spring:
  profiles:
    active: dev
---
server:
  port: 8083
spring:
  profiles: dev #指定属于哪个环境
---
server:
  port: 8084
spring:
  profiles: pro #指定属于哪个环境
复制代码

3、激活指定profile
    1、在配置文件中指定 spring.profiles.active=dev
    2、命令行：
        java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev；
        可以直接在测试的时候，配置传入命令行参数
    3、虚拟机参数；
        -Dspring.profiles.active=dev
复制代码

6、配置文件加载位置

springboot 启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置文
件
–file:./config/
–file:./
–classpath:/config/
–classpath:/
优先级由高到底，高优先级的配置会覆盖低优先级的配置
SpringBoot会从这四个位置全部加载主配置文件；互补配置
我们还可以通过spring.config.location来改变默认的配置文件位置
项目打包好以后，我们可以使用命令行参数的形式，启动项目的时候来指定配置文件的新位置；指定配置文件和默认加载的这些配置文件共同起作用形成互补配置；
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties
复制代码

7、外部配置加载顺序

SpringBoot也可以从以下位置加载配置；优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置
1、命令行参数
    所有的配置都可以在命令行上进行指定
    java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.servlet.context-path=/abc
    多个配置用空格分开； --配置项=值

由jar包外向jar包内进行寻找；
优先加载带profile

2、jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
3、jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件

再来加载不带profile

4、jar包外部的application.properties或application.yml(不带spring.profile)配置文件
5、jar包内部的application.properties或application.yml(不带spring.profile)配置文件
复制代码

所有支持的配置加载来源： 参考官方文档

8、自动配置原理

配置文件到底能写什么？怎么写？自动配置原理： 配置文件能配置的属性参照

1、自动配置原理
    1）、SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration
    2）、@EnableAutoConfiguration 作用：
        利用AutoConfigurationImportSelector给容器中导入一些组件
        可以查看selectImports()方法的内容；
复制代码

    //获取候选的配置
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
    
    List<String> configurations = getCandidateConfigurations(annotationMetadata,attributes);

    //扫描所有jar包类路径下 META‐INF/spring.factories
    //把扫描到的这些文件的内容包装成properties对象
    //从properties中获取到EnableAutoConfiguration.class类（类名）对应的值，然后把他们添加在容器中
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());

    loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    
    Enumeration<URL> urls = (classLoader != null ?classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
    
    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
复制代码

    将类路径下META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到了容器中；
    每一个这样的 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；
    3）、每一个自动配置类进行自动配置功能
    4）、以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理
复制代码

//表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@Configuration
//启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpProperties绑定起来；并把HttpProperties加入到ioc容器中
@EnableConfigurationProperties(HttpProperties.class)
//Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
//判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；
@ConditionalOnClass(CharacterEncodingFilter.class)
//判断配置文件中是否存在某个配置，spring.http.encoding.enabled；如果不存在，判断也是成立的
//即使我们配置文件中不配置spring.http.encoding.enabled=true，也是默认生效的；
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)
public class HttpEncodingAutoConfiguration {
    
    他已经和SpringBoot的配置文件映射了
    private final HttpProperties.Encoding properties;

    //只有一个有参构造器的情况下，参数的值就会从容器中拿
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
		this.properties = properties.getEncoding();
	}

    @Bean   //给容器中添加一个组件，这个组件的某些值需要从properties中获取
    @ConditionalOnMissingBean   //判断容器没有这个组件？
    public CharacterEncodingFilter characterEncodingFilter() {
    	CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
    	filter.setEncoding(this.properties.getCharset().name());
    	filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
    	filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
    	return filter;
    }
}
复制代码

        根据当前不同的条件判断，决定这个配置类是否生效？
        一但这个配置类生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
    5）、所有在配置文件中能配置的属性都是在xxxxProperties类中封装者；配置文件能配置什么就可以参照某个功能对应的这个属性类
复制代码

//从配置文件中获取指定的值和bean的属性进行绑定
@ConfigurationProperties(prefix = "spring.http")
public class HttpProperties {}
复制代码

    精髓：
        1）、SpringBoot启动会加载大量的自动配置类
        2）、我们看我们需要的功能有没有SpringBoot默认写好的自动配置类；
        3）、我们再来看这个自动配置类中到底配置了哪些组件；（只要我们要用的组件有，我们就不需要再来配置了）
        4）、给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值；
    xxxxAutoConfigurartion：自动配置类；
    给容器中添加组件
    xxxxProperties:封装配置文件中相关属性；
2、细节
    1、@Conditional派生注解（Spring注解版原生的@Conditional作用）
        作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置里面的所有内容才生效；
        
        @Conditional扩展注解            作用（判断是否满足当前指定条件）
        @ConditionalOnJava              系统的java版本是否符合要求
        @ConditionalOnBean              容器中存在指定Bean；
        @ConditionalOnMissingBean       容器中不存在指定Bean；
        @ConditionalOnExpression        满足SpEL表达式指定
        @ConditionalOnClass             系统中有指定的类
        @ConditionalOnMissingClass      系统中没有指定的类
        @ConditionalOnSingleCandidate   容器中只有一个指定的Bean，或者这个Bean是首选Bean
        @ConditionalOnProperty          系统中指定的属性是否有指定的值
        @ConditionalOnResource          类路径下是否存在指定资源文件
        @ConditionalOnWebApplication    当前是web环境
        @ConditionalOnNotWebApplication 当前不是web环境
        @ConditionalOnJndi              JNDI存在指定项
    自动配置类必须在一定的条件下才能生效；
    我们怎么知道哪些自动配置类生效；
    我们可以通过启用 debug=true属性；来让控制台打印自动配置报告，这样我们就可以很方便的知道哪些自动配置类生效；
复制代码

============================
CONDITIONS EVALUATION REPORT
============================


Positive matches（自动配置类启用的）
-----------------

   CodecsAutoConfiguration matched:
      - @ConditionalOnClass found required class 'org.springframework.http.codec.CodecConfigurer' (OnClassCondition)

   CodecsAutoConfiguration.JacksonCodecConfiguration matched:
      - @ConditionalOnClass found required class 'com.fasterxml.jackson.databind.ObjectMapper' (OnClassCondition)
Negative matches:（没有启动，没有匹配成功的自动配置类）
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)

   AopAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.aspectj.lang.annotation.Aspect' (OnClassCondition)
复制代码

三、日志

1、日志框架

2、SLF4j使用

3、SpringBoot日志关系

4、日志使用

5、切换日志框架

四、SpringBoot与Web开发

1、简介

使用SpringBoot；
    1）、创建SpringBoot应用，选中我们需要的模块；
    2）、SpringBoot已经默认将这些场景配置好了，只需要在配置文件中指定少量配置就可以运行起来
    3）、自己编写业务代码
自动配置原理？
    这个场景SpringBoot帮我们配置了什么？能不能修改？能修改哪些配置？能不能扩展？xxx
    xxxxAutoConfiguration：帮我们给容器中自动配置组件；
    xxxxProperties:配置类来封装配置文件的内容；
复制代码

2、SpringBoot对静态资源的映射规则

二、SpringBoot接口Http协议开发实战

1、SpringBoot2.xHTTP请求配置讲解

简介：SpringBoot2.xHTTP请求注解讲解和简化注解配置技巧
1、@RestController and @RequestMapping是springMVC的注解，不是springboot特有的	
2、@RestController = @Controller + @ResponseBody	
3、@SpringBootApplication = @SpringBootConfiguration + @EnableAutoConfiguration + @ComponentScan
    或@Configuration + @EnableAutoConfiguration + @ComponentScan
复制代码

2、开发接口必备工具之PostMan接口调试工具介绍和使用

简介：模拟Http接口测试工具PostMan安装和讲解

	1、接口调试工具安装和基本使用
	2、下载地址：https://www.getpostman.com/
复制代码

3、SpringBoot基础HTTP接口GET请求实战

简介:讲解springboot接口，http的get请求，各个注解使用
    1)单一参数
        @RequestMapping(path = "/{id}", method = RequestMethod.GET)
    	public String getUser(@PathVariable String id ) {}
    	
    2）可以同时指定多个提交方法
        @RequestMapping(path = "/{depid}/{userid}", method = RequestMethod.GET) 
    	getUser(@PathVariable("depid") String departmentID,@PathVariable("userid") String userid)
    
    3）一个顶俩
    	@GetMapping = @RequestMapping(method = RequestMethod.GET)
    	@PostMapping = @RequestMapping(method = RequestMethod.POST)
    	@PutMapping = @RequestMapping(method = RequestMethod.PUT)
    	@DeleteMapping = @RequestMapping(method = RequestMethod.DELETE)
    
    4）可以设置默认值，比如分页 
        @RequestParam(value = "name", required = true)
    		
    5)@RequestBody 请求体映射实体类
        需要指定http头为 content-type为application/json charset=utf-8
    
    6）@RequestHeader 请求头，比如鉴权
    	@RequestHeader("access_token") String accessToken
    
    7）HttpServletRequest request自动注入获取参数
复制代码

4、SpringBoot基础HTTP接口POST,PUT,DELETE请求实战

简介：讲解http请求post，put, delete提交方式
复制代码

5、常用json框架介绍和Jackson返回结果处理

简介：介绍常用json框架和注解的使用，自定义返回json结构和格式

1、常用框架 阿里 fastjson,谷歌gson等
    JavaBean序列化为Json，性能：Jackson > FastJson > Gson > Json-lib 同个结构
    Jackson、FastJson、Gson类库各有优点，各有自己的专长
    空间换时间，时间换空间

2、jackson处理相关自动
    指定字段不返回：@JsonIgnore
    指定日期格式：@JsonFormat(pattern="yyyy-MM-dd hh:mm:ss",locale="zh",timezone="GMT+8")
    空字段不返回：@JsonInclude(Include.NON_NUll)
    指定别名：@JsonProperty
复制代码

6、SpringBoot2.x目录文件结构讲解

 简介：讲解SpringBoot目录文件结构和官方推荐的目录规范

 1、目录讲解
     src/main/java：存放代码
     src/main/resources
     	static: 存放静态文件，比如 css、js、image, （访问方式 http://localhost:8080/js/main.js）
     	templates:存放静态页面jsp,html,tpl
     	config:存放配置文件,application.properties
     	resources:

 2、引入依赖 Thymeleaf
     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    注意：如果不引人这个依赖包，html文件应该放在默认加载文件夹里面，
    比如resources、static、public这个几个文件夹，才可以访问

 3、同个文件的加载顺序,静态资源文件
    Spring Boot 默认会挨个从META/resources > resources > static > public  里面找是否存在相应的资源，如果有则直接返回。

 4、默认配置	
 	1）官网地址：https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-developing-web-applications.html#boot-features-spring-mvc-static-content

 	2）spring.resources.static-locations = classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/ 

 5、静态资源文件存储在CDN
复制代码

7、SpringBoot2.x文件上传实战

简介：HTML页面文件上传和后端处理实战
springboot文件上传 MultipartFile file，源自SpringMVC
    1）静态页面直接访问：localhost:8080/index.html
    	注意点：如果想要直接访问html页面，则需要把html放在springboot默认加载的文件夹下面
    2）MultipartFile对象的transferTo方法，用于文件保存（效率和操作比原先用FileOutStream方便和高效）
    	访问路径 http://localhost:8080/images/39020dbb-9253-41b9-8ff9-403309ff3f19.jpeg
复制代码

8、jar包方式运行web项目的文件上传和访问处理（核心知识）

简介：讲解SpingBoot2.x使用 java -jar运行方式的图片上传和访问处理
1、文件大小配置，启动类里面配置
    @Bean  
    public MultipartConfigElement multipartConfigElement() {  
        MultipartConfigFactory factory = new MultipartConfigFactory();  
        //单个文件最大  
        factory.setMaxFileSize("10240KB"); //KB,MB  
        /// 设置总上传数据总大小  
        factory.setMaxRequestSize("1024000KB");  
        return factory.createMultipartConfig();  
    }  

2、打包成jar包，需要增加maven依赖
    <build>
    	<plugins>
            <plugin>
            	<groupId>org.springframework.boot</groupId>
            	<artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
    	</plugins>
    </build>
	如果没加相关依赖，执行maven打包，运行后会报错:no main manifest attribute, in XXX.jar

	GUI：反编译工具，作用就是用于把class文件转换成java文件

3、文件上传和访问需要指定磁盘路径
    application.properties中增加下面配置
    	1) web.images-path=/Users/jack/Desktop
    	2) spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,classpath:/test/,file:${web.upload-path} 

4、文件服务器：fastdfs，阿里云oss，nginx搭建一个简单的文件服务器复制代码

转载于:https://juejin.im/post/5bec25da6fb9a049dd7fd70f