RabbitMQ的项目示例

最新推荐文章于 2024-05-04 20:18:20 发布
最新推荐文章于 2024-05-04 20:18:20 发布
阅读量2.8k 收藏 8
点赞数 2
分类专栏： java 文章标签： 技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cartoonmiao/article/details/51920766
版权

RabbitMQ的项目示例

RabbitMQ简介

MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入队列的消息（针对应用程序的数据）来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此来通信，直接调用通常是用于诸如远程过程调用的技术。排队指的是应用程序通过 队列来通信。队列的使用除去了接收和发送应用程序同时执行的要求。其中较为成熟的MQ产品有IBM WEBSPHERE MQ。

以下是自己敲的一个小项目，代码复制可用。

创建java项目

这里写图片描述

创建测试类，导入jar包

这里写图片描述

示例 1

其中P代表生产者、C表示消费者、中间红色部分代表消息队列
这里写图片描述

package com.rabbit;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
/**    
 *      
 * 类名称：Test01   
 * 类描述：发送消息    
 * 创建人：xxx    
 *     
 */
public class Test01 {

    public static void main(String[] args) throws IOException, TimeoutException {  

        //创建链接工厂
        ConnectionFactory connFac = new ConnectionFactory() ;  

        //默认链接的主机名,RabbitMQ-Server安装在本机，所以可以直接用127.0.0.1 
        connFac.setHost("127.0.0.1");  

        //创建链接   
        Connection conn = connFac.newConnection() ;  

        //创建信息管道  
        Channel channel = conn.createChannel() ;  

        // 创建一个名为queue01的队列，防止队列不存在   
        String queueName = "queue01" ;  

        //进行信息声明        1.队列名2.是否持久化，3是否局限与链接，4不再使用是否删除，5其他的属性
        channel.queueDeclare(queueName, false, false, false, null) ; 
        String msg = "Hello World!";  

        //发送消息  
        // 在RabbitMQ中，消息是不能直接发送到队列，它需要发送到交换器（exchange）中。
        // 第一参数空表示使用默认exchange，第二参数表示发送到的queue，第三参数是发送的消息是（字节数组）
        channel.basicPublish("", queueName , null , msg.getBytes());  

        System.out.println("发送  message[" + msg + "] to "+ queueName +" success!");  

        //关闭管道
        channel.close();  
        //关闭连接
        conn.close();   
    }  
}

控制台中显示：
这里写图片描述

RabbitMQ中显示：
这里写图片描述

package com.rabbit;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.ConsumerCancelledException;
import com.rabbitmq.client.QueueingConsumer;
import com.rabbitmq.client.QueueingConsumer.Delivery;
import com.rabbitmq.client.ShutdownSignalException;

/**    
 *      
 * 类名称：Test02   
 * 类描述：接受消息    
 * 创建人：xxx   
 *     
 */

public class Test02 {

    public static void main(String[] args) throws IOException, ShutdownSignalException,
    ConsumerCancelledException, InterruptedException, TimeoutException {  

        // 创建链接工厂
        ConnectionFactory connFac = new ConnectionFactory() ;  

        //默认链接的主机名,RabbitMQ-Server安装在本机，所以可以直接用127.0.0.1 
        connFac.setHost("127.0.0.1");  

        //创建链接    
        Connection conn = connFac.newConnection() ;  

        //创建信息管道  
        Channel channel = conn.createChannel() ;  

        //定义Queue名称  
        String queueName = "queue01";  
        //1.队列名2.是否持久化，3是否局限与链接，4不再使用是否删除，5其他的属性
        channel.queueDeclare(queueName, false, false, false, null) ;  

        //上面的部分，与Test01是一样的  

        //声明一个消费者,配置好获取消息的方式  
        QueueingConsumer consumer = new QueueingConsumer(channel) ;  
        channel.basicConsume(queueName, true, consumer) ;  

        //循环获取消息  
        while(true){  

            //循环获取信息  
            //指向下一个消息，如果没有会一直阻塞
            Delivery delivery = consumer.nextDelivery() ;  

            String msg = new String(delivery.getBody()) ;    

            System.out.println("接收 message[" + msg + "] from " + queueName);  
        }  
    }
}

