devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

rabbitmq学习笔记9 ： spring整合rabbitmq_convertandsend参数有几个

作者：你好赵伟 | 2024-06-16 21:03:42

赞

踩

convertandsend参数有几个

一、准备工作

  • maven依赖
  1. <dependency>
  2.   <groupId>com.rabbitmq</groupId>
  3.   <artifactId>amqp-client</artifactId>
  4.   <version>4.0.2</version>
  5. </dependency>
  6.  
  7. <dependency>
  8.   <groupId>org.springframework.amqp</groupId>
  9.   <artifactId>spring-rabbit</artifactId>
  10.   <version>1.7.9.RELEASE</version>
  11. </dependency>
  • 创建配置文件spring-rabbitmq.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.                            http://www.springframework.org/schema/beans/spring-beans.xsd
  6.                            http://www.springframework.org/schema/rabbit
  7.                            http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
  8.  
  9. </beans>
  10.

二、配置消息生产者

1、配置连接

  1. <!--连接工厂-->
  2. <rabbit:connection-factory id="rabbitConnectionFactory" host="127.0.0.1" port="5672"
  3.                            username="test" password="test"  virtual-host="/test"
  4.                            channel-cache-size="50" />

   注：该配置还有publisher-confirms、publisher-returns等参数，用于消息确认。

2、配置admin：producer中的exchange,queue会自动的利用该admin自动在spring中生成

  1. <!-- 定义admin,producer中的exchange,queue会自动的利用该admin自动在spring中生成 -->
  2. <rabbit:admin connection-factory="rabbitConnectionFactory"/>

3、定义rabbitmq模板（消息生产者通过模板类进行推送数据）

  1. <!-- 定义rabbitmq模板，指定连接工厂、exchange、queue等 -->
  2. <rabbit:template id="amqpTemplate" connection-factory="rabbitConnectionFactory" exchange="XXX" queue="XXX"/>

注意：

  • 消费发送是通过rabbitTemplate.convertAndSend()这个方法进行发送的
  • rabbitTemplate.convertAndSend()用三个参数，分别代表exchange、routing-key（queue）、message，如果调用时不写exchange，第二个参数代表queue，比如rabbitTemplate.convertAndSend(queue,message)表示将消息直接发布到queue队列中
  • 如果在模板中指定了默认exchange和queue，如果消息在发布时没指定exchange和queue，则消息直接通过默认的exchange将消息推送给对应的queue，如果只配置了queue，则表示直接将消息发布到queue队列中
  • 我通常的做法是不指定exchange和queue，通过代码进行指定

4、配置队列

  1. <!-- 队列声明 :
  2.      durable：true、false true：在服务器重启时，能够存活
  3.      exclusive ：当连接关闭后是否自动删除队列；是否私有队列，如果私有，其他通道不能访问当前队列
  4.      autodelete：当没有任何消费者使用时，自动删除该队列 -->
  5. <!-- 用于发布/订阅模式的队列 -->
  6. <rabbit:queue name="myFanoutQueue" durable="true" exclusive="false" auto-delete="false"/>
  7. <!-- 用于路由模式的队列 -->
  8. <rabbit:queue name="myDirectQueue" durable="true" exclusive="false" auto-delete="false"/>
  9. <!-- 用于主题模式的队列 -->
  10. <rabbit:queue name="myTopicQueue_error"  durable="true" exclusive="false" auto-delete="false"/>
  11. <rabbit:queue name="myTopicQueue_warn"  durable="true" exclusive="false" auto-delete="false"/>

