Java spike combat system integration series - RabbitMQ implement asynchronous messages sent

Summary:

This post is "Java spike combat system a series of articles," the eighth chapter, in this article we will integrate messaging middleware RabbitMQ, including adding a dependency, configuration information, and added a custom injection-related operational components, such as RabbitTemplate and so on, the final preliminary sending and receiving messages, and the next chapter in its integration with the mail service, realize the function "user spike successfully send e-mail notification message" of!

content:

For messaging middleware RabbitMQ, surely you have not used a small partner, should also have heard, it is a wide range of applications currently available messaging middleware, asynchronous communication can be achieved messaging, business services decoupling module, interfaces, limiting , message distribution and other functions, in the micro-services, distributed system architecture can be said to act as a great role! (Detailed description, Debug not go into details here, you little friends can look at their official website and introduce more typical application scenarios)!

In this post, we will use RabbitMQ serve as components of a message sent by the "mail service" in conjunction to achieve "asynchronous transmit user spike successful e-mail notification message telling the user that spike has been successful!" Let it later chapters introduce the actual code that went into it.

(1) To use RabbitMQ, the premise was installed RabbitMQ service in local development environment or server, as shown below home to visit their backend Debug Console after a successful locally installed RabbitMQ service applications:

Then we begin to integrate with SpringBoot. You first need to join its dependence on its version number is consistent with SpringBoot version, the version number is 1.5.7.RELEASE:

<!--rabbitmq-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
    <version>${spring-boot.version}</version>
</dependency>

 

然后需要在配置文件application.properties中加入RabbitMQ服务相关的配置，比如其服务所在的Host、端口Port等等：

#rabbitmq
spring.rabbitmq.virtual-host=/
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

spring.rabbitmq.listener.simple.concurrency=5
spring.rabbitmq.listener.simple.max-concurrency=15
spring.rabbitmq.listener.simple.prefetch=10

 

（2）紧接着，我们借助SpringBoot天然具有的一些特性，自动注入RabbitMQ一些组件的配置，包括其“单一实例消费者”配置、“多实例消费者”配置以及用于发送消息的操作组件实例“RabbitTemplate”的配置：

//通用化 Rabbitmq 配置
@Configuration
public class RabbitmqConfig {
  private final static Logger log = LoggerFactory.getLogger(RabbitmqConfig.class);

  @Autowired
  private Environment env;

  @Autowired
  private CachingConnectionFactory connectionFactory;

  @Autowired
  private SimpleRabbitListenerContainerFactoryConfigurer factoryConfigurer;

  //单一消费者
  @Bean(name = "singleListenerContainer")
  public SimpleRabbitListenerContainerFactory listenerContainer(){
      SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
      factory.setConnectionFactory(connectionFactory);
      factory.setMessageConverter(new Jackson2JsonMessageConverter());
      factory.setConcurrentConsumers(1);
      factory.setMaxConcurrentConsumers(1);
      factory.setPrefetchCount(1);
      factory.setTxSize(1);
      return factory;
  }

  //多个消费者
  @Bean(name = "multiListenerContainer")
  public SimpleRabbitListenerContainerFactory multiListenerContainer(){
      SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
      factoryConfigurer.configure(factory,connectionFactory);
      factory.setMessageConverter(new Jackson2JsonMessageConverter());
      //确认消费模式-NONE
      factory.setAcknowledgeMode(AcknowledgeMode.NONE);
      factory.setConcurrentConsumers(env.getProperty("spring.rabbitmq.listener.simple.concurrency",int.class));
      factory.setMaxConcurrentConsumers(env.getProperty("spring.rabbitmq.listener.simple.max-concurrency",int.class));
      factory.setPrefetchCount(env.getProperty("spring.rabbitmq.listener.simple.prefetch",int.class));
      return factory;
  }

  @Bean
  public RabbitTemplate rabbitTemplate(){
      connectionFactory.setPublisherConfirms(true);
      connectionFactory.setPublisherReturns(true);
      RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
      rabbitTemplate.setMandatory(true);
      rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
          @Override
          public void confirm(CorrelationData correlationData, boolean ack, String cause) {
              log.info("消息发送成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
          }
      });
      rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
          @Override
          public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
              log.warn("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
          }
      });
      return rabbitTemplate;
  }
}

 

 在RabbitMQ的消息发送组件RabbitTemplate的配置中，我们还特意加入了“消息发送确认”、“消息丢失回调”的输出配置，即当消息正确进入到队列后，即代表消息发送成功；当消息找不到对应的队列（在某种程度上，其实也就是找不到交换机和路由）时，会输出消息丢失。

（3）完了之后，我们准备开始使用RabbitMQ实现消息的发送和接收。首先，我们需要在RabbitmqConfig配置类中创建队列、交换机、路由以及绑定等Bean组件，如下所示：

 

