【手撕Spring源码】深度理解SpringBoot

已于 2023-11-14 21:12:34 修改
阅读量1.1k 收藏 1
点赞数 2
分类专栏： 手撕框架源码 文章标签： spring spring boot servlet 源码
于 2023-06-07 19:10:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyb18507175502/article/details/131068546
版权

文章目录

Tomcat内嵌容器

Tomcat 基本结构

Server
└───Service
    ├───Connector (协议, 端口)
    └───Engine
        └───Host(虚拟主机 localhost)
            ├───Context1 (应用1, 可以设置虚拟路径, / 即 url 起始路径; 项目磁盘路径, 即 docBase )
            │   │   index.html
            │   └───WEB-INF
            │       │   web.xml (servlet, filter, listener) 3.0
            │       ├───classes (servlet, controller, service ...)
            │       ├───jsp
            │       └───lib (第三方 jar 包)
            └───Context2 (应用2)
                │   index.html
                └───WEB-INF
                        web.xml

注意：

  • Connector连接器，它决定了将来你的请求是以什么协议，那个端口连接到我们的Tomcat服务器上。
  • 我们的Tomcat其实是由多个应用组成的，每个应用在Tomcat中有一个称呼叫做Context。每个Context的组成分为静态资源、动态资源。
  • Tomcat能够直接识别的只有三大组件：Servlet、Listener、Filter，而且这三个组件还要经过web.xml文件进行配置才能被Tomcat识别并使用。我们自己写的Controller、Service不能直接用，他们也是通过三大组件间接调用才能被Tomcat使用。
  • 随着Servlet规范的升级，它在3.0版本就可以不需要web.xml文件了，转而通过编程的方式去添加三大组件。
  • 我们等下要说的内嵌容器也是通过编程的方式来添加的
  • Tomcat中的每个应用都要配置两个地方：
    • 虚拟目录：就是指访问应用时url的起始地址，一般配为/。当然两个应用不能重复
    • 项目磁盘路径

创建Tomcat内嵌容器

public static void main(String[] args) throws LifecycleException, IOException {
    // 1.创建 Tomcat 对象
    Tomcat tomcat = new Tomcat();
    tomcat.setBaseDir("tomcat");  //设置基础目录，产生的一些临时文件会放在这里，这里采用的相对路径

    // 2.创建项目文件夹, 即 docBase 文件夹(2.3两步其实就是创建一个应用)
    File docBase = Files.createTempDirectory("boot.").toFile();
    docBase.deleteOnExit();

    // 3.创建 Tomcat 项目, 在 Tomcat 中称为 Context
    Context context = tomcat.addContext("", docBase.getAbsolutePath());  //创建一个应用指定虚拟目录和项目文件夹

    // 4.编程添加 Servlet
    //给该应用添加一个Servlet初始化器，这个初始化器会在容器启动之后进行回调
    //在这个Servlet初始化器中我们可以拿到ServletContext，从而进行三大组件的添加
    context.addServletContainerInitializer(new ServletContainerInitializer() {
        @Override
        public void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException {
            HelloServlet helloServlet = new HelloServlet();
            ctx.addServlet("aaa", helloServlet).addMapping("/hello");  //addMapping提供该Servlet的映射路径
        }
    }, Collections.emptySet());

    // 5.启动 Tomcat
    tomcat.start();

    // 6.创建连接器, 设置监听端口
    Connector connector = new Connector(new Http11Nio2Protocol());
    connector.setPort(8080);
    tomcat.setConnector(connector);
}

public class HelloServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        resp.getWriter().print("""
                <h3>hello</h3>
                """);
    }
}

内嵌Tomcat集成Spring 容器

