Spring Boot 入门（配置、原理、日志)

之前只在项目中使用，这里还是再总结一下：

---

SpringBoot 系列：
1. Spring Boot 入门、原理、日志
2. Spring Boot中的Thymeleaf、自动配置、国际化、容器
3. SpringBoot 数据访问、启动配置原理以及自定义Starter
4. SpringBoot 与缓存并整合 Redis
5. SpringBoot 与消息队列并整合 RabbitMQ

---

Spring Boot 入门

概述

Spring Boot 简化了 Spring 应用开发：

• 由原来的 Spring 全家桶简化成 SpringBoot 的 J2EE一站式解决方案
• 以及后来的 Spring Cloud 分布式整体解决方案。

优点：

• 快速创建独立运行的 Spring 项目并可以集成主流框架
• 使用嵌入式的 Servlet 容器，应用无需打成 WAR 包
• starters 自动依赖与版本控制
• 自动化配置，简化开发
• 无需配置 XML，无代码生成

单体应用与微服务：
单体应用，即所有的功能模块都在一个应用中，使用复制形式实现水平扩展。
而微服务其实是一种架构风格，一个应用由一组小型服务组成，通过HTTP的方式进行互通；
每一个功能元素最终都是一个可独立替换和独立升级的软件单元。

---

环境配置

1.在 pom.xml 中配置：

		<!-- 指定父项目，由父项目管理Spring Boot 应用里面的所有依赖版本 -->
		<parent>
	        <groupId>org.springframework.boot</groupId>
	        <artifactId>spring-boot-starter-parent</artifactId>
	        <version>1.5.9.RELEASE</version>
	    </parent>
	    <dependencies>
	    	<!-- 通过 starter 场景启动器（其它 acvitmq 等），导入 web 模块 -->
	        <dependency>
	            <groupId>org.springframework.boot</groupId>
	            <artifactId>spring-boot-starter-web</artifactId>
	        </dependency>
	    </dependencies>

2.编写启动 Spring Boot 主程序：

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

此时就配置完成可以编写 Controller 了：

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

只需要运行 Main 方法就可以启动应用，打包也只需打成 JAR 可执行包，配置打包插件：

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

3.其实也可以使用 Spring Initializr 来快速创建

---

SpringBootApplication 注解

由前面可知 SpringBootApplication 注解用于标注一个主程序类，说明这是一个Spring Boot应用，而它其实是一个组合注解：

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

• @Configuration：使用的是 Spring 的注解来标注配置类，配置类其实是配置文件，使用的是 @Component 被标注成 Spring 的组件。

2.@EnableAutoConfiguration：开启自动配置功能；以前我们需要配置的东西，Spring Boot帮我们自动配置，也是一个组合注解，如下：

• @AutoConfigurationPackage：自动配置包，使用 Spring 的底层注解@Import(AutoConfigurationPackages.Registrar.class) ，会将主配置类所在包及下面所有子包里面的组件扫描到 Spring 容器。
• @Import(EnableAutoConfigurationImportSelector.class)：将我们所需要的场景组件的自动配置类（xxxAutoConfiguration）导入到容器。从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，帮助我们自动配置。

---

配置文件

Spring Boot 全局配置文件可以对自动配置的默认配置值进行修改，而配置文件有两种形式：

• application.properties：我们正常使用的配置文件

		server.port = 8081

• application.yml：使用 YAML 标记语言的文件，以数据为中心，比json、xml更适合作配置文件

		server:
			port: 8081
		  	context-path: /

---

YAML 语法

基本语法

• k:(空格)v 表示一堆键值对（空格不能省略）
• 以空格缩进的形式来控制层级关系，即左对齐的一列是同一层级
• 属性和值是大小写敏感的

值的类型

1. 字面量（数字，字符串，布尔）：直接写，字符串默认不用加上引号；加上双引号则不会转义特殊字符，而单引号会转移特殊字符。
2. 对象、Map：在下一行写对象的属性和值的关系

		# 第一种
		user:
			name: moke
			age: 22
		# 第二种
		user: {name: moke,age: 22}

