SpringBoot再学习（入门、yaml、日志）

SpringBoot学习

1、SpringBoot入门

1、Spingboot简介

​ 简化Spring应用开发的框架；整个Spring技术栈的大整合；J2EE开发的一站式解决方案；嵌入式的Servlet容器；大量的自动配置简化开发；starts自动依赖与版本控制。

2、创建maven项目

​ idea配置manven,设置为本地配置文件及本地maven仓库。

3、导入springboot相关依赖

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

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

    <!--打包插件，可以将应用打成jar包-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

4、编写启动类

package com.ybjt;

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

/**
 * @author zxh
 * @create 2019-12-04 17:15
 * @SpringBootApplication 标注一个主程序类，说明是一个springboot应用
 */
@SpringBootApplication
public class AppRun {
    public static void main(String[] args) {
        //启动springboot应用
        SpringApplication.run(AppRun.class,args);
    }
}

5、编写controller/service测试

package com.ybjt.home.controller;

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

/**
 * @author zxh
 * @create 2019-12-04 17:17
 */
@Controller
public class HomeController {

    @RequestMapping("/hello")
    @ResponseBody
    public String hello(){
        return "HELLO WORLD!";
    }
}

6、简化部署

通过maven将项目打成jar包，在命令提示符窗口，java -jar 路径名，进行启动。

7、HelloWorld探究

pom文件：

	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>
	它的父项目是：
	<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.0.0.RELEASE</version>
        <relativePath>../../spring-boot-dependencies</relativePath>
    </parent>

	它来管理spring应用里所有的依赖版本

springboot的版本仲裁中心：

​ 以后我们导入的依赖默认不需要版本号(没有在dependencies里管理的依赖任然需要声明版本号)

启动器：

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

​ spring-boot-starter-web:springboot场景启动器，导入web模块正常运行的组件；springboot将所有功能场景都提取出来，做成一个个的启动器，只需要在项目里面引入这些starter,相关场景的所有依赖都会导入，用什么功能就导入什么场景的启动器。

主程序类：

​ @SpringBootApplication注解 表示这是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) })

@SpringBootConfiguration :springboot的配置类，标注到某个类上，表示这是一个springboot的配置类。
	@Configuration :配置类上来标注的注解。
		配置类---配置文件；配置类也是容器中的组件：@Component

@EnableAutoConfiguration ：开启自动配置功能；以前手动配置的内容，由springboot来自动配置。
	@AutoConfigurationPackage ：自动配置包
		@Import(AutoConfigurationPackages.Registrar.class) ：给容器中添加一个组件，导入的组件由AutoConfigurationPackages.Registrar.class来指定。
	将主启动类所在的包及下面所有子包里面的所有组件扫描到spring容器中
	@Import(AutoConfigurationImportSelector.class)	：导入那些组件的选择器，将所有需要导入的组件以全类名的方式返回，这些组件将会被添加到容器中。会给容器中导入非常多的自动配置类（xxxAutoConfigrition）,就是给容器中导入这个场景需要的所有组件，并配置好这些组件；有了自动配置类，就免去了手动编写配置注入功能组件等工作。
	List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
	springboot在启动的时候从类路径下的META-INFO/spring.factories中获取EnableAutoConfigriation指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效了，帮我们进行自动配置，以前我们自己配置的东西，自动配置类都帮我们。

2、idea配置mysql数据库连接

​ 当连接报错时，进行一下设置即可连接。

​ https://blog.youkuaiyun.com/tripleDemo/article/details/100136478

3、idea使用lombok

简化实体类get、set、tostring、构造器的书写：（偷懒、装13专用）

①安装插件

②导入依赖

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.10</version>
    <scope>provided</scope>
</dependency>

③使用注解

@Data @NoArgsConstructor @AllArgsConstructor

package com.ybjt.user.pojo;
import lombok.Data;

import java.util.Date;
/**
 * @author zxh
 * @create 2019-12-16 16:53
 */
@Data
public class User {
    private String id;
    private String username;
    private String address;
    private String avatar;
    private String phone;
    private String email;
    private String sex;
    private String ip;
    private Date jointime;

}

4、YAML配置文件

1、yaml基本语法

以数据为中心，比json,xml更适合做配置文件

​ K: V 表示一对键值对（空格必须有）

​ 以空格的缩进来控制层级关系，只要左对齐的一列数据，都是同一层级的；属性和值都是大小写敏感的。左侧对齐则层级一致，#表示注释，字符串不需要加引号，""包含转义与不转义的区别。

server:
	port: 8099
	path: /hello