public static void main(String[] args) throws LifecycleException, IOException {
        // 1.创建 Tomcat 对象
        Tomcat tomcat = new Tomcat();
        tomcat.setBaseDir("tomcat");

        // 2.创建项目文件夹, 即 docBase 文件夹
        File docBase = Files.createTempDirectory("boot.").toFile();
        docBase.deleteOnExit();

        // 3.创建 Tomcat 项目, 在 Tomcat 中称为 Context
        Context context = tomcat.addContext("", docBase.getAbsolutePath());

        WebApplicationContext springContext = getApplicationContext();

        // 4.编程添加 Servlet
        context.addServletContainerInitializer(new ServletContainerInitializer() {
            @Override
            public void onStartup(Set<Class<?>> c, ServletContext ctx) throws ServletException {
                HelloServlet helloServlet = new HelloServlet();
                ctx.addServlet("aaa", helloServlet).addMapping("/hello");

//				代码优化：这种不具有通用性
//                DispatcherServlet dispatcherServlet = springContext.getBean(DispatcherServlet.class);
//                ctx.addServlet("dispatcherServlet", dispatcherServlet).addMapping("/");

				//拿到所有的注册bean(他们都有一个公共的父类就是ServletRegistrationBean)
                for (ServletRegistrationBean registrationBean : springContext.getBeansOfType(ServletRegistrationBean.class).values()) {
                    //onStartup方法的内部就是进行Servlet的注册，其效果等于上面注释掉的两行
                    registrationBean.onStartup(ctx);
                }
            }
        }, Collections.emptySet());

        // 5.启动 Tomcat
        tomcat.start();

        // 6.创建连接器, 设置监听端口
        Connector connector = new Connector(new Http11Nio2Protocol());
        connector.setPort(8080);
        tomcat.setConnector(connector);
    }
	
	//该方法创建Spring容器
    public static WebApplicationContext getApplicationContext() {
//        AnnotationConfigServletWebServerApplicationContext
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(Config.class);
        context.refresh();
        return context;
    }

    @Configuration
    static class Config {
        @Bean
        public DispatcherServletRegistrationBean registrationBean(DispatcherServlet dispatcherServlet) {
            return new DispatcherServletRegistrationBean(dispatcherServlet, "/");
        }

        @Bean
        // 这个例子中必须为 DispatcherServlet 提供 AnnotationConfigWebApplicationContext, 否则会选择 XmlWebApplicationContext 实现
        public DispatcherServlet dispatcherServlet(WebApplicationContext applicationContext) {
            return new DispatcherServlet(applicationContext);
        }

        @Bean
        public RequestMappingHandlerAdapter requestMappingHandlerAdapter() {
            RequestMappingHandlerAdapter handlerAdapter = new RequestMappingHandlerAdapter();
            handlerAdapter.setMessageConverters(List.of(new MappingJackson2HttpMessageConverter()));
            return handlerAdapter;
        }

        @RestController
        static class MyController {
            @GetMapping("hello2")
            public Map<String,Object> hello() {
                return Map.of("hello2", "hello2, spring!");
            }
        }
    }
}
  • Spring提供了一种ServletRegistrationBean，我们将来在容器里扫描到了ServletRegistrationBean，就会由这些ServletRegistrationBean去注册Servlet。
  • SpringBoot中是先创建的Spring容器，在Spring容器初始化的时候会调用一个refresh方法，这个方法中又会调用onRefresh和finishRefresh方法：
    在这里插入图片描述
    在这里插入图片描述

Boot 自动配置

什么是自动配置类

自动配置类是Spring Boot的一大特色。它可以根据你添加的jar包自动配置相关功能，减少你的配置量。

自动配置类一般命名为XxxAutoConfiguration,并放在SpringBoot的autoconfigure的包下,如:

  • org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration
  • org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
  • org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration

这些自动配置类一般会根据你添加的依赖来判断是否生效，比如添加spring-boot-starter-web依赖会激活WebMvcAutoConfiguration配置类。本质是因为Spring Boot 提供的自动配置类，基本都有 @ConditionalOnClass 条件注解，判断我们项目中存在指定的类，才会创建对应的 Bean。而拥有指定类的前提，一般是需要我们引入对应框架的stater依赖。

我们举一个例子：

Spring Boot 中的自动配置类是根据条件注解（Conditional Annotations）来判断是否该生效的。条件注解是一种用于控制 Bean 的创建和加载的注解，它可以根据一些特定的条件来决定是否启用某个配置类或者 Bean。

Spring Boot 提供了一些常用的条件注解，例如：

  • @ConditionalOnClass：当类路径中存在指定的类时，该注解生效。
  • @ConditionalOnMissingClass：当类路径中不存在指定的类时，该注解生效。
  • @ConditionalOnBean：当容器中存在指定的 Bean 时，该注解生效。
  • @ConditionalOnMissingBean：当容器中不存在指定的 Bean 时，该注解生效。
  • @ConditionalOnProperty：当配置文件中存在指定的属性或者属性值时，该注解生效。
  • @ConditionalOnResource：当类路径中存在指定的资源文件时，该注解生效。
  • @ConditionalOnWebApplication：当应用程序是一个 Web 应用程序时，该注解生效。
  • @ConditionalOnNotWebApplication：当应用程序不是一个 Web 应用程序时，该注解生效。
  • @ConditionalOnExpression：当 SpEL 表达式的值为 true 时，该注解生效。
  • @ConditionalOnJava：当 Java 版本符合指定的范围时，该注解生效。
  • @ConditionalOnJndi：当 JNDI 存在时，该注解生效。
  • @ConditionalOnSingleCandidate：当容器中只有一个候选的 Bean 时，或者有多个候选的 Bean 但是有一个被标记为首选（@Primary）时，该注解生效。³

