spring-boot集成redis实现消息发布订阅模式，以及多个订阅模式的实现

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

# redis
spring:
  redis:
    host: 127.0.0.1
    port: 6379
#    password:
    database: 1
    timeout: 5000
    jedis:
      pool:
        max-active: 8
        max-wait: 1
        max-idle: 500
        min-idle: 0

@EnableScheduling//开启定时器功能
@Component
public class MessageSender {
  @Autowired
  private StringRedisTemplate stringRedisTemplate;

  /**
   * 间隔2秒，通过stringRedisTemplate对象向redis消息队列chat频道发布消息
   */
  @Scheduled(fixedDelay = 2000)
  public void sendMessage() {
    stringRedisTemplate.convertAndSend("chat", String.valueOf(Math.random()));
  }
}

@Component
public class MessageReceiver {

  /**
   * 接收消息方法
   */
  public void receiverMessage(String message) {
    System.out.println("MessageReceiver收到一条新消息：" + message);
  }
}

/**
 * redis配置
 *
 * @author 段誉
 * @create 2019-03-25 9:59
 */
@Configuration//相当于xml中的beans
public class RedisConfig {

  @Bean
  RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                          MessageListenerAdapter listenerAdapter) {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    //订阅了一个叫chat的通道
    container.addMessageListener(listenerAdapter, new PatternTopic("chat"));
    return container;
  }

  /**
   * 消息监听器适配器，绑定消息处理器，利用反射技术调用消息处理器的业务方法
   * @param receiver
   * @return
   */
  @Bean
  MessageListenerAdapter listenerAdapter(MessageReceiver receiver) {
    //给messageListenerAdapter 传入一个消息接受的处理器，利用反射的方法调用“receiveMessage”
    //不填defaultListenerMethod默认调用handleMessage
    return new MyMessageListenerAdapter1(receiver, "receiverMessage");
  }

  /**
   * 读取内容的template
   */
  @Bean
  StringRedisTemplate template(RedisConnectionFactory connectionFactory) {
    return new StringRedisTemplate(connectionFactory);
  }
}

MessageReceiver收到一条新消息：0.7372683821918483
MessageReceiver收到一条新消息：0.800095651812774

  @Bean
  RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                          MessageListenerAdapter listenerAdapter) {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    //订阅了一个叫chat的通道
    container.addMessageListener(listenerAdapter, new PatternTopic("chat"));
    
    container.addMessageListener(listenerAdapter, new PatternTopic("chat1"));
    return container;
  }

@EnableScheduling
@Component
public class MessageSender2 {
  @Autowired
  private StringRedisTemplate stringRedisTemplate;

  /**
   * 间隔2秒，通过stringRedisTemplate对象向redis消息队列chat频道发布消息
   */
  @Scheduled(fixedDelay = 2000)
  public void sendMessage() {
    stringRedisTemplate.convertAndSend("chat1", "来自chat1的消息" + Math.random());
  }
}

MessageReceiver收到一条新消息：0.9988032526665156
MessageReceiver收到一条新消息：来自chat1的消息0.5760191019007642
MessageReceiver收到一条新消息：0.37241454741448377
MessageReceiver收到一条新消息：来自chat1的消息0.639498468451238

@Bean
MessageListenerAdapter listenerAdapter2(MessageReceiver receiver) {
  return new MessageListenerAdapter(receiver, "receiverMessage2");
}

@Component
public class MessageReceiver2 {

  /**
   * 接收消息方法
   */
  public void receiverMessage(String message) {
    System.out.println("MessageReceiver收到一条新消息：" + message);
  }
}

@Bean
MessageListenerAdapter listenerAdapter2(MessageReceiver2 receiver) {
  return new MessageListenerAdapter(receiver, "receiverMessage");
}

@Bean
RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                        MessageListenerAdapter listenerAdapter1,
                                        MessageListenerAdapter listenerAdapter2) {
  RedisMessageListenerContainer container = new RedisMessageListenerContainer();
  container.setConnectionFactory(connectionFactory);
  //订阅了一个叫chat的通道
  container.addMessageListener(listenerAdapter1, new PatternTopic("chat"));
  container.addMessageListener(listenerAdapter2, new PatternTopic("chat1"));
  return container;
}

//开启定时器功能
@EnableScheduling
@Component
public class MessageSender {
  @Autowired
  private StringRedisTemplate stringRedisTemplate;

  /**
   * 间隔2秒，通过stringRedisTemplate对象向redis消息队列chat1频道发布消息
   */
  @Scheduled(fixedDelay = 2000)
  public void sendMessage1() {
    stringRedisTemplate.convertAndSend("chat1", String.valueOf(Math.random()));
  }

  @Scheduled(fixedDelay = 2000)
  public void sendMessage2() {
    stringRedisTemplate.convertAndSend("chat2", String.valueOf(System.currentTimeMillis()));
  }
}

收到一条chat2新消息：1555564092816
收到一条chat1新消息：0.257614690680789
收到一条chat2新消息：1555564094830
收到一条chat1新消息：0.3996585101720651
收到一条chat2新消息：1555564096833
收到一条chat1新消息：0.6767629866464419
收到一条chat2新消息：1555564098836
收到一条chat1新消息：0.14106474791507906