5、设置exchange，并且配置与队列queue的关系（durable、auto-delete与队列参数同一个意思）

  1. <!-- 定义交互机 发布/订阅模式 -->
  2. <rabbit:fanout-exchange name="myFanoutExchange" durable="true" auto-delete="false">
  3.     <rabbit:bindings>
  4.         <rabbit:binding queue="myFanoutQueue"></rabbit:binding>
  5.     </rabbit:bindings>
  6. </rabbit:fanout-exchange>
  7.  
  8. <!-- 定义交互机 路由模式（需要routing-key） -->
  9. <rabbit:direct-exchange name="myDirectExchange" durable="true" auto-delete="false">
  10.     <rabbit:bindings>
  11.         <rabbit:binding queue="myDirectQueue" key="error"></rabbit:binding>
  12.     </rabbit:bindings>
  13. </rabbit:direct-exchange>
  14.  
  15.  
  16. <!--定义交互机 主题模式 -->
  17. <rabbit:topic-exchange name="myTopicExchange" durable="true" auto-delete="false">
  18.     <rabbit:bindings>
  19.        <rabbit:binding queue="myTopicQueue_error" pattern="error.#" ></rabbit:binding>
  20.         <rabbit:binding queue="myTopicQueue_error" pattern="warn.#" ></rabbit:binding>
  21.        <rabbit:binding queue="myTopicQueue_warn" pattern="warn.*"></rabbit:binding>
  22.     </rabbit:bindings>
  23. </rabbit:topic-exchange>

注意：

  • 路由模式需要指定key，表示exchange通过key（routing-key）将消息发布到queue中
  • 主题模式是通过pattern参数来表示routing-key的

6、定义消息发布类

  1. public class SpringSender {
  2.     public static void sendMessage(String exchange,String routingKey,Object  message){
  3.         //加载配置文件
  4.         AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-rabbitmq.xml");
  5.         //获取rabbitmqTemplate模板
  6.         RabbitTemplate rabbitTemplate = applicationContext.getBean(RabbitTemplate.class);
  7.         //发送消息
  8.         rabbitTemplate.convertAndSend(exchange,routingKey,message);
  9.     }
  10.  
  11.     public static void main(String[] args) throws Exception{
  12.         SpringSender.sendMessage("myTopicExchange","warn.item","主题模式，发布警告信息");
  13.     }
  14. }

注意：

  • 根据上面消息的配置，我们可以知道该消息会发布到myTopicQueue_error和myTopicQueue_warn两个队列中，因为routing-key为“warn.item”，符合上述其与exchange的绑定关系
  • rabbitTemplate.convertAndSend()通过多态实现的。如果exchange为空，等同与调用rabbitTemplate.convertAndSend(routingKey,message)，表示将message发送到名为“routingKey”的队列中。如果exchange、routingKey为空时，等同于调用rabbitTemplate.convertAndSend(message)，此时rabbitmq模板需要指定默认queue。
  • 如果rabbitmq模板指定了默认exchange、queue，但是程序里调用发布消息的方法也指定了exchange、queue，那么以程序里面的参数为准
  • 如果rabbitmq模板指定了默认exchange，但是调用rabbitTemplate.convertAndSend(routingKey,message)时，routingKey（queue）跟exchange没有绑定关系，发送数据失败
  • rabbitTemplate.convertAndSend方法说明
  1. /**
  2.  * 发送消息到默认的交换机和队列（不带有自定义参数）
  3.  * @param messageObject 消息对象
  4.  * @return boolean 发送标记 
  5.  */
  6. RabbitTemplate.convertAndSend(messageObject);
  7.  
  8. /**
  9.  * 发送消息到默认的交换机和队列
  10.  * @param messageObject 消息对象
  11.  * @param messageObject 自定义参数，在监听器ConfirmCallback中可以取到。
  12.  * @return boolean 发送标记 
  13.  */
  14. RabbitTemplate.correlationConvertAndSend(messageObject,correlationdata);
  15.  
  16. /**
  17.  * 发送消息到指定的队列
  18.  * @param queue           队列名称
  19.  * @param messageObject   消息对象
  20.  * @param messageObject 自定义参数，在监听器ConfirmCallback中可以取到。
  21.  * @return boolean 发送标记 
  22.  */
  23. RabbitTemplate.convertAndSend(queue, messageObject,correlationdata);
  24.  
  25. /**
  26.  * 发送消息到指定的交换机和队列
  27.  * @param exchange       交换机名称
  28.  * @param queue          队列名称
  29.  * @param messageObject 自定义参数，在监听器ConfirmCallback中可以取到。
  30.  * @return boolean 发送标记 
  31.  */
  32. RabbitTemplate.convertAndSend(exchange,queue,messageObject,correlationdata);
  33.  
  34. /**
  35.  * 发送消息到默认的交换机和队列（不带有自定义参数）
  36.  Send方法还有很多，此处只列举一种
  37.  * @param Message AMQP封装的消息对象
  38.  * @return void
  39.  */
  40. RabbitTemplate.send(Message message);
  41.

 

