SpringBoot自动装配原理解析_Java

什么是spring boot自动装配

spring boot自动装配是指在spring boot应用启动时，根据类路径下的jar包依赖、bean定义、各种配置文件等信息，自动配置spring应用上下文的bean。

这种机制极大地简化了配置工作，使得开发者可以更加专注于业务逻辑的实现。

在深入自动装配原理前，我们先看下 spi 机制。

spi 机制

spi（service provider interface）是一种动态替换服务提供者的机制。它允许一个服务接口有多个服务提供者，并且在程序运行时动态选择一个服务提供者。

spi又分为 jdk spi 和 spring spi。

jdk spi

在 java 平台上，spi 通常是通过 java.util.serviceloader 类实现的，这种机制在java标准库中广泛应用，如jdbc驱动的管理。

spi可以很灵活的让接口和实现分离，让服务提供者只提供接口，第三方来实现，然后可以使用配置文件的方式来实现替换或者扩展。

工作原理

java spi 的工作原理基于以下几个步骤：

定义服务接口：首先定义一个服务接口（或抽象类），作为服务的规范。
提供服务实现：编写接口的具体实现类。
注册服务实现：在 meta-inf/services 目录下创建一个以接口全限定名为名的文件，文件内容为接口实现类的全限定名。
加载服务实现：使用 java.util.serviceloader 来加载并使用这些实现。

举例说明一下：

（1）创建一个 demodao 的接口

public interface demodao {<!--{cke_protected}{c}%3c!%2d%2d%20%2d%2d%3e-->}

（2）分别创建两个实现类

public class mysqldao implements demodao {<!--{cke_protected}{c}%3c!%2d%2d%20%2d%2d%3e-->}

public class oracledao implements demodao {<!--{cke_protected}{c}%3c!%2d%2d%20%2d%2d%3e-->}

（3）在resources下新建meta-inf/services/目录，在该目录下新建接口全限定名的文件com.study.spring.z_spi.demodao，文件内容是上面那两个实现类。

com.study.spring.z_spi.mysqldao
com.study.spring.z_spi.oracledao

（4）使用 jdk 提供的serviceloader来测试下

public class jdkspiapplication {
    public static void main(string[] args) {
        serviceloader<demodao> demodaos = serviceloader.load(demodao.class);
        demodaos.iterator().foreachremaining(t -> {
            system.out.println(t);
        });
    }
}

输出结果：
com.study.spring.z_spi.mysqldao@6e8cf4c6
com.study.spring.z_spi.oracledao@12edcd21

jdbc drivermanager

java spi 机制在jdbc驱动管理中的应用主要体现在jdbc 4.0及以上版本的驱动自动发现和加载上。

在jdbc4.0之前，连接数据库的时候，通常会用class.forname(“com.mysql.jdbc.driver”)先加载数据库相关的驱动，然后再进行获取连接等的操作。
而jdbc4.0之后不需要用class.forname(“com.mysql.jdbc.driver”)来加载驱动，直接获取连接就可以了，这种方式就是使用了java的spi扩展机制来实现。

定义服务接口

在jdbc中，服务接口是由java平台定义的java.sql.driver接口，所有的jdbc驱动都必须实现这个接口，以提供与数据库建立连接的能力。

提供服务实现

数据库厂商（如mysql、oracle等）为它们的数据库提供jdbc驱动程序，这些驱动程序实现了java.sql.driver接口。

注册服务提供者

jdbc驱动的注册是通过在驱动程序的jar包中的meta-inf/services目录下创建一个名为java.sql.driver的文件来完成的。这个文件包含了实现java.sql.driver接口的驱动类的全限定名。当jvm启动时，它会查找这个文件，并加载其中指定的驱动类。

在这里插入图片描述

加载服务提供者

在jdbc 4.0及以上版本中，drivermanager类在初始化时会使用java的spi机制自动加载所有在meta-inf/services/java.sql.driver文件中指定的驱动类。
这是通过serviceloader类实现的，它会查找并加载所有可用的jdbc驱动实现。

