SpringBoot2（1） 基础篇 自动配置

SpringBoot系列：

SpringBoot2（2）应用篇 web开发

SpringBoot2（3）应用篇 数据访问 单元测试Junit5 指标监控Actuator 高级特性profile

01、SpringBoot基础入门

1.1、 SpringBoot的优点

（1）SpringBoot可以快速创建出生产级别的Spring应用

（2）内嵌web服务器

（3）自动starter依赖，简化构建配置

（4）自动配置Spring以及第三方功能

（5）提供生产级别的监控、健康检查及外部化配置

（6）无代码生成、无需编写XML

总结：

SpringBoot是整合Spring技术栈的一站式框架

SpringBoot是简化Spring技术栈的快速开发脚手架

1.2 SpringBoot的缺点

（1）人称版本帝，迭代快，需要时刻关注变化

（2）封装太深，内部原理复杂，不容易精通

2、时代背景  微服务与分布式 https://blog.csdn.net/chengqingshihuishui/article/details/110788281

02 SpringBoot2入门

1、系统要求（现在应该要求更高了）

• Java 8 & 兼容java14 .
• Maven 3.3+
• idea 2019.1.2

1.1 maven设置（pom.xml中的maven本身相关标签） 配置好jdk版本  plugin，profile，proties标签都可以设置

https://blog.csdn.net/chengqingshihuishui/article/details/110453732

2、HelloWorld

2.1 创建maven工程

2.2 引入依赖

        org.springframework.boot
        spring-boot-starter-parent
        2.3.4.RELEASE


    
        
            org.springframework.boot
            spring-boot-starter-web
        

    

说明：引入parent标签，该标签会自动管理SpringBoot中模块的版本（版本仲裁），使用SpringBoot  factory中的组件，都不用写版本号了。

2.3 创建主程序

/**
 * 主程序类
 * @SpringBootApplication：这是一个SpringBoot应用
 */
@SpringBootApplication
public class MainApplication {

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

2.4 编写业务

@RestController  /* @Controller + @ResponseBody*/
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(){
        return "Hello, Spring Boot 2!";
    }
}

@RestController注解相当于@ResponseBody（根据配置好的视图解析器返回页面） ＋ @Controller合在一起的作用

如果只是使用@RestController注解Controller，则Controller中的方法无法返回jsp页面，配置的视图解析器InternalResourceViewResolver不起作用，返回的内容就是Return 里的内容。

但是，SpringBoot不支持jsp，所以使用了使用@RestController这个注解，就不能返回jsp,html页面，视图解析器无法解析jsp,html页面

2.5 测试

直接运行main方法

2.6 简化配置

application.properties

server.port=8888

2.7 简化部署（pom.xml中）

        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        

把项目打成jar包，直接在目标服务器执行即可。

注意点：

• 取消掉cmd的快速编辑模式

03 自动配置原理

1、SpringBoot特点

1.1 依赖管理

依赖管理    

        org.springframework.boot
        spring-boot-starter-parent
        2.3.4.RELEASE


他的父项目
 
    org.springframework.boot
    spring-boot-dependencies
    2.3.4.RELEASE
  

几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制
1、引入依赖默认都可以不写版本
2、引入非版本仲裁的jar，要写版本号。

修改默认版本号 pom.xml中，用properties标签修改（maven的功能）

https://blog.csdn.net/chengqingshihuishui/article/details/110453732 参考里面的自定义属性

        1.8
        5.1.49

导入stater场景启动器

1、见到很多 spring-boot-starter-* ： *就某种场景
2、只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景
https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4、见到的  *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖

  org.springframework.boot
  spring-boot-starter
  2.3.4.RELEASE
  compile

特别说明：starter帮我导入了所有依赖，更爽的是，starter帮我们写好了默认的自动配置（1.2节）。修改自动配置，只需要写配置文件即可

1.2 自动配置

    org.springframework.boot
    spring-boot-starter-tomcat
    2.3.4.RELEASE
    compile