三、配置消息消费者

1、定义主题模式的两个实现类

  1. /**
  2.  * 用于接收routing-key为warn或error的消息
  3.  */
  4. public class TopicErrorReceiver implements ChannelAwareMessageListener{
  5.     @Override
  6.     public void onMessage(Message message, Channel channel) throws Exception {
  7.         try{
  8.             System.out.println("************************ddd********************************");
  9.             System.out.println("主题模式 warn/error 接收信息："+new String(message.getBody()));
  10.             System.out.println("********************************************************");
  11.             //设置手工应答
  12.             channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
  13.         }catch (Exception e){
  14.             channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
  15.         }
  16.     }
  17. }
  18.  
  1. /**
  2.  * 用于接收routing-key为warn的消息
  3.  */
  4. public class TopicWarnReceiver implements ChannelAwareMessageListener{
  5.  
  6.     @Override
  7.     public void onMessage(Message message, Channel channel) throws Exception {
  8.         try{
  9.             System.out.println("************************ddd********************************");
  10.             System.out.println("主题模式 warm 接收信息："+new String(message.getBody()));
  11.             System.out.println("********************************************************");
  12.             //设置手工应答
  13.             channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
  14.         }catch (Exception e){
  15.             channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
  16.         }
  17.     }
  18. }

注：接收类都是实现了ChannelAwareMessageListener接口，并重写了onMessage方法

2、定义监听，并绑定接收者与队列的关系（即接收者监听哪些队列）

  1. <!-- 定义监听 -->
  2. <rabbit:listener-container connection-factory="rabbitConnectionFactory" acknowledge="manual" >
  3.     <!-- 发布订阅模式监听-->
  4.     <rabbit:listener ref="directReceiver"  queue-names="myFanoutQueue"/>
  5.     <!-- 路由模式监听 -->
  6.     <rabbit:listener ref="directReceiver"  queue-names="myDirectQueue"/>
  7.     <!-- 主题模式监听-->
  8.     <rabbit:listener ref="topicErrorReceiver" queue-names="myTopicQueue_error"/>
  9.     <rabbit:listener ref="topicWarnReceiver" queue-names="myTopicQueue_warn"/>
  10. </rabbit:listener-container>
  11.  
  12. <bean id="directReceiver" class="com.chensr.until.rabbitmq.springRabbitmq.DirectReceiver"/>
  13. <bean id="fanoutReceiver" class="com.chensr.until.rabbitmq.springRabbitmq.FanoutReceiver"/>
  14. <bean id="topicErrorReceiver" class="com.chensr.until.rabbitmq.springRabbitmq.TopicErrorReceiver"/>
  15. <bean id="topicWarnReceiver" class="com.chensr.until.rabbitmq.springRabbitmq.TopicWarnReceiver"/>

注意：

  • acknowledge="manual" 表示手工应答，如果值为auto则表示自动应答
  • DirectReceiver、FanoutReceiver写法与TopicErrorReceiver 类似，这里不重复

3、测试

  • 执行SpringSender.sendMessage("myTopicExchange","warn.item","主题模式，发布警告信息"); 控制台显示

    

  • 执行SpringSender.sendMessage("myTopicExchange","error.item","主题模式，发布警告信息");控制台只显示（表明只有myTopicQueue_error接收到消息）

    

  • 执行执行SpringSender.sendMessage("","myTopicQueue_error"," queue message");控制台只显示（表明只有myTopicQueue_error接收到消息）

    

  • 从上面的例子可以看出，接收者跟所谓的模式没有关系，它只跟绑定的队列有关队列有数据即进行接受。至于队列的数据是通过什么模式得到的，都与接收者无关

四、confirm-callback监听（用于监听exchange是否接收成功）

