<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.liurb.springboot.scaffold</groupId>
        <artifactId>backend-parent</artifactId>
        <version>1.0.0</version>
        <relativePath />
    </parent>

    <artifactId>redis-spring-boot-starter</artifactId>
    <version>1.0.0</version>
    <name>redis-spring-boot-starter</name>
    <description>redis-spring-boot-starter</description>

    <properties>
        <fastjson-spring-boot-starter.version>1.0.0</fastjson-spring-boot-starter.version>
        <gson-spring-boot-starter.version>1.0.0</gson-spring-boot-starter.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <dependency>
            <groupId>org.liurb.springboot.scaffold</groupId>
            <artifactId>fastjson-spring-boot-starter</artifactId>
            <version>${fastjson-spring-boot-starter.version}</version>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.liurb.springboot.scaffold</groupId>
            <artifactId>gson-spring-boot-starter</artifactId>
            <version>${gson-spring-boot-starter.version}</version>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
            <optional>true</optional>
            <exclusions>
                <exclusion>
                    <artifactId>tomcat-embed-el</artifactId>
                    <groupId>org.apache.tomcat.embed</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </dependency>

        <!--表示两个项目之间依赖不传递；不设置optional或者optional是false，表示传递依赖-->
        <!--例如：project1依赖a.jar(optional=true),project2依赖project1,则project2不依赖a.jar-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <classifier>exec</classifier>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

依赖说明：

1）spring-data-redis：spring官方提供的主要用于操作Redis

2）commons-pool2：连接池

3）lettuce-core：redis连接池使用lettuce

4）fastjson-spring-boot-starter：这里是我们上一章创建的自定义 fastjson starter

5）gson-spring-boot-starter：gson starter 这个后面会说到，配置在这里是可以通过开关去切换使用哪个作为解析器

插件说明：

加入 "<classifier>exec</classifier>"，否则其他项目引入后会提示包内的类找不到。

三、构建配置

搭建好的 starter 目录与代码如下图。

1. redis配置信息 RedisConfigProperties

@Data
@Component
@ConfigurationProperties(prefix = "redis.starter.config")
public class RedisConfigProperties {

    private String serializer;

    private String host;

    private int port;

    private String password;
    
    // todo ...
}

主要通过配置文件的方式注入一些 redis 配置信息，这里通过前缀适配的方式，yml 文件样例大概如下所示

#redis starter 配置样例
redis:
  starter:
    config:
      #序列化
      serializer: fastjson
      host: 127.0.0.1
      port: 6379
      database: 8
      password:
      lettuce:
        pool:
          max-active: 8
          max-idle: 8
          min-idle: 0
          max-wait: -1

其中 serializer 为设置当前 redis 配置使用哪种解析器，后面会介绍这里可以配置为 gson

2. 公共Lettuce链接工厂 BaseLettuceConnectionFactory

public abstract class BaseLettuceConnectionFactory {

        /**
     * 创建连接池
     *
     * @param database 数据库
     * @return
     */
    public LettuceConnectionFactory getLettuceConnectionFactory(int database) {
        
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();

        //获取redis配置
        RedisConfigProperties redisConfigProperties = getRedisConfigProperties();
        RedisConfigProperties.LettuceConfig.PoolConfig pool = redisConfigProperties.getLettuce().getPool();

        // todo ...
    }

        /**
     * 获取redis配置的抽象方法
     *
     * 由子类提供该redis配置
     *
     * @return
     */
    public abstract RedisConfigProperties getRedisConfigProperties();
}

可以看到这是一个抽象类，并有一个抽象方法 getRedisConfigProperties , 就是通过配置子类去加载用哪个配置信息(fastjson或gson)

3. 公共redis配置类 BackendFastjsonRedisConfig

public class BackendFastjsonRedisConfig extends BaseLettuceConnectionFactory {

    @Resource
    RedisConfigProperties redisConfigProperties;

    
    /**
     * 获取redis模板实例
     *
     * @param database 数据库
     * @return
     */
    public RedisTemplate<String, Object> getRedisTemplate(int database) {
        // todo ...
    }
    
    @Override
    public RedisConfigProperties getRedisConfigProperties() {

        return redisConfigProperties;
    }

}

可以看到这里注入了 RedisConfigProperties 配置类，并实现抽象方法返回这个注入的配置。

4. fastjson redis配置类 FastjsonRedisConfig

@AutoConfiguration
@EnableConfigurationProperties(value = RedisConfigProperties.class)
@ConditionalOnProperty(
        name = "redis.starter.config.serializer",
        havingValue = "fastjson"
)
public class FastjsonRedisConfig extends BackendFastjsonRedisConfig {

    @Value("${redis.starter.config.database:1}")
    private int database;

    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> redisTemplate() {

        return getRedisTemplate(database);
    }

}

配置类这里也设置了一个开关，当配置文件使用 fastjson 时，这个配置才会生效。

5. 抽象公共redis工具类 BaseRedisUtil

@Slf4j
public abstract class BaseRedisUtil {

    public abstract RedisTemplate<String, Object> getRedisTemplate();

    /**
     * Redis基本（字符串）操作
     * 将设置某个key的值，如果 key 已经持有其他值，就覆写旧值，无视类型。
     *
     * @param key 键
     * @param value 值
     * @return
     */
    public boolean set(String key, Object value) {
        getRedisTemplate().opsForValue().set(key, value);
        return true;
    }
    
    // ....
}

这个抽象类可以定义一些常用的redis方法，子类只需要继承抽象类，并实现传入 redisTemplate 实例，即可使用里面的方法。

四、加载自动化配置

从 springboot 2.7 版本后，已经不提倡使用 spring.factories 方式，需要使用新的方式来声明。

创建 org.springframework.boot.autoconfigure.AutoConfiguration.imports 文件


├── src
│   └── main
│       └── resources
│           ├── META-INF
│           │   └── spring
│           │       └── org.springframework.boot.autoconfigure.AutoConfiguration.imports

文件内容为上面创建的 redis 配置类包路径

org.liurb.springboot.starter.redis.conf.RedisConfig

五、项目打包

mvn clean install -Dmaven.test.skip=true

打包成功后，在本地仓库下会看到如下图的几个文件

【springboot进阶】基于starter项目构建（二）构建starter项目-redis

一、创建 redis-spring-boot-starter 项目

二、添加 pom 文件依赖