文章目录
  1. 1. 新建原型项目
  2. 2. 开发阶段
    1. 2.1. 1.配置参数映射RedisProperties
    2. 2.2. 2.实现自动化配置RedisAutoConfiguration.java
    3. 2.3. Starter自动化运作原理
    4. 2.4. 3.自定义spring.factories
    5. 2.5. 4.创建测试项目my-redis-starter-test
    6. 2.6. 补充

使用springboot开发应用已经有一段时间了,我们都沉醉于它简洁的配置和平滑的上手曲线。

在springboot的开发中,starter是一个核心的配置,只需要引入对应模块的starter,然后在application.properties中引入对应的配置项,就可以开发业务逻辑了。

这一切都归功于springboot的自动配置的能力。

那么本文就让我们基于Jedis客户端封装一个我们自己的简易版starter,较为深入的了解一下springboot的自动配置魔法。

新建原型项目

首先让我们新建一个maven项目,引入基础依赖,核心依赖为

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>        

该依赖中包含的spring-boot-autoconfigure提供了自动配置的功能。

完整的pom.xml如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.snowalker</groupId>
    <artifactId>my-redis-starter</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>my-redis-starter</name>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.3.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

由于我们是要封装Jedis的starter因此引入了Jedis依赖。

开发阶段

1.配置参数映射RedisProperties

这里我们新建一个类,类名为RedisProperties,就是一个POJO类,目的是映射配置文件application.properties到实体的字段中。

/**
* @author snowalker
* @date 2018/7/10
* @desc Redis配置
*/
@ConfigurationProperties(prefix = "redis.starter")
public class RedisProperties {

    private String host;
    private int port;

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public int getPort() {
        return port;
    }

    public void setPort(int port) {
        this.port = port;
    }
}

可以看到就是一个普通的POJO类,在类上添加注解 @ConfigurationProperties(prefix = “redis.starter”) 标记当前类为一个配置属性类,对应的配置文件中配置项的前缀为:redis.starter。

对于本例来讲,配置文件中对应的完整配置项为:

redis.starter.host=xxx.xxx.xxx.xxx
redis.starter.port=xxxx

2.实现自动化配置RedisAutoConfiguration.java

自动化配置的核心就是提供实体bean的组装和初始化,对于本starter而言,我们主要组装的核心bean就是 Jedis 这个实体。