1、在配置工厂连接的时候，设置publisher-confirms="true"

  1. <!--连接工厂-->
  2. <rabbit:connection-factory id="rabbitConnectionFactory" host="127.0.0.1" port="5672"
  3.                            username="test" password="test"  virtual-host="/test"
  4.                            channel-cache-size="50" publisher-confirms="true"/>

2、在定义rabbitmq模板时，指定confirm-callback的实现类

  1. <!-- 定义rabbitmq模板，指定连接工厂、exchange、queue等 -->
  2. <rabbit:template id="amqpTemplate" connection-factory="rabbitConnectionFactory" exchange="myDirectExchange"
  3.                  confirm-callback="confirmCallback" />

3、创建实现类ConfirmCallback，实现RabbitTemplate.ConfirmCallback接口

  1. public class ConfirmCallback implements RabbitTemplate.ConfirmCallback {
  2.     /**
  3.      * CorrelationData 是在发送消息时传入回调方法的参数，可以用于区分消息对象。 CorrelationData对象中只有一个属性 String id。
  4.      * 通过这个参数，我们可以区分当前是发送哪一条消息时的回调，并通过ack参数来进行失败重发功能
  5.      * 
  6.      * @param correlationData 回调的相关数据.
  7.      * @param ack true for ack, false for nack
  8.      * @param cause 专门给NACK准备的一个可选的原因，其他情况为null。
  9.      */
  10.     @Override
  11.     public void confirm(CorrelationData correlationData, boolean ack, String cause) {
  12.         System.out.println("********************************************************");
  13.         System.out.println("exChange确认"+ ack +"   "+cause);
  14.         System.out.println("********************************************************");
  15.     }
  16. }

4、在配置文件中定义confirmCallback

<bean id="confirmCallback" class="com.chensr.until.rabbitmq.springRabbitmq.ConfirmCallback"/>

5、测试：执行SpringSender.sendMessage("myTopicExchange","error","queue message fanout" );，控制台显示

********************************************************

exChange确认true   null

********************************************************

注意：

  • 不管发送成功与否都会执行这个方法
  • 只有在配置中找不到exchange，ack才会是false
  • 发送数据是exchange为空，或者不填的时候，ack都为true即调用rabbitTemplate.convertAndSend(“”,routingKey,message)或者rabbitTemplate.convertAndSend(routingKey,message)，ack都是true

 

五、confirm-callback监听（basicpublish推送消息到queue失败时回调）

1、在定义rabbitmq模板时，指定return-callback的实现类，并且设置mandatory="true"

  1. <!-- 定义rabbitmq模板，指定连接工厂、exchange、queue等 -->
  2. <rabbit:template id="amqpTemplate" connection-factory="rabbitConnectionFactory"
  3.                  confirm-callback="confirmCallback" return-callback="returnCallback" mandatory="true"/>

注：mandatory为true表示推送消息到queue失败时调用return-callback

2、创建实现类ReturnCallback，实现RabbitTemplate.ReturnCallback接口

  1. public class ReturnCallback implements RabbitTemplate.ReturnCallback {
  2.     @Override
  3.     public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
  4.         System.out.println("********************************************************");
  5.         System.out.println("失败确认:"+message+" | "+replyCode+" | "+replyText+" | "+exchange+" | "+routingKey);
  6.         System.out.println("********************************************************");
  7.     }
  8. }

3、在配置文件中定义returnedMessage

<bean id="returnCallback" class="com.chensr.until.rabbitmq.springRabbitmq.ReturnCallback"/>

4、测试：执行SpringSender.sendMessage("myTopicExchange","error123","queue message" );，由于routing-key没匹配到对应的队列，所以控制台打印报错信息

********************************************************

失败确认:(Body:'queue message' MessageProperties [headers={}, timestamp=null, messageId=null, userId=null, receivedUserId=null, appId=null, clusterId=null, type=null, correlationId=null, correlationIdString=null, replyTo=null, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, deliveryMode=null, receivedDeliveryMode=PERSISTENT, expiration=null, priority=0, redelivered=null, receivedExchange=null, receivedRoutingKey=null, receivedDelay=null, deliveryTag=0, messageCount=null, consumerTag=null, consumerQueue=null]) | 312 | NO_ROUTE | myTopicExchange | error123