控制台中显示：
这里写图片描述

RabbitMQ中显示：
这里写图片描述

示例 2:

其中P代表生产者、C表示消费者、中间红色部分代表消息队列
这里写图片描述

注意：先运行消费者1.2.3 然后运行生产者； 生产者会随机均分。

生产者

package com.rabbit3;

import java.io.IOException;  

import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  
import com.rabbitmq.client.ConnectionFactory;  
import com.rabbitmq.client.MessageProperties;

/**    
 *      
 * 类名称：NewTask   
 * 类描述：发送者    
 * 创建人：xxx      
 *     
 */

public class NewTask  
{  
    // 队列名称  
    private final static String QUEUE_NAME = "workqueue_persistence";  

    public static void main(String[] args) throws IOException, Exception  
    {  
        // 创建连接和频道  
        ConnectionFactory factory = new ConnectionFactory();  
        factory.setHost("localhost");  
        Connection connection = factory.newConnection();  
        Channel channel = connection.createChannel();  

        // 声明队列  
        boolean durable = true;// 1、设置队列持久化  
        channel.queueDeclare(QUEUE_NAME, durable, false, false, null);  

        // (测试)发送条消息，依次在消息后面附加点  
        for (int i = 5; i > 0; i--)  
        {  
            String dots = "";  
            for (int j = 0; j <= i; j++)  
            {  
                dots += ".";  
            }  
            String message = "helloworld" + dots + dots.length();  
            //MessageProperties消息属性 2、设置消息持久化  
            channel.basicPublish("", QUEUE_NAME, MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());  
            System.out.println(" [x] Sent '" + message + "'");  
        }  

        // 关闭频道和资源  
        channel.close();  
        connection.close();  
    }  
}

消费者1 

package com.rabbit3;

import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  
import com.rabbitmq.client.ConnectionFactory;  
import com.rabbitmq.client.QueueingConsumer;  
/**    
 *      
 * 类名称：Work1   
 * 类描述：接收者1
 * 创建人：xxx    
 *     
 */
public class Work1  
{  
    // 队列名称  
    private final static String QUEUE_NAME = "workqueue_persistence";  

    public static void main(String[] argv) throws java.io.IOException,  
            java.lang.InterruptedException, Exception  
    {  
        System.out.println("接收者1：");
        // 区分不同工作进程的输出  
        int hashCode = Work1.class.hashCode();  

        // 创建连接和频道  
        ConnectionFactory factory = new ConnectionFactory();  
        factory.setHost("localhost");  
        Connection connection = factory.newConnection();  
        Channel channel = connection.createChannel();  

        // 声明队列  
        boolean durable = true;  
        channel.queueDeclare(QUEUE_NAME, durable, false, false, null);  
        System.out.println(hashCode+ " [*] Waiting for messages.");  

        //设置最大服务转发消息数量  
        int prefetchCount = 1;  
        channel.basicQos(prefetchCount);  
        QueueingConsumer consumer = new QueueingConsumer(channel);  

        // 指定消费队列  
        boolean ack1 = false; 

        // 打开应答机制  
        channel.basicConsume(QUEUE_NAME, ack1, consumer);  
        while (true)  
        {  
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
            String message = new String(delivery.getBody());  

            System.out.println(hashCode + " [x] Received '" + message + "'");  
            doWork(message);  
            System.out.println(hashCode + " [x] Done");  
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);  

        }  

    }  

    /** 
     *  每个点耗时1s 
     *  
     *  我们使用Thread.sleep来模拟耗时的任务。我们在发送到队列的消息的末尾添加一定数量的点，
     *  每个点代表在工作线程中需要耗时1秒，例如hello…将会需要等待3秒。
     */   
    private static void doWork(String task) throws InterruptedException  
    {  
        for (char ch : task.toCharArray())  
        {  
            if (ch == '.')  
                Thread.sleep(1000);  
        }  
    }  
}