在这里插入图片描述

连接管理

当应用程序尝试通过drivermanager.getconnection()方法连接数据库时，drivermanager会遍历所有已加载的驱动实例，尝试建立连接。一旦某个驱动成功建立连接，它就会返回这个连接，并且不会继续尝试其他的驱动实例。

springboot spi 机制

spring boot 对 spi 机制进行了扩展，以支持其自动配置和模块化架构。

spring boot 利用 spring.factories （从 springboot 2.7 起自动配置不推荐使用 /meta-inf/spring.factories 文件，而是在/meta-inf/spring/org.springframework.boot.autoconfigure.autoconfiguration.imports）文件，这个文件列出了与自动配置相关的接口及其实现类，spring boot 启动时会加载这些配置。

spring.factories

这个文件里面使用键值对的格式列出了多种服务类型及其对应的实现类，常见的服务类型包括：

org.springframework.boot.autoconfigure.enableautoconfiguration：用于自动配置。
org.springframework.context.applicationlistener：用于应用事件监听器。
org.springframework.boot.autoconfigure.template.templateavailabilityprovider：用于模板引擎的可用性判断。

# application listeners
org.springframework.context.applicationlistener=\
org.springframework.boot.autoconfigure.backgroundpreinitializer

# auto configure
org.springframework.boot.autoconfigure.enableautoconfiguration=\
org.springframework.boot.autoconfigure.admin.springapplicationadminjmxautoconfiguration,\
org.springframework.boot.autoconfigure.aop.aopautoconfiguration

不使用spi

现在我们先来看下，不使用 spi 机制，怎么实现 bean 的配置。

新建一个项目，将新类myappdemo注入 ioc 容器。

在这里插入图片描述

在另一个项目 demo 中，引入 myapp 的依赖，并测试调用 test 方法。

@springbootapplication
public class starterdemoapplication {
	public static void main(string[] args) {
		springapplication.run(starterdemoapplication.class, args);
	}
}

@springboottest
class starterdemoapplicationtests {

	@autowired
	private applicationcontext applicationcontext;

	@test
	void contextloads() {
		myappdemo demo = applicationcontext.getbean(myappdemo.class);
		demo.test();
	}
}

测试发现找不到该 bean 对象

在这里插入图片描述

为什么引入的第三方依赖包中的 bean 没有生效呢？

原因是因为，在类上添加@component注解来声明bean对象时，还需要保证@component注解能被spring的组件扫描到。
springboot项目中的@springbootapplication注解，具有包扫描的作用，但是它只会扫描启动类所在的当前包以及子包。
当前包：com.starter.demo，第三方依赖中提供的包：com.myapp.demo（扫描不到）

所以，有两种方案可以解决

@componentscan 组件扫描第三方依赖的包路径；
@import 导入（使用@import导入的类会被spring加载到ioc容器中）。

@componentscan 组件扫描

@springbootapplication
@componentscan(basepackages = {"com.starter","com.myapp"})
public class starterdemoapplication {

	public static void main(string[] args) {
		springapplication.run(starterdemoapplication.class, args);
	}
}

缺点：当需要引入大量的第三方依赖，就需要在启动类上配置大量要扫描的包，这种方式会很繁琐。

import 导入

@target(elementtype.type)
@retention(retentionpolicy.runtime)
@documented
public @interface import {

	/**
	 * {@link configuration @configuration}, {@link importselector},
	 * {@link importbeandefinitionregistrar}, or regular component classes to import.
	 */
	class<?>[] value();
}

从源码可以看到，导入形式有以下几种

普通类
配置类
importselector的实现类
importbeandefinitionregistrar的实现类

导入普通类

@springbootapplication
@import(myappdemo.class)
public class starterdemoapplication {
	public static void main(string[] args) {
		springapplication.run(starterdemoapplication.class, args);
	}
}

导入配置类

去掉myappdemo类上的@component注解，新建一个myappconfig配置类。

