springboot

spring Boot

https://spring.io/

spring boot用于开发

spring cloud（云）用于管理微服务

特征

• 创建独立的弹簧应用
• 直接嵌入 Tomcat、Jetty 或底图（无需部署 WAR 文件）
• 提供有意见的"启动器"依赖关系，以简化生成配置
• 尽可能自动配置弹簧和第三方库
• 提供生产就绪功能，如指标、运行状况检查和外部配置
• 绝对没有代码生成，也没有 XML 配置要求

spring的理念是什么

spring是为了解决企业级应用开发的复杂性而创建的，简化开发！

什么是部署

1. 将源代码生成可运行的软件包，例如 jar 包或 war 包等；
2. 将可运行的软件包放到目标环境上；
3. 配置目标环境使得软件包能够运行起来；

在ssm项目中所有的依赖都是自己来管理的，在spring boot中这些依赖都是成套的不需要自己来管理

<!--    starter-prent里面包含boot所有的starter（启动器）-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.1</version>
    </parent>

可以自己去写starter

命名要求：

官方的：spring-boot-starter-name

第三方：name-spring-boot-starter

spring boot默认扫描规则

建议把主启动类放在需要扫描包的上层

注解

@SpringBootApplication：放在主启动类上面

Spring Boot Hello Word

导包

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>test</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

2.controller

package com.example.test.pojo.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

@Slf4j/*日志*/
@RestController/*@ResponseBody和@Controller的合并*/
@RequestMapping("/user")/*网页总地址*/
public class UserController {
    /*get请求就用@GetMapping  post请求就使用@PostMapping*/
    @GetMapping("/insert")
    public String hello(){
        return "hello";
    }
}

run

@SpringBootApplication
public class TestApplication {

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

}

hello的探究

pom文件

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

它的父项目是
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.1.3.RELEASE</version>
        <relativePath>../../spring-boot-dependencies</relativePath>
    </parent>
它来真正的管理spring boot应用里面的依赖版本

spring boot版本的仲裁中心；

以后我们导入版本是不需要写版本号的（没有在dependencies中管理的自然要写版本号）

导入依赖（导入启动器）

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

spring-boot-starter-web

spring-boot-starter：springboot场景启动器；帮我们导入了web模块正常运行所依赖的组件；

spring boot 将所有的功能场景都抽取出来，做成一个一个的starter（启动器），只需要在这些项目引用这些starter相关场景的所有依赖都会导入进来，要用什么功能就导入什么场景的启动器

主程序，主入口类

package com.example.test;

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

@SpringBootApplication
public class TestApplication {

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

}

@SpringBootApplication翻译过来是springboot应用 标注在那个类上表示那个类springboot主配置类

spring boot就应该运行这个main方法来运行spring boot程序

@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 ** spring boot的配置类

​ 标注在某个类上，表示这是一个springboot的配置类

​ @Configuration配置类上来标注这个注解

​ 配置类--------配置文件

​ 配置类也是容器中的一个组件@Component

@EnableAutoConfiguration 开启自动配置功能

​ 以前我们需要配置的东西，spring boot帮我们自动配置；@EnableAutoConfiguration 告诉spring boot开启自动配置功能；这样自动配置才能生效；

​ @AutoConfigurationPackage :自动配置包
​ @lmport(AutoConfigurationPackages.Registrar.class) :
Spring的底层注解@lmport ,给容器中导入一个组件 ;导入的组件由AutoConfigurationPackages.Registrar.class ;

将主配置类( @SpringBootApplication标注的类)的所在包及下面所有子包里面的所有组件扫描到Spring容器;

EnableAutoConfigurationlmportSelector :导入哪些组件的选择器;
将所有需要导，入的组件以全类名的方式返回;这些组件就会被添加到容器中;
会给容器中导入非常多的自动配置类( xxxAutoConfiguration) ; 就是给容器中导入这个场景需要的所
有组件,并配置好这些组件;

有了自动配置类,免去了我们手动编写配置注入功能组件等的工作;
SpringFactoriesL oader.loadFactoryNames(EnableAutoConfiguration.lass,classLoader);
Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，
将这些值作为自动配置类导入到容器中，

自动配置类就生效,帮我们进行自动配置工作;以前我们需要自己配置的
东西，自动配置类都帮我们配置;

J2EE的整体整合解决方案和自动配置都在spring-boot- autoconfigure-1.5.9.RELEASE.jar

