【SpringBoot 配置 01】

一、简单介绍SpringBoot

1、微服务的概述

1)、要想了解微服务首先应该知道单体应用

浏览器-->tomcat:war--db   war包放到Tomcat然后他通过浏览器访问

一个单体应用程序把它所有的功能放在一个单一进程中...并且通过在多个服务器上复制这个单体进行扩展

2)、微服务

一个微服务架构把每个功能元素放进一个独立的服务中...并且通过跨服务器分发这些服务进行扩展，只在需要时复制

2、使用springboot创建第一个项目：helloworld

需求：浏览器发送hello请求，服务器接收请求并处理，响应Hello World字符串

1）创建一个maven工程

2）pom文件导入spring boot相关的依赖

<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>

3）编写一个主程序：启动spring boot应用

package com.wufq.springBoot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @SpringBootApplication 来标注一个主程序类，说明这是一个springboot应用
 */

@SpringBootApplication
public class HelloMainApplication {

    public static void main(String[] args){
//        启动spring应用-->传入主程序类和可变的参数
        SpringApplication.run(HelloMainApplication.class,args);
    }
}

4）编写Controller（控制层）、Service

package com.wufq.springBoot.Controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloController {

    @ResponseBody  //把Hello world返回给浏览器
    @RequestMapping("/hello") //接受浏览器发送的hello请求
    public String hello(){
        return "Hello world";
    }
}

5）用jar包模式简化部署工作

首先在pom文件内引入build（这个插件，可以将应用打包成一个可执行的jar包）

  <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

然后打jar包，并执行

mvn clean install -DskipTests

java -jar xxx.jar

3、解析上面的HelloWorld工程

3.1、POM文件

1）父项目

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

他的父项目是
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>1.5.9.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>
他来真正管理Spring Boot应用里面的所有依赖版本；

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

（意思就是，只需要在父项目parent中写明版本，后面依赖dependency不需要写版本了，../../spring-boot-dependencies就会帮我们去管理所依赖的版本）

2）启动器

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

• spring-boot-starter-web：其实是两部分，一部分为spring-boot-starter，另外一部分为web
• spring-boot-starter场景启动器；帮我们导入了web模块正常运行所依赖的组件，这也意味着如果我们需要导入邮件组件时，只需要把web换成mail,即：spring-boot-starter-mail
• Spring Boot将所有的功能场景抽取出来，做成一个个的starter(启动器)，只需要在项目里面引入这些starter相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器。

3.2、主程序类

/**
 * @SpringBootApplication 来标注一个主程序类，说明这是一个springboot应用
 */

@SpringBootApplication
public class HelloMainApplication {

    public static void main(String[] args){
//        启动spring应用-->传入主程序类和可变的参数
        SpringApplication.run(HelloMainApplication.class,args);
    }
}

@SpringBootApplication：很关键，标注在某个类上才能说明这个类是SpringBoot的主配置类，SpringBoot就应运行这个类的main方法来启动SpringBoot应用。

====展开SpringBootApplication，发现@SpringBootApplication是由多个不同的注解组成====

