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
public class TestApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }
}

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官方启动器，运用第三方启动器相关常识，期望本文对大家有所帮助。

SpringBoot中自定义starter实例与原理

1 自定义启动器

1.1 创立项目

1.1.1 项目名

1.1.2 springboot版本号

1.2 创立Football

1.3 创立装备类

1.4 创立AutoConfiguration

1.5 spring.factories

2 测验启动器

2.1 引进依赖

2.2 application.yml

2.3 TestController

2.4 TestApplication

2.5 测验用例

2.6 测验结果

3 原理剖析

4 延伸常识

4.1 spring官方启动器

4.2 spring-boot-starter

4.3 第三方启动器

5 文章总结

作者信息

SpringBoot中自定义starter实例与原理

1 自定义启动器

1.1 创立项目

1.1.1 项目名

1.1.2 springboot版本号

1.2 创立Football

1.3 创立装备类

1.4 创立AutoConfiguration

1.5 spring.factories

2 测验启动器

2.1 引进依赖

2.2 application.yml

2.3 TestController

2.4 TestApplication

2.5 测验用例

2.6 测验结果

3 原理剖析

4 延伸常识

4.1 spring官方启动器

4.2 spring-boot-starter

4.3 第三方启动器

5 文章总结

相关文章

Flutter(九)层叠布局-Stack

SwiftUI 初次实战—布局总结

超有用的Android开发技巧：拦截界面View创建

v-formly – 一个让你不用画UI就可以构建create/edit页面的库

作者信息