Spring Boot 中的自动配置类通常会使用这些条件注解来判断是否需要加载某些配置。例如，以下是 Spring Boot 中的一个自动配置类，用于配置 Thymeleaf 模板引擎：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({TemplateMode.class, SpringTemplateEngine.class})
@AutoConfigureAfter(WebMvcAutoConfiguration.class)
public class ThymeleafAutoConfiguration {

    public static final String DEFAULT_PREFIX = "classpath:/templates/";

    public static final String DEFAULT_SUFFIX = ".html";

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnMissingBean(name = "defaultTemplateResolver")
    public static class DefaultTemplateResolverConfiguration {

        @Bean
        public SpringResourceTemplateResolver defaultTemplateResolver(
                ThymeleafProperties properties) {
            SpringResourceTemplateResolver resolver = new SpringResourceTemplateResolver();
            resolver.setPrefix(properties.getPrefix());
            resolver.setSuffix(properties.getSuffix());
            resolver.setTemplateMode(properties.getMode());
            if (properties.getEncoding() != null) {
                resolver.setCharacterEncoding(properties.getEncoding().name());
            }
            resolver.setCacheable(properties.isCache());
            Integer order = properties.getTemplateResolverOrder();
            if (order != null) {
                resolver.setOrder(order);
            }
            resolver.setCheckExistence(properties.isCheckTemplate());
            return resolver;
        }

    }

    // other configurations
}

从上面的代码可以看出，该自动配置类使用了以下的条件注解：

  • @ConditionalOnClass：当类路径中存在 TemplateMode.class 和 SpringTemplateEngine.class 时，该注解生效。这两个类是 Thymeleaf 的核心类，如果不存在，说明没有引入 Thymeleaf 的依赖，那么就不需要加载该配置类。
  • @AutoConfigureAfter：当 WebMvcAutoConfiguration.class 加载完成后，该注解生效。这个注解用于控制自动配置类的加载顺序，保证 WebMvcAutoConfiguration.class 先于 ThymeleafAutoConfiguration.class 加载，因为后者依赖于前者的配置。
  • @ConditionalOnMissingBean：当容器中不存在名为 defaultTemplateResolver 的 Bean 时，该注解生效。这个注解用于避免自动配置类和用户自定义的配置类冲突，如果用户已经定义了一个名为 defaultTemplateResolver 的 Bean，那么就不需要加载该配置类。

通过这些条件注解，Spring Boot 可以根据实际的情况来决定是否加载该自动配置类，从而实现自动配置的功能。

自动配置类内部通常会做以下几件事:

  1. 根据类路径中的类和属性来判断该配置是否生效。
  2. 配置相关的Bean，如DispatcherServlet、HibernateJpaVendorAdapter等。
  3. 设置相关的属性，如server.port属性设置嵌入式Servlet容器的端口。
  4. 根据条件注解例如@ConditionalOnClass，@ConditionalOnMissingBean等来决定配置是否生效。
  5. 发出相关的事件，如EmbeddedServletContainerInitializedEvent事件。
  6. 导入相关的配置类，如WebMvcConfigurer等。

自动配置类让我们很容易的构建Spring Boot应用，而不用做太多的配置，真正实现了开箱即用的理念。只需要引入starter依赖，并根据需要修改一下自动配置类提供的默认值就可以了。所以,简而言之，自动配置类是SpringBoot提供的根据场景智能配置的配置类，可以根据类路径条件和属性值来自动配置相关的Bean，并设置好属性，简化我们的配置过程。

我们总结一下：

  • 自动配置要满足的条件
    • 引入了对应的starter(条件配置)
  • 创建哪些Bean
    • 条件注解
  • 创建的 Bean 的属性？
    • 通过@ConfigurationProperties注解进行赋值(本质就是通过我们的配置文件进行赋值)

@EnableConfigurationProperties注解就是把使用了@ConfigurationProperties注解的类纳入容器管理

自动配置类原理