2、值的写法

字面量：普通的值（数字、字符串、布尔）: k: v

如果是字符串默认不用加单引号或者双引号

​ “xx”：不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思。

​ ‘xx’：会转义特殊字符，特殊字符最终只是一个普通的字符串数据

对象、Map(属性和值)（键值对）：

k: v 在下一行来写对象的属性和值的关系；注意缩进；对象还是k: v 的方式

person:
	name: zhangsan
	age: 115

行内写法：

pserson: {name: zhangsan,age: 115,address: 中关村}

数组（list、set）：

​ 用-值来表示数组中的元素

pets:
	- cat
	- dog
	- pig

​ 行内写法：

pets: [cat,dog,pig]

3、配置文件值注入

yml配置文件，编写值：

user:
  id: 007
  name: bob
  address: china
  tid: 003

对应实体类，添加相应注解：

package com.ybjt.home.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @author zxh
 * @create 2019-12-05 10:13
 * 将配置文件中配置的每一个属性的值，映射到这个组件中。
 * @ConfigurationProperties(prefix = "user") 告诉springboot将本类中的所有属性个配置文件中相关的
 * 配置进行绑定；prefix = "user" 配置文件中哪个下面的所有属性进行一一映射
 * @Component 只有组件中的容器，才能使用容器提供的ConfigurationProperties映射功能
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
@ConfigurationProperties(prefix = "user")
@Component
public class User {
    private String id;
    private String name;
    private String address;
    private Date time;
    private String tid;
}

进行单元测试：

package com.ybjt;

import com.ybjt.home.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * springboot单元测试
 * 可以方便的类似编码的方式，进行自动注入。
 */
@SpringBootTest
class SpringbootQuickstartApplicationTests {

    @Autowired
    User user;

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

输出结果：

User(id=7, name=Administrator, address=china, time=null, tid=3)

4、@value和@ConfigurationProperties获取值比较

	@ConfigurationProperties	@value
功能	批量注入配置文件中的属性	一个个指定
松散绑定	支持	不支持
Spel	不支持	支持
jsr303数据效验	支持	不支持
复杂类型封装	支持	不支持

​ 如果我们只是在某个业务中，需要获取配置文件的某项值，就使用@value，如果说专门编写了javabean来和配置文件进行映射，就使用@ConfigurationProperties。

//启动数据校验
@Data
@NoArgsConstructor
@AllArgsConstructor
@ConfigurationProperties(prefix = "user")
@Component
@Validated
public class User {
    @Email
    private String id;
    private String name;
    private String address;
    private Date time;
    private String tid;
}

5、@PropertiesSource 和 @ImportResource

​ @PropertiesSource加载指定的配置文件（将配置文件中的属性和实体类映射时，记载指定的配置文件。）

@PropertiesSource(value={"classpath:properties.yml"})

​ @ImportResource 导入Spring的配置文件，让配置文件生效，声明在启动类上。（添加组件）

@ImportResourece(location={"calsspath:beans.xml"})

​ 推荐使用全注解的方式：

@Configuration 指定配置类 
    @Bean 返回值注册到容器中
@Configuration
public class myConnfig{
    