3. 数组、List、Set

		# 第一种
		myList:
			- a
			- b
		# 第二种
		myList: [a,b]

值的注入
比如上面我们配置了一个 user 对象的值，那么如何注入到我们容器的对象中呢，如下：

1. 配置文件处理器

		<!--导入配置文件处理器-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-configuration-processor</artifactId>
			<optional>true</optional>
		</dependency>

2. yml 配置值

		user:
		    name: hello
		    age: 18
		    boss: false
		    birth: 2017/12/12
		    father:
		      name: moke
		      age: 30

3. 注入值：@ConfigurationProperties 和 @Value

		//使用 @ConfigurationProperties
		@Component
		@ConfigurationProperties(prefix = "user")
		public class User{...}
		//使用 @Value
		public class User{
			@Value("${user.name}")
			private String name;
			...
		}

区别：
@PropertySource、@ImportResource、@Bean 注解：
@PropertySource：加载指定的配置文件

		@PropertySource(value = {"classpath: redis.yml"})

@ImportResource：导入 Spring 的配置文件，即使用我们原来在 Spring 中使用 xml 配置文件

		@ImportResource(locations = {"classpath: beans.xml"})

但是 SpringBoot 不建议使用 xml 配置文件，而是使用配置类：

		@Configuration
		public class MyConfig{
			//将方法的返回值添加到容器中，默认的 id 就是方法名
			@Bean
			public User user(){
				return new User();
			}
		}

配置占位符

		person:
			name: 张三${random.uuid}
			age: ${random.int}

---

Profile 多环境

1. 多 Profile 文件
   比如在主配置文件编写的时候，文件名：application.yml、application-test.yml、application-dev.yml，可以在住配置文件中激活环境所需要的配置文件：

		spring:
		  profiles:
		    active: test

2. 多文档块
   不需要编写多个配置文件，使用 — 来划分不同的文档块，不同文档块指定不同的环境

		spring:
		  profiles:
		    active: dev
		---
		spring:
		  profiles: test
		server:
		  port: 8081
		---
		spring:
		  profiles: dev
		server:
		  port: 8081

3. 激活指定 profile
   之前我们激活指定 profile 都是通过在配置文件中配置 spring.profiles.active 来激活，也可以使用命令行的方式激活，在启动时添加参数：–spring.profiles.active=dev；或者使用虚拟机参数：Dspring.profiles.active=test。

---

加载配置文件

配置文件加载位置，优先级从高到低，配置会互补，而相同则覆盖低优先级配置内容

1. file:./config/
2. file:./
3. classpath:/config/
4. classpath:/

或者通过 spring.config.location 来改变默认的配置文件位置（配置文件/命令行）

加载外部配置（由高到低）
1.命令行参数：所有的配置都可以在命令行上进行指定
2.来自java:comp/env的JNDI属性
3.Java系统属性（System.getProperties()）
4.操作系统环境变量
5.RandomValuePropertySource配置的random.*属性值
6.jar包外部的application-{profile}.properties或application.yml(带spring.profile)配置文件
7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件
8.jar包外部的application.properties或application.yml(不带spring.profile)配置文件
9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件
10.@Configuration注解类上的@PropertySource
11.通过SpringApplication.setDefaultProperties指定的默认属性

---

自动配置原理

配置文件可以配置的属性：官方文档

之前有说 SpringBoot 启动的时候使用 @EnableAutoConfiguration 开启了自动配置功能，而 @EnableAutoConfiguration 是利用 EnableAutoConfigurationImportSelectort 向容器导入组件，相关的方法：

把从 spring.factories 中扫描到的文件内容封装成 properties 对象，然后就可以从 properties 中获取到 EnableAutoConfiguration.class 类中对应的值，然后把它们添加到容器中。

我们以 AciveMQautoConfiguration 为例，这是 ActiveMQ 的自动配置类

