Spring Boot入门

1.Spring Boot简介

简化Spring应用开发的一个框架
整个Spring技术栈的一个大整合

2.微服务

微服务最早由Martin Fowler与James Lewis于2014年共同提出。
微服务：架构风格
一个应用应该是一组小型服务；可以通过HTTP的方式进行互通；每一个功能元素最终都是一个可独立替换和独立升级的软件单元。

3.第一个Spring Boot程序

（1）导入依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

（2）编写一个主程序

作用：启动Spring Boot

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * @SpringBootApplication来标注一个主程序类，说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        //Spring应用启动起来
        SpringApplication.run(Application.class,args);
    }
}

（3）编写相关的Controller、Service

@Controller
public class HelloController {
    @ResponseBody
    @RequestMapping("/hello")
    public String hello(){
        return "Hello World!";
    }
}

（4）简化部署（打jar包）

导入插件

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

操作步骤

Spring Boot基础注解

1.主程序类、主入口类

/**
 * @SpringBootApplication来标注一个主程序类，说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class Application {
    public static void main(String[] args) {

        //Spring应用启动起来
        SpringApplication.run(Application.class,args);
    }
}

@SpringBootApplication：Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    @AliasFor(
        annotation = EnableAutoConfiguration.class,
        attribute = "exclude"
    )
    Class<?>[] exclude() default {};

    @AliasFor(
        annotation = EnableAutoConfiguration.class,
        attribute = "excludeName"
    )
    String[] excludeName() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};
}

@SpringBootConfiguration：Spring Boot的配置类；标注在某个类上，表示这是一个Spring Boot的配置类；@Configuration：配置类上来标注这个注解；配置类相当于配置文件；配置类也是容器中的一个组件；@Component。
@EnableAutoConfiguration：开启自动配置功能；@AutoConfigurationPackage：自动配置包，将主配置类的所在包及下面所有子包里面的所有组件扫描到Spring容器。

Spring Boot快速创建

1.使用Spring Initializer快速创建Spring Boot项目

2.resources文件夹中目录结构

1.static：保存所有的静态资源；比如js、css、images
2.templates：保存所有的模板页面；（Spring Boot默认jar包使用嵌入式的Tomcat，默认不支持JSP页面）；可以使用模板引擎（freemarker、thymeleaf）
3.application.properties：Spring Boot应用的配置文件，可以修改一些默认设置

Spring Boot配置文件

1.配置文件

Spring Boot使用一个全局的配置文件，配置文件名是固定的
application.properties
application.yml
配置文件的作用：修改Spring Boot自动配置的默认值。
YAML 标记语言：以数据为中心，比json、xml等更适合做配置文件。

2.YAML语法

（1）基本语法

k:(空格)v 表示一对键值对（空格必须有），以空格的缩进来控制层级关系，只要是左对齐的一列数据，都是同一层级的，属性和值大小写敏感。

server:
    port: 8081
    path: /hello

（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.配置文件值注入

last-name相当于lastName

person:
  lastName: zhangsan
  age: 18
  boss: false
  birth: 2014/12/12
  map: {k1: v1,k2: v2}
  list:
    - lisi
    - wangwu
  dog:
    name: 小狗
    age: 2

/**
 * 将配置文件配置的每一个属性值，映射到这个组件中
 * @ConfigurationProperties：告诉Spring Boot将本类中的所有属性和配置文件中相关的配置进行绑定；
 * prefix = "person"；配置文件中哪个下面的所用属性进行一一映射
 *
 * 只用这个组件是容器中的组件，才能提供@ConfigurationProperties功能
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;

    private Map<String,Object> map;
    private List<Object> list;
    private Dog dog;

可以导入配置文件处理器，以后编写配置就有提示

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

配置文件yml和properties都能获取到值
如果只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value；
如果专门编写了一个JavaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties。

4.@PropertySource&@ImportResource

@PropertySource：加载指定的配置文件
@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效
Spring Boot里面没有Spring的配置文件，我们自己编写的配置文件，也不能自动识别，想让Spring的配置配置文件生效，加载进来，@ImportResource：标注在一个配置类上，开发中不常用

@ImportResource(locations = {"classpath:beans.xml"})
导入Spring的配置文件让其生效

不编写Spring的配置文件

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

    <bean id="helloService" class="com.guan.springboot.service.HelloService">

    </bean>
</beans>

SpringBoot推荐给容器中添加组件的方式：推荐使用全注解的方式
1.配置类类似于Spring配置文件
2.使用@Bean给容器中添加组件

/**
 * @author
 * @date 2019/10/27 0027
 * @Configuration指明当前类是一个配置类：就是代替之前的Spring配置文件
 * 在配置文件中用<bean></bean标签加组件
 */
@Configuration
public class MyAppConfig {
    /**
     * 将方法的返回值添加到容器中：容器中这个组件默认的id就是方法名
     */
    @Bean
    public HelloService helloService(){
        System.out.println("配置类@Bean给容器中添加组件了...");
        return new HelloService();
    }
}