消费者2

package com.rabbit3;

import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  
import com.rabbitmq.client.ConnectionFactory;  
import com.rabbitmq.client.QueueingConsumer;  
/**    
 *      
 * 类名称：Work2   
 * 类描述：接收者2
 * 创建人：xxx     
 *     
 */
public class Work2  
{  
    // 队列名称  
    private final static String QUEUE_NAME = "workqueue_persistence";  

    public static void main(String[] argv) throws java.io.IOException,  
            java.lang.InterruptedException, Exception  
    {  
        System.out.println("接收者2：");
        // 区分不同工作进程的输出  
        int hashCode = Work2.class.hashCode();  

        // 创建连接和频道  
        ConnectionFactory factory = new ConnectionFactory();  
        factory.setHost("localhost");  
        Connection connection = factory.newConnection();  
        Channel channel = connection.createChannel();  

        // 声明队列  
        boolean durable = true;  
        channel.queueDeclare(QUEUE_NAME, durable, false, false, null);  
        System.out.println(hashCode+ " [*] Waiting for messages."); 

        //设置最大服务转发消息数量  
        int prefetchCount = 1;  
        channel.basicQos(prefetchCount);  
        QueueingConsumer consumer = new QueueingConsumer(channel);  

        // 指定消费队列  
        boolean ack2 = false; 

        // 打开应答机制  
        channel.basicConsume(QUEUE_NAME, ack2, consumer);  
        while (true)  
        {  
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
            String message = new String(delivery.getBody());  

            System.out.println(hashCode + " [x] Received '" + message + "'");  
            doWork(message);  
            System.out.println(hashCode + " [x] Done");  
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);  

        }  

    }  

    /** 
     *  每个点耗时1s 
     *  
     *  我们使用Thread.sleep来模拟耗时的任务。我们在发送到队列的消息的末尾添加一定数量的点，
     *  每个点代表在工作线程中需要耗时1秒，例如hello…将会需要等待3秒。
     */  
    private static void doWork(String task) throws InterruptedException  
    {  
        for (char ch : task.toCharArray())  
        {  
            if (ch == '.')  
                Thread.sleep(1000);  
        }  
    }  
}

消费者3

package com.rabbit3;

import com.rabbitmq.client.Channel;  
import com.rabbitmq.client.Connection;  
import com.rabbitmq.client.ConnectionFactory;  
import com.rabbitmq.client.QueueingConsumer;  
/**    
 *      
 * 类名称：Work3   
 * 类描述：接收者3
 * 创建人：xxx     
 *     
 */
public class Work3  
{  
    // 队列名称  
    private final static String QUEUE_NAME = "workqueue_persistence";  