而 Properties 类默认是通过 spring.factories 中的 url 获取到的 Properties，而通过 @ConfigurationProperties 注解允许从我们自定义的配置文件中注入修改的值：

---

@Conditional 注解

在自动配置加载 Properties 类前，会先进行条件的判断，自动配置类必须在一定的条件下才能生效；
而它们都是基于 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，会在启动时打印自动配置报告：

---

日志框架

Spring 框架默认使用的是 JCL，而 SpringBoot 改为 SLF4J 和 logback。

---

SLF4J 的原理

我们只需要调用日志门面 SLF4J 抽象层中的方法，而不是直接调用日志的实现类，除了导入 SLF4J 还需要导入相应日志的实现（可以不是默认的 logback，但是需要一个中间层来适配），参考官方的图片：

此外，在开发过程中，框架会使用自己的底层配置的日志实现框架，那如何都通过 SLF4J 提供的方法进行统一的日志输出呢？将应用中其他 日志实现 替换成调用 SLF4J 的中间包，参考官方图片：

而这些中间包的引入，可以通过SpringBoot 的依赖关系，看到 SpringBoot 都帮我们完成了：

所以在引入其他框架时，我们只需要把这个框架本身的日志框架排除，比如 SpringBoot 对 Spring 框架中 commons-logging 的排除：

SpringBoot 中使用 SLF4J

在 SpringBoot 中使用 SLF4J

		Logger logger = LoggerFactory.getLogger(getClass());

		//日志的级别；
		//由低到高   trace<debug<info<warn<error
		//可以调整输出的日志级别；日志就只会在这个级别以以后的高级别生效
		logger.trace("这是trace日志...");
		logger.debug("这是debug日志...");
		//SpringBoot默认给我们使用的是info级别的，没有指定级别的就用SpringBoot默认规定的级别；root级别
		logger.info("这是info日志...");
		logger.warn("这是warn日志...");
		logger.error("这是error日志...");

而我们可以在配置文件中配置级别，以及使用日志的其他功能：

		logging:
		  # 日志打印级别
		  level: trace
		  # 可以指定完整的路径,以及生成的日志文件名
		  file: F:/springboot.log
		  # 在当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用 spring.log 作为默认文件
		  path: /spring/log
		  pattern:
		    # 在控制台输出的日志的格式
		    console: '%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n'
		    # 指定文件中日志输出的格式
		    file: '%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} ==== %msg%n'
		#	 日志的格式
		#    %d表示日期时间，
		#    %thread表示线程名，
		#    %-5level：级别从左显示5个字符宽度
		#    %logger{50} 表示logger名字最长50个字符，否则按照句点分割。
		#    %msg：日志消息，
		#    %n是换行符

还可以自己定义配置文件
给类路径下放上每个日志框架自己的配置文件即可；SpringBoot就不会使用他默认配置的

Logging System	Customization
Logback	logback-spring.xml, logback-spring.groovy, logback.xml or logback.groovy
Log4j2	log4j2-spring.xml or log4j2.xml
JDK (Java Util Logging)	logging.properties

带 spring 和不带 spring 是有区别的，比如：

• logback.xml：直接就被日志框架识别了；
• logback-spring.xml：日志框架就不直接加载日志的配置项，由SpringBoot解析日志配置，可以使用SpringBoot的高级Profile功能

SpringBoot Profile： 可以指定某段配置只在某个环境下生效

		<springProfile name="dev">
		    <!-- dev环境下的输出格式 -->
		  	<pattern>%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n</pattern>
		</springProfile>

切换日志框架
可以按照slf4j的日志适配图，进行相关的切换，比如切换到 slf4j+log4j2，先排除再引入：

   		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <artifactId>spring-boot-starter-logging</artifactId>
                    <groupId>org.springframework.boot</groupId>
                </exclusion>
            </exclusions>
        </dependency>
		<dependency>
		  <groupId>org.springframework.boot</groupId>
		  <artifactId>spring-boot-starter-log4j2</artifactId>
		</dependency>