小傅哥，feat：redis 模块，环境和使用

docs/dev-ops/environment/docker-compose.yml

@@ -28,7 +28,7 @@ services:
     depends_on:
       mysql:
         condition: service_healthy
-
+  # MySQL
   mysql:
     image: mysql:8.0.32
     container_name: mysql
@@ -61,6 +61,17 @@ services:
     container_name: mysql-job-dbdata
     volumes:
       - /var/lib/mysql
+  # Redis
+  redis:
+    image: redis:7.2.0
+    container_name: redis
+    ports:
+      - 6379:6379
+    volumes:
+      - ./redis/redis.conf:/usr/local/etc/redis/redis.conf
+    command: redis-server /usr/local/etc/redis/redis.conf
+    networks:
+      - my-network
 
 networks:
   my-network:

docs/dev-ops/environment/redis/redis.conf

+bind 0.0.0.0
+port 6379
+requirepass 123456
\ No newline at end of file

pom.xml

@@ -101,7 +101,6 @@
                 <artifactId>commons-codec</artifactId>
                 <version>1.15</version>
             </dependency>
-
             <dependency>
                 <groupId>org.apache.dubbo</groupId>
                 <artifactId>dubbo</artifactId>
@@ -112,16 +111,16 @@
                 <artifactId>dubbo-spring-boot-starter</artifactId>
                 <version>3.0.9</version>
             </dependency>
-<!--            <dependency>-->
-<!--                <groupId>org.apache.dubbo</groupId>-->
-<!--                <artifactId>dubbo-registry-nacos</artifactId>-->
-<!--                <version>3.2.2</version>-->
-<!--            </dependency>-->
             <dependency>
                 <groupId>com.alibaba.nacos</groupId>
                 <artifactId>nacos-client</artifactId>
                 <version>2.1.0</version>
             </dependency>
+            <dependency>
+                <groupId>org.redisson</groupId>
+                <artifactId>redisson-spring-boot-starter</artifactId>
+                <version>3.23.4</version>
+            </dependency>
 
             <!-- 工程模块 -->
             <dependency>

xfg-frame-archetype-std-app/pom.xml

@@ -87,14 +87,14 @@
             <groupId>org.apache.dubbo</groupId>
             <artifactId>dubbo-spring-boot-starter</artifactId>
         </dependency>
-<!--        <dependency>-->
-<!--            <groupId>org.apache.dubbo</groupId>-->
-<!--            <artifactId>dubbo-registry-nacos</artifactId>-->
-<!--        </dependency>-->
         <dependency>
             <groupId>com.alibaba.nacos</groupId>
             <artifactId>nacos-client</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.redisson</groupId>
+            <artifactId>redisson-spring-boot-starter</artifactId>
+        </dependency>
 
         <!-- 工程模块；启动依赖 trigger->domain, infrastructure-->
         <dependency>

xfg-frame-archetype-std-app/src/main/java/cn/bugstack/config/RedisClientConfig.java