使用Spring Initializer快速创建Spring Boot项目

IDEA都支持使用Spring的项目创建向导快速创建一个Spring Boot项目;
选择我们需要的模块;向导会联网创建Spring Boot项目;

默认生成的Spring Boot项目;

• 主程序已经生成好了,我们只需要我们自己的逻辑

• resources文件夹中目录结构

• static :保存所有的静态资源; js CSS images ;

• templates :保存所有的模板页面; ( Spring Boot默认jar包使用嵌入式的Tomcat ,默认不支持]SP页
  面) ;可以使用模板引擎( freemarker, thymeleaf ) ;

• application.properties : Spring Boot应用的配置文件;

spring boot配置

配置文件

spring boot使用全局的配置文件，配置文件名是固定的；

• application.properties
• application.yml

配置文件的作用：

修改spring boot自动配置的默认值；

YAML ( YAML Ain’t Markup Language )
YAML A Markup Language :是一个标记语言
YAML isn’t Markup Language :不是一个标记语言;

标记语言:
以前的配置文件;大多都使用的是xxxx.xml文件;
YAML :以数据为中心,比json、xml等更适合做配置文件;

YAML :

server:
  port: 81

xml:

<server>
   <port>81</port>
</server>

YAML语法：

k: v 表示一对键值段（必要要有空格）

以空格来分层级关系，只要左对齐的一列数据都是同一个层级(下面示例)。

server:
    port: 80
    poth: /hello

属性和值也是大小写敏感：

值的写法

字面量：普通值（数字，字符串，布尔）

字符串默认不用加上单引号或者双引号;
“”:双引号;不会转义字符串里面的特殊字符;特殊字符会作为本身想表示的意思
name: “zhangsan \n lisi” :输出; zhangsan换行lisi

​ ":单引号;会转义特殊字符,特殊字符最终只是一 个普通的字符串数据
​ name: ‘zhangsan \n lis’ :输出; zhangsan \n lisi

对象和Map（属性和值）映射过来就是键值段

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

friends:
   lastName: zhangsan
   age: 20

行内写法：

friends: {  lastName: zhangsan,age: 20} 

数组（List, set);

用- 一个表示数组值

Animals
   - dog
   - cat

行内写法：

Animals: [dog,cat]

ConfigurationProperties注解

在application.yml实际操作：

导入文件处理器：配置文件处理就有提示了

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

@Component ->这个主键是容器组件，才能提供@ConfigurationProperties功能

@Data这个是一个引擎注解，自动生成set get方法和toString方法

@ConfigurationProperties(prefix = “person”) 告诉spring boot从配置文件哪里映射prefix从哪里开始

@Component
@Data
@ConfigurationProperties(prefix = "person")
public class Person {
    private String username;
    private Map<String,Object>map;
    private List<Object>list;
    private Date time;
    private Object[] array;
    private Dog dog;
}

yaml：

person:
  username: 王孟涛
  map: {k1: v1,k2: v2}
  list: 集合
  time: 2020/2/9
  array:
    - 数组1
    - 数组2
    - 数组3
  dog:
    username: 小杨
    age: 19

如果在application.properties中：

注意idea默认是以utf-8来编译的

如果乱码就设置

settings

File Encodings

设置成uft-8

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zs9VhMoN-1652497282926)(C:\Users\34912\Desktop\java 笔记\框架\img\1612839089063.png)]

person.username=小王
person.time=2020/07/12
person.array=array1
person.map.ke1=v1
person.map.ke2=v2
person.dog.username=小杨
person.dog.age=20
person.list=l1,l2,l3

@value和ConfigurationProperties注解的区别

 @Value("${username}")
    private String username;
  @Value("#{12+12}")
    private int age;