以上starter会：

（1）自动配好Tomcat

• 引入Tomcat依赖。
• 配置Tomcat

（2）自动配好SpringMVC

• 引入SpringMVC全套组件
• 自动配好SpringMVC常用组件（功能）

（3）自动配好Web常见功能，如：字符编码问题

 

• SpringBoot帮我们配置好了所有web开发的常见场景

（4）默认的包结构

• 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来
• 无需以前的包扫描配置
• 想要改变扫描路径，@SpringBootApplication(scanBasePackages="com.atguigu")或者@ComponentScan 指定扫描路径

@SpringBootApplication
= @SpringBootConfiguration
+ @EnableAutoConfiguration（帮助SpringBoot应用将所有符合条件的@Configuration配置都加载到当前SpringBoot，并创建对应配置类的Bean，并把该Bean实体交给IoC容器进行管理。）
+ @ComponentScan("com.atguigu.boot")

（5）各种配置拥有默认值

• 默认配置最终都是映射到某个类上，如：MultipartProperties
• 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象

（6）按需加载所有自动配置项

• 非常多的starter
• 引入了哪些场景这个场景的自动配置才会开启
• SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面（除了SpringBoot自带的，还可以自己找一堆第三方starter）

2、容器功能

2.1 组件添加

复习链接前面的spring注解版的@Bean、@Component、@Controller、@Service、@Repository、@ComponentScan、@Import、@Conditional

https://blog.csdn.net/chengqingshihuishui/article/details/115417673 

 

特别讲（1）：@Configuration  （配置类中添加组件，就像原来在xml配置文件中添加组件）

Lite模式： 配置类组件 之间无依赖关系用Lite模式加速容器启动过程，减少判断

Full模式：配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 * Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
 * Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
 *      组件依赖必须使用Full模式默认。其他默认是否Lite模式
 */

@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.atguigu.boot")
public class MainApplication {

    public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        //3、从容器中获取组件

        Pet tom01 = run.getBean("tom", Pet.class);

        Pet tom02 = run.getBean("tom", Pet.class);

        System.out.println("组件："+(tom01 == tom02));


        //4、去查找MyConfig类里面的Bean（MyConfig需要有@Configuration）
        MyConfig bean = run.getBean(MyConfig.class);
        System.out.println(bean);

        //如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
        //保持组件单实例
        User user = bean.user01();
        User user1 = bean.user01();
        System.out.println(user == user1);


        User user01 = run.getBean("user01", User.class);
        Pet tom = run.getBean("tom", Pet.class);

        System.out.println("用户的宠物："+(user01.getPet() == tom));
    }
}

特别讲（2）@Conditional  衍生出的 ConditionalOnMissingBean 和 ConditionalOnBean

https://docs.spring.io/spring-boot/docs/2.4.5/reference/htmlsingle/#boot-features-bean-conditions

条件装配：满足Conditional指定的条件，则进行组件注入