5.Profile

（1）多Profile文件

我们在主配置文件编写的时候，文件名可以是 application-{profile}.properties/yml
默认使用application.properties的配置

（2）yml支持多文档块方式

server:
  port: 8081

spring:
  profiles:
    active: dev
--- #环境配置文件分隔符
server:
  port: 8083
spring:
  profiles: dev #指定以下的配置为dev环境的配置
---
server:
  port: 8084
spring:
  profiles: prod

（3）激活指定profile

在配置文件中指定
spring.profiles.active=dev

命令行
–spring.profiles.active=dev

命令窗口
java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

虚拟机参数
-Dspring.profiles.active=dev

Spring Boot自动配置原理

1.配置文件加载位置

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

2.外部配置加载顺序

SpringBoot也可以从以下位置加载配置； 优先级从高到低；高优先级的配置覆盖低优先级的配置，所有的配置会 形成互补配置
（1）命令行参数
所有的配置都可以在命令行上进行指定，多个配置用空格分开， --配置项=值
java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --server.port=8087 --server.context-path=/abc
（2）来自java:comp/env的JNDI属性
（3）Java系统属性（System.getProperties()）
（4）操作系统环境变量
（5）RandomValuePropertySource配置的random.*属性值
由jar包外向jar包内进行寻找，优先加载带profile
（6）jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
（7）jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件，再来加载不带profile
（8）jar包外部的application.properties或application.yml(不带spring.profile)配置文件
（9）jar包内部的application.properties或application.yml(不带spring.profile)配置文件
（10）@Configuration注解类上的@PropertySource
（11）通过SpringApplication.setDefaultProperties指定的默认属性

3.自动配置原理

（1）自动配置原理

Spring Boot启动的时候加载主配置类，开启了自动配置功能@EnableAutoConfiguration

@EnableAutoConfiguration作用：利用AutoConfigurationImportSelector给容器中导入一些组件，详细信息可以查看以下代码：

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
        AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = this.filter(configurations, autoConfigurationMetadata);
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}

SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

扫描所有jar包类路径下 META-INF/spring.factories，把扫描到的这些文件的内容包装成properties对象，从properties中获取到EnableAutoConfiguration.calss类（类名）对应的值，然后把它们添加到容器中

总结：将类路径下 META-INF/spring.factories 里面配置的所有EnableAutoConfiguration的值加入到了容器中

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
# ......

每一个这样的 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中，用它们来做自动配置

（2）每一个自动配置类进行自动配置功能

以HttpEncodingAutoConfiguration为例解释自动配置原理

@Configuration(
    proxyBeanMethods = false
) //表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件
@EnableConfigurationProperties({HttpProperties.class}) //启用指定类的ConfigurationProperties功能，将配置文件中对应的值和HttpProperties绑定起来，并把HttpProperties加入到ioc容器中
@ConditionalOnWebApplication(
    type = Type.SERVLET
) //Spring底层@Conditional注解，根据条件判断，如果满足指定的条件，整个配置类里面的配置就会生效    判断当前应用是否是web应用，如果是，当前配置生效
@ConditionalOnClass({CharacterEncodingFilter.class}) //判断当前项目有没有CharacterEncodingFilter这个类，CharacterEncodingFilter是SpringMVC中进行乱码解决的过滤器
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
) //判断配置文件中是否存在spring.http.encoding这个配置，matchIfMissing = true表示如果不存在，判断也成立
public class HttpEncodingAutoConfiguration {
	//和SpringBoot的配置文件映射
    private final 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(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }

根据当前不同的条件判断，决定这个配置类是否生效，一旦这个配置类生效，这个配置类就会给容器中添加各种组件，这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的。

所有在配置文件中能配置的属性都是在xxxProperties类中封装着，配置文件能配置什么就可以参照某个功能对应的这个属性类

@ConfigurationProperties(
    prefix = "spring.http"
) //从配置文件中获取指定的值和bean的属性进行绑定
public class HttpProperties {
    private boolean logRequestDetails;
    private final HttpProperties.Encoding encoding = new HttpProperties.Encoding();

总结（核心思想）：
（1）SpringBoot启动会加载大量的自动配置类
（2）我们看我们需要的功能有没有SpringBoot默认写好的自动配置类
（3）我们再来看这个自动配置类中到底配置了哪些组件（只要我们要用的组件有，我们就不需要再来配置了）
（4）给容器中自动配置类添加组件的时候，会从properties类中获取某些属性，我们就可以在配置文件中指定这些属性的值

xxxAutoConfiguration：自动配置类
给容器中添加组件
xxxProperties：封装配置文件中相关属性

4.@Conditional派生注解

作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置类里面的所有的内容才生效

自动配置类必须在一定条件下才能生效
通过在application.properties配置文件中，启用 debug=true属性，来让控制台打印自动配置报告