+package cn.bugstack.config;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufAllocator;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.buffer.ByteBufOutputStream;
+import org.redisson.Redisson;
+import org.redisson.api.RedissonClient;
+import org.redisson.client.codec.BaseCodec;
+import org.redisson.client.protocol.Decoder;
+import org.redisson.client.protocol.Encoder;
+import org.redisson.config.Config;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.ConfigurableApplicationContext;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.io.IOException;
+
+/**
+ * Redis 客户端，使用 Redisson <a href="https://github.com/redisson/redisson">Redisson</a>
+ *
+ * @author Fuzhengwei bugstack.cn @小傅哥
+ */
+@Configuration
+@EnableConfigurationProperties(RedisClientConfigProperties.class)
+public class RedisClientConfig {
+
+    @Bean("redissonClient")
+    public RedissonClient redissonClient(ConfigurableApplicationContext applicationContext, RedisClientConfigProperties properties) {
+        Config config = new Config();
+        // 根据需要可以设定编解码器；https://github.com/redisson/redisson/wiki/4.-%E6%95%B0%E6%8D%AE%E5%BA%8F%E5%88%97%E5%8C%96
+        // config.setCodec(new RedisCodec());
+
+        config.useSingleServer()
+                .setAddress("redis://" + properties.getHost() + ":" + properties.getPort())
+                .setPassword(properties.getPassword())
+                .setConnectionPoolSize(properties.getPoolSize())
+                .setConnectionMinimumIdleSize(properties.getMinIdleSize())
+                .setIdleConnectionTimeout(properties.getIdleTimeout())
+                .setConnectTimeout(properties.getConnectTimeout())
+                .setRetryAttempts(properties.getRetryAttempts())
+                .setRetryInterval(properties.getRetryInterval())
+                .setPingConnectionInterval(properties.getPingInterval())
+                .setKeepAlive(properties.isKeepAlive())
+        ;
+
+        return Redisson.create(config);
+    }
+
+    static class RedisCodec extends BaseCodec {
+
+        private final Encoder encoder = in -> {
+            ByteBuf out = ByteBufAllocator.DEFAULT.buffer();
+            try {
+                ByteBufOutputStream os = new ByteBufOutputStream(out);
+                JSON.writeJSONString(os, in, SerializerFeature.WriteClassName);
+                return os.buffer();
+            } catch (IOException e) {
+                out.release();
+                throw e;
+            } catch (Exception e) {
+                out.release();
+                throw new IOException(e);
+            }
+        };
+
+        private final Decoder<Object> decoder = (buf, state) -> JSON.parseObject(new ByteBufInputStream(buf), Object.class);
+
+        @Override
+        public Decoder<Object> getValueDecoder() {
+            return decoder;
+        }
+
+        @Override
+        public Encoder getValueEncoder() {
+            return encoder;
+        }
+
+    }
+
+}

xfg-frame-archetype-std-app/src/main/java/cn/bugstack/config/RedisClientConfigProperties.java

+package cn.bugstack.config;
+
+import lombok.Data;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * @author Fuzhengwei bugstack.cn @小傅哥
+ * @description Redis 连接配置 <a href="https://github.com/redisson/redisson/tree/master/redisson-spring-boot-starter">redisson-spring-boot-starter</a>
+ * @create 2023-09-03 16:51
+ */
+@Data
+@ConfigurationProperties(prefix = "redis.sdk.config", ignoreInvalidFields = true)
+public class RedisClientConfigProperties {
+
+    /** host:ip */
+    private String host;
+    /** 端口 */
+    private int port;
+    /** 账密 */
+    private String password;
+    /** 设置连接池的大小，默认为64 */
+    private int poolSize = 64;
+    /** 设置连接池的最小空闲连接数，默认为10 */
+    private int minIdleSize = 10;
+    /** 设置连接的最大空闲时间（单位：毫秒），超过该时间的空闲连接将被关闭，默认为10000 */
+    private int idleTimeout = 10000;
+    /** 设置连接超时时间（单位：毫秒），默认为10000 */
+    private int connectTimeout = 10000;
+    /** 设置连接重试次数，默认为3 */
+    private int retryAttempts = 3;
+    /** 设置连接重试的间隔时间（单位：毫秒），默认为1000 */
+    private int retryInterval = 1000;
+    /** 设置定期检查连接是否可用的时间间隔（单位：毫秒），默认为0，表示不进行定期检查 */
+    private int pingInterval = 0;
+    /** 设置是否保持长连接，默认为true */
+    private boolean keepAlive = true;
+
+}

xfg-frame-archetype-std-app/src/main/resources/application-dev.yml

@@ -17,7 +17,7 @@ spring:
   datasource:
     username: root
     password: 123456
-    url: jdbc:mysql://127.0.0.1:3306/xfg_frame_archetype?useUnicode=true&characterEncoding=utf8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&serverTimezone=UTC&useSSL=true
+    url: jdbc:mysql://127.0.0.1:13306/xfg_frame_archetype?useUnicode=true&characterEncoding=utf8&autoReconnect=true&zeroDateTimeBehavior=convertToNull&serverTimezone=UTC&useSSL=true
     driver-class-name: com.mysql.cj.jdbc.Driver
   hikari:
     pool-name: Retail_HikariCP
