二、SpringBoot核心教程之自动配置原理解析

最新推荐文章于 2024-06-29 07:00:00 发布

猿小许

最新推荐文章于 2024-06-29 07:00:00 发布

阅读量196

点赞数

分类专栏： SpringBoot2教程文章标签： spring boot java spring

本文链接：https://blog.csdn.net/weixin_44205087/article/details/122686778

版权

SpringBoot2教程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

前言

本节更详细地介绍了如何使用 Spring Boot。它涵盖了诸如构建系统、自动配置以及如何运行应用程序等主题。我们还介绍了一些 Spring Boot 最佳实践。尽管 Spring Boot 没有什么特别之处（它只是您可以使用的另一个库），但有一些建议可以让您的开发过程更轻松一些。

如果您刚开始使用 Spring Boot，您可能应该在深入了解本节之前阅读SpringBoot入门指南。

一、构建系统

1.1 依赖管理

Spring Boot 的每个版本都提供了它支持的依赖项的精选列表。实际上，您不需要在构建配置中为任何这些依赖项提供版本，因为 Spring Boot 会为您管理。当您升级 Spring Boot 本身时，这些依赖项也会以一致的方式升级。

如果需要，您仍然可以指定版本并覆盖 Spring Boot 的建议。

依赖管理    
<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
</parent>

他的父项目
 <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.4.RELEASE</version>
  </parent>

几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

1.2 Starters 启动器

Starters 是一组方便的依赖描述符，您可以将其包含在您的应用程序中。您可以获得所需的所有 Spring 和相关技术的一站式商店，而无需搜索示例代码和复制粘贴加载的依赖描述符。例如，如果您想开始使用 Spring 和 JPA 进行数据库访问，请将spring-boot-starter-data-jpa依赖项包含在您的项目中。

启动器包含许多依赖项，您需要这些依赖项使项目快速启动并运行，并具有一致的、受支持的托管传递依赖项集。

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、所有场景启动器最底层的依赖
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
  <version>2.3.4.RELEASE</version>
  <scope>compile</scope>
</dependency>

1、引入依赖默认都可以不写版本
2、引入非版本仲裁的jar，要写版本号
查看spring-boot-dependencies里面规定当前依赖的版本用的key.
在当前项目里面重写配置

 <properties>
          <mysql.version>5.1.43</mysql.version>
</properties>

以下应用程序启动器由该org.springframework.boot组下的 Spring Boot 提供：
在这里插入图片描述

1.3 自动配置

1、 ctrl+点击pom.xml文件中的spring-boot-starter-web可以打开starter-web的配置信息
在这里插入图片描述
在这个文件中，我们可以看到又自动配置了

1、自动配好SpringMVC
    ○ 自动配好SpringMVC
    ○ 自动配好SpringMVC常用组件（功能）
2、自动配好Web常见功能，如：字符编码问题   
    ○ SpringBoot帮我们配置好了所有web开发的常见场景
3、默认的包结构
    ○ 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来，无需以前的包扫描配置
    ○ 想要改变扫描路径，在服务启动类上面加上注解@ComponentScan
        如下：
             @SpringBootConfiguration
             @EnableAutoConfiguration
             @ComponentScan("com.atguigu.boot")
4、按需加载所有自动配置项
  ○ 非常多的starter
  ○ 引入了哪些场景这个场景的自动配置才会开启
  ○ SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

在这里插入图片描述

二、容器功能

2.1 组件添加

2.1.1 @Configuration

Full模式与Lite模式

类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断
配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式

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

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

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @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");
    }
}


################################@Configuration测试代码如下########################################
@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、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
        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.1.2 @Import

@Import({User.class, DBHelper.class}) 给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名

@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}

2.1.3 @Conditional （条件装配）

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

@ConditionalOnProperty 注解
@ConditionalOnMissingBean注解

@ConditionalOnMissingBean，它是修饰bean的一个注解，主要实现的是，当你的bean被注册之后，如果而注册相同类型的bean，就不会成功，它会保证你的bean只有一个，即你的实例只有一个，当你注册多个相同的bean时，会出现异常，以此来告诉开发人员。

@Component
public class AutoConfig {
  @Bean
  public AConfig aConfig() {
    return new AConfig("lind");
  }
 
  @Bean
  @ConditionalOnMissingBean(AMapper.class)
  public AMapper aMapper1(AConfig aConfig) {
    return new AMapperImpl1(aConfig);
  }
 
