Spring整合Rabbitmq

最新推荐文章于 2025-03-03 16:52:06 发布
最新推荐文章于 2025-03-03 16:52:06 发布
阅读量1.3k 收藏
点赞数
分类专栏： mq
RabbitMQ是流行的开源消息队列系统，用erlang语言开发。在项目中，将一些无需即时返回且耗时的操作提取出来，进行了异步处理，需要用到RabbitMQ

没有找到一篇完整的文章介绍Spring如何整合Rabbitmq应用，琢磨一天搞出的一个入门的demo与伙伴们分享.

第一步linux环境下安装rabbitMQ,小弟用的是ubantu，不想浪费太多时间这种安装上

sudo apt-get install rabbitmq-server

默认启动端口5672 测试账户guest 密码guest

官方常用命令，想更改用户的可以参考，这里不作详细说明http://www.rabbitmq.com/man/rabbitmqctl.1.man.html

也可以省去安装115.28.141.137个人私服已配置好

第二步添加依赖包

?
1
2
3
4
5
6
7
8
9
10
11
<dependency>
             <groupId>org.springframework.amqp</groupId>
             <artifactId>spring-rabbit</artifactId>
             <version> 1.3 . 5 .RELEASE</version>
         </dependency>
     
         <dependency>
             <groupId>commons-lang</groupId>
             <artifactId>commons-lang</artifactId>
             <version> 2.6 </version>
         </dependency>

第三步配置生产者工程服务配置

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<?xml version= "1.0" encoding= "UTF-8" ?>
<beans xmlns= "http://www.springframework.org/schema/beans"
     xmlns:context= "http://www.springframework.org/schema/context"
     xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" xmlns:task= "http://www.springframework.org/schema/task"
     xmlns:rabbit= "http://www.springframework.org/schema/rabbit"
     xsi:schemaLocation="http: //www.springframework.org/schema/beans
       http: //www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http: //www.springframework.org/schema/context
       http: //www.springframework.org/schema/context/spring-context.xsd
       http: //www.springframework.org/schema/integration/ip
       http: //www.springframework.org/schema/integration/ip/spring-integration-ip-2.0.xsd
       http: //www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
       http: //www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd
       http: //www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http: //www.springframework.org/schema/rabbit
       http: //www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd
       ">
 
     <!-- 引入jdbc配置文件 -->
     <context:property-placeholder location= "classpath:conf/jdbc.properties" />
 
     <!-- 扫描文件（自动将servicec层注入） -->
     <context:component-scan base- package = "mq.service" />
     <!-- 连接服务配置 -->
     <rabbit:connection-factory id= "connectionFactory"
         host= "115.28.141.137" username= "guest" password= "guest" port= "5672" />
 
     <rabbit:admin connection-factory= "connectionFactory" />
 
     <!-- queue 队列声明 -->
     <rabbit:queue id= "queue_one" durable= "true" auto-delete= "false"
         exclusive= "false" name= "queue_one" />
 
 
     <!-- exchange queue binging key 绑定 -->
     <rabbit:direct-exchange name= "my-mq-exchange"
         durable= "true" auto-delete= "false" id= "my-mq-exchange" >
         <rabbit:bindings>
             <rabbit:binding queue= "queue_one" key= "queue_one_key" />
         </rabbit:bindings>
     </rabbit:direct-exchange>
 
     <!-- spring amqp默认的是jackson
     的一个插件,目的将生产者生产的数据转换为json存入消息队列，由于fastjson的速度快于jackson,这里替换为fastjson的一个实现
     -->
     <bean id= "jsonMessageConverter" class = "mq.util.FastJsonMessageConverter" ></bean>
 
     <!-- spring template声明-->
     <rabbit:template exchange= "my-mq-exchange" id= "amqpTemplate"
         connection-factory= "connectionFactory" message-converter= "jsonMessageConverter" />
</beans>

FastJsonMessageConverter 类代码如下

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package mq.util;
 
import java.io.UnsupportedEncodingException;
 
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.support.converter.AbstractMessageConverter;
import org.springframework.amqp.support.converter.MessageConversionException;
 
import com.alibaba.druid.support.logging.Log;
import com.alibaba.druid.support.logging.LogFactory;
import com.alibaba.fastjson.JSON;
 
public class FastJsonMessageConverter  extends AbstractMessageConverter {
     private static Log log = LogFactory.getLog(FastJsonMessageConverter. class );
  
     public static final String DEFAULT_CHARSET = "UTF-8" ;
  
     private volatile String defaultCharset = DEFAULT_CHARSET;
      
