【spring boot】【redis】spring boot 集成redis的发布订阅机制

package com.sxd.swapping.config;

import com.sxd.swapping.redisReceiver.RedisReceiver;
import com.sxd.swapping.redisReceiver.RedisReceiver2;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;



/**
 * @author sxd
 * @date 2019/5/27 16:13
 */
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)
public class RedisConfig {



    /**
     * redis消息监听器容器
     * 可以添加多个监听不同话题的redis监听器，只需要把消息监听器和相应的消息订阅处理器绑定，该消息监听器
     * 通过反射技术调用消息订阅处理器的相关方法进行一些业务处理
     * @param connectionFactory
     * @param listenerAdapter
     * @return
     */
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                            MessageListenerAdapter listenerAdapter,
                                            MessageListenerAdapter listenerAdapter2)
    {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);

        //可以添加多个 messageListener
        //可以对 messageListener对应的适配器listenerAdapter  指定本适配器 适配的消息类型  是什么
        //在发布的地方 对应发布的redisTemplate.convertAndSend("user",msg);  那这边的就对应的可以消费到指定类型的 订阅消息
        container.addMessageListener(listenerAdapter, new PatternTopic("user"));
        container.addMessageListener(listenerAdapter2, new PatternTopic("goods"));

        return container;
    }


    /**
     * 消息监听器适配器，绑定消息处理器，利用反射技术调用消息处理器的业务方法
     *
     * receiveMessage 是默认监听方法 一般不变
     * @param redisReceiver redis消息处理器，自定义的
     * @return
     */
    @Bean
    MessageListenerAdapter listenerAdapter(RedisReceiver redisReceiver) {
        System.out.println("消息适配器1进来了");
        return new MessageListenerAdapter(redisReceiver, "receiveMessage");
    }


    /**
     * 消息监听器适配器，绑定消息处理器，利用反射技术调用消息处理器的业务方法
     *
     * receiveMessage 是默认监听方法 一般不变
     * @param redisReceiver2 redis消息处理器，自定义的
     * @return
     */
    @Bean
    MessageListenerAdapter listenerAdapter2(RedisReceiver2 redisReceiver2) {
        System.out.println("消息适配器2进来了");
        return new MessageListenerAdapter(redisReceiver2, "receiveMessage");
    }



    //使用默认的工厂初始化redis操作模板
    @Bean
    StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
        return new StringRedisTemplate(connectionFactory);
    }


    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(factory);
        RedisSerializer keySerializer = new StringRedisSerializer();
//        RedisSerializer valueSerializer = new GenericJackson2JsonRedisSerializer();
        //key采用字符串反序列化对象
        redisTemplate.setKeySerializer(keySerializer);
        //value也采用字符串反序列化对象
        //原因：管道操作，是对redis命令的批量操作，各个命令返回结果可能类型不同
        //可能是 Boolean类型 可能是String类型 可能是byte[]类型 因此统一将结果按照String处理
        redisTemplate.setValueSerializer(keySerializer);
        return redisTemplate;
    }









}

package com.sxd.swapping.redisReceiver;

import org.springframework.stereotype.Service;

/**
 *
 * redis 订阅发布  消息接收器/处理器
 * @author sxd
 * @date 2019/5/30 17:12
 */
@Service
public class RedisReceiver {

    public void receiveMessage(String message) {
        System.out.println("消息处理器1>我处理用户信息："+message);
        //这里是收到通道的消息之后执行的方法
        //此处执行接收到消息后的 业务逻辑
    }
}

package com.sxd.swapping.redisReceiver;

import org.springframework.stereotype.Service;

/**
 * redis 订阅发布  消息接收器/处理器2
 * @author sxd
 * @date 2019/5/30 17:15
 */
@Service
public class RedisReceiver2 {

    public void receiveMessage(String message) {
        System.out.println("消息处理器2>我处理商品信息："+message);
        //这里是收到通道的消息之后执行的方法
        //此处执行接收到消息后的 业务逻辑
    }
}

@Autowired
    RedisTemplate redisTemplate;


    /**
     * redis 发布订阅pubsub
     */
    @RequestMapping(value = "/redisPubSub")
    public void redisPubSub(String msg){
        if (msg.contains("用户")){
            redisTemplate.convertAndSend("user",msg);
        }else {
            redisTemplate.convertAndSend("goods",msg);
        }
    }