  @Bean
  public AMapper aMapper2(AConfig aConfig) {
    return new AMapperImpl2(aConfig);
  }
}

因为在aMapper1上面标识了AMapper类型的bean只能有一个实现 @ConditionalOnMissingBean(AMapper.class)，所以在进行aMapper2注册时，系统会出现上面图上的异常，这是正常的。
当我们把 @ConditionalOnMissingBean(AMapper.class) 去掉之后，你的bean可以注册多次，这时需要用的@Primary来确定你要哪个实现；一般来说，对于自定义的配置类，我们应该加上@ConditionalOnMissingBean注解，以避免多个配置同时注入的风险。

@Primary标识哪个是默认的bean

@Bean
public AMapper aMapper1(AConfig aConfig) {
  return new AMapperImpl1(aConfig);
}
 
@Bean
@Primary
public AMapper aMapper2(AConfig aConfig) {
  return new AMapperImpl2(aConfig);
}

@ConditionalOnProperty
通过其三个属性prefix,name以及havingValue来实现的，其中prefix表示配置文件里节点前缀，name用来从application.properties中读取某个属性值，havingValue表示目标值。

如果该值为空，则返回false;
如果值不为空，则将该值与havingValue指定的值进行比较，如果一样则返回true;否则返回false。
返回值为false，则该configuration不生效；为true则生效。
下面代码演示为配置文件lind.redis.enable为true时才会注册RedisFactory这个bean

@Configuration
@ConditionalOnProperty(prefix="lind.redis",name = "enable", havingValue = "true")
public class RedisConfig {
  @Bean
  public RedisMap redisMap(){
    return new RedisMapImpl();
  }
}

@ConditionalOnBean // 当给定的在bean存在时,则实例化当前Bean
@ConditionalOnMissingBean // 当给定的在bean不存在时,则实例化当前Bean
@ConditionalOnClass // 当给定的类名在类路径上存在，则实例化当前Bean
@ConditionalOnMissingClass // 当给定的类名在类路径上不存在，则实例化当前Bean

2.2 原生配置文件引入

2.2.1 @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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="haha" class="stu01.com.bean.User">
        <property name="name" value="zhangsan"></property>
        <property name="id" value="18"></property>
    </bean>

    <bean id="hehe" class="stu01.com.bean.User">
        <property name="name" value="lisi"></property>
        <property name="id" value="20"></property>
    </bean>
</beans>

测试

package stu01.com.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import stu01.com.bean.User;

@Configuration
@ImportResource("classpath:beans.xml")
public class Myconfig {
    @Autowired
    ApplicationContext applicationContext;

    @Bean
    public User getUser(){
        applicationContext.getBean("myconfig");
        boolean haha = applicationContext.containsBean("haha");
        boolean hehe = applicationContext.containsBean("hehe");
        System.out.println("haha："+haha);//true
        System.out.println("hehe："+hehe);//true
        User user=(User) applicationContext.getBean("haha");
        System.out.println(user.toString());
        return user;
    }
}

2.3 配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用；

package stu01.com.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import stu01.com.bean.User;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;

@Configuration
@ImportResource("classpath:beans.xml")
public class Myconfig {
    @Autowired
    ApplicationContext applicationContext;

    @Bean
    public User getUser() throws IOException {
        Properties pps = new Properties();
        pps.load(new FileInputStream("E:\\IdealWork\\SpringBootStu\\Stu01\\src\\main\\resources\\a.properties"));
        Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
        User user = new User();
        while(enum1.hasMoreElements()) {
            String strKey = (String) enum1.nextElement();
            String strValue = pps.getProperty(strKey);
            System.out.println(strKey + "=" + strValue);
            //封装到JavaBean。
           if(strKey.equals("name")){
               user.setName(strValue);
           }
           if(strKey.equals("id")){
               user.setId(strValue);
           }

        }
        System.out.println(user.toString());
        return user;
    }
}

结果：
在这里插入图片描述

2.3.1 使用注解获取配置文件中的配置信息

@ConfigurationProperties(prefix = “mycar”） 在需要被注入值的类上添加注解，prefix的值，与配置文件中的前缀一一对应。

package stu01.com.bean;


import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "user-info")
public class User {
    String name;
    String id;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                '}';
    }
}

application.properties配置文件

userInfo.name="lisi"
userInfo.id=88888