//构建异步发送邮箱通知的消息模型
    @Bean
    public Queue successEmailQueue(){
        return new Queue(env.getProperty("mq.kill.item.success.email.queue"),true);
    }

    @Bean
    public TopicExchange successEmailExchange(){
        return new TopicExchange(env.getProperty("mq.kill.item.success.email.exchange"),true,false);
    }

    @Bean
    public Binding successEmailBinding(){
        return BindingBuilder.bind(successEmailQueue()).to(successEmailExchange()).with(env.getProperty("mq.kill.item.success.email.routing.key"));
    }

 

其中，环境变量实例env读取的那些属性我们是配置在application.properties文件中的，如下所示：

mq.env=test

#秒杀成功异步发送邮件的消息模型
mq.kill.item.success.email.queue=${mq.env}.kill.item.success.email.queue
mq.kill.item.success.email.exchange=${mq.env}.kill.item.success.email.exchange
mq.kill.item.success.email.routing.key=${mq.env}.kill.item.success.email.routing.key

 

紧接着，我们需要在通用的消息发送服务类 RabbitSenderService 中写一段发送消息的方法，该方法用于接收“订单编号”参数，然后在数据库中查询其对应的详细订单记录，将该记录充当“消息”并发送至RabbitMQ的队列中，等待被监听消费：

/**
* RabbitMQ通用的消息发送服务
* @Author:debug (SteadyJack)
* @Date: 2019/6/21 21:47
**/
@Service
public class RabbitSenderService {

  public static final Logger log= LoggerFactory.getLogger(RabbitSenderService.class);

  @Autowired
  private RabbitTemplate rabbitTemplate;

  @Autowired
  private Environment env;

  @Autowired
  private ItemKillSuccessMapper itemKillSuccessMapper;

  //秒杀成功异步发送邮件通知消息
  public void sendKillSuccessEmailMsg(String orderNo){
      log.info("秒杀成功异步发送邮件通知消息-准备发送消息：{}",orderNo);

      try {
          if (StringUtils.isNotBlank(orderNo)){
              KillSuccessUserInfo info=itemKillSuccessMapper.selectByCode(orderNo);
              if (info!=null){
                  //TODO:rabbitmq发送消息的逻辑
                  rabbitTemplate.setMessageConverter(new Jackson2JsonMessageConverter());
                  rabbitTemplate.setExchange(env.getProperty("mq.kill.item.success.email.exchange"));
                  rabbitTemplate.setRoutingKey(env.getProperty("mq.kill.item.success.email.routing.key"));

                  //TODO：将info充当消息发送至队列
                  rabbitTemplate.convertAndSend(info, new MessagePostProcessor() {
                      @Override
                      public Message postProcessMessage(Message message) throws AmqpException {
                          MessageProperties messageProperties=message.getMessageProperties();
                          messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
                          messageProperties.setHeader(AbstractJavaTypeMapper.DEFAULT_CONTENT_CLASSID_FIELD_NAME,KillSuccessUserInfo.class);
                          return message;
                      }
                  });
              }
          }
      }catch (Exception e){
          log.error("秒杀成功异步发送邮件通知消息-发生异常，消息为：{}",orderNo,e.fillInStackTrace());
      }
  }
}

 

（4）最后，是在通用的消息接收服务类RabbitReceiverService中实现消息的接收，其完整的源代码如下所示：

/**
 * RabbitMQ通用的消息接收服务
 * @Author:debug (SteadyJack)
 * @Date: 2019/6/21 21:47
 **/
@Service
public class RabbitReceiverService {

  public static final Logger log= LoggerFactory.getLogger(RabbitReceiverService.class);

  @Autowired
  private MailService mailService;

  @Autowired
  private Environment env;

  @Autowired
  private ItemKillSuccessMapper itemKillSuccessMapper;

  //秒杀异步邮件通知-接收消息
  @RabbitListener(queues = {"${mq.kill.item.success.email.queue}"},containerFactory = "singleListenerContainer")
  public void consumeEmailMsg(KillSuccessUserInfo info){
      try {
          log.info("秒杀异步邮件通知-接收消息:{}",info);
      //到时候这里将整合邮件服务发送邮件通知消息的逻辑

      }catch (Exception e){
          log.error("秒杀异步邮件通知-接收消息-发生异常：",e.fillInStackTrace());
      }
  }
}

 

至此，关于SpringBoot整合消息中间件RabbitMQ的代码实战，本篇文章就介绍到这里了。

最后一点，我们需要进行测试，即用户在界面发起“抢购”的请求操作之后，如果能秒杀成功，则RabbitMQ会发送、接收一条消息，如下所示：

好了，关于RabbitMQ的使用，本文到此就暂且告一段落了，在下一篇文章中我们将把它与邮件服务进行整合，实现“用户秒杀成功后异步发送邮件通知消息给到用户邮箱”的功能！除此之外，我们还将在后面的篇章介绍“如何使用RabbitMQ的死信队列，处理用户下单成功后却超时未支付的订单~在那里我们将采取失效的操作”。

补充：

1、目前，这一秒杀系统的整体构建与代码实战已经全部完成了，完整的源代码数据库地址可以来这里下载：gitee.com/steadyjack/… 记得Fork跟Star啊！！

2、最后，不要忘记了关注一下Debug的技术微信公众号：