SpringBoot中自定义starter实例与原理

分手后的思念是犯贱 2023-10-09 17:47 29阅读 0赞

## 1 自定义启动器 ##

本文首先提出以下开发需求：需要自定义一个启动器spring-boot-football-starter，业务方引入这个启动器之后可以直接使用Football实例。

### 1.1 创建项目 ###

#### 1.1.1 项目名 ####

java-front-football-starter
    复制代码

#### 1.1.2 springboot版本号 ####

<dependency>
        <artifactId>spring-boot-dependencies</artifactId>
        <groupId>org.springframework.boot</groupId>
        <scope>import</scope>
        <type>pom</type>
        <version>2.1.7.RELEASE</version>
    </dependency>
    复制代码

### 1.2 创建Football ###

@Getter
    @Setter
    public class Football {
        private String a;
        private String b;
    }
    复制代码

### 1.3 创建配置类 ###

@Getter
    @Setter
    @ConfigurationProperties(prefix = "football") // prefix不支持驼峰命名
    public class FootballProperties {
        private boolean enable = true;
        private String a;
        private String b;
    }
    复制代码

### 1.4 创建AutoConfiguration ###

@Slf4j
    @Configuration
    @ConditionalOnClass(Football.class) // 只有当classpath中存在Football类时才实例化本类
    @EnableConfigurationProperties(FootballProperties.class)
    public class FootballAutoConfiguration {
    
        @Autowired
        private FootballProperties footballProperties;
    
        @Bean
        @ConditionalOnMissingBean(Football.class) // 只有当容器不存在其它Football实例时才使用此实例
        public Football football() {
            if (!footballProperties.isEnable()) {
                String defaultValue = "default";
                Football football = new Football();
                football.setA(defaultValue);
                football.setB(defaultValue);
                log.info("==========football close bean={}==========", JSON.toJSONString(football));
                return football;
            }
            Football football = new Football();
            football.setA(footballProperties.getA());
            football.setB(footballProperties.getB());
            log.info("==========football open bean={}==========", JSON.toJSONString(football));
            return football;
        }
    }
    复制代码

*  条件注解说明

@ConditionalOnBean
    只有在当前上下文中存在某个对象时才进行实例化Bean
    
    @ConditionalOnClass
    只有classpath中存在class才进行实例化Bean
    
    @ConditionalOnExpression
    只有当表达式等于true才进行实例化Bean
    
    @ConditionalOnMissingBean
    只有在当前上下文中不存在某个对象时才进行实例化Bean
    
    @ConditionalOnMissingClass
    某个class类路径上不存在时才进行实例化Bean
    
    @ConditionalOnNotWebApplication
    当前应用不是WEB应用才进行实例化Bean
    复制代码

### 1.5 spring.factories ###

*  工厂文件位置

- src/main/resources
        - META-INF
            -spring.factories
    复制代码

*  工厂文件内容

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    com.java.front.football.starter.configuration.FootballAutoConfiguration
    复制代码

## 2 测试启动器 ##

### 2.1 引入依赖 ###

<dependency>
        <groupId>com.java.test</groupId>
        <artifactId>java-front-football-starter</artifactId>
        <version>1.0.0</version>
    </dependency>
    复制代码

### 2.2 application.yml ###

server:
      port: 9999
    football:
      enable: true
      a: "aaa"
      b: "bbb"
    复制代码

### 2.3 TestController ###

@RestController
    @RequestMapping("/test/football")
    public class TestController {
    
        @Resource
        private Football football;
    
        @GetMapping
        public Football get() {
            return football;
        }
    }
    复制代码

### 2.4 TestApplication ###

@SpringBootApplication
    public class TestApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(TestApplication.class, args);
        }
    }
    复制代码

### 2.5 测试用例 ###

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT, classes = TestApplication.class)
    @RunWith(SpringJUnit4ClassRunner.class)
    public class TestControllerTest {
    
        @Test
        public void test() {
            String response = HttpUtil.get("http://localhost:9999/test/football");
            Assert.assertTrue(!StringUtils.isEmpty(response));
        }
    }
    复制代码

### 2.6 测试结果 ###

==========football open bean={"a":"aaa","b":"bbb"}==========
    复制代码

## 3 原理分析 ##

*  启动类

*  `SpringBootApplication`

@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)})
    public @interface SpringBootApplication {
        //......
    }
    复制代码

*  `EnableAutoConfiguration`

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
        //......
    }
    复制代码

*  `AutoConfigurationImportSelector`

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    
        protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
                AnnotationMetadata annotationMetadata) {
            if (!isEnabled(annotationMetadata)) {
                return EMPTY_ENTRY;
            }
            AnnotationAttributes attributes = getAttributes(annotationMetadata);
            // 加载配置
            List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
            configurations = removeDuplicates(configurations);
            Set<String> exclusions = getExclusions(annotationMetadata, attributes);
            checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = filter(configurations, autoConfigurationMetadata);
            fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationEntry(configurations, exclusions);
        }
    }
    复制代码

