// 創(chuàng)建Redisson客戶端
RedissonClient redisson = Redisson.create();
// 獲取RTopic對象
RTopic<String> topic = redisson.getTopic("myTopic");
// 發(fā)布消息
topic.publish("Hello, Redisson!");
// 添加監(jiān)聽器
topic.addListener(String.class, (channel, msg) -> {
    System.out.println("Received message: " + msg);
});
// 關閉Redisson客戶端
redisson.shutdown();

        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.14.1</version>
        </dependency>

redis:
  sdk:
    config:
      host: localhost
      port: 6379
      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

/**
 * @description redis連接配置
 * @create 2023/12/17 20:48:13
 */
@Data
@ConfigurationProperties(prefix = "redis.sdk.config", ignoreInvalidFields = true)
public class RedissonCientConfigProperties {
    /** 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;
}

/**
 * @description redisson 消息主題注解
 * @create 2023/12/17 21:56:10
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@Documented
public @interface RedisTopic {
    // 主題名稱
    String topic() default "";
}

/**
 * @description redis客戶端
 * @create 2023/12/17 20:49:41
 */
@Configuration
@EnableConfigurationProperties(RedisCientConfigProperties.class)
public class RedisClientConfig {
     public RedissonClient redissonClient(ConfigurableApplicationContext applicationContext, RedisCientConfigProperties properties) {
        Config config = new Config();
        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())
        ;
        RedissonClient redissonClient = Redisson.create(config);
        // 注冊消息發(fā)布訂閱主題Topic
        // 找到所有實現了Redisson中MessageListener接口的bean名字
        String[] beanNamesForType = applicationContext.getBeanNamesForType(MessageListener.class);
        for (String beanName : beanNamesForType) {
            // 通過bean名字獲取到監(jiān)聽bean
            MessageListener bean = applicationContext.getBean(beanName, MessageListener.class);
            Class<? extends MessageListener> beanClass = bean.getClass();
            // 如果bean的注解里包含我們的自定義注解RedisTopic.class，則以RedisTopic注解的值作為name將該bean注冊到bean工廠，方便在別處注入
            if (beanClass.isAnnotationPresent(RedisTopic.class)) {
                RedisTopic redisTopic = beanClass.getAnnotation(RedisTopic.class);
                RTopic topic = redissonClient.getTopic(redisTopic.topic());
                topic.addListener(String.class, bean);
                ConfigurableListableBeanFactory beanFactory = applicationContext.getBeanFactory();
                beanFactory.registerSingleton(redisTopic.topic(), topic);
            }
        }
        return redissonClient;
    }
}

@Slf4j
@Service
@RedisTopic(topic = "testRedisTopic02")
public class RedisTopicListener02 implements MessageListener<String> {
    @Override
    public void onMessage(CharSequence channel, String msg) {
        log.info("02-監(jiān)聽消息(Redis 發(fā)布/訂閱): {}", msg);
    }
}

@Slf4j
@Repository
public class OrderRepository implements IOrderRepository {
    @Resource(name = "testRedisTopic02")
    private RTopic testRedisTopic02;
    @Resource(name = "testRedisTopic03")
    private RTopic testRedisTopic03;
    @Override
    public String createOrder(OrderAggregate orderAggregate) {
        // 向  testRedisTopic02 發(fā)布消息
        testRedisTopic02.publish(JSON.toJSONString(orderEntity));
        // 向  testRedisTopic03 發(fā)布消息
        testRedisTopic03.publish(JSON.toJSONString(orderEntity));
        return orderId;
    }    
}