     public FastJsonMessageConverter() {
         super ();
         //init();
     }
      
     public void setDefaultCharset(String defaultCharset) {
         this .defaultCharset = (defaultCharset != null ) ? defaultCharset
                 : DEFAULT_CHARSET;
     }
      
     public Object fromMessage(Message message)
             throws MessageConversionException {
         return null ;
     }
      
     @SuppressWarnings ( "unchecked" )
     public <T> T fromMessage(Message message,T t) {
         String json = "" ;
         try {
             json = new String(message.getBody(), "UTF-8" );
         } catch (UnsupportedEncodingException e) {
             e.printStackTrace();
         }
         return (T) JSON.parseObject(json, t.getClass());
     }  
      
  
     protected Message createMessage(Object objectToConvert,
             MessageProperties messageProperties)
             throws MessageConversionException {
         byte [] bytes = null ;
         try {
             String jsonString = JSON.toJSONString(objectToConvert);
             bytes = jsonString.getBytes( this .defaultCharset);
         } catch (UnsupportedEncodingException e) {
             throw new MessageConversionException(
                     "Failed to convert Message content" , e);
         }
         messageProperties.setContentType(MessageProperties.CONTENT_TYPE_JSON);
         messageProperties.setContentEncoding( this .defaultCharset);
         if (bytes != null ) {
             messageProperties.setContentLength(bytes.length);
         }
         return new Message(bytes, messageProperties);
  
     }
}

生产者代码Producer

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<p>
package mq.service;
</p>
 
<p>
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
  
@Service
public class ProducerMq {
      
     @Autowired
     private AmqpTemplate amqpTemplate;
      
     public void sendDataToCrQueue(Object obj) {
         amqpTemplate.convertAndSend( "queue_one_key" , obj);
     }  
}
</p>

 

第四步配置消费者服务工程配置

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?xml version= "1.0" encoding= "UTF-8" ?>
<beans xmlns= "http://www.springframework.org/schema/beans"
     xmlns:context= "http://www.springframework.org/schema/context"
     xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" xmlns:task= "http://www.springframework.org/schema/task"
     xmlns:rabbit= "http://www.springframework.org/schema/rabbit"
     xsi:schemaLocation="http: //www.springframework.org/schema/beans
       http: //www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http: //www.springframework.org/schema/context
       http: //www.springframework.org/schema/context/spring-context.xsd
       http: //www.springframework.org/schema/integration/ip
       http: //www.springframework.org/schema/integration/ip/spring-integration-ip-2.0.xsd
       http: //www.springframework.org/schema/integration http://www.springframework.org/schema/integration/spring-integration.xsd
       http: //www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd
       http: //www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http: //www.springframework.org/schema/rabbit
       http: //www.springframework.org/schema/rabbit/spring-rabbit-1.0.xsd
       ">
 
     <!-- 引入jdbc配置文件 -->
     <context:property-placeholder location= "classpath:conf/jdbc.properties" />
 
     <!-- 扫描文件（自动将servicec层注入） -->
     <context:component-scan base- package = "mq.service" />
     <task:executor id= "taskExecutor" pool-size= "1-4" queue-capacity= "128" /> 
      <!-- 连接服务配置  -->
    <rabbit:connection-factory id= "connectionFactory" host= "115.28.141.137" username= "guest"
         password= "guest" port= "5672"  />
          
    <rabbit:admin connection-factory= "connectionFactory" />
     
    <!-- queue 队列声明-->
    <rabbit:queue id= "queue_one" durable= "true" auto-delete= "false" exclusive= "false" name= "queue_one" />
     <!-- exchange queue binging key 绑定 -->
     <rabbit:direct-exchange name= "my-mq-exchange" durable= "true" auto-delete= "false" id= "my-mq-exchange" >
         <rabbit:bindings>
             <rabbit:binding queue= "queue_one" key= "queue_one_key" />
         </rabbit:bindings>
     </rabbit:direct-exchange>
     <bean id= "queueOneLitener" class = "mq.service.QueueOneLitener" />
         <!-- queue litener  观察 监听模式 当有消息到达时会通知监听在对应的队列上的监听对象-->
     <rabbit:listener-container connection-factory= "connectionFactory" acknowledge= "auto" task-executor= "taskExecutor" >
         <rabbit:listener queues= "queue_one" ref= "queueOneLitener" /> <span></span> </rabbit:listener-container>
</beans>

监听器代码queueOneLitener

?
1
2
3
4
5
6
7
8
9
10
11
package mq.service;
 
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;
  