Spring Boot 中的自动配置类的原理是这样的：

  • Spring Boot 会根据 spring.factories 文件中的键值对，找到所有标注了 @EnableAutoConfiguration 注解的配置类。这些配置类就是自动配置类，它们通常以 AutoConfiguration 结尾，例如 ThymeleafAutoConfiguration，DataSourceAutoConfiguration 等。
  • Spring Boot 会将这些自动配置类加载到 Spring 容器中，但是并不是所有的自动配置类都会生效。Spring Boot 会根据每个自动配置类上的条件注解（Conditional Annotations）来判断是否需要启用该配置类。条件注解是一种用于控制 Bean 的创建和加载的注解，它可以根据一些特定的条件来决定是否启用某个配置类或者 Bean。
  • Spring Boot 会根据条件注解的结果，按照一定的顺序，选择合适的自动配置类，为应用程序提供默认的配置。这些配置可以覆盖 Spring Boot 的默认配置，也可以被用户的自定义配置覆盖。

假设已有第三方的两个自动配置类

@Configuration // ⬅️第三方的配置类
static class AutoConfiguration1 {
    @Bean
    public Bean1 bean1() {
        return new Bean1();
    }
}

@Configuration // ⬅️第三方的配置类
static class AutoConfiguration2 {
    @Bean
    public Bean2 bean2() {
        return new Bean2();
    }
}

提供一个配置文件 META-INF/spring.factories，key 为导入器类名，值为多个自动配置类名，用逗号分隔

MyImportSelector=\
AutoConfiguration1,\
AutoConfiguration2

注意

  • 上述配置文件中 MyImportSelector 与 AutoConfiguration1，AutoConfiguration2 为简洁均省略了包名，自己测试时请将包名根据情况补全

引入自动配置

@Configuration // ⬅️本项目的配置类
@Import(MyImportSelector.class)
static class Config { }

static class MyImportSelector implements DeferredImportSelector {
    // ⬇️该方法从 META-INF/spring.factories 读取自动配置类名，返回的 String[] 即为要导入的配置类
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return SpringFactoriesLoader
            .loadFactoryNames(MyImportSelector.class, null).toArray(new String[0]);
    }
}

总结💡：

  1. 自动配置类本质上就是一个配置类而已，只是用 META-INF/spring.factories 管理，与应用配置类解耦
  2. @Enable 打头的注解本质是利用了 @Import
  3. @Import 配合 DeferredImportSelector 即可实现导入，selectImports 方法的返回值即为要导入的配置类名

我们刚才演示了自动配置类是如何被Import导入的，那么SpringBoot自带的自动配置类在哪里呢？在这里插入图片描述

有很多很多，这个时候我们思考一个问题：如果我自己本项目的配置类与第三方的自动配置类有些bean的定义冲突了会怎么样？
在这里插入图片描述

  • 在Spring中是第三方的生效

  • 在SpringBoot中则会报错，因为在SpringBoot中默认是不能覆盖的，当然我们也可以通过代码来设置：context.getDefaultListableBeanFactory().setAllowBeanDefinitionOverriding(true);

原因是：

  • 在Bean工厂中是默认可以后注册的bean覆盖掉前面注册的bean(Spring中)
  • DeferredImportSelector 的导入会在最后执行，为的是让其它配置优先解析，如果使用的是ImportSelector则会先导入
    在这里插入图片描述

一般我们是认为自己的配置高于第三方的自动配置的，所以在SpringBoot中我们一般使用DeferredImportSelector让第三方的配置最后加载，保证自己的配置先解析先生效。

在第三方配置中可以通过@ConditionalOnMissingBean注解避免与用户配置的冲突：

    @Configuration // 第三方的配置类
    static class AutoConfiguration1 {
        @Bean
        @ConditionalOnMissingBean
        public Bean1 bean1() {
            return new Bean1("第三方");
        }
    }

Aop自动配置

在这里插入图片描述

在这里插入图片描述
这四个bean就是AopAutoConfiguration帮我们加上的。那么这4个bean它们具体是怎么来的，有什么用处呢？

我们来看看AopAutoConfiguration的源码：

在这里插入图片描述

这个类中又定义了两个静态内部类：
在这里插入图片描述

这里生效的是AspectJAutoProxyingConfiguration静态内部类，进去之后又是二选一，逻辑和上面差不多：
在这里插入图片描述
这次生效的是CglibAutoProxyConfiguration。其中这个类上的@EnableAspectJAutoProxy注解帮我们又引入了AutoProxyCreator。如此和我们结果中新出现的4个bean就都吻合上了。