    public static void main(String[] argv) throws java.io.IOException,  
            java.lang.InterruptedException, Exception  
    {  
        System.out.println("接收者3：");
        // 区分不同工作进程的输出  
        int hashCode = Work3.class.hashCode();  

        // 创建连接和频道  
        ConnectionFactory factory = new ConnectionFactory();  
        factory.setHost("localhost");  
        Connection connection = factory.newConnection();  
        Channel channel = connection.createChannel();  

        // 声明队列  
        boolean durable = true;  
        channel.queueDeclare(QUEUE_NAME, durable, false, false, null);  
        System.out.println(hashCode+ " [*] Waiting for messages.");  

        //设置最大服务转发消息数量  
        int prefetchCount = 1;  
        channel.basicQos(prefetchCount);  
        QueueingConsumer consumer = new QueueingConsumer(channel);  

        // 指定消费队列  
        boolean ack3 = false; 

        // 打开应答机制  
        channel.basicConsume(QUEUE_NAME, ack3, consumer);  
        while (true)  
        {  
            QueueingConsumer.Delivery delivery = consumer.nextDelivery();  
            String message = new String(delivery.getBody());  

            System.out.println(hashCode + " [x] Received '" + message + "'");  
            doWork(message);  
            System.out.println(hashCode + " [x] Done");  
            channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);  

        }  

    }  

    /** 
     *  每个点耗时1s 
     *  
     *  我们使用Thread.sleep来模拟耗时的任务。我们在发送到队列的消息的末尾添加一定数量的点，
     *  每个点代表在工作线程中需要耗时1秒，例如hello…将会需要等待3秒。
     */   
    private static void doWork(String task) throws InterruptedException  
    {  
        for (char ch : task.toCharArray())  
        {  
            if (ch == '.')  
                Thread.sleep(1000);  
        }  
    }  
}

结果

控制台中显示：
这里写图片描述
这里写图片描述
这里写图片描述