功能	@ConfigurationProperties	@value
特点	批量注入配置文件的属性	一个个指定
松散绑定 （松散语法）	支持	不支持
spEL(#{12+12})	不支持	支持
JSR303数据校验(@Validated)	支持	不支持
复杂类型的封装（map等）	支持	不支持

配置文件yml还是properties他们都能获取到值;
如果说,我们只是在某个业务逻辑中需要获取一下配置文件中的某项值,使用@Value ;
如果说,我们专门编写了- -个javaBean来和配置文件进行映射;

配置文件注入值数据校验

@Component
@Data
@Validated
@ConfigurationProperties(prefix = "person")
public class Person {
    @Email//取校验是不是收到的是邮箱信息
    private String username;
    private Map<String,Object>map;
    private List<Object>list;
    private Date time;
    private Object[] array;
    private Dog dog;
}

@PropertySource与@ImportResource

Property（性能）Source（来源）

@PropertySource(value = {“classpath:person.propeties”})加载指定配置文件

@PropertySource(value = {"classpath:person.propeties"})
@Component
@Data
@ConfigurationProperties(prefix = "person")
public class Person {

    private String username;
    private Map<String,Object>map;
    private List<Object>list;
    private Date time;
    private Object[] array;
    private Dog dog;
}

person.propertes的配置文件

person.username=小王
person.time=2020/07/12
person.array=array1
person.map.ke1=v1
person.map.ke2=v2
person.dog.username=小杨
person.dog.age=20
person.list=l1,l2,l3

@ImportResource

@ImportResource :导入Spring的配置文件,让配置文件里面的内容生效;
Spring Boot里面没有Spring的配置文件,我们自己编写的配置文件,也不能自动识别; .
想让Spring的配置文件生效,加载进来; @ImportResource标注在一个配置类 上

<?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="helloService" class="com.wang.springbootyaml.service.HelloService">

    </bean>
</beans>

主运行类上面

@ImportResource(locations = {"classpath:beans.xml"})
//导入spring的配置文件让他生效

spring boot 推荐给容器加组件的方式：

1.配置类==spring配置文件

/*
* @Configuration  指名当前类是一个配置类：就是用来替代之前的spring配置文件
* */
@Configuration
public class MyConfig {
    /*方法的返回值添加到对象中；容器中这组件默认id就是方法名*/
    @Bean
    public HelloService helloService(){
        System.out.println("配置类启动");
        return new HelloService();
    }

配置文件占位符

UUID（Universally Unique Identifier）全局唯一标识符，定义为一个字符串主键，采用32位数字组成，编码采用16进制，定义了在时间和空间都完全惟一的系统信息。

 #生成一个随机整数
 person.username=王${random.int}
 person.time=2020/07/12
 person.array=array1${random.uuid}
 person.map.ke1=v1
 person.map.ke2=v2
 person.dog.username=${person.username}小杨
#如果没有配置person.abc:12   ：后面就是给的默认值  只会拼接不会相加   如果没有给默认值会报错
 person.dog.age=20 ${person.abc:12}
 person.list=l1,l2,l3

profile

多profile文件

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

application.properties 默认情况使用这个配置文件

application-dev.properties

application-prod.properties

yml的配置方法

#默认是第一个的配置
#---这个是分割开每一个部分是独立的配置
#spring: profiles: dev  给这个配置取名字
server:
  port: 8080
spring:
  profiles:
    active: pord
---
server:
  port: 8081

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

激活profile

1. 在配置文件中指定：

spring.profiles.active=prod

2. 命令行：

​ --spring.profiles.active=prod

这个的优先级大于spring.profiles.active=prod

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jQYq7lvZ-1652497282928)(C:\Users\34912\Desktop\java 笔记\框架\img\1613093036559.png)]

cmd配置命令符

先打包打成packge

打包默认使用第一个配置文件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fSOujpgN-1652497282928)(C:\Users\34912\Desktop\java 笔记\框架\img\1613093463294.png)]

虚拟机参数；

-Dspring.profiles.active=prod

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EPM0abze-1652497282929)(C:\Users\34912\Desktop\java 笔记\框架\img\1613093829099.png)]

配置文件加载位置

springboot启动会扫描以下位置的application.properties或者application.yml文件作为Spring boot的默认配置
文件
file…/config/
-file:./ .
-classpath:/config/
-classpath:/

优先级由高到低，改优先级的配置会覆盖低优先级

越在外面的配置，优先级越大，包括的东西也越多

spring boot会从这四个位置全部加载主配置文件，会出现一种状况互补配置

外部配置文件加载顺序

SpringBoot也可以从以下位置加载配置;优先级从高到低;高优先级的配置覆盖低优先级的配置,所有的配置会
形成互补配置

1.命令行参数

java -jar spring boot-02-config-02-0.0.1-SNAPSHOT.jar -server.port=8087 --server .context path=/abc

多个参数使用空格分开；–配置项=值