@@ -34,6 +34,22 @@ spring:
 #  mapper-locations: classpath:/mybatis/mapper/*.xml
 #  config-location:  classpath:/mybatis/config/mybatis-config.xml
 
+# Redis
+redis:
+  sdk:
+    config:
+      host: 127.0.0.1
+      port: 6379
+      password: 123456
+      pool-size: 10
+      min-idle-size: 5
+      idle-timeout: 30000
+      connect-timeout: 5000
+      retry-attempts: 3
+      retry-interval: 1000
+      ping-interval: 60000
+      keep-alive: true
+
 # Dubbo
 dubbo:
   application:

xfg-frame-archetype-std-app/src/test/java/cn/bugstack/test/infrastructure/redis/RedisTest.java

+package cn.bugstack.test.infrastructure.redis;
+
+import cn.bugstack.infrastructure.redis.IRedisService;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.redisson.api.RLock;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import javax.annotation.Resource;
+
+/**
+ * Redis
+ * @author Fuzhengwei bugstack.cn @小傅哥
+ */
+@Slf4j
+@RunWith(SpringRunner.class)
+@SpringBootTest
+public class RedisTest {
+
+    @Resource
+    private IRedisService redissonService;
+
+    @Test
+    public void test_setValue() {
+        redissonService.setValue("xfg", "test123");
+        log.info("设置属性值");
+    }
+
+    @Test
+    public void test_getValue() {
+        String xfg = redissonService.getValue("xfg");
+        log.info("测试结果:{}", xfg);
+    }
+
+    @Test
+    public void test_remove() {
+        redissonService.remove("60711088280");
+    }
+
+    /**
+     * 可重入锁，加锁和解锁。Redisson的分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口，同时还支持自动过期解锁。
+     * lock.lock();
+     * lock.lock(10, TimeUnit.SECONDS);
+     * lock.tryLock(3, 10, TimeUnit.SECONDS);
+     * lock.lockAsync();
+     * lock.lockAsync(10, TimeUnit.SECONDS);
+     * Future<Boolean> res = lock.tryLockAsync(3, 10, TimeUnit.SECONDS);
+     */
+    @Test
+    public void test_ReentrantLock() throws Exception {
+        RLock lock = redissonService.getLock("");
+        try {
+            // 1. 最常见的使用方法
+            lock.lock();
+
+        } finally {
+            lock.unlock();
+        }
+    }
+
+
+}

xfg-frame-archetype-std-infrastructure/pom.xml

@@ -18,6 +18,11 @@
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.redisson</groupId>
+            <artifactId>redisson-spring-boot-starter</artifactId>
+        </dependency>
+
         <!-- 系统模块 -->
         <dependency>
             <groupId>cn.bugstack</groupId>

xfg-frame-archetype-std-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/IRedisService.java