public class QueueOneLitener implements  MessageListener{
     public void onMessage(Message message) {
     
         System.out.println( " data :" + new String(message.getBody()));
     }
}

第五步测试

消费者端控制层生产数据

控制层Controller

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package mq.controller;
 
import javax.annotation.Resource;
 
import mq.service.ProducerMq;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
@Controller
public class MessageController {
     @Resource
     private ProducerMq producer;
     @RequestMapping ( "/producer" )
     public String producer() throws Exception {
         for ( int i= 0 ;i< 100 ;i++){
             producer.sendDataToCrQueue( "data" +i);
         }
         return "index" ;
     }
 
 
}

运行结果

 

spring整合RabbitMQ
程 序 猿的博客
12-09 212
RabbitMQ整合 SpringCloud实战 注意一点，在发送消息的时候对template进行配置mandatory=true保证监听有效 生产端还可以配置其他属性，比如发送重试，超时时间、次数、间隔等 消费端核心配置 首先配置手工确认模式，用于ACK的手工处理，这样我们可以保证消息的可靠性送达，或者在消费端消费失败的时候可以做到重回队列、根据业务记录日志等处理 可以设置消费端的监听个数和...
spring集成rabbitmq实现rpc
05-03
本文将详细讲解如何在Spring项目中集成RabbitMQ，实现基于RPC（远程过程调用）的通信模式。 首先，我们需要在项目中引入Spring AMQP库，这是Spring对RabbitMQ的官方支持。可以通过在pom.xml文件中添加以下Maven依赖...
Spring整合RabbitMQ
06-26
Spring整合RabbitMQ  搭建购物车系统  利用MQ实现商品数据同步
Spring 整合RabbitMQ
zyq13870585230的博客
11-05 2908
目录1. 搭建生产者工程1.1. 创建工程1.2. 添加依赖1.3. 配置整合1.4. 发送消息2. 搭建消费者工程2.1. 创建工程2.2. 添加依赖5.2.3. 配置整合5.2.4. 消息监听器1）队列监听器2）广播监听器13）广播监听器24）星号通配符监听器5）井号通配符监听器6）井号通配符监听器2 1. 搭建生产者工程 1.1. 创建工程 1.2. 添加依赖 两个工程的pom.xml文件内容为如下： <?xml version="1.0" encoding="UTF-8"?> <
Spring Boot整合RabbitMQ
最新发布
哟，你又在偷偷写bug！
03-03 1792
// 创建队列 @Bean public Queue queue() {/*** @param name 队列名字* @param durable 声明一个持久队列(该队列将在服务器重启后继续存在)，则为true} // 创建交换机（Direct类型） @Bean public DirectExchange exchange() {} // 绑定队列到交换机 @Bean public Binding binding() {} }
spring 整合 rabbitmq
raccoon_hzy的博客
12-28 1094
spring 整合 rabbitmq （rabbitmq的简单认识）         Rabbitmq 是一种消息队列 消息队列都会包含 producer（生产者），consumer（消费者）及broker（代理）         RabbitMQ 是信息传输的中间者。本质上，他从生产者（producers）接收消息，转发这些消息给消费者（consumers）.换句话说，他能够按
spring整合rabbitmq
gongwenxi的博客
09-05 181
spring整合rabbitmq 生产者 导包 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.1.7.RELEASE</version&gt
spring整合rabbitmq的实例
11-22
本文将详细介绍如何整合Spring与RabbitMQ，以实现高效的消息传递。 首先，我们要理解Spring对RabbitMQ的支持主要体现在Spring AMQP项目中，它为RabbitMQ提供了一套高级抽象层，使得开发者能够更加便捷地使用...
spring-rabbit
05-26
spring-rabbit RabbitMQ spring-boot
Spring 集成RabbitMq
weixin_30737363的博客
07-18 222
Spring 集成RabbitMq 一、基本配置 1、pom添加以下jar 　　　　　<dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactI...
RabbitMQ消息中间件快速入门
欢迎来到编程小栈
07-19 2607
文章目录一、同步和异步通讯1. 同步通讯2. 异步通讯二、RabbitMQ1. MessageQueue对比2. RabbitMQ快速入门【1】安装与启动【2】基本结构3. 五种消息模型介绍【1】入门案例1）publisher实现2）consumer实现4. SpringAMQP实现【1】Basic Queue 基本消息队列1）消息发送2）消息接收3）测试【2】WorkQueue工作消息队列1）消息发送2）消息接收3）测试4）prefetch提前获取【3】发布订阅三种模式1）Fanout[1] 声明队列和交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值