2.来自java:comp/env的JNDI属性
3.Java系统属性( System.getProperties() )
4.操作系统环境变量
5.RandomValuePropertySource配置的random.*属性值

由jar报外向jar包内寻找：

优先加载带profile的：

6.jar包外部的application-profile}.properties或application.ym(带spring.profile)配置文件
7.jar包内部的application-{profile}.properties或application.yml(带spring.profile)配置文件

在来加载不带profile的：

8.jar包外部的application.properties或application.ym(不带spring.profile)配置文件
9.jar包内部的application.properties或application.yml(不带spring.profile)配置文件
10.@Configuration注解类.上的@PropertySource
11.通过SpringApplication.setDefaultProperties指定的默认属性

参考官方文档

自动装配的原理

配置文件到底写什么，怎么写，自动装配原理

配置文件能配置的属性参照

自动配置原理：

1. spring boot 启动时，加载主配置类，开启自动配置功能 @EnableAutoConfiguration
2. @EnableAutoConfiguration作用：

• ​ 利用 AutoConfigurationImportSelector给容器导入一些组件，
• ​ 可以插件selectImports（）方法的内容；
• ​ List configurations = this.getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置

​ SpringFactoriesLoader.loadFactoryNames(） 它是

​ 扫描类路径下jar包类路径下的 META-INF/spring.factories

​ 把扫描到的这些文件的内容包装成properties对象

​ 从properties中获取到EnableAutoConfiguration.class类(类名)对应的值，然后把他们添加在容器中

将类路径下的META-INF/spring.factories里面使有的配置EnableAutoConfiguration的值加入到容器中，

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jReactiveDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jReactiveRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.r2dbc.R2dbcRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.ElasticsearchRestClientAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.neo4j.Neo4jAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration,\
org.springframework.boot.autoconfigure.r2dbc.R2dbcTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketRequesterAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketServerAutoConfiguration,\
org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
org.springframework.boot.autoconfigure.security.rsocket.RSocketSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.saml2.Saml2RelyingPartyAutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\
org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration

每一个这样的xxxAutoConfiguration类都是容器中的- 一个组件,都加入到容器中;用他们来做自动配置;

每一个自动配置类进行自动配置功能；

以**HttpEncodingAutoConfiguration(http编码自动配置)**为例解释自动配置原理；

@Configuration //表示这是一 一个配置类，以前编写的配置文件一样,也可以给容器中添加组件
@EnableConfigurationProperties (HttpEncodingProperties.class) //启动指定类的ConfigurationProperties功能;将配置文件中对应的值和HttpEncodingProperties绑定起来;并把HttpEncodingProperties加入到ioc容器中

@ConditionalOnWebApplication //Spr ing底层@Conditional注解( Spring注解版)， 根据不同的条件,如果满足指定的条件，整个配置类里面的配置就会生效;判断当前应 用是否是web应用,如果是，当前配置类生效

@ConditionalOnClass (CharacterEncodingFilter.class) //判断当前项目有没有这个类CharacterEncodingFilter ; SpringMVC中进行乱码解决的过滤器; 

@ConditionalOnProperty(prefix = "spring. http. encoding", value = "enabled"，matchIfMissing =true) //判断配置文件中是否存在某个配置 spring . http. encoding . enabled ;如果不存在，判断也是成立的
//即使我们配置文件中不配置pring . http. encoding. enabled=true，也是默认生效的; 
public class HttpEncodingAutoConfiguration {
    
    //他已经和SpringBoot的配置文件映射了
private final HttpEncodingProperties properties;
//只有一一个有参构造器的情况下，参数的值就会从容器中拿
public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
this.properties = properties;
}
@Bean
//给容器中添加一一个组件，这个组件的某些值需要从properties中获取
@ConditionalOnMissingBean(CharacterEncodingFilter.class)
public CharacterEncodingFilter characterEncodingFilter() {
CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
filter. setEncoding(this . properties. getCharset().name());
filter . setForceRequestEncoding(this . properties . shouldForce(Type . REQUEST));
filter . setForceResponseEncoding(this . properties. shouldForce(Type . RESPONSE));
return filter;
}

根据当前不同的条件判断，决定这个配置是否生效？

一但这个配置类生效 ;这个配置类就会给容器中添加各种组件;这些组件的属性是从对应的properties类中获取
的,这些类里面的每一个属性又 是和配置文件绑定的;

所有在配置文件中能配置的属性都是在xxxxProperties类中封装者’;配置文件能配置什么就可以参照某个功
能对应的这个属性类

@ConfigurationProperties(prefix = "spring. http. encoding") //从配置文件中获取指定的值和bean的属性
进行绑定
public class HttpEncodingProperties {
public static final Charset DEFAULT CHARSET = Charset. forName("UTF-8");

精髓：

1)、SpringBoot启动会加载大量的自动配置类

2)、我们看我们需要的功能有没有SpringBoot默认写好的自动配置类;