+package cn.bugstack.infrastructure.redis;
+
+import org.redisson.api.*;
+
+/**
+ * Redis 服务
+ * @author Fuzhengwei bugstack.cn @小傅哥
+ */
+public interface IRedisService {
+
+    /**
+     * 设置指定 key 的值
+     *
+     * @param key   键
+     * @param value 值
+     */
+    <T> void setValue(String key, T value);
+
+    /**
+     * 设置指定 key 的值
+     *
+     * @param key     键
+     * @param value   值
+     * @param expired 过期时间
+     */
+    <T> void setValue(String key, T value, long expired);
+
+    /**
+     * 获取指定 key 的值
+     *
+     * @param key 键
+     * @return 值
+     */
+    <T> T getValue(String key);
+
+    /**
+     * 获取队列
+     *
+     * @param key 键
+     * @param <T> 泛型
+     * @return 队列
+     */
+    <T> RQueue<T> getQueue(String key);
+
+    /**
+     * 加锁队列
+     *
+     * @param key 键
+     * @param <T> 泛型
+     * @return 队列
+     */
+    <T> RBlockingQueue<T> getBlockingQueue(String key);
+
+    /**
+     * 延迟队列
+     *
+     * @param rBlockingQueue 加锁队列
+     * @param <T> 泛型
+     * @return 队列
+     */
+    <T> RDelayedQueue<T> getDelayedQueue(RBlockingQueue<T> rBlockingQueue);
+
+    /**
+     * 自增 Key 的值；1、2、3、4
+     *
+     * @param key 键
+     * @return 自增后的值
+     */
+    long incr(String key);
+
+    /**
+     * 指定值，自增 Key 的值；1、2、3、4
+     *
+     * @param key 键
+     * @return 自增后的值
+     */
+    long incrBy(String key, long delta);
+
+    /**
+     * 自减 Key 的值；1、2、3、4
+     *
+     * @param key 键
+     * @return 自增后的值
+     */
+    long decr(String key);
+
+    /**
+     * 指定值，自增 Key 的值；1、2、3、4
+     *
+     * @param key 键
+     * @return 自增后的值
+     */
+    long decrBy(String key, long delta);
+
+
+    /**
+     * 移除指定 key 的值
+     *
+     * @param key 键
+     */
+    void remove(String key);
+
+    /**
+     * 判断指定 key 的值是否存在
+     *
+     * @param key 键
+     * @return true/false
+     */
+    boolean isExists(String key);
+
+    /**
+     * 将指定的值添加到集合中
+     *
+     * @param key   键
+     * @param value 值
+     */
+    void addToSet(String key, String value);
+
+    /**
+     * 判断指定的值是否是集合的成员
+     *
+     * @param key   键
+     * @param value 值
+     * @return 如果是集合的成员返回 true，否则返回 false
+     */
+    boolean isSetMember(String key, String value);
+
+    /**
+     * 将指定的值添加到列表中
+     *
+     * @param key   键
+     * @param value 值
+     */
+    void addToList(String key, String value);
+
+    /**
+     * 获取列表中指定索引的值
+     *
+     * @param key   键
+     * @param index 索引
+     * @return 值
+     */
+    String getFromList(String key, int index);
+
+    /**
+     * 将指定的键值对添加到哈希表中
+     *
+     * @param key   键
+     * @param field 字段
+     * @param value 值
+     */
+    void addToMap(String key, String field, String value);
+
+    /**
+     * 获取哈希表中指定字段的值
+     *
+     * @param key   键
+     * @param field 字段
+     * @return 值
+     */
+    String getFromMap(String key, String field);
+
+    /**
+     * 将指定的值添加到有序集合中
+     *
+     * @param key   键
+     * @param value 值
+     */
+    void addToSortedSet(String key, String value);
+
+    /**
+     * 获取 Redis 锁（可重入锁）
+     *
+     * @param key 键
+     * @return Lock
+     */
+    RLock getLock(String key);
+
+    /**
+     * 获取 Redis 锁（公平锁）
+     *
+     * @param key 键
+     * @return Lock
+     */
+    RLock getFairLock(String key);
+
+    /**
+     * 获取 Redis 锁（读写锁）
+     *
+     * @param key 键
+     * @return RReadWriteLock
+     */
+    RReadWriteLock getReadWriteLock(String key);
+
+    /**
+     * 获取 Redis 信号量
+     *
+     * @param key 键
+     * @return RSemaphore
+     */
+    RSemaphore getSemaphore(String key);
+
+    /**
+     * 获取 Redis 过期信号量
+     * <p>
+     * 基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。
+     * 同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。
+     *
+     * @param key 键
+     * @return RPermitExpirableSemaphore
+     */
+    RPermitExpirableSemaphore getPermitExpirableSemaphore(String key);
+
+    /**
+     * 闭锁
+     *
+     * @param key 键
+     * @return RCountDownLatch
+     */
+    RCountDownLatch getCountDownLatch(String key);
+
+    /**
+     * 布隆过滤器
+     *
+     * @param key 键
+     * @param <T> 存放对象
+     * @return 返回结果
+     */
+    <T> RBloomFilter<T> getBloomFilter(String key);
+
+}

xfg-frame-archetype-std-infrastructure/src/main/java/cn/bugstack/infrastructure/redis/RedissonService.java