Spring Boot 是利用了自动配置类来简化了 aop 相关配置

  • AOP 自动配置类为 org.springframework.boot.autoconfigure.aop.AopAutoConfiguration
  • 可以通过 spring.aop.auto=false 禁用 aop 自动配置
  • AOP 自动配置的本质是通过 @EnableAspectJAutoProxy 来开启了自动代理，如果在引导类上自己添加了 @EnableAspectJAutoProxy 那么以自己添加的为准
  • @EnableAspectJAutoProxy 的本质是向容器中添加了 AnnotationAwareAspectJAutoProxyCreator 这个 bean 后处理器，它能够找到容器中所有切面，并为匹配切点的目标类创建代理，创建代理的工作一般是在 bean 的初始化阶段完成的
  • @EnableAspectJAutoProxy注解中的proxyBeanMethods我前面的文章说到过它是用来控制动态代理的方法，是JDK还是CGLIB。

DataSource自动配置

这里我们将MyBatis自动配置和事务自动配置一起放进来说，因为他们的关系比较紧密

  • 对应的自动配置类为：org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration
  • 它内部采用了条件装配，通过检查容器的 bean，以及类路径下的 class，来决定该 @Bean 是否生效
    在这里插入图片描述

简单说明一下，Spring Boot 支持两大类数据源：

  • EmbeddedDatabase - 内嵌数据库连接池
  • PooledDataSource - 非内嵌数据库连接池

PooledDataSource 又支持如下数据源

  • hikari 提供的 HikariDataSource
  • tomcat-jdbc 提供的 DataSource
  • dbcp2 提供的 BasicDataSource
  • oracle 提供的 PoolDataSourceImpl

如果知道数据源的实现类类型，即指定了 spring.datasource.type，理论上可以支持所有数据源，但这样做的一个最大问题是无法订制每种数据源的详细配置（如最大、最小连接数等）

这里还要提一个被自动加入的bean叫做DataSourceProperties。

它用来绑定环境变量中的以spring.datasource打头的键值信息
在这里插入图片描述
它会被用在创建DataSource中，要读取一些username、password信息的时候：

在这里插入图片描述

MyBatis自动配置

  • MyBatis 自动配置类为 org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration
    在这里插入图片描述

  • 它主要配置了两个 bean

    • SqlSessionFactory - MyBatis 核心对象，用来创建 SqlSession

    • SqlSessionTemplate - SqlSession 的实现，此实现会与当前线程绑定(就是保证多个方法调用只要他们是同一个线程的获取到的SqlSession对象是同一个)

      • 在哪使用过呢？

      • 容器管理Mapper其实不是把Mapper接口交给容器，而是借助MapperFactoryBean来生产一个产品，这个产品是Mapper对象，他生产产品方法就是：
        在这里插入图片描述

      • 也就是先要拿到SqlSession对象，然后通过SqlSession去getMapper，而这里getSqlSession获得的就是SqlSessionTemplate
        在这里插入图片描述

    • 用 ImportBeanDefinitionRegistrar 的方式扫描所有标注了 @Mapper 注解的接口

  • 还有一个相关的 bean：MybatisProperties，它会读取配置文件中带 mybatis. 前缀的配置项进行定制配置

  • 还有一个内嵌配置类MapperScannerRegistrarNotFoundConfiguration
    在这里插入图片描述

    • 而这个AutoConfiguredMapperScannerRegistrar实现了一个ImportBeanDefinitionRegistrar接口，这个接口实现了之后就可以使用编程的方法定义BeanDefinition。这里它补充的就是Mapper的BeanDefinition，它会根据Mapper接口类型，把每个Mapper接口封装成MapperFactoryBean，然后作为BeanDefinition加入到BeanFactory。
    • AutoConfiguredMapperScannerRegistrar他去进行扫描的时候你需要指定一个包的名字。一般是通过@AutoConfigurationPackages 来确定扫描的包。

      • 就比如说我们SpringBoot的启动类上面有一个注解叫做@SpringBootApplication，我们点进去看他是一个组合注解：
        在这里插入图片描述

      • 我们继续点进@EnableAutoConfiguration就可以发现@AutoConfigurationPackage：
        在这里插入图片描述

      • 将当前启动类的包名记录下来

@MapperScan 注解的作用与 MybatisAutoConfiguration 类似，会注册 MapperScannerConfigurer 有如下区别

  • @MapperScan 扫描具体包（当然也可以配置关注哪个注解）
  • @MapperScan 如果不指定扫描具体包，则会把引导类范围内，所有接口当做 Mapper 接口
  • MybatisAutoConfiguration 关注的是所有标注 @Mapper 注解的接口，会忽略掉非 @Mapper 标注的接口

这里可能会有疑问，之前介绍的都是将具体类交给 Spring 管理，怎么到了 MyBatis 这儿，接口就可以被管理呢？

  • 其实并非将接口交给 Spring 管理，而是每个接口会对应一个 MapperFactoryBean，是后者被 Spring 所管理，接口只是作为 MapperFactoryBean 的一个属性来配置