@Configuration
@ConditionalOnClass(Jedis.class)    // 存在Jedis这个类才装配当前类
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {


    @Bean
    @ConditionalOnMissingBean   // 没有Jedis这个类才进行装配
    public Jedis jedis(RedisProperties redisProperties) {
        return new Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}

可以看到,我们这里通过@Bean注解组装了一个Jedis的Bean,外界只需要通过注入即可使用。

先解释下几个核心的注解:

  1. @Configuration: 声明当前类为一个配置类
  2. @ConditionalOnClass(Jedis.class):当SpringIoc容器内存在Jedis这个Bean时才装配当前配置类
  3. @EnableConfigurationProperties(RedisProperties.class):这是一个开启使用配置参数的注解,value值就是我们配置实体参数映射的ClassType,将配置实体作为配置来源。
  4. @ConditionalOnMissingBean:当SpringIoc容器内不存在Jedis这个Bean的时候才进行装配,否则不装配。

这些注解是我们实现自动配置的关键,体现了spring的哲学: 约定优于配置

其余没有用到的注解这里也一并补充下:

@ConditionalOnBean:当SpringIoc容器内存在指定Bean的条件
@ConditionalOnClass:当SpringIoc容器内存在指定Class的条件
@ConditionalOnExpression:基于SpEL表达式作为判断条件
@ConditionalOnJava:基于JVM版本作为判断条件
@ConditionalOnJndi:在JNDI存在时查找指定的位置
@ConditionalOnMissingBean:当SpringIoc容器内不存在指定Bean的条件
@ConditionalOnMissingClass:当SpringIoc容器内不存在指定Class的条件
@ConditionalOnNotWebApplication:当前项目不是Web项目的条件
@ConditionalOnProperty:指定的属性是否有指定的值
@ConditionalOnResource:类路径是否有指定的值
@ConditionalOnSingleCandidate:当指定Bean在SpringIoc容器内只有一个,
                                或者虽然有多个但是指定首选的Bean
@ConditionalOnWebApplication:当前项目是Web项目的条件

以上注解都是元注解@Conditional演变而来的,根据不用的条件对应创建以上的具体条件注解。

到目前为止我们还没有完成自动化配置starter,离成功已经不远了,那么我们趁热打铁继续对Springboot自动化运行原理进行讲解。

Starter自动化运作原理

我们开发springboot应用的时候都知道要在启动类加注解:@SpringBootApplication

在注解@SpringBootApplication上存在一个开启自动化配置的注解@EnableAutoConfiguration来完成自动化配置,注解源码如下所示:

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({EnableAutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

在@EnableAutoConfiguration注解内使用到了@import注解来完成导入配置的功能,
而EnableAutoConfigurationImportSelector内部则是使用了SpringFactoriesLoader.loadFactoryNames方法进行扫描具有META-INF/spring.factories文件的jar包。

先来看下spring-boot-autoconfigure包内的spring.factories文件内容,如下所示:

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnClassCondition

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
.....省略

可以看到配置的结构形式是Key/Value形式,如果存在多个Value时则使用,隔开,那我们在自定义starter内也可以使用这种形式来完成,因为我们的目的是为了完成自动化配置,所以我们这里Key则是需要使用org.springframework.boot.autoconfigure.EnableAutoConfiguration

3.自定义spring.factories

自定义spring.factories的步骤很简单,只需要在src/main/resource目录下创建META-INF目录,并在该目录下添加文件spring.factories,文件内容为:

org.springframework.boot.autoconfigure.EnableAutoConfiguration=
com.snowalker.demo.redis.RedisAutoConfiguration

到这里,我们自定义my-redis-starter的步骤已经完成,那么就让我们建立一个测试项目来测试一下这个starter是否有效。

4.创建测试项目my-redis-starter-test

  1. pom文件如下所示,我只展示核心的代码。

    <dependencies>
            <dependency>
                <groupId>com.snowalker</groupId>
                <artifactId>my-redis-starter</artifactId>
                <version>1.0.0</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
  2. 书写配置文件

在配置文件application.properties中引入下面的配置,因为我是用的本地的测试Redis,因此主机名为127.0.0.1

redis.starter.host=127.0.0.1
redis.starter.port=6379
  1. 运行测试

在测试工程的启动类中添加如下代码,测试功能是否正常。

@SpringBootApplication
public class RedisDistributedLockStarterDemoApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context =
                SpringApplication.run
                (RedisDistributedLockStarterDemoApplication.class, args);
        Jedis jedis = context.getBean(Jedis.class);
        jedis.set("name", "snowalker");
        jedis.setex("snowalker", 10, "snowalker");
        System.out.println(jedis.get("name"));
        context.close();
    }
}

简单描述一下运行的过程,首先我们获取spring上下文,从上下文中取出我们在starter中自动装配的Jedis的bean。

然后就可以基于该Bean实现我们想要的功能,这里我设置了一个串到redis中,查看控制台

2018-07-10 17:17:49.773 DEBUG 7428 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     : 
Creating shared instance of singleton bean 'jedis'
2018-07-10 17:17:49.773 DEBUG 7428 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     : 
Creating instance of bean 'jedis'
2018-07-10 17:17:49.773 DEBUG 7428 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     : 
Returning cached instance of singleton bean 'com.snowalker.demo.redis.RedisAutoConfiguration'
2018-07-10 17:17:49.774 DEBUG 7428 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     :
 Creating shared instance of singleton bean 'redis.starter-com.snowalker.demo.redis.RedisProperties'
2018-07-10 17:17:49.774 DEBUG 7428 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     : 
Creating instance of bean 'redis.starter-com.snowalker.demo.redis.RedisProperties'
2018-07-10 17:17:49.774 DEBUG 7428 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     : 
Eagerly caching bean 'redis.starter-com.snowalker.demo.redis.RedisProperties' to allow for resolving potential circular references
2018-07-10 17:17:49.780 DEBUG 7428 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     : 
Finished creating instance of bean 'redis.starter-com.snowalker.demo.redis.RedisProperties'
2018-07-10 17:17:49.780 DEBUG 7428 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     : 
Autowiring by type from bean name 'jedis' via factory method to bean named 'redis.starter-com.snowalker.demo.redis.RedisProperties'
2018-07-10 14:50:44.280 DEBUG 18416 --- [           main] o.s.b.f.s.DefaultListableBeanFactory     : 
Returning cached instance of singleton bean 'jedis'
snowalker

日志等级为DEBUG,可以看到我们自定义的Redis配置注入的过程以及从上下文中我们获取到了一个单例Bean–jedis。到这里说明我们定义的starter成功的完成了Bean的自动化装配和注入。

补充

除了上文我们说到的使用定义spring.factories完成Bean的自动装配,还有另外的一种方式,那就是通过 @Enablexxxx 注解实现Bean的自动化装配。

过程也很好理解,只需要我们自定义一个注解,@EnableRedis,这个名字可以任意指定。

代码如下

@Inherited
@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(RedisAutoConfiguration.class)
public @interface EnableRedis {
}

代码就是这么简洁,核心在于 @Import(RedisAutoConfiguration.class) 这个注解,其实他的作用和spring.factories一样,引入org.springframework.boot.autoconfigure.EnableAutoConfiguration的配置类–
com.snowalker.demo.redis.RedisAutoConfiguration完成自动Bean的装配。

使用也很容易,只需要在启动类添加注解即可,代码如下

@EnableRedis
@SpringBootApplication
public class RedisDistributedLockStarterDemoApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context =
                SpringApplication.run(RedisDistributedLockStarterDemoApplication.class, args);
        Jedis jedis = context.getBean(Jedis.class);
        jedis.set("name", "snowalker");
        jedis.setex("snowalker", 10, "snowalker");
        System.out.println(jedis.get("name"));
        context.close();
    }
}

执行的效果和定义spring.factories一致,因为他们本质上是一样的。

本文只是一个入门,springboot还有很多特性值得我们去挖掘,而我们会继续深入学习……

参考来源https://segmentfault.com/a/1190000011433487

文章目录
  1. 1. 新建原型项目
  2. 2. 开发阶段
    1. 2.1. 1.配置参数映射RedisProperties
    2. 2.2. 2.实现自动化配置RedisAutoConfiguration.java
    3. 2.3. Starter自动化运作原理
    4. 2.4. 3.自定义spring.factories
    5. 2.5. 4.创建测试项目my-redis-starter-test
    6. 2.6. 补充
Fork me on GitHub