********************************************************

注意：

  • 同上，如果执行SpringSender.sendMessage("","error123","queue message" );，由于没有找到对应的队列“error123”,所以调用ReturnCallback.returnedMessage方法
  • confirm-callback监听ack返回false，不管是否匹配到队列，都不会执行ReturnCallback.returnedMessage方法。因为exchange接收数据是否，此时还没走到推送数据到队列这一步，所以不会以失败处理

 

六、FastJsonMessageConverter转换类（可以将map自动转成json格式）

1、添加maven依赖

  1. <dependency>
  2.   <groupId>org.codehaus.jackson</groupId>
  3.   <artifactId>jackson-mapper-asl</artifactId>
  4.   <version>1.9.13</version>
  5. </dependency>

2、在定义rabbitmq模板时，指定转换器message-converter="jsonMessageConverter"

  1. <!-- 定义rabbitmq模板，指定连接工厂、exchange、queue等 -->
  2. <rabbit:template id="amqpTemplate" connection-factory="rabbitConnectionFactory" message-converter="jsonMessageConverter"
  3.                  confirm-callback="confirmCallback" return-callback="returnCallback" mandatory="true"/>

3、配置bean（也可以重写）

<bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.JsonMessageConverter"></bean>

4、测试：（将map转成json格式）

  1. public class SpringSender {
  2.     public static void sendMessage(String exchange,String routingKey,Object  message){
  3.         //加载配置文件
  4.         AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-rabbitmq.xml");
  5.         //获取rabbitmqTemplate模板
  6.         RabbitTemplate rabbitTemplate = applicationContext.getBean(RabbitTemplate.class);
  7.         //发送消息
  8.         rabbitTemplate.convertAndSend(exchange,routingKey,message);
  9.     }
  10.  
  11.     public static void main(String[] args) throws Exception{
  12.         HashMap<String ,Object> map = new HashMap<String, Object>();
  13.         map.put("message","queue message fanout");
  14.         SpringSender.sendMessage("myFanoutExchange","myFanoutQueue",map);
  15.     }
  16. }

输出

********************************************************

发布/订阅 接收信息：{"message":"queue message fanout"}

********************************************************

注：如果发生的消息是字符串，接收到的信息为字符串

 