事务自动配置

  • 事务自动配置类有两个：

    • org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration
    • org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration

  • 前者配置了 DataSourceTransactionManager 用来执行事务的提交、回滚操作

  • 后者功能上对标 @EnableTransactionManagement，包含以下三个 bean

    • BeanFactoryTransactionAttributeSourceAdvisor 事务切面类，包含通知和切点
    • TransactionInterceptor 事务通知类，由它在目标方法调用前后加入事务操作
    • AnnotationTransactionAttributeSource 会解析 @Transactional 及事务属性，也包含了切点功能

  • 如果自己配置了 DataSourceTransactionManager 或是在引导类加了 @EnableTransactionManagement，则以自己配置的为准

MVC自动配置

ServletWebServerFactoryAutoConfiguration

  • 提供 ServletWebServerFactory

DispatcherServletAutoConfiguration

  • 提供 DispatcherServlet
  • 提供 DispatcherServletRegistrationBean

WebMvcAutoConfiguration

  • 配置 DispatcherServlet 的各项组件，提供的 bean 见过的有
    • 多项 HandlerMapping
    • 多项 HandlerAdapter
    • HandlerExceptionResolver

ErrorMvcAutoConfiguration

  • 提供的 bean 有 BasicErrorController

MultipartAutoConfiguration

  • 它提供了 org.springframework.web.multipart.support.StandardServletMultipartResolver
  • 该 bean 用来解析 multipart/form-data 格式的数据

HttpEncodingAutoConfiguration

  • POST 请求参数如果有中文，无需特殊设置，这是因为 Spring Boot 已经配置了 org.springframework.boot.web.servlet.filter.OrderedCharacterEncodingFilter
  • 对应配置 server.servlet.encoding.charset=UTF-8，默认就是 UTF-8
  • 当然，它只影响非 json 格式的数据

条件装配

条件装配的底层是本质上是 @Conditional注解 与 Condition接口。

那么多自动配置类，不一定每一个都要生效，或者配置类中的Bean不一定非要全部放到容器中，不满足某种条件则不添加，怎么做呢？

这个时候就要使用条件装配了！

比如条件是【类路径下必须有 dataSource】这个 bean ，怎么做呢？

首先编写条件判断类，它实现 Condition 接口，编写条件判断逻辑

static class MyCondition1 implements Condition { 
    // ⬇️如果存在 Druid 依赖，条件成立
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return ClassUtils.isPresent("com.alibaba.druid.pool.DruidDataSource", null);
    }
}

其次，在要导入的自动配置类上添加 @Conditional(MyCondition1.class)，将来此类被导入时就会做条件检查

@Configuration // 第三方的配置类
@Conditional(MyCondition1.class) // ⬅️加入条件
static class AutoConfiguration1 {
    @Bean
    public Bean1 bean1() {
        return new Bean1();
    }
}

分别测试加入和去除 druid 依赖，观察 bean1 是否存在于容器

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.17</version>
</dependency>

附：注解小总

@EnableConfigurationProperties

@EnableConfigurationProperties注解的作用是启用指定类的ConfigurationProperties绑定功能。

使用@ConfigurationProperties注解的类，其中的属性可以与配置文件中前缀匹配的属性绑定，如:

@ConfigurationProperties(prefix = "book")
public class BookProperties {
    private String name;
    private int age;
}

然后在配置文件中添加:

book.name=三体
book.age=10

BookProperties中的name和age属性就会与配置文件的book.name和book.age属性绑定。

但是，只使用@ConfigurationProperties注解是不够的，还需要使用@EnableConfigurationProperties注解将其激活，如:

@Configuration
@EnableConfigurationProperties(BookProperties.class)
public class BookConfiguration {
}

@EnableConfigurationProperties注解接收一个或多个@ConfigurationProperties注解的类，并将其激活，使其可以绑定相关的配置。

所以，@EnableConfigurationProperties的作用就是启用@ConfigurationProperties注解的配置绑定功能。如果不使用该注解，@ConfigurationProperties注解的类中的属性将无法与配置绑定。
@EnableConfigurationProperties通常与@ConfigurationProperties注解的类放在一起，一起定义相关的配置项，如:

@Configuration
@EnableConfigurationProperties(BookProperties.class)
public class BookConfiguration {
    
    @Bean
    public BookProperties bookProperties() {
        return new BookProperties();
    }
}

这样BookProperties中的属性就可以很好的与application.properties(或.yml)中的配置绑定了。

所以综上，@EnableConfigurationProperties注解用于激活@ConfigurationProperties注解的配置绑定功能，两者搭配使用可以很方便的将配置绑定到Bean的属性中。

