【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