@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
//@ConditionalOnBean(name = "tom")
@ConditionalOnMissingBean(name = "tom")
public class MyConfig {


    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */

    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom22")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

public static void main(String[] args) {
        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //2、查看容器里面的组件
        String[] names = run.getBeanDefinitionNames();
        for (String name : names) {
            System.out.println(name);
        }

        boolean tom = run.containsBean("tom");
        System.out.println("容器中Tom组件："+tom);

        boolean user01 = run.containsBean("user01");
        System.out.println("容器中user01组件："+user01);

        boolean tom22 = run.containsBean("tom22");
        System.out.println("容器中tom22组件："+tom22);
    }

2.2  原生配置文件引入

（1）@ImportResource

https://docs.spring.io/spring-boot/docs/2.4.5/reference/htmlsingle/#boot-features-bean-conditions

（3.3.2. Importing XML Configuration）

如果绝对必须使用基于XML的配置，我们建议您仍然从一个@Configuration类开始。然后，您可以使用@ImportResource批注来加载XML配置文件。

@ImportResource("classpath:beans.xml")
public class MyConfig {
       \\接上面config代码
        boolean haha = run.containsBean("haha");
        boolean hehe = run.containsBean("hehe");
        System.out.println("haha："+haha);//true
        System.out.println("hehe："+hehe);//true

}

2.3 配置绑定

（1）@ConfigurationProperties

该注解有一个prefix属性，通过指定的前缀，绑定配置文件中的配置，该注解可以放在类上，也可以放在方法上

表示使用配置文件中前缀为user1的属性的值初始化该bean定义产生的的bean实例的同名属性

配置文件：

mycar.brand=Audi

mycar.price=300000

@ConfigurationProperties和@Value赋值的差异 见

https://blog.csdn.net/chengqingshihuishui/article/details/110788281

/**
 * 只有在容器中的组件，才会拥有SpringBoot提供的强大功能
 */
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {

    private String brand;
    private Integer price;

   //get，set，toString  后面可以用@Data注解搞定

（2）@EnableConfigurationProperties

使使用 @ConfigurationProperties 注解的类生效。

如果一个配置类只配置@ConfigurationProperties注解，而没有使用@Component，那么在IOC容器中是获取不到properties 配置文件转化的bean。说白了 @EnableConfigurationProperties 相当于把使用 @ConfigurationProperties 的类进行了一次注入。
测试发现 @ConfigurationProperties 与 @EnableConfigurationProperties 关系特别大。

在某个启动类，或者测试类中，使用@EnableConfigurationProperties，激活（1）中的car

@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
//@ConditionalOnBean(name = "tom")
@ConditionalOnMissingBean(name = "tom")
@EnableConfigurationProperties(Car.class)
//1、开启Car配置绑定功能
//2、把这个Car这个组件自动注册到容器中
public class MyConfig {
}

 

3、自动配置原理入门

3.1 引导加载自动配置类

启动类上面的@SpringBootApplication注解

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
        @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication{
}

该注解综合了@SpringBootConfiguration+@EnableAutoConfiguration+@ComponentScan

（1）@SpringBootConfiguration

@SpringBootConfiguration继承自@Configuration，二者功能也一致，标注当前类是配置类，
并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到spring容器中，并且实例名就是方法名。

根据Spring文档， @ SpringBootConfiguration只是Spring标准@Configuration批注的替代方法。 两者之间的唯一区别是@SpringBootConfiguration允许自动找到配置。

（2）@ComponentScan

指定扫描哪些，该注解是Spring注解；

（3）@EnableAutoConfiguration 

自动配置的核心注解，可以继续分解成@AutoConfigurationPackage+@Import(AutoConfigurationImportSelector.class)

① @AutoConfigurationPackage

自动配置包？指定了默认的包规则

AutoConfigurationPackage注解的作用是将 添加该注解的类所在的package 作为 自动配置package 进行管理。

        可以通过 AutoConfigurationPackages 工具类获取自动配置package列表。当通过注解@SpringBootApplication标注启动类时，已经为启动类添加了@AutoConfigurationPackage注解。路径为 @SpringBootApplication -> @EnableAutoConfiguration -> @AutoConfigurationPackage。也就是说当SpringBoot应用启动时默认会将启动类所在的package作为自动配置的package。
参考：https://blog.csdn.net/ttyy1112/article/details/101284541

② @Import(AutoConfigurationImportSelector.class)

1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
2、调用List configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
3、利用工厂加载 Map> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
4、从META-INF/spring.factories位置来加载一个文件。
    默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件（为了SpringBoot能扫描到配置，我们自己写的starter一定要创建这个META-INF/spring.factories）
    spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

文件里面写死了spring-boot一启动就要给容器中加载的所有配置类
spring-boot-autoconfigure-2.3.4.RELEASE.jar/META-INF/spring.factories 文件：
# 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,\

总结：

（1）、 @Import(AutoConfigurationPackages.Registrar.class)，实现是将主配置类（@SpringBootApplication）标注的所有包及子包里面的所有组件扫描到Spring容器当中。
（2）、 @Import(AutoConfigurationImportSelector.class)，实现的是SpringBoot 在启动的时候从类路径下的 META-INF/spring.factores 中获取EnableAutoConfiguration指定的值，将这些作为自动配置类导入到容器当中，自动配置类就生效，帮我们进行自动配置的工作。

3.2 按需开启自动配置

虽然我们127个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration
按照条件装配规则（@Conditional），最终会按需配置。

3.3 修改默认配置

SpringBoot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先

原理是：默认配置注解上都会有ConditionalOnMissingBean，一旦有了自己的Bean，自然默认Bean就不会生效了

比如：

@Bean
@ConditionalOnBean(MultipartResolver.class)  //容器中有这个类型组件
@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) //容器中没有这个名字 multipartResolver 的组件
public MultipartResolver multipartResolver(MultipartResolver resolver) {
//给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
//SpringMVC multipartResolver。防止有些用户配置的文件上传解析器不符合规范
// Detect if the user has created a MultipartResolver but named it incorrectly
  return resolver;
}

上例就会使用自己的解析器，而不是默认的

总结：

• SpringBoot先加载所有的自动配置类  xxxxxAutoConfiguration
• 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定
• 生效的配置类就会给容器中装配很多组件
• 只要容器中有这些组件，相当于这些功能就有了
• 定制化配置

① 用户直接自己@Bean替换底层的组件

② 用户去看这个组件是获取的配置文件什么值就去修改。

xxxxxAutoConfiguration ---> 组件  ---> xxxxProperties里面拿值  ----> application.properties

4、开发小工具

4.1 Lombok https://projectlombok.org/

这个工具用一个@Data注解，就可以帮你写get，set，toString方法，让你的代码更加简洁

使用方法：

Step1：maven添加依赖