@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 {

@SpringBootConfiguration：Spring Boot的配置类；标注在某个类上，表示这是一个SpringBoot的配置类

-->展开SpringBootConfiguration，发现也是由多个注解组成，其中

　　@Configuration：是Spring定义的配置；配置类上标注这个注解；配置类---配置文件；配置类也是容器中的一个组件；@Component(@Configuration更深的一层)

@EnableAutoConfiguration：(核心注解)开启自动配置功能

以前我们需要配置的东西（如Spring框架是通过spring.xml文件来完成的），SpringBoot帮我们自动配置；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置功能才能生效

　　====展开EnableAutoConfiguration，发现@EnableAutoConfiguration也是由多个不同的注解组成====

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

@AutoConfigurationPackage：（定义默认的包扫描规则）自动配置包

　　====展开后@Import({AutoConfigurationPackage.Registrar.class})：Spring的底层注解@import，给容器中导入一个组件，导入的组件由AutoConfigurationPackage.Registrar.class；

　　将主配置类（@SpringBootApplication标注的类）的所有包及下面所有子包里面的所有组件扫描到Spring容器；

 

 @Import({EnableAutoConfigurationImportSelector.class})：给容器中导入组件？EnableAutoConfigurationImportSelector：自动导入那些组件的选择器；

将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中；会给容器导入非常多的自动配置类（xxxAutoConfiguration）;就是给容器中导入这个场景需要的所有组件，并配置好这些组件；有了这些自动配置类，免去了我们手动编写配置注入功能组件等的工作；

4、使用Spring Initializer（创建向导）快速创建Spring Boot项目

步骤：Idea--file--new--spring initializer--填写group、Artifact、选择Type(以maven方式创建项目等)...--Developer Tools（选择需要创建的模块，如：web）--填写项目名--finish

这样就默认生成了SpringBoot项目：

• pom文件和主程序都已经创建好了，我们就可以按照自己的逻辑编写程序了
• resources文件夹中目录结构

　　　　　|-- static：保存所有的静态资源；jss css images

　　　　　|-- templates：保存所有的模板页面（Spring Boot默认jar包使用嵌入式的tomcat,默认不支持jsp页面）;可以使用模板引擎（freemarker、thymeleaf）

　　　　　|-- application.properties：Spring Boot应用的配置文件，可以修改一些默认设置。（比如修改端口：server.port=8081）

二、Spring Boot配置

1、配置文件

SpringBoot使用的两个全局的配置文件，配置文件名是固定的

• application.properties
• application.yml

配置文件的作用：修改SpringBoot自动配置的默认值；SpringBoot在底层都给我们自动配置好

YAML：是一个标记语言，同样也不是一个标记语言

标记语言：

　　以前的配置文件，大多数使用的是xml文件

YAML：以数据为中心，比json、xml等更适合做配置文件

YAML配置例子

server:
  port: 8081

XML配置例子

  <server>
    <port>8081</port>
  </server>

2、YAML语法

1）基本语法

　k: v 表示一对键值对（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: 
     name: zhangsan
     age: 20

　　行内写法

frends: {name: zhangsan,age: 18}

数组、list、set

用 - 值表示数组中的一个元素

pets: 
    - cat
    - dog
    - pig

行内写法

pets: [cat,dog,pig]

#案例演示：

1）在主配置类的同层目录下，创建bean.Person类，包含私有属性：name(String),age(Integer),bosser(Boolean)，birth(Data)，map，list,dog（对象属性）（dog属性包含：name，age）

  　然后创建getter、setter、toString方法

2）在application.yml文件中配置属性值

server:
  port: 8081

person:
  name: zhangsan
  age: 18
  bosser: false
  birth: 1990/01/05

  maps: {k1: v1,k2: v2}
  lists:
      - lisi
      - zhangsan
  dog:
    name: 金毛
    age: 2

3）JavaBean：在Person类中，将配置文件中每一个属性映射到这个组件中 。即：获取值的方式：@ConfigurationProperties(prefix = "person")

/**
 * 将配置文件中每一个属性的值，映射到这个组件中
 * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中的属性进行关联
 * prefix = "person" 前缀，配置文件中的那个下面的所有属性进行一一映射
 *
 * @Component：只有这个组件是容器内的组件，才能给容器提供@ConfigurationProperties功能,即:把javabean加到容器中
 */

@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;

注意：映射时会有一个“Spring Boot Configuration Annotation Processor not fount in classpath”提示，根据提示在pom文件中添加）

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

4）在test程序主类测试中进行SpringBoot单元测试，验证yml文件内赋值的属性是否成功

package com.wufq.springboot01helloquick;

import com.wufq.springboot01helloquick.bean.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/*
* SpringBoot单元测试
* @RunWith(SpringRunner.class)：单元测试用SpringRunner的驱动进行测试
*
* 可以在测试期间很方便的类似编码一样进行自动注入等容器的功能
* */
@RunWith(SpringRunner.class)
@SpringBootTest
public class Springboot01HelloQuickApplicationTests {

    /*
    * autowired有4种模式，byName、byType、constructor、autodectect

    其中@Autowired注解是使用byType方式的

    byType方式是根据属性类型在容器中寻找bean类

    规则如下：

    1.Spring先去容器中寻找NPerson类型的bean（先不扫描person字段）

    2.若找不到一个bean，会抛出异常

    3.若找到一个Person类型的bean，自动匹配，并把bean装配到person中

    4.若Person类型的bean有多个，则扫描后面person字段进行名字匹配，匹配成功后将bean装配到person中

    * */
    @Autowired
    Person person;

    @Test
    public void contextLoads() {
        System.out.println(person);
    }
}

 ## 在application.properties文件中配置属性（编码问题）

#idea使用的是utf-8，中文乱码：file--setting-搜索：file encodings，选择编码格式为utf-8，勾选单选框
        
#配置
person.name=张三
person.age=18
person.birth=2020/02/02
person.bosser=false
person.dog.name=金毛
person.dog.age=2
person.maps.k1=v1
person.maps.k2=v2
person.lists={a,b,c}

3、配置文件注入

1）@value获取值和@ConfigurationProperties获取值

@ConfiguratrionProperties

@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;

@value

/**
 * @RestController:是
 * @Controller和@ResponseBody的结合，写@RestController以后，就不需要写@ResponseBody了
 */
@RestController
public class HelloController {

    @Value("${person.name}")
    private String name;

    @RequestMapping("/sayhello")
    public String hell(){
        return "Hello"+name;
    }
}

 如果说，我们只是在某个业务逻辑中需要获取一下配置文件中的某项值，使用@Value

如果说，我们专门编写一个javaBean来和配置文件进行映射，我们就直接使用@ConfigurationProperties;

 2）@PropertySource&@ImportResource&@Bean

@PropertySource：加载指定的配置文件

如何理解：以Person为例，现在Person已经绑定了application.properties的全局变量（@ConfigurationProperties(prefix = "person")），

属性的值都是从此文件内获取，如果后面的配置都配置到全局配置文件内，那么全局配置文件（application.properties）就太大了，

想把一些和SpringBoot无关的配置提取出来，就可以用到@PropertySource加载指定的文件

#案例演示：

-- 有一个和SpringBoot无关的配置文件：person.properties

person.name=苍老师
person.age=18
person.birth=2020/02/02
person.bosser=false
person.dog.name=金毛
person.dog.age=2
person.maps.k1=v1
person.maps.k2=v2
person.lists={a,b,c}

-- 把此文件的属性值注入到javaBean中，这时候就用到了@PropertySource来引入

@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String name;
    private Integer age;
    private Boolean bosser;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

@ImportResource：导入Spring的配置文件，让配置文件里面的内容生效

想让Spring的配置文件生效，加载进来，@ImportSource标注在一个配置类上

#案例演示：

-- bean.xml的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="services" class="com.wufq.springboot01helloquick.Service.HelloServices"></bean>
</beans>

-- 主配置类导入bean.xml文件

@ImportResource(locations = "classpath:bean.xml")
@SpringBootApplication
public class Springboot01HelloQuickApplication {

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

}

-- 测试类测试SpringBoot是否导入Spring的配置文件

//    获取ioc容器
    @Autowired  //根据属性类型在容器中寻找bean类,并将bean装配到HelloServices中
    ApplicationContext ioc;

//    测试ioc容器是否包含id
    @Test
    public void testHelloService(){
        Boolean b = ioc.containsBean("services");
        System.out.println("======"+b);
    }

==执行结果===
true

以上编写xml文件的方式太过麻烦，所以SpringBoot推荐给容器中添加组件的方式，推荐使用全注解的方式

1）配置类<==>Spring的配置文件

2）使用@Bean给容器中添加组件

=======编写配置类=====

/*
* 在类之前加上@Configuration 告诉SpringBoot这个类是一个配置类，并且这个配置类来替代Spring的配置文件
* */
@Configuration
public class MyAppConfig {

    /*
    * Spring的配置文件中用<bean id="" class=""></bean>标签来给属性赋值
    *配置类可以用@Bean来代替，并且容器的id就是方法名
    * */
    @Bean
    public HelloServices helloServices(){
        System.out.println("配置类@bean给容器中添加组件");
        return new HelloServices();
    }
}

=====测试类测试=====

//    获取ioc容器
    @Autowired  //根据属性类型在容器中寻找bean类,并将bean装配到HelloServices中
    ApplicationContext ioc;

//    测试ioc容器是否加载进去
    @Test
    public void testHelloService(){
        Boolean b = ioc.containsBean("helloservice");  //helloservice指的是id
        System.out.println("======"+b);
    }

===执行结果====
true
如果把helloservice换成service，结果为false -->说明配置类的方法名的确是id

4、配置文件占位符

 1）随机数

${random.value}、${random.int}、${random.long}

${random.ini(10)}、${random.ini[1024,65535]}

2）占位符获取之前配置的值，如果没有可以用：指定默认值

person.name=张三${random.uuid}
person.age=${random.int}
person.birth=2020/02/02
person.bosser=false
person.dog.name=${person.name}_金毛
#person.num:2指person.num没有找到的话就给一个默认值2
person.dog.age=${person.num:2}2  
person.maps.k1=v1
person.maps.k2=v2
person.lists={a,b,c}

5、profile：Spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境

 1）多Profile文件：

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

默认使用application.properties的配置

举例：

 2）yml文件不需要像properties文件新建多个，只需要用多文档快方式即可

server:
  port: 8081

---
server:
  port: 8082
spring:
  profiles: dev

---
server:
  port: 8083
spring:
  profiles: prod

3）激活指定的profile

-- properties文件激活使用哪个环境的application-{profile}.propreties

spring.profiles.active=dev

 -- yml文件指定使用哪个环境

server:
  port: 8081
spring:
  profiles:
    active: prod

 --命令行激活

两种方式：第一种：打包后直接在终端运行并指定

java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev；

第二种：在idea中打开Edit Configurations-->在program arguments标签内编写：

--spring.profiles.active=dev

 --虚拟机参数

同样可以在idea中打开Edit Configurations-->在program arguments标签内编写：

-Dspring.profiles.active=dev

6、配置文件加载位置

springboot启动默认加载application.properties或者application.yml作为主配置文件，一般是放在resources文件夹下，但是也可以放在下面的文件：

–file:./config/          #指：直接在工程project下创建一个config文件，里面放application.properties/yml文件

–file:./　　　　　　　　　　#指：直接在工程project下放application.properties/yml文件 

–classpath:/config/      #指：在当前类（resources文件夹）下创建一个config文件，里面放application.properties/yml文件 

–classpath:/　　　　　　　　#指：在当前类（resources文件夹）下放application.properties/yml文件 

以上四种优先级由高到底，高优先级的配置会覆盖低优先级的配置；

-- 如果这四个位置都有application.properties/yml文件，springboot会从这四个位置全部加载主配置文件，但是只会加载高优先级的配置，这时候一般可以用互补配置

比如：在-file:./config/application.properties文件内配置项目的访问路径

server.port=8081
#配置项目访问路径
server.servlet.context-path=/boot02

配置以后，访问时就需要加上项目访问路径：localhost:8081/boot02/hello

-- 可以通过spring.config.location来改变默认的配置文件位置

但是只能在项目打包后，使用命令行参数的形式，启动项目的时候来指定配置文件的新位置。指定配置文件和默认加载的这些配置文件共同起作用形成互补配置

java -jar spring-boot-02-config-02-0.0.1-SNAPSHOT.jar --spring.config.location=G:/application.properties