Springboot 配置RabbitMQ文档的方法步骤

<dependency>

  <groupid>org.springframework.boot</groupid>

  <artifactid>spring-boot-starter-amqp</artifactid>

  <version> 1.5 . 2 .release</version>

</dependency>

# rabbitmq

spring.rabbitmq.host = dev-mq.a.pa测试数据

spring.rabbitmq.port = 5672

spring.rabbitmq.username = admin

spring.rabbitmq.password = admin

spring.rabbitmq.virtualhost = /message-test/

package message.test.configuration;

import org.springframework.amqp.core.acknowledgemode;

import org.springframework.amqp.core.amqptemplate;

import org.springframework.amqp.core.binding;

import org.springframework.amqp.core.bindingbuilder;

import org.springframework.amqp.core.directexchange;

import org.springframework.amqp.core.queue;

import org.springframework.amqp.rabbit.config.simplerabbitlistenercontainerfactory;

import org.springframework.amqp.rabbit.connection.cachingconnectionfactory;

import org.springframework.amqp.rabbit.connection.connectionfactory;

import org.springframework.amqp.rabbit.core.rabbittemplate;

import org.springframework.beans.factory.annotation.autowired;

import org.springframework.beans.factory.annotation.qualifier;

import org.springframework.boot.autoconfigure.amqp.rabbitproperties;

import org.springframework.context.annotation.bean;

import org.springframework.context.annotation.configuration;

@configuration

public class amqpconfiguration {

/**

  * 消息编码

  */

  public static final string message_encoding = "utf-8" ;

  public static final string exchange_issue = "exchange_message_issue" ;

  public static final string queue_issue_user = "queue_message_issue_user" ;

  public static final string queue_issue_all_user = "queue_message_issue_all_user" ;

  public static final string queue_issue_all_device = "queue_message_issue_all_device" ;

  public static final string queue_issue_city = "queue_message_issue_city" ;

  public static final string routing_key_issue_user = "routing_key_message_issue_user" ;

  public static final string routing_key_issue_all_user = "routing_key_message_issue_all_user" ;

  public static final string routing_key_issue_all_device = "routing_key_message_issue_all_device" ;

  public static final string routing_key_issue_city = "routing_key_message_issue_city" ;

  public static final string exchange_push = "exchange_message_push" ;

  public static final string queue_push_result = "queue_message_push_result" ;

  @autowired

  private rabbitproperties rabbitproperties;

  @bean

  public queue issueuserqueue() {

   return new queue(queue_issue_user);

  }

  @bean

  public queue issuealluserqueue() {

   return new queue(queue_issue_all_user);

  }

  @bean

  public queue issuealldevicequeue() {

   return new queue(queue_issue_all_device);

  }

  @bean

  public queue issuecityqueue() {

   return new queue(queue_issue_city);

  }

  @bean

  public queue pushresultqueue() {

   return new queue(queue_push_result);

  }

  @bean

  public directexchange issueexchange() {

   return new directexchange(exchange_issue);

  }

  @bean

  public directexchange pushexchange() {

   // 参数1：队列

   // 参数2：是否持久化

   // 参数3：是否自动删除

   return new directexchange(exchange_push, true , true );

  }

  @bean

  public binding issueuserqueuebinding( @qualifier ( "issueuserqueue" ) queue queue,

     @qualifier ( "issueexchange" ) directexchange exchange) {

    return bindingbuilder.bind(queue).to(exchange).with(routing_key_issue_user);

  }

  @bean

  public binding issuealluserqueuebinding( @qualifier ( "issuealluserqueue" ) queue queue,

     @qualifier ( "issueexchange" ) directexchange exchange) {

   return bindingbuilder.bind(queue).to(exchange).with(routing_key_issue_all_user);

  }

  @bean

  public binding issuealldevicequeuebinding( @qualifier ( "issuealldevicequeue" ) queue queue,

     @qualifier ( "issueexchange" ) directexchange exchange) {

   return bindingbuilder.bind(queue).to(exchange).with(routing_key_issue_all_device);

  }

  @bean

  public binding issuecityqueuebinding( @qualifier ( "issuecityqueue" ) queue queue,

     @qualifier ( "issueexchange" ) directexchange exchange) {

   return bindingbuilder.bind(queue).to(exchange).with(routing_key_issue_city);

  }

  @bean

  public binding pushresultqueuebinding( @qualifier ( "pushresultqueue" ) queue queue,

     @qualifier ( "pushexchange" ) directexchange exchange) {

   return bindingbuilder.bind(queue).to(exchange).withqueuename();

  }

  @bean

  public connectionfactory defaultconnectionfactory() {

   cachingconnectionfactory connectionfactory = new cachingconnectionfactory();

   connectionfactory.sethost(rabbitproperties.gethost());

   connectionfactory.setport(rabbitproperties.getport());

   connectionfactory.setusername(rabbitproperties.getusername());

   connectionfactory.setpassword(rabbitproperties.getpassword());

   connectionfactory.setvirtualhost(rabbitproperties.getvirtualhost());

   return connectionfactory;

  }

  @bean

  public simplerabbitlistenercontainerfactory rabbitlistenercontainerfactory(

     @qualifier ( "defaultconnectionfactory" ) connectionfactory connectionfactory) {

   simplerabbitlistenercontainerfactory factory = new simplerabbitlistenercontainerfactory();

   factory.setconnectionfactory(connectionfactory);

   factory.setacknowledgemode(acknowledgemode.manual);

   return factory;

  }

  @bean

  public amqptemplate rabbittemplate( @qualifier ( "defaultconnectionfactory" ) connectionfactory connectionfactory)

  {

   return new rabbittemplate(connectionfactory);

  }

}

body = json.tojsonstring(issuemessage).getbytes(amqpconfiguration.message_encoding);

  rabbittemplate.convertandsend(amqpconfiguration.exchange_issue,

             amqpconfiguration.routing_key_issue_user, body);

@rabbitlistener (queues = amqpconfiguration.queue_push_result)

public void handlepushresult( @payload byte [] data, channel channel,

     @header (amqpheaders.delivery_tag) long deliverytag) {

}