3)、我们再来看这个自动配置类中到底配置了哪些组件; (只要我们要用的组件有,我们就不需要再来配置了)

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

xxxxAutoConfigurartion :自动配置类;

给容器中添加组件

xxxxProperties:封装配置文件中相关属性;

细节

1、@Conditional派生注解 ( Spring注解版原生的@Conditional作用)

作用:必须是@Conditional指定的条件成立,才给容器中添加组件,配置配里面的所有内容才生效;

条件注解	对应的Condition 处理类	处理逻辑
@ConditionalOnBean	OnBeanCondition	Spring容器中是否存在对应的实例。可以通过实例的类型、类名、注解、昵称去容器中查找(可以配置从当前容器中查找或者父容器中查找或者两者一起查找)
@ConditionalOnClass	OnClassCondition	类加载器中是否存在对应的类。可以通过Class指定(value属性)或者Class的全名指定(name属性)如果是多个类或者多个类名的话，关系是”与”关系，也就是说这些类或者类名都必须同时在类加载器中存在
@ConditionalOnExpression	OnExpressionCondition	判断SpEL 表达式是否成立
@ConditionalOnMissingBean	OnBeanCondition	Spring容器中是否缺少对应的实例。可以通过实例的类型、类名、注解、昵称去容器中查找(可以配置从当前容器中查找或者父容器中查找或者两者一起查找)
@ConditionalOnMissingClass	OnClassCondition	跟ConditionalOnClass的处理逻辑一样，只是条件相反，在类加载器中不存在对应的类
@ConditionalOnProperty	OnPropertyCondition	应用环境中的屬性是否存在。提供prefix、name、havingValue以及matchIfMissing属性。prefix表示属性名的前缀，name是属性名，havingValue是具体的属性值，matchIfMissing是个boolean值，如果属性不存在，这个matchIfMissing为true的话，会继续验证下去，否则属性不存在的话直接就相当于匹配不成功
@ConditionalOnResource	OnResourceCondition	是否存在指定的资源文件。只有一个属性resources，是个String数组。会从类加载器中去查询对应的资源文件是否存在
@ConditionalOnSingleCandidate	OnBeanCondition	Spring容器中是否存在且只存在一个对应的实例。只有3个属性value、type、search。跟ConditionalOnBean中的这3种属性值意义一样
@ConditionalOnWebApplication	OnWebApplicationCondition	应用程序是否是Web程序，没有提供属性，只是一个标识。会从判断Web程序特有的类是否存在，环境是否是Servlet环境，容器是否是Web容器等

自动配置必须要在一定环境下才会生效

​ 我怎么才能知道那些自动配置类生效

​ 在配置中启用debug=true属性；来让控制台来打印自动配置报告，

CONDITIONS EVALUATION REPORT
============================


Positive matches:（匹配成功）
-----------------

   AopAutoConfiguration matched:
      - @ConditionalOnProperty (spring.aop.auto=true) matched (OnPropertyCondition)

   AopAutoConfiguration.ClassProxyingConfiguration matched:
      - @ConditionalOnMissingClass did not find unwanted class 'org.aspectj.weaver.Advice' (OnClassCondition)
      - @ConditionalOnProperty (spring.aop.proxy-target-class=true) matched (OnPropertyCondition)
          
          
                                        
Negative matches:(没有匹配成功)
-----------------

   ActiveMQAutoConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)

   AopAutoConfiguration.AspectJAutoProxyingConfiguration:
      Did not match:
         - @ConditionalOnClass did not find required class 'org.aspectj.weaver.Advice' (OnClassCondition)

日志

市面上的日志框架;

JUL、JCL、Jboss-logging. logback. log4j、 log4j2、 s4…

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

左边选一个门面(抽象层)、右边来选一个实现;

日志门面: SLF4J ;

日志实现: Logback ;