@Configuration
@ConfigurationProperties(prefix = “user-info”)
@EnableConfigurationProperties(User.class)

在配置类上添加以上注解测试

package stu01.com.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.ImportResource;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import stu01.com.bean.User;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Properties;

@Configuration
@ConfigurationProperties(prefix = "user-info")
@EnableConfigurationProperties(User.class)
public class Myconfig {
    @Autowired
    ApplicationContext applicationContext;

    @Bean
    public User getUser() throws IOException {

        applicationContext.getBean("myconfig");
        boolean haha = applicationContext.containsBean("user");
        boolean hehe = applicationContext.containsBean("hehe");
        System.out.println("haha：" + haha);//true
        System.out.println("hehe：" + hehe);//true
        User user = (User) applicationContext.getBean("user");
        System.out.println(user.toString());

        return user;
    }
}

三、自动配置原理入门

3.1 引导加载自动配置类

在这里插入图片描述
点击程序的启动类上的@SpringBootApplication注解，会出现下面的类，上面被加上了几个注解
@SpringBootConfiguration：代表当前是一个配置类；
@ComponentScan：指定扫描哪些，Spring注解；

@EnableAutoConfiguration：自动配置的注解

3.1.1 @AutoConfigurationPackage

点击注解@EnableAutoConfiguration，直到看到AutoConfigurationPackage自动配置包：指定了默认的包规则

@Import(AutoConfigurationPackages.Registrar.class)  //给容器中导入一个组件
public @interface AutoConfigurationPackage {}

//利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来？MainApplication 所在包下。

3.1.2 @Import(AutoConfigurationImportSelector.class)

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

文件里面写死了spring-boot一启动就要给容器中加载的所有配置类
在这里插入图片描述

3.2 按需开启自动配置项

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

自动配置是非侵入性的。在任何时候，您都可以开启定义自己的配置来替换自动配置的特定部分。例如你想添加自己的DataSourceBean,则默认的嵌入式数据库支持会默认退出。

如果您需要了解当前正在应用哪些自动配置以及原因，请使用–debug开关启动您的应用程序。这样做可以为选择的核心记录器启用调试日志，并将条件报告记录到控制台。

3.2.1 禁用特定的自动配置类

如果您发现正在应用您不想要的特定自动配置类，您可以使用 exclude 属性@SpringBootApplication来禁用它们，如下例所示：

@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
public class MyApplication {

}

3.3 修改默认配置

        @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默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先

@Bean
	@ConditionalOnMissingBean
	public CharacterEncodingFilter characterEncodingFilter() {
    }

3.3.1 总结：

● SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
● 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定
● 生效的配置类就会给容器中装配很多组件
● 只要容器中有这些组件，相当于这些功能就有了
● 定制化配置
○ 用户直接自己@Bean替换底层的组件
○ 用户去看这个组件是获取的配置文件什么值就去修改。

四、最佳实践&开发技巧

4.1 Lombok

建华JavaBean开发

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>


idea中搜索安装lombok插件

===============================简化JavaBean开发===================================
@NoArgsConstructor
//@AllArgsConstructor
@Data
@ToString
@EqualsAndHashCode
public class User {

    private String name;
    private Integer age;

    private Pet pet;

    public User(String name,Integer age){
        this.name = name;
        this.age = age;
    }


}



================================简化日志开发===================================
@Slf4j
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(@RequestParam("name") String name){
        
        log.info("请求进来了....");
        
        return "Hello, Spring Boot 2!"+"你好："+name;
    }
}

4.2 dev-tools 无须重启部署项目

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

项目或者页面修改以后：Ctrl+F9；

下一篇：三、SpringBoot核心教程之Web开发过程分析

猿小许

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
二、SpringBoot核心教程之自动配置原理解析

前言本节更详细地介绍了如何使用 Spring Boot。它涵盖了诸如构建系统、自动配置以及如何运行应用程序等主题。我们还介绍了一些 Spring Boot 最佳实践。尽管 Spring Boot 没有什么特别之处（它只是您可以使用的另一个库），但有一些建议可以让您的开发过程更轻松一些。如果您刚开始使用 Spring Boot，您可能应该在深入了解本节之前阅读SpringBoot入门指南。一、构建系统1.1 依赖管理Spring Boot 的每个版本都提供了它支持的依赖项的精选列表。实际上，您不需要
复制链接

扫一扫