@configuration
public class myappconfig {
    @bean
    public myappdemo myappdemo() {
        return new myappdemo();
    }
}

在启动类上导入配置类

@springbootapplication
@import(myappconfig.class)
public class starterdemoapplication {
	public static void main(string[] args) {
		springapplication.run(starterdemoapplication.class, args);
	}
}

导入importselector的实现类

新建 importselector的实现类

public class myappimportselector implements importselector {

    public string[] selectimports(annotationmetadata importingclassmetadata) {
        return new string[] {"com.myapp.demo.myappdemo"};
    }
}

在启动类上导入myappimportselector

@springbootapplication
@import(myappimportselector.class)
public class starterdemoapplication {

	public static void main(string[] args) {
		springapplication.run(starterdemoapplication.class, args);
	}
}

导入importbeandefinitionregistrar的实现类

新建 importbeandefinitionregistrar 的实现类

public class myappimportbeandefinitionregistrar implements importbeandefinitionregistrar {
    public void registerbeandefinitions(annotationmetadata importingclassmetadata, beandefinitionregistry registry, beannamegenerator importbeannamegenerator) {

        beandefinitionbuilder builder = beandefinitionbuilder.rootbeandefinition(myappdemo.class);


        registry.registerbeandefinition("myappdemotest", builder.getbeandefinition());
    }
}

在启动类上导入myappimportbeandefinitionregistrar

@springbootapplication
@import(myappimportbeandefinitionregistrar.class)
public class starterdemoapplication {
	public static void main(string[] args) {
		springapplication.run(starterdemoapplication.class, args);
	}
}

模块装配

通过@import 注解，我们可以导入第三方依赖包中的配置类。

但是基于上面的方式，我们在引入第三方依赖时，还要知道第三方依赖中有哪些配置类和哪些bean对象？相当麻烦！

而第三方依赖自己最清楚自己有哪些配置类、有那些 bean 对象，它提供一个注解，通过这个注解，外部系统可以引入自己所需要的 bean 对象。

这个注解一般都以@enablexxx开头，注解中封装的就是@import注解，外部系统在使用时只需要加上@enablexxxxx注解即可。

@retention(retentionpolicy.runtime)
@target(elementtype.type)
@import(myappconfig.class)
public @interface enablemyapp {}

@springbootapplication
@enablemyapp
public class starterdemoapplication {
	public static void main(string[] args) {
		springapplication.run(starterdemoapplication.class, args);
	}
}

spring 中的模块装配，是在3.1 之后引入了大量的@enablexxx 注解，来快速整合激活相对应的模块。
如：
● enabletransactionmanagement ：开启注解事务驱动
● enablewebmvc ：激活 springwebmvc
● enableaspectjautoproxy ：开启注解 aop 编程
● enablescheduling ：开启调度功能（定时任务）
模块装配的核心原则：自定义注解+@import 导入组件

使用spi

即使是采用@enablexxx注解，还是觉得麻烦怎么办？

我想引入第三方依赖后，直接就去使用它，而不是再单独写一个什么什么注解。

下面我们来看看基于 spring 的 spi 机制怎么去实现。

在在resources目录下创建meta-inf 目录，并新建 spring.factories文件，文件内容如下：

org.springframework.boot.autoconfigure.enableautoconfiguration=\
com.myapp.demo.myappconfig

@configuration
public class myappconfig {

    @bean
    public myappdemo myappdemo() {
        return new myappdemo();
    }
}

我们只是引入了第三方依赖包，并没有手动配置，也没有写什么注解啊，就可以通过ioc容器或di依赖拿到bean对象了，这就是springboot自动配置的强大之处。

自动装配源码

从 springboot 核心注解说起

@springbootconfiguration
@enableautoconfiguration
@componentscan(excludefilters = { @filter(type = filtertype.custom, classes = typeexcludefilter.class),
		@filter(type = filtertype.custom, classes = autoconfigurationexcludefilter.class) })
public @interface springbootapplication {}

重点看@enableautoconfiguration，核心中的核心，重点中的重点。

在这里插入图片描述