SpringBoot再学习（学不死，就往死里学！）
SpringBoot学习
1、SpringBoot入门
1、Spingboot简介
简化Spring应用开发的框架；整个Spring技术栈的大整合；J2EE开发的一站式解决方案；嵌入式的Servlet容器；大量的自动配置简化开发；starts自动依赖与版本控制。
2、创建maven项目
idea配置manven,设置为本地配置文件及本地maven仓库。
3、导入springboot相关依赖
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.0.0.RELEASEversion>
parent>
<dependencies>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-maven-pluginartifactId>
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.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.0.0.RELEASEversion>
parent>
它的父项目是：
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-dependenciesartifactId>
<version>2.0.0.RELEASEversion>
<relativePath>../../spring-boot-dependenciesrelativePath>
parent>
它来管理spring应用里所有的依赖版本
springboot的版本仲裁中心：
以后我们导入的依赖默认不需要版本号(没有在dependencies里管理的依赖任然需要声明版本号)
启动器：
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
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.csdn.net/tripleDemo/article/details/100136478
3、idea使用lombok
简化实体类get、set、tostring、构造器的书写：（偷懒、装13专用）
①安装插件
②导入依赖
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.10version>
<scope>providedscope>
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…
| 日志门面 （日志的抽象层） | 日志实现 |
|---|---|
左边选一个门面（抽象层）、右边来选一个实现；
日志门面： 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.bootgroupId>
<artifactId>spring-boot-starterartifactId>
dependency>
SpringBoot使用它来做日志功能；
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-loggingartifactId>
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.springframeworkgroupId>
<artifactId>spring-coreartifactId>
<exclusions>
<exclusion>
<groupId>commons-logginggroupId>
<artifactId>commons-loggingartifactId>
exclusion>
exclusions>
dependency>
SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只需要把这个框架依赖的日志框架排除掉即可；
4、日志使用；
1、默认配置
SpringBoot默认帮我们配置好了日志；
//记录器
Logger logger = LoggerFactory.getLogger(getClass());
@Test
public void contextLoads() {
//System.out.println();
//日志的级别；
//由低到高 trace
//可以调整输出的日志级别；日志就只会在这个级别以以后的高级别生效
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">
可以指定某段配置只在某个环境下生效
springProfile>
如：
<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
<layout class="ch.qos.logback.classic.PatternLayout">
<springProfile name="dev">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ----> [%thread] ---> %-5level %logger{50} - %msg%npattern>
springProfile>
<springProfile name="!dev">
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} ==== [%thread] ==== %-5level %logger{50} - %msg%npattern>
springProfile>
layout>
appender>
如果使用logback.xml作为日志配置文件，还要使用profile功能，会有以下错误
no applicable action for [springProfile]
5、切换日志框架
可以按照slf4j的日志适配图，进行相关的切换；
slf4j+log4j的方式；
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
<exclusions>
<exclusion>
<artifactId>logback-classicartifactId>
<groupId>ch.qos.logbackgroupId>
exclusion>
<exclusion>
<artifactId>log4j-over-slf4jartifactId>
<groupId>org.slf4jgroupId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>org.slf4jgroupId>
<artifactId>slf4j-log4j12artifactId>
dependency>
切换为log4j2
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
<exclusions>
<exclusion>
<artifactId>spring-boot-starter-loggingartifactId>
<groupId>org.springframework.bootgroupId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-log4j2artifactId>
dependency>