redismq发布订阅

/**
   * redis发布消息
   *
   * @param receiver
   * @return
   */
public static void main(String[] args) {

	ApplicationContext ct=SpringApplication.run(MessagepushApplication.class, args);

	StringRedisTemplate template = ct.getBean(StringRedisTemplate.class);
	template.convertAndSend("messagepush", "Hello message !");
	template.convertAndSend("messagepush3", "Hello message3 !");

}


/**
 * redis订阅消息监听
*
* @param receiver
* @return
*/
@Configuration
public class RedisMessageListener {

@Bean
RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                        MessageListenerAdapter offlineListenerAdapter,
                                        MessageListenerAdapter onlineListenerAdapter,
                                        MessageListenerAdapter voltageListenerAdapter) {
    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    //设备下线消息订阅处理器
    container.addMessageListener(offlineListenerAdapter, new PatternTopic("messagepush"));
    //设备上线消息订阅处理器
    container.addMessageListener(onlineListenerAdapter, new PatternTopic("messagepush3"));
    //设备电量消息订阅处理器
    container.addMessageListener(voltageListenerAdapter, new PatternTopic("voltage"));
    return container;
}

/**
 * 设备下线消息订阅处理器,并指定处理方法
 *
 * @param receiver
 * @return
 */
@Bean
MessageListenerAdapter offlineListenerAdapter(ReceiverRedisMessage receiver) {
    MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "offlineReceive");
    return messageListenerAdapter;
}

/**
 * 设备上线消息订阅处理器,并指定处理方法
 *
 * @param receiver
 * @return
 */
@Bean
MessageListenerAdapter voltageListenerAdapter(ReceiverRedisMessage receiver) {
    MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "voltageReceive");
    return messageListenerAdapter;
}

/**
 * 设备电量消息订阅处理器,并指定处理方法
 *
 * @param receiver
 * @return
 */
@Bean
MessageListenerAdapter onlineListenerAdapter(ReceiverRedisMessage receiver) {
    MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver, "onlineReceive");
    return messageListenerAdapter;
}


@Bean
ReceiverRedisMessage receiver(CountDownLatch latch) {
    return new ReceiverRedisMessage(latch);
}

@Bean
CountDownLatch latch() {
    return new CountDownLatch(1);
}

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

}

/**
 * 订阅者业务逻辑处理
  *
  * @param jsonMsg
  */
@Component
public class ReceiverRedisMessage {

private CountDownLatch latch;
@Autowired
public ReceiverRedisMessage(CountDownLatch latch) {
    this.latch = latch;
}

private static final Logger logger = LoggerFactory.getLogger(ReceiverRedisMessage.class);


/**
 * 设备下线消息订阅处理器
 *
 * @param jsonMsg
 */
public void offlineReceive(String jsonMsg) {
    logger.info("[开始消费REDIS消息队列messagepush数据...]");
    try {
        logger.info("[消费REDIS消息队列messagepush数据成功.][" + jsonMsg + "]");
    } catch (Exception e) {
        logger.error("[消费REDIS消息队列messagepush数据失败，失败信息:{}]", e.getMessage());
    }
    latch.countDown();
}

/**
 * 设备上线消息订阅处理器
 *
 * @param jsonMsg
 */
public void onlineReceive(String jsonMsg) {
    logger.info("[开始消费REDIS消息队列messagepush3数据...]");
    try {
        logger.info("[开始组装推送消息...]");
        logger.info("[消费REDIS消息队列messagepush3数据成功.][" + jsonMsg + "]");
    } catch (Exception e) {
        logger.error("[消费REDIS消息队列messagepush3数据失败，失败信息:{}]", e.getMessage());
    }
    latch.countDown();
}

/**
 * 设备电量消息订阅处理器
 *
 * @param jsonMsg
 */
public void voltageReceive(String jsonMsg) {
    logger.info("[开始消费REDIS消息队列voltage数据...]");
    try {
        logger.info("[消费REDIS消息队列voltage数据成功.][" + jsonMsg + "]");
    } catch (Exception e) {
        logger.error("[消费REDIS消息队列voltage数据失败，失败信息:{}]", e.getMessage());
    }
    latch.countDown();
}

}