CartoonMiao
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ 相关整合实战项目（完结）
HUJIAXIN的博客
09-17 902
RabbitMQ 整合 PD 商城实战项目流程总结 一、订单流量削峰（解耦） 简单模式，若多添加几个消费者则用工作模式。 导入商城项目 将 step5 课前资料里面 /elasticsearch/pd商城.zip 解压。 第二层目录下 pd-web 文件夹解压到 rabbitmq 工程目录下面。 修改 pom.xml 文件中的 SpringBoot 版本为 2.3.2.RELEASE（可拖拽至 idea 内更改）。 在 rabbitmq 工程中导入模块（若之前在 idea 内更改则可以直接
从原理到实战，手把手教你在项目中使用RabbitMQ
代码界的扛把子
06-27 585
/ 获取Rabbitmq消息，并保存到DB // 说明：这里仅作为示例，如果有多种类型的消息，可以根据消息判定，简单的用 if...else 处理，复杂的用工厂 + 策略模式 notifyService.saveArticleNotify(JsonUtil.toObj(message, UserFootDO.class), NotifyTypeEnum.PRAISE);} log.info("启动成功，点击进入首页: {}", config.getHost());
RabbitMQ项目实战(持续更新)
zhang19903848257的博客
09-30 3297
RabbitMq项目实战 实战一：使用延迟队列和备份队列实现考试信息定时存储 需求分析： 在线考试系统： 考生考试——随机生成试卷——考生规定时间内答卷——提交试卷——计算分数——考生每道题目入库 分析： 假如考试时间为2个小时，考生生成试卷后，如果遇到掉线或者其他情况未能在规定时间内交卷的，系统默认交卷并计算成绩和题目入库。并通过微信告诉学生，您的试卷已经自动提交。 实现方式一（不推荐）:通过死信队列实现延迟队列 将过期消息入死信队列，消费死信队列。 创建交换机和队列 package marchsof
【架构系列】RabbitMQ应用场景及在实际项目中如何搭建可靠的RabbitMQ架构体系
最新发布
c18213590220的博客
05-04 1571
本文将深入探讨RabbitMQ的应用场景以及如何在实际项目中构建可靠的RabbitMQ架构体系。
Spring整合RabbitMQ
Mr_yu_shao的博客
08-31 3198
超简单！入门级SpringBoot整合RabbitMQ，一看就会！
【RabbitMQ】Spring整合RabbitMQ、Spring实现RabbitMQ五大工作模式（万字长文）
qq_61903414的博客
04-15 2616
订阅模式与前两种不同，订阅模式需要使用到fanout类型的交换机，并且将队列与之绑定，他的生产者在xml文件里需要去创建两个队列与fanout类型的交换机并绑定，在发送消息时指定交换机名称即可，而消费者则与前者相同，只是需要修改指定监听的队列名。此处由于创建的交换机类型是fanout广播类型不需要去配置路由，如果创建的direct交换机不止需要配置队列名属性，还需要配置路由属性，如果是topic交换机则需要配置通配符。同样在消费者创建的xml文件里我们路创建队列监听器容器来将不同队列的消息映射到不同的类。
消息中间件--rabbitmq项目示例
02-21
本项目示例将深入探讨如何使用RabbitMQ来实现高效、可靠的通信机制。 ### 1. 消息中间件的基本概念 消息中间件是用于应用程序之间异步通信的软件，它通过解耦生产者和消费者，使得发送方和接收方无需同时在线即可...
rabbitmq代码示例
04-08
在这个“rabbitmq代码示例”中，我们将深入探讨如何使用C语言和Python（对应压缩包中的`RabbitMQDemo-C`和`RabbitMQDemo-P`）来与RabbitMQ进行交互。 首先，让我们了解RabbitMQ的基本概念： 1. **生产者（Producer...
rabbitmq简单示例
11-08
本示例旨在通过一个简单的demo，向你展示如何使用RabbitMQ以及其四种Exchange Types的基本用法，同时也会提及一些API的使用技巧。以下将详细阐述这些知识点： 1. **RabbitMQ基础**：RabbitMQ是一个开源的消息代理，...
RabbitMQ使用示例
02-17
在实际项目中，你可以根据需求设置更复杂的交换机和路由规则，以满足各种场景下的消息处理需求。对于压缩包内的PDF教程，它可能包含更深入的RabbitMQ操作指南，包括安装、配置、监控和故障排查等，建议仔细阅读以...
SpringBoot集成RabbitMQ代码示例
04-02
本文将深入探讨如何在SpringBoot项目中集成RabbitMQ，通过代码示例来展示具体步骤和实现。 首先，集成RabbitMQ需要在SpringBoot的`pom.xml`文件中添加依赖。你需要引入`spring-boot-starter-amqp`依赖，这会包含...
RabbitMQ项目
11-22
RabbitMq的详细代码，包括了所有的注释，里边有不同类型的交换机类型设置
rabbitmq（java实例）
01-09
rabbitmq（java实例），环境eclipse + maven
rabbitMQ Java开发案例
09-17
javaAPI SpringMVC 集成rabbitMQ 很全的例子,实现了生产消费,重复消费等功能
rabbitmq demo实例
08-21
rabbitmq demo实例
rabbitmq.net各种实例
08-15
rabbitma.net 分发，点对点，应答，广播、各种实例代码
RabbitMQ 入门案例项目
InterestAndFun的博客
11-23 753
本文不作消息队列的实现原理、异步处理优劣、rabbitmq安装说明、消息工作模式等内容分析，只讲述rabbitmq实际开发中的步骤说明，帮助同学快速上手体验消息队列的使用。本文使用SpringAMQP，并非rabbitmq官方文档上的原生http请求连接。
RabbitMQ项目实战(一）
诨号无敌鸭的博客
04-18 716
前情提要：我们了解了消息队列，RabbitMQ的入门，交换机，以及核心特性等知识，现在终于来到了激动人心的项目实战环节！本小节主要介绍通过Spring Boot RabbitMQ Starter 在SpringBoot项目中跑通测试RabbitMQ，话不多说，我们马上开始！
RabbitMQ基本使用详解及示例
热门推荐
OceanSky的专栏
10-19 1万+
RabbitMQ简介 AMQP,即Advanced Message Queuing Protocol,高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布订阅）、可靠性、安全。RabbitMQ是一个开源的AMQP实现，服务端用Erlang语言...
rabbitmq项目实战
09-01
RabbitMQ是一个功能强大的开源消息队列系统，可以用于构建可靠、可扩展的分布式应用程序。...以上是一个基本的RabbitMQ项目实战示例，你可以根据自己的需求对其进行扩展和改进。希望对你有所帮助！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值