@ConditionalXXX

@Conditional开头的注解通常用于条件化的创建Bean或配置类。根据某些条件判断，决定Bean或配置类是否生效。

Spring Boot提供了很多@Conditional开头的注解，主要有:

  • @ConditionalOnBean：根据Bean是否存在来决定是否创建Bean。
  • @ConditionalOnMissingBean：根据Bean是否不存在来决定是否创建Bean。
  • @ConditionalOnClass：根据类是否存在来决定是否创建Bean。
  • @ConditionalOnMissingClass：根据类是否不存在来决定是否创建Bean。
  • @ConditionalOnProperty：根据指定的配置属性是否存在或匹配来决定一个配置类是否生效.
  • @ConditionalOnWebApplication：在Web应用下创建Bean。
  • @ConditionalOnNotWebApplication：在非Web应用下创建Bean。
  • 等等。

查找范围一般就是类路径下或者配置文件。

这些注解通常用在自动配置类或Bean中，用于根据条件来决定配置或Bean是否生效。比如:

@Configuration
@ConditionalOnClass(DataSource.class)
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {
   // ...
}

这里的DataSourceAutoConfiguration自动配置类只有在类路径中存在DataSource类的情况下才会生效。

它们的作用主要是:

  1. 实现按需加载，而不是全部激活。根据条件选择加载对应的配置。
  2. 避免在一些不需要的场景下创建不必要的Bean，节省资源。
  3. 增强程序的灵活性，可以根据不同的环境和条件来激活不同的配置。

所以，总体来说，@Conditional开头的注解用于根据某些条件来决定一个配置类或Bean是否生效，其目的主要是实现自动化和按需加载,提高程序的灵活性。它们是Spring Boot自动配置如此强大的核心要素之一。

@EnableXxx VS @Import

@EnableXxx注解和@Import注解都用于导入配置类和激活某个功能，但是二者还是有一定区别的:

  1. @EnableXxx注解专注于激活某个功能或某个模块，如@EnableWebMvc激活Spring MVC功能。而@Import更加底层，可以直接导入任意配置类。

  2. @EnableXxx注解内部通常使用@Import注解来导入相关配置类和激活功能。所以@EnableXxx可以看作是@Import的一种包装和应用。@Import注解的用法更加灵活。

  3. @EnableXxx注解一般会导入该功能领域内的比较固定的配置类。而@Import可以根据ImportSelector的返回结果导入选择性的配置类，更加灵活。

  4. 两者的最终目的都是导入配置类并激活相关功能，只是@EnableXxx注解对这一过程进行了封装，提供了更加高层的抽象。

  5. 我们在使用Spring Boot时，一般优先选择@EnableXxx注解来激活某功能模块，它提供了更加易用的抽象。如果需要更加灵活的配置，那么可以选择直接使用@Import注解。

