本章内容主要介绍如何通过封装相关的redission连接配置和工具类，最终完成一个通用的redission starter。并且本文还会进行对封装的starter进行引入测试，最终实现想要的效果。
参考文章： SpringBoot日常：自定义实现SpringBoot Starter

逻辑实现

下面直接进入主题，介绍整体用到的文件和逻辑内容。首先需要创建一个maven项目，这一步省略

POM.xml

在pom配置文件中引入自动加载和redssion的依赖

<dependencies>
    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson-spring-boot-starter</artifactId>
        <version>3.17.7</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-configuration-processor</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

RedissionConfig

创建一个RedissionConfig的配置连接类，主要是加载相关的redis配置并进行连接

@Configuration
@ConditionalOnClass(Redisson.class)
@EnableConfigurationProperties({RedissionProperties.class})
public class RedissionConfig {

    @Bean
    RedissonClient redissonClient(RedissionProperties redissionProperties) {
        Config config = new Config();
        String prefix = "redis://";
        if (redissionProperties.isSsl()) {
            //加密
            prefix = "rediss://";
        }
        config.useSingleServer()
                .setAddress(prefix+redissionProperties.getHost()+":"+ redissionProperties.getPort())
                .setConnectTimeout(redissionProperties.getTimeOut())
                .setPassword(redissionProperties.getPassword());
        return Redisson.create(config);
    }
}

RedissionProperties

创建一个RedissionProperties的配置类，主要包括一些redis相关的连接配置

@ConfigurationProperties(prefix="xxx.redission")
public class RedissionProperties {

    /**
     * 连接地址
     */
    private String host;

    /**
     * 连接端口号
     */
    private int port;

    /**
     * 认证密码
     */
    private String password;

    /**
     * 超时时间 默认0
     */
    private int timeOut;

    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;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getTimeOut() {
        return timeOut;
    }

    public void setTimeOut(int timeOut) {
        this.timeOut = timeOut;
    }

    public boolean isSsl() {
        return isSsl;
    }

    public void setSsl(boolean ssl) {
        isSsl = ssl;
    }

    /**
     * 是否加密 默认不加密 false
     */
    private boolean isSsl;
}

RedissionUtils

创建一个RedissionUtils的工具操作类，该工具类可以方便外部进行数据操作，本工具类并不完善，只有字符串的操作和锁操作，如需其他数据类型的操作，请自行补充

@Component
public final class RedissionUtils {

    @Autowired
    private RedissonClient redissonClient;


    private static final long DEFAULT_GETLOCK_TIMEOUT = 5;


    public void set(String key, String vul) {
        redissonClient.getBucket(key).set(vul);
    }


    public Object get(String key) {
        return redissonClient.getBucket(key).get();
    }


    public String getString(String key) {
        RBucket<String> bucket = redissonClient.getBucket(key);
        return bucket.get();
    }


    public <T> void setAndExpire(String key, T value, long expiredTime) {
        RBucket<T> bucket = redissonClient.getBucket(key);
        bucket.set(value, expiredTime, TimeUnit.SECONDS);
    }

    /**
     * 获取锁
     * @param lockKey
     * @return
     */
    public boolean getLock(String lockKey) {
        RLock rLock = redissonClient.getLock(lockKey);
        try {
            boolean res = rLock.tryLock(DEFAULT_GETLOCK_TIMEOUT,  TimeUnit.SECONDS);
            return res;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //无论如何, 最后都要解锁
            rLock.unlock();
        }
        return false;
    }

    /**
     *
     * @param lockKey 锁的key
     * @param timeOut 获取锁的超时时间
     * @return
     */
    public boolean getLock(String lockKey, long timeOut) {
        RLock rLock = redissonClient.getLock(lockKey);
        try {
            boolean res = rLock.tryLock(timeOut,  TimeUnit.SECONDS);
            return res;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //无论如何, 最后都要解锁
            rLock.unlock();
        }
        return false;
    }

}

spring.factories

在resource/META-INF下需要创建一个自动装载配置文件spring.factories， 里面的内容如下，主要填写配置类和工具类的路径

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  cn.cys.starter.redission.config.RedissionConfig,\
  cn.cys.starter.redission.utils.RedissionUtils

功能测试

完成逻辑实现以后，需要对上面的maven项目进行打包，再放入maven仓库(本地操作其实就是mvn install)
接着再创建一个maven项目，将redission starter引入，然后进行测试。具体的使用如下

application.yml配置

在application.yml填写相应的配置信息

xxx:
  redission:
    host: 192.168.110.110
    port: 6379
    password: CR2@wwqqsqsc
    timeOut: 5
    isSsl: false

POM.xml

pom文件引入redssion starter包

<dependency>
    <groupId>cn.cys.easy.boot</groupId>
    <artifactId>easy-redission-boot-starter</artifactId>
    <version>1.0.0_base</version>
</dependency>

TestController

本文直接在controller进行引入操作测试

@RestController
public class TestController {

    @Autowired
    private RedissionUtils redissonUtils;

    @GetMapping("/test")
    public void test() {

        redissonUtils.set("myname","lisi");
        System.out.println(redissonUtils.get("myname"));
        System.out.println(redissonUtils.getString("myname"));
        System.out.println("========test Redission start");
    }
}

运行测试

启动服务，调用接口查看