+package cn.bugstack.infrastructure.redis;
+
+import org.redisson.api.*;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.time.Duration;
+
+/**
+ * Redis 服务 - Redisson
+ * @author Fuzhengwei bugstack.cn @小傅哥
+ */
+@Service("redissonService")
+public class RedissonService implements IRedisService {
+
+    @Resource
+    private RedissonClient redissonClient;
+
+    public <T> void setValue(String key, T value) {
+        redissonClient.<T>getBucket(key).set(value);
+    }
+
+    @Override
+    public <T> void setValue(String key, T value, long expired) {
+        RBucket<T> bucket = redissonClient.getBucket(key);
+        bucket.set(value, Duration.ofMillis(expired));
+    }
+
+    public <T> T getValue(String key) {
+        return redissonClient.<T>getBucket(key).get();
+    }
+
+    @Override
+    public <T> RQueue<T> getQueue(String key) {
+        return redissonClient.getQueue(key);
+    }
+
+    @Override
+    public <T> RBlockingQueue<T> getBlockingQueue(String key) {
+        return redissonClient.getBlockingQueue(key);
+    }
+
+    @Override
+    public <T> RDelayedQueue<T> getDelayedQueue(RBlockingQueue<T> rBlockingQueue) {
+        return redissonClient.getDelayedQueue(rBlockingQueue);
+    }
+
+    @Override
+    public long incr(String key) {
+        return redissonClient.getAtomicLong(key).incrementAndGet();
+    }
+
+    @Override
+    public long incrBy(String key, long delta) {
+        return redissonClient.getAtomicLong(key).addAndGet(delta);
+    }
+
+    @Override
+    public long decr(String key) {
+        return redissonClient.getAtomicLong(key).decrementAndGet();
+    }
+
+    @Override
+    public long decrBy(String key, long delta) {
+        return redissonClient.getAtomicLong(key).addAndGet(-delta);
+    }
+
+    @Override
+    public void remove(String key) {
+        redissonClient.getBucket(key).delete();
+    }
+
+    @Override
+    public boolean isExists(String key) {
+        return redissonClient.getBucket(key).isExists();
+    }
+
+    public void addToSet(String key, String value) {
+        RSet<String> set = redissonClient.getSet(key);
+        set.add(value);
+    }
+
+    public boolean isSetMember(String key, String value) {
+        RSet<String> set = redissonClient.getSet(key);
+        return set.contains(value);
+    }
+
+    public void addToList(String key, String value) {
+        RList<String> list = redissonClient.getList(key);
+        list.add(value);
+    }
+
+    public String getFromList(String key, int index) {
+        RList<String> list = redissonClient.getList(key);
+        return list.get(index);
+    }
+
+    public void addToMap(String key, String field, String value) {
+        RMap<String, String> map = redissonClient.getMap(key);
+        map.put(field, value);
+    }
+
+    public String getFromMap(String key, String field) {
+        RMap<String, String> map = redissonClient.getMap(key);
+        return map.get(field);
+    }
+
+    public void addToSortedSet(String key, String value) {
+        RSortedSet<String> sortedSet = redissonClient.getSortedSet(key);
+        sortedSet.add(value);
+    }
+
+    @Override
+    public RLock getLock(String key) {
+        return redissonClient.getLock(key);
+    }
+
+    @Override
+    public RLock getFairLock(String key) {
+        return redissonClient.getFairLock(key);
+    }
+
+    @Override
+    public RReadWriteLock getReadWriteLock(String key) {
+        return redissonClient.getReadWriteLock(key);
+    }
+
+    @Override
+    public RSemaphore getSemaphore(String key) {
+        return redissonClient.getSemaphore(key);
+    }
+
+    @Override
+    public RPermitExpirableSemaphore getPermitExpirableSemaphore(String key) {
+        return redissonClient.getPermitExpirableSemaphore(key);
+    }
+
+    @Override
+    public RCountDownLatch getCountDownLatch(String key) {
+        return redissonClient.getCountDownLatch(key);
+    }
+
+    @Override
+    public <T> RBloomFilter<T> getBloomFilter(String key) {
+        return redissonClient.getBloomFilter(key);
+    }
+
+
+}