*  `getCandidateConfigurations`

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
    
        protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
            List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
            Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
            return configurations;
        }
    }
    复制代码

*  `loadFactoryNames`

public final class SpringFactoriesLoader {
    
        // 工厂加载路径
        public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
    
        public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
            String factoryClassName = factoryClass.getName();
            return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
        }
    
        private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
            MultiValueMap<String, String> result = cache.get(classLoader);
            if (result != null) {
                return result;
            }
            try {
                // 根据路径加载工厂信息（FootballAutoConfiguration）
                Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
                result = new LinkedMultiValueMap<>();
                while (urls.hasMoreElements()) {
                    URL url = urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    for (Map.Entry<?, ?> entry : properties.entrySet()) {
                        String factoryClassName = ((String) entry.getKey()).trim();
                        for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                            result.add(factoryClassName, factoryName.trim());
                        }
                    }
                }
                cache.put(classLoader, result);
                return result;
            } catch (IOException ex) {
                throw new IllegalArgumentException("Unable to load factories from location [" FACTORIES_RESOURCE_LOCATION + "]", ex);
            }
        }
    }
    复制代码

## 4 延伸知识 ##

### 4.1 spring官方启动器 ###

https://docs.spring.io/spring-boot/docs/2.1.7.RELEASE/reference/html/using-boot-build-systems.html#using-boot-starter
    复制代码

*  英文介绍

> Starters are a set of convenient dependency descriptors that you can include in your application. You get a one-stop shop for all the Spring and related technologies that you need without having to hunt through sample code and copy-paste loads of dependency descriptors. For example, if you want to get started using Spring and JPA for database access, include the spring-boot-starter-data-jpa dependency in your project

*  中文介绍

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

### 4.2 spring-boot-starter ###

这个启动器是核心启动器，功能包括自动配置支持、日志记录和YAML。任意引入一个启动器点击分析，最终发现引用核心启动器。

*  引用`spring-boot-starter-data-redis`

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    复制代码

*  发现引用`spring-boot-starter`

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.1.7.RELEASE</version>
        <scope>compile</scope>
    </dependency>
    复制代码

*  发现引用`spring-boot-autoconfigure`

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-autoconfigure</artifactId>
        <version>2.1.7.RELEASE</version>
        <scope>compile</scope>
    </dependency>
    复制代码

*  工厂文件位置

/META-INF/spring.factories
    复制代码

*  文件中指定Redis自动配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
    复制代码

*  自动装配类`RedisAutoConfiguration`

@Configuration
    @ConditionalOnClass(RedisOperations.class)
    @EnableConfigurationProperties(RedisProperties.class) // 配置信息类
    @Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
    public class RedisAutoConfiguration {
        //......
    }
    复制代码

*  配置信息类`RedisProperties`

@ConfigurationProperties(prefix = "spring.redis")
    public class RedisProperties {
        private int database = 0;
        private String url;
        private String host = "localhost";
        private String password;
        private int port = 6379;
        //......
    }
    复制代码

*  application.yml文件配置

spring
        redis
            host:xxx
            port:xxx
            password:xxx
    复制代码

### 4.3 第三方启动器 ###

如果使用第三方启动器，如何知道在yml文件中设置什么配置项？本章节以mybatis为例：

*  引入`mybatis-spring-boot-starter`

<dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.2.3</version>
    </dependency>
    复制代码

*  自动装配依赖

<dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-autoconfigure</artifactId>
    </dependency>
    复制代码

*  工厂文件位置

/META-INF/spring.factories
    复制代码

*  文件中指定MyBatis自动配置

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration
    复制代码

*  自动配置类`MybatisAutoConfiguration`

@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
    @ConditionalOnSingleCandidate(DataSource.class)
    @EnableConfigurationProperties(MybatisProperties.class) // 配置信息类
    @AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
    public class MybatisAutoConfiguration implements InitializingBean {
        //......
    }
    复制代码

*  配置信息类`MybatisProperties`

@ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
    public class MybatisProperties {
        public static final String MYBATIS_PREFIX = "mybatis";
        private String configLocation;
        private String[] mapperLocations;
        private String typeAliasesPackage;
        private Class<?> typeAliasesSuperType;
        //......
    }
    复制代码

*  application.yml文件配置

mybatis:
      mapperLocations: classpath:db/sqlmappers/*.xml
      configLocation: classpath:db/mybatis-config.xml
    复制代码

## 5 文章总结 ##

第一章节介绍如何自定义一个简单启动器，第二章节对自定义启动器进行测试，第三章节通过源码分析介绍启动器运行原理，第四章进行知识延伸介绍spring官方启动器，使用第三方启动器相关知识，希望本文对大家有所帮助。

作者：JAVA前线  
链接：https://juejin.cn/post/7221923392261210169