SpringBoot :底层是Spring框架, Spring框架默认是用JCL ;

SpringBoot选用SLF4j和logback ;

SLF4j使用

1. 如何在系统中使用SLF4j

以后开发的时候，日志记录方法的调用，不应该来直接调用日志对方的实现类，而是调用日志抽象层里面的方法；给系统里面导入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");
  }
}

图示：导包需要

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tVBzca0c-1652497282930)(C:\Users\34912\Desktop\java 笔记\框架\img\concrete-bindings.png)]

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

2.遗留问题

如何统一使用SLF4J

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HY9ixCAn-1652497282930)(C:\Users\34912\Desktop\java 笔记\框架\img\legacy.png)]

如何让系统中所有的日志都统一到sIf4j ;

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

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

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

spring boot 日志关系

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

spring boot 使用它来做日志功能

  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-logging</artifactId>
      <version>2.4.2</version>
      <scope>compile</scope>
    </dependency>

底层依赖关系：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZF6FSR7X-1652497282931)(C:\Users\34912\Desktop\java 笔记\框架\img\image-20210222103236118.png)]

总结:

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

2)、SpringBoot也把其他的日志都替换成了slf4j ;

3)、中间替换包?

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8Vn9p6Ze-1652497282931)(C:\Users\34912\Desktop\java 笔记\框架\img\image-20210222105113976.png)]

如果我们要引入其他框架?-定要把这个框架的默认日志依赖移除掉?
Spring框架用的是commons-logging ;

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

SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只

需要把这个框架依赖的日志框架排除掉;

日志使用

@RunWith(SpringRunner.class)
@SpringBootApplication
public class SpringBootLoggingApplication {
        Logger logger = LoggerFactory.getLogger(getClass());
        //日志级别
        //从低到高 trace<debug<info<warn<error
        //可以调节日志的输出级别
        @Test
                public void test(){
                logger.trace("这是trace");
                logger.debug("这是debug");
                logger.info("这是info");
                logger.warn("这是warn");
                logger.error("这是error");
        }
}

logging.level.com.wang=warn
#不指定路径在本项目中生成日志
#指定路径在路径下生成日志
#logging.file=D:/spring.log
#指定路径
logging.path=spring/log
#设置文件的格式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-51eve1 === %logger{50} ==== %msg%n

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

你可以用thymeleaf 用这个引擎在做，类似jsp 但是比jsp好很多，直接就可以在网页运行，不需要tomcat

但是又一些语法

如：th:text

th:href

th:src

很多，thymeleaf官网有介绍，你明天可以试试这个引擎，

动态的要建立在temp这个文件夹下面，不然spring Boot 找不到，static这个是css js sass less 图片等静态类容放的文件夹！欧克我还是先学springboot学完了在学这些东西,把 css js 可以学, less sass 不用，学多了装不下，容易忘,

SpringBoot能自动适配所有的日志，而且底层使用slf4j+logback的方式记录日志，引入其他框架的时候，只

需要把这个框架依赖的日志框架排除掉;





## 日志使用

```java
@RunWith(SpringRunner.class)
@SpringBootApplication
public class SpringBootLoggingApplication {
        Logger logger = LoggerFactory.getLogger(getClass());
        //日志级别
        //从低到高 trace<debug<info<warn<error
        //可以调节日志的输出级别
        @Test
                public void test(){
                logger.trace("这是trace");
                logger.debug("这是debug");
                logger.info("这是info");
                logger.warn("这是warn");
                logger.error("这是error");
        }
}

logging.level.com.wang=warn
#不指定路径在本项目中生成日志
#指定路径在路径下生成日志
#logging.file=D:/spring.log
#指定路径
logging.path=spring/log
#设置文件的格式
logging.pattern.file=%d{yyyy-MM-dd} === [%thread] === %-51eve1 === %logger{50} ==== %msg%n

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

你可以用thymeleaf 用这个引擎在做，类似jsp 但是比jsp好很多，直接就可以在网页运行，不需要tomcat

但是又一些语法

如：th:text

th:href

th:src

很多，thymeleaf官网有介绍，你明天可以试试这个引擎，

动态的要建立在temp这个文件夹下面，不然spring Boot 找不到，static这个是css js sass less 图片等静态类容放的文件夹！欧克我还是先学springboot学完了在学这些东西,把 css js 可以学, less sass 不用，学多了装不下，容易忘,