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

@Configuration
public class RedisConfig {
    @Value("${redis.server.nodes}")
    private String redisServerNodes;
 
    @Value("${redis.server.password}")
    private String redisServerPassword;
 
    //Redis集群配置,單機(jī)的redis注釋掉該方法，在application配置文件里面配置就可以了
    @Bean
    public RedisClusterConfiguration getRedisClusterConfiguration() {
 
        RedisClusterConfiguration redisClusterConfiguration = new RedisClusterConfiguration();
 
        String[] serverArray = redisServerNodes.split(",");
        Set<RedisNode> nodes = new HashSet<RedisNode>();
        for (String ipPort : serverArray) {
            String[] ipAndPort = ipPort.split(":");
            nodes.add(new RedisNode(ipAndPort[0].trim(), Integer.parseInt(ipAndPort[1])));
        }
        redisClusterConfiguration.setClusterNodes(nodes);
        RedisPassword pwd = RedisPassword.of(redisServerPassword);
        redisClusterConfiguration.setPassword(pwd);
        return redisClusterConfiguration;
    }
 
    //指定redisTemplate類型，如下為<String, Object>
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        // 使用JSON格式序列化對象，對緩存數(shù)據(jù)key和value進(jìn)行轉(zhuǎn)換
        Jackson2JsonRedisSerializer<Object> jacksonSeial = new Jackson2JsonRedisSerializer<>(Object.class);
        // 解決查詢緩存轉(zhuǎn)換異常的問題
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(objectMapper);
 
        // 設(shè)置RedisTemplate模板API的序列化方式為JSON
        template.setDefaultSerializer(jacksonSeial);
        return template;
    }
 
     /**
     * Redis消息監(jiān)聽器容器
     * 這個容器加載了RedisConnectionFactory和消息監(jiān)聽器
     * 可添加多個不同話題的redis監(jiān)聽器，需要將消息監(jiān)聽器和消息頻道綁定，
     * 通過反射調(diào)用消息訂閱處理器的相關(guān)方法進(jìn)行業(yè)務(wù)處理
     *
     * @param  redisConnectionFactory       連接工廠
     * @param  listener                     Redis消息監(jiān)聽器
     * @param  MessageListenerAdapter       Redis消息監(jiān)聽適配器
     * @return RedisMessageListenerContainer    消息監(jiān)聽容器
     */
    @Bean
    @SuppressWarnings("all")
    public RedisMessageListenerContainer container(RedisConnectionFactory redisConnectionFactory,
                                                   RedisMessageListener listener,
                                                   MessageListenerAdapter adapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(redisConnectionFactory);
        // 所有的訂閱消息，都需要在這里進(jìn)行注冊綁定
        // new PatternTopic(TOPIC_NAME1) 表示發(fā)布信息的頻道
        // 可以添加多個頻道以及配置不同的頻道
        container.addMessageListener(listener, new PatternTopic(SystemConstants.TOPIC_NAME1));
        container.addMessageListener(adapter, new PatternTopic(SystemConstants.TOPIC_NAME2));
 
        /**
         * 設(shè)置序列化對象
         * 特別注意：1. 發(fā)布的時候和訂閱方都需要設(shè)置序列化
         *         2. 設(shè)置序列化對象必須放在 {加入消息監(jiān)聽器} 這步后面，不然接收器接收不到消息
         */
        Jackson2JsonRedisSerializer seria = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        seria.setObjectMapper(objectMapper);
        container.setTopicSerializer(seria);
        return container;
    }
 
    /**
     * 這個地方是給messageListenerAdapter 傳入一個消息接受的處理器，利用反射的方法調(diào)用“receiveMessage”
     * 也有好幾個重載方法，這邊默認(rèn)調(diào)用處理器的方法 叫OnMessage
     *
     * @param redisMessageReceiver 消息接收對象
     * @return 消息監(jiān)聽適配器
     */
    @Bean
    public MessageListenerAdapter listenerAdapter(RedisMessageReceiver redisMessageReceiver) {
        MessageListenerAdapter receiveMessage = new MessageListenerAdapter(printMessageReceiver, "onMessage");
        Jackson2JsonRedisSerializer<Object> seria = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        seria.setObjectMapper(objectMapper);
        receiveMessage.setSerializer(seria);
        return receiveMessage;
    }
}

//方式一：
@Slf4j
@Component
public class RedisMessageListener implements MessageListener {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private CacheManager cacheManager;
 
    @Override
    public void onMessage(Message message, byte[] pattern) {
    // 接收的topic
    log.info("接收消息頻道:" + new String(pattern));
    //序列化對象（特別注意：發(fā)布的時候需要設(shè)置序列化；訂閱方也需要設(shè)置序列化）
    MessageDto<?> messageDto = (MessageDto<?>) redisTemplate.getValueSerializer().deserialize(message.getBody());
    //MessageDto<T>為自己編寫的一個消息對象類（如自定義有：String data，String title，T content 等屬性）
    log.info("接收消息內(nèi)容：{}", messageDto);
    //根據(jù)消息內(nèi)容做具體業(yè)務(wù)邏輯。。。。。。。。。
    //。。。。。。。。。。。。。。。。。。。。。。
    }
}

//方式二
@Slf4j
@Component
public class RedisMessageReceiver {
 
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;
 
    /**
     * 方法命名規(guī)則必須為function(Object messageDto) / function(Object messageDto,String topic)
     * @param messageDto 消息對象
     * @param topic 消息頻道名稱
     */
    public void onMessage(Object messageDto , String topic) {
        // 接收消息頻道
        log.info("接收消息頻道:" + topic);
        //接收消息內(nèi)容
        log.info("接收消息內(nèi)容:{}",messageDto);
    }
}

@Slf4j
@Component
public class RedisMessageUtils {
 
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;
 
    /**
     * 向通道發(fā)布消息
     */
    public void sendMessage(String topic, Object message) {
        if (!StringUtils.hasText(topic)) {
            return;
        }
        try {
            redisTemplate.convertAndSend(topic, message);
            log.info("發(fā)送消息成功，topic：{}，message：{}", topic, message);
        } catch (Exception e) {
            log.info("發(fā)送消息失敗，topic：{}，message：{}", topic, message);
            e.printStackTrace();
        }
    }
}

@RestController
@RequestMapping("/user")
public class UserController{
 
  @Autowired
  private UserService userService;
 
  @PostMapping("/getUsers")  
  public List<User> queryUsers(@RequestBody UserDto userDto){
   List<User> users=userService.queryUsers(userDto);
   //發(fā)送測試消息
   RedisMessageUtils.sendMessage(SystemConstants.TOPIC_NAME2, new MessageDto());
   return users;
  }
}