十八岁讨厌编程
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
腾讯T4大佬手撕springboot，详解得如此清晰明了
芒果不是程序猿v：lemon-hanwa 的博客
08-29 205
由于细节内容实在太多啦，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！ 整理了一份SpringBoot电子版。覆盖了Java EE、Spring Boot 基础、MVC框架、视图技术、数据库访问、Spring Data JPA、Spring Boot 配置、部署Spring Boot应用、Testing单元测试等大量知识点。 如果需要获取到这个【SpringBoot】文档的话帮忙转发一下然后再关注我私信回复“资料”得到获取方式吧！ 目录 Java EE简介 S..
我的tomcat7源码手撕过程
01-11
Tomcat初始化流程分析，Tomcat启动流程分析 Tomcat处理一次请求过程分析 servlet初始化流程
手撕spring核心源码，彻底搞懂spring流程
xiexiaojing的博客
03-26 912
引子十几年前，刚工作不久的程序员还能过着很轻松的日子。记得那时候公司里有些开发和测试的女孩子，经常有问题解决不了的，不管什么领域的问题找到我，我都能帮她们解决。但是那时候我没有主动学习技术的意识，只是满足于解决问题，错过了能力提升最好的阶段。老公是个截然相反的类型，我就看他天天在宿舍里学习。学来学去也就那样了。他不陪我玩，我虽然心里不乐意，但是还好那时候未卜先知：知道自己...
阿里p8带你手撕springboot源码
weixin_45169806的博客
07-21 173
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(typ..
手撕SpringBoot源码启动流程分析
05-29 212
main函数开始 run方法 最终的执行代码块如下： 其中最重要的2块 setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); 上面的方法会去**\spring-boot-autoconfigure-2.3.0.RELEASE.jar**包中寻找spring.factories文件，该文件定义了springboot自动装配需要的所有的bean 然后通过反射实例化bean
【手撕Spring源码】SpringBoot启动过程中发生了什么？
十八岁讨厌编程的博客
06-06 548
本文涉及SpringBoot启动详解、启动演示、启动过程总结等内容。
H5游戏源码 手撕鬼子.zip
10-15
游戏源码 欢迎下载
手撕Mybatis源码，自己动手实现Mybatis
最新发布
11-14
手撕Mybatis源码，自己动手实现Mybatis。通过研究Mybatis源码，参照它实现一个类似的框架，以便于自己更好的理解Mybatis。
C语言手撕机器学习深度学习算法.zip
10-19
C语言手撕机器学习深度学习算法.zip
vivo iQOO 12系统手撕方案
06-21
vivo iQOO 12系统手撕方案
徒手撕springboot第一个项目（不用IDE）
SHIJIERUCIMEIHAO的专栏
10-13 401
用惯了IDE来创建项目，咱不能忘记他原始纯洁的一面，别有一番风味！ 系统预备条件： 安装好jdk8； 安装好maven； 在D盘建一个目录myboot,并在该目录下myboot新建src目录和一个pom.xml文件（maven约定）， 如下图所示： 编写pom.xml文件内容， <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" .
springboot使用的是什么语言
weixin_35749545的博客
12-29 2029
Spring Boot 是使用 Java 语言编写的。 Spring Boot 是一个快速开发框架，可以让开发人员轻松地创建独立的，生产级的基于 Spring 的应用程序。 Spring Boot 提供了一些开箱即用的功能，使得开发人员无需进行配置就能使用这些功能。 ...
springboot是什么
YSPLX的博客
09-13 295
SpringBoot： 使用ssm整合完成开发,pom导入大量jar(很多坐标)，xml配置文件，是一种以格式为中心配置,标签结构分明,配置文件比较繁琐，构建都是独立的应用。 Springboot是对spring技术栈整合： 特点: 1: Springboot 程序都是独立的应用。 2：直接嵌入Tomcat，Jetty或Undertow(无需部署WAR文件) 3：提供了丰富starter 启动器配置，直接构建我们环境。(jar依赖坐标) 4：自动的导入第三方库 5: 提供丰富的程序运行监控监控。 6：s
SpringBoot是什么
weixin_42073629的博客
04-11 731
随着动态语言的流行（Ruby、Groovy、Scala、Node.js），Java的开发显得格外的笨重，繁多的配置、低下的开发效率、复杂的部署流程以及第三方技术集成难度大。 在上述环境下，SpringBoot 应运而生。它使用“习惯优于配置”（项目中存在大量的配置，此外还内置一个习惯性的配置，让你无须手动进行配置）的理念让你的项目快速运行起来。 使用 Spring Boot 很容易创建一个独立...
SpringBoot
兴趣是最好的老师
06-24 379
1.什么是SpringBoot？静态语言：先编译后运行动态语言：例如js，无需编译，直接运行
什么是SpringBoot
CHL123456789的专栏
08-06 1108
（1）什么是SpringBoot        随着动态语言比较流行，java ee 开发 显得格外繁琐，底下的开发效率，复杂的部署，等，因此spring boot 横空出世，应用而生。Spring Boot是Spring社区发布的一个开源项目，使用spring boot 很容易创建一个独立运行（运行jar，内置servlet容器）的框架项目，使用spring boot 你只需很少的spri
SpringBoot介绍
路在何方
09-17 1019
1.什么是SpringBoot      随着动态语言的流行（Ruby、Groovy、Scala、Node.js)，java的开发显得格外的笨重：繁多的配置，低下的开发效率、复杂的部署流程以及第三方技术集成难度大，因此，springboot应用而生。       Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用...
Springboot----入门使用
weixin_44831330的博客
11-09 230
什么是Springboot 上面是引自官网的一段话，大概是说： Spring Boot 是所有基于 Spring 开发的项目的起点。Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件 简单的来说，使用springboot并不是什么新的框架，它默认配置了很多框架的使用方式，它使用 “习惯优于配置” （项目中存在大量的配置，此外还内置一个习惯...
springboot简介
fenlin88l的博客
04-17 904
Spring诞生时是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需 开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通 过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能 Spring 2.5引入...
手撕transformer
09-28
手撕Transformer的过程可以帮助我们更好地理解Transformer模型的原理和细节。 要手撕Transformer，首先需要了解Transformer模型的基本结构和原理。Transformer由编码器（Encoder）和解码器（Decoder）组成，每个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

十八岁讨厌编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值