七、完整配置文件spring-rabbitmq.xml内容

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  5.                            http://www.springframework.org/schema/beans/spring-beans.xsd
  6.                            http://www.springframework.org/schema/rabbit
  7.                            http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
  8.  
  9.     <!-- 引入rabbitmq配置文件 -->
  10.     <bean id="configProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
  11.         <property name="locations">
  12.             <list>
  13.                 <value>classpath:conf/rabbitmq.properties</value>
  14.             </list>
  15.         </property>
  16.     </bean>
  17.  
  18.     <!--连接工厂-->
  19.     <rabbit:connection-factory id="rabbitConnectionFactory" host="127.0.0.1" port="5672"
  20.                                username="test" password="test"  virtual-host="/test"
  21.                                channel-cache-size="50" publisher-confirms="true"/>
  22.  
  23.     <!-- 定义admin,producer中的exchange,queue会自动的利用该admin自动在spring中生成 -->
  24.     <rabbit:admin connection-factory="rabbitConnectionFactory"/>
  25.  
  26.     <!-- 定义rabbitmq模板，指定连接工厂、exchange、queue等 -->
  27.     <rabbit:template id="amqpTemplate" connection-factory="rabbitConnectionFactory" message-converter="jsonMessageConverter"
  28.                      confirm-callback="confirmCallback" return-callback="returnCallback" mandatory="true"/>
  29.  
  30.  
  31.     <!-- 队列声明 :
  32.          durable：true、false true：在服务器重启时，能够存活
  33.          exclusive ：当连接关闭后是否自动删除队列；是否私有队列，如果私有，其他通道不能访问当前队列
  34.          autodelete：当没有任何消费者使用时，自动删除该队列 -->
  35.     <!-- 用于发布/订阅模式的队列 -->
  36.     <rabbit:queue name="myFanoutQueue" durable="true" exclusive="false" auto-delete="false"/>
  37.     <!-- 用于路由模式的队列 -->
  38.     <rabbit:queue name="myDirectQueue" durable="true" exclusive="false" auto-delete="false"/>
  39.     <!-- 用于主题模式的队列 -->
  40.     <rabbit:queue name="myTopicQueue_error"  durable="true" exclusive="false" auto-delete="false"/>
  41.     <rabbit:queue name="myTopicQueue_warn"  durable="true" exclusive="false" auto-delete="false"/>
  42.  
  43.  
  44.     <!-- 定义交互机 发布/订阅模式 -->
  45.     <rabbit:fanout-exchange name="myFanoutExchange" durable="true" auto-delete="false">
  46.         <rabbit:bindings>
  47.             <rabbit:binding queue="myFanoutQueue"></rabbit:binding>
  48.         </rabbit:bindings>
  49.     </rabbit:fanout-exchange>
  50.  
  51.     <!-- 定义交互机 路由模式（需要routing-key） -->
  52.     <rabbit:direct-exchange name="myDirectExchange" durable="true" auto-delete="false">
  53.         <rabbit:bindings>
  54.             <rabbit:binding queue="myDirectQueue" key="error"></rabbit:binding>
  55.         </rabbit:bindings>
  56.     </rabbit:direct-exchange>
  57.  
  58.  
  59.     <!-- 定义交互机 主题模式 ;-->
  60.     <rabbit:topic-exchange name="myTopicExchange" durable="true" auto-delete="false">
  61.         <rabbit:bindings>
  62.            <rabbit:binding queue="myTopicQueue_error" pattern="error.#" ></rabbit:binding>
  63.             <rabbit:binding queue="myTopicQueue_error" pattern="warn.#" ></rabbit:binding>
  64.            <rabbit:binding queue="myTopicQueue_warn" pattern="warn.*"></rabbit:binding>
  65.         </rabbit:bindings>
  66.     </rabbit:topic-exchange>
  67.  
  68.  
  69.  
  70.     <!-- 定义监听 -->
  71.     <rabbit:listener-container connection-factory="rabbitConnectionFactory" acknowledge="manual" >
  72.         <!-- 发布订阅模式监听-->
  73.         <rabbit:listener ref="fanoutReceiver"   queue-names="myFanoutQueue" />
  74.         <!-- 路由模式监听 -->
  75.         <rabbit:listener ref="directReceiver"  queue-names="myDirectQueue"/>
  76.         <!-- 主题模式监听-->
  77.         <rabbit:listener ref="topicErrorReceiver" queue-names="myTopicQueue_error"/>
  78.         <rabbit:listener ref="topicWarnReceiver" queue-names="myTopicQueue_warn"/>
  79.     </rabbit:listener-container>
  80.  
  81.     <!--接收者实现类-->
  82.     <bean id="directReceiver" class="com.chensr.until.rabbitmq.springRabbitmq.DirectReceiver"/>
  83.     <bean id="fanoutReceiver" class="com.chensr.until.rabbitmq.springRabbitmq.FanoutReceiver"/>
  84.     <bean id="topicErrorReceiver" class="com.chensr.until.rabbitmq.springRabbitmq.TopicErrorReceiver"/>
  85.     <bean id="topicWarnReceiver" class="com.chensr.until.rabbitmq.springRabbitmq.TopicWarnReceiver"/>
  86.  
  87.     <!--confirmCallback回调-->
  88.     <bean id="confirmCallback" class="com.chensr.until.rabbitmq.springRabbitmq.ConfirmCallback"/>
  89.     <!--returnCallback回调-->
  90.     <bean id="returnCallback" class="com.chensr.until.rabbitmq.springRabbitmq.ReturnCallback"/>
  91.     <!--消息转换器，转成json格式-->
  92.     <bean id="jsonMessageConverter" class="org.springframework.amqp.support.converter.JsonMessageConverter"></bean>
  93. </beans>

注：由于接收者都是继承ChannelAwareMessageListener，实现onMessage方法，所以这里不提供相应的代码

 

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/728278
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号