    org.projectlombok
    lombok

Step2：添加配合lombok工作的IDEA插件   https://projectlombok.org/setup/intellij

官网特别说明：从2020.3版开始，Jetbrains IntelliJ IDEA编辑器不需要插件就可以与lombok兼容。

Step3：在Bean组件上，添加lombok的注解 https://projectlombok.org/features/all

@NoArgsConstructor
//@AllArgsConstructor
@Data
@ToString
@EqualsAndHashCode
public class User {

    private String name;
    private Integer age;
    private Pet pet;
}

以上注解通通看官网，最常用的是@Data 

4.2 dev-tools

这个工具可以让你的项目 和 页面 修改以后直接Ctrl+F9 就快速重新部署。

使用方法

     org.springframework.boot
     spring-boot-devtools
     true

4.3 超级神器  Spring Initailizr（项目初始化向导）

可以根据我们选择好的开发场景，自动导入依赖，自动创建项目结构，自动编写好主配置类。

04 配置文件

1、文件类型

1.1 properties

同以前的properties用法

1.2 yaml

https://blog.csdn.net/chengqingshihuishui/article/details/110788281  6.2 yaml语言

YAML语言是一个以数据为中心的语言（是一个标记语言，又不是一个标记语言），比json、xml等更适合做配置文件

2、配置提示（maven小工具）

自定义的类和配置文件绑定一般没有提示。 在pom.xml中，加入以下，就会有提示。

        
            org.springframework.boot
            spring-boot-configuration-processor
            true
        


 
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            org.springframework.boot
                            spring-boot-configuration-processor
                        
                    
                
            
        
    

 

一、项目：boot-01-helloworld

二、项目：boot-01-helloworld2

三、项目：boot-05-web-01-admin 拦截器

四、项目：boot-09-profile

五、项目：boot-09-customer-starter  无关的依赖通通删除，这个案例只做一个starter

可以仿照一个starter写注解、

boot-09-hello 引入自定义starter