    @Bean//将方法的返回值添加到容器，容器中这个组件默认的id就是方法名
    public HelloService helloService(){
        return new HelloService();
    }
}

6、配置文件占位符

​ 随机数

$(random.value)
$(random.int)
$(random.long)
$(random.int(10))
$(random.int(1024,65535))

​ 占位符获取之前配置的值，如果没有可以：默认值

person.name= 张三
person.dog.name= $(person.name:李四)_dog

7、profile多环境支持

多profile文件：

​ 在编写配置文件的时候，可以使用application-dev.properties的方式，配置不同情况下使用的配置文件。

默认加载的是application.properties的配置文件

YML支持多文档块方式：

#设置服务端口
server:
  port: 8099
user:
  id: 007
  name: bob
  address: china
  tid: 003
spring:
  profiles:
    active: dev
---
server:
  port: 8083
spring:
  profiles: pro
---
server:
  port: 8066
spring:
  profiles: dev

激活指定的配置文件：

spring.profiles.active=dev

​ 命令行的方式：

--spring.profiles.active=dev

8、配置文件加载顺序

​ springboot启动会扫描以下位置的application.properteis/yml配置文件， 作为springboot的主配置文件：

-file:./config
-file:./
-classpath:/config/
-classpath:/
以上是按照优先级从高到低，所有位置的文件都会被加载，高优先级配置内容会覆盖低优先级的配置内容。互补配置

​ 可以通过spring.config.location来改变默认配置，指定的配置文件和默认的配置会形成互补配置。

java -jar springboot-study.jar --spring.config.location=D：application.properties

9、外部配置文件加载顺序

​ springboot可以从以下位置加载配置，优先级从高到低，高优先级的配置覆盖低优先级的配置，所有的配置会形成互补配置

​ ①命令行参数

java -jar springboot-study.jar --server.port=8096
多个配置项用空格分隔

​ ②外部配置文件，从外向内查找加载，优先加载application-dev.properties形式命名的配置文件,再来加载application.properties的配置文件，多个配置文件形成互补配置。

SPEL使用#{}取值

10、自动配置原理

springboot使用一个全局的配置文件，配置文件名是固定的。

application.properties
application.yml
application.yaml

配置文件的作用：修改springboot自动配置的默认值。

自动配置原理

1.springboot启动的时候加载主配置类，开启了自动配置功能：@EnableAutoConfiguration
加载xxxAutoConfiguration类作为自动配置类。

以HttpEncodingAutoConfiguration为例说明：

//表示这是一个配置类
@Configuration(proxyBeanMethods = false)
//启动指定类的ConfigurationProperties功能，将配置文件中的值与类的属性绑定,并将这个配置类添加到spring的容器中。
@EnableConfigurationProperties(HttpProperties.class)
//spring底层注解@Condition注解，根据不同的条件，如果满足指定的条件，整个配置类才会生效：判断当前应用是否是web应用
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
//判断当前有没有CharacterEncodingFilter类，springmvc中乱码解决的过滤器
@ConditionalOnClass(CharacterEncodingFilter.class)
//判断是否存在spring.http.encoding配置，如果不存在也成立。即默认为true
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)

所有的配置文件中能配的属性都是在xxxProperties类中封装的：

@ConfigurationProperties(prefix = "spring.http")
public class HttpProperties {
	private boolean logRequestDetails;
	private final Encoding encoding = new Encoding();
}

精髓：

• springboot 启动会加载大量的自动配置类

• 看我们需要的功能springboot没有默认写好的自动配置类

• 再来看这个自动配置类中到底配置了那些组件（我们要用的组件有，就不需要再配置了）

• 给容器中自动配置类添加组件的时候，会从xxxPropertie类中获取某些属性，我们就可以在配置文件中指定这些属性的值。

  细节：@Conditional注解

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

  派生注解：

  ​ @ConditionalOnJava 系统的java版本是否符合要求

  ​ @ConditionalOnBean 容器中存在指定Bean；

  ​ @ConditionalOnMissingBean 容器中不存在指定Bean；

  ​ @Conditional扩展注解 作用（判断是否满足当前指定条件）

  ​ @ConditionalOnExpression 满足SpEL表达式指定

  ​ @ConditionalOnClass 系统中有指定的类

  ​ @ConditionalOnMissingClass 系统中没有指定的类

  ​ @ConditionalOnSingleCandidate 容器中只有一个指定的Bean，或者这个Bean是首选Bean @ConditionalOnProperty 系统中指定的属性是否有指定的值

  ​ @ConditionalOnResource 类路径下是否存在指定资源文件

  ​ @ConditionalOnWebApplication 当前是web环境

  ​ @ConditionalOnNotWebApplication 当前不是web环境

  ​ @ConditionalOnJndi JNDI存在指定项

  我们可以通过启用 debug=true属性（主配置文件）；来让控制台打印自动配置报告==**，这样我们就可以很方便的知道哪些自动配置类生效；

5、springboot日志

​ springboot选用SLF4J和logback；

​ https://www.bilibili.com/video/av38657363?p=21

1、日志框架

小张；开发一个大型系统；

​ 1、System.out.println("")；将关键数据打印在控制台；去掉？写在一个文件？

​ 2、框架来记录系统的一些运行时信息；日志框架 ； zhanglogging.jar；

​ 3、高大上的几个功能？异步模式？自动归档？xxxx？ zhanglogging-good.jar？

​ 4、将以前框架卸下来？换上新的框架，重新修改之前相关的API；zhanglogging-prefect.jar；

​ 5、JDBC—数据库驱动；

​ 写了一个统一的接口层；日志门面（日志的一个抽象层）；logging-abstract.jar；

​ 给项目中导入具体的日志实现就行了；我们之前的日志框架都是实现的抽象层；

市面上的日志框架；

JUL、JCL、Jboss-logging、logback、log4j、log4j2、slf4j…

日志门面 （日志的抽象层）	日志实现
JCL（Jakarta Commons Logging） SLF4j（Simple Logging Facade for Java） jboss-logging	Log4j JUL（java.util.logging） Log4j2 Logback

左边选一个门面（抽象层）、右边来选一个实现；

日志门面： SLF4J；

日志实现：Logback；

SpringBoot：底层是Spring框架，Spring框架默认是用JCL；‘

​ SpringBoot选用 SLF4j和logback

2、SLF4j使用

1、如何在系统中使用SLF4j https://www.slf4j.org

以后开发的时候，日志记录方法的调用，不应该来直接调用日志的实现类，而是调用日志抽象层里面的方法；

给系统里面导入slf4j的jar和 logback的实现jar

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

图示；

每一个日志的实现框架都有自己的配置文件。使用slf4j以后，配置文件还是做成日志实现框架自己本身的配置文件；

2、遗留问题

a（slf4j+logback）: Spring（commons-logging）、Hibernate（jboss-logging）、MyBatis、xxxx

统一日志记录，即使是别的框架和我一起统一使用slf4j进行输出？

如何让系统中所有的日志都统一到slf4j；

​ 1、将系统中其他日志框架先排除出去；

​ 2、用中间包来替换原有的日志框架；

​ 3、我们导入slf4j其他的实现

3、SpringBoot日志关系

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

SpringBoot使用它来做日志功能；

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

底层依赖关系

总结：

​ 1）、SpringBoot底层也是使用slf4j+logback的方式进行日志记录

​ 2）、SpringBoot也把其他的日志都替换成了slf4j；

​ 3）、中间替换包？

@SuppressWarnings("rawtypes")
public abstract class LogFactory {

    static String UNSUPPORTED_OPERATION_IN_JCL_OVER_SLF4J = "http://www.slf4j.org/codes.html#unsupported_operation_in_jcl_over_slf4j";

    static LogFactory logFactory = new SLF4JLogFactory();

​ 4）、如果我们要引入其他框架？一定要把这个框架的默认日志依赖移除掉？

​ Spring框架用的是commons-logging；

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<exclusions>
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；

4、日志使用；

1、默认配置

SpringBoot默认帮我们配置好了日志；

	//记录器
	Logger logger = LoggerFactory.getLogger(getClass());
	@Test
	public void contextLoads() {
		//System.out.println();

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

	}

    日志输出格式：
		%d表示日期时间，
		%thread表示线程名，
		%-5level：级别从左显示5个字符宽度
		%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
		%msg：日志消息，
		%n是换行符
    -->
    %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n

SpringBoot修改日志的默认配置

logging.level.com.atguigu=trace


#logging.path=
# 不指定路径在当前项目下生成springboot.log日志
# 可以指定完整的路径；
#logging.file=G:/springboot.log

# 在当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用 spring.log 作为默认文件
logging.path=/spring/log

#  在控制台输出的日志的格式
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} - %msg%n
# 指定文件中日志输出的格式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-5level === %logger{50} ==== %msg%n

logging.file	logging.path	Example	Description
(none)	(none)		只在控制台输出
指定文件名	(none)	my.log	输出日志到my.log文件
(none)	指定目录	/var/log	输出到指定目录的 spring.log 文件中

2、指定配置

给类路径下放上每个日志框架自己的配置文件即可；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

logback.xml：直接就被日志框架识别了；

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

<springProfile name="staging">
    <!-- configuration to be enabled when the "staging" profile is active -->
  	可以指定某段配置只在某个环境下生效
</springProfile>

如：

<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <!--
        日志输出格式：
			%d表示日期时间，
			%thread表示线程名，
			%-5level：级别从左显示5个字符宽度
			%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 
			%msg：日志消息，
			%n是换行符
        -->
        <layout class="ch.qos.logback.classic.PatternLayout">
            <springProfile name="dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
            <springProfile name="!dev">
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%n</pattern>
            </springProfile>
        </layout>
    </appender>

如果使用logback.xml作为日志配置文件，还要使用profile功能，会有以下错误

no applicable action for [springProfile]

5、切换日志框架

可以按照slf4j的日志适配图，进行相关的切换；

slf4j+log4j的方式；

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <exclusions>
    <exclusion>
      <artifactId>logback-classic</artifactId>
      <groupId>ch.qos.logback</groupId>
    </exclusion>
    <exclusion>
      <artifactId>log4j-over-slf4j</artifactId>
      <groupId>org.slf4j</groupId>
    </exclusion>
  </exclusions>
</dependency>

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
</dependency>

切换为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>