rabbitmq入门案例

最新推荐文章于 2022-04-25 21:38:26 发布
最新推荐文章于 2022-04-25 21:38:26 发布
阅读量141 收藏
点赞数 1
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/DDDQD/article/details/119648503

pom.xml(虽然有几种模式,但是pom.xml内容不变)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.it.source</groupId>
    <artifactId>day078_rabbitmq_demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client -->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <!--和springboot2.0.5对应-->
            <version>5.4.1</version>
        </dependency>
        
    </dependencies>

</project>

fanout模式

消费者1

package cn.itjim._01_hello._03_fanout;


import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * 1.创建队列
 * 2.队列绑定到交换机
 * 3.每个消费者要监听自己的队列
 */
public class Consumers1 {
    public static final String FANOUT_QUEUE1="FANOUT_QUEUE1";
    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //同时处理的消息数量
        channel.basicQos(1);
        //创建队列
        channel.queueDeclare(FANOUT_QUEUE1,true,false, false, null);
        //队列绑定交换机
        //参数一:队列名,参数二:交换机名字,参数三:routingkey
        channel.queueBind(FANOUT_QUEUE1,Sender.FANOUT_EXCHANGE,"");
        //回调,重写回调方法,消费消息
        Consumer con  = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+new String(body));
                System.out.println("consumerTag="+consumerTag);
                System.out.println("envelope="+envelope);
                System.out.println("properties="+properties);
                //System.out.println(1/0);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("========================");
                //在所有业务说做完之后,手动签收
                channel.basicAck(envelope.getDeliveryTag(), false);//参数一: ,参数二:是否签收多个,false
            }
        };
        //监听队列
        //参数二:是否自动签收
        channel.basicConsume(FANOUT_QUEUE1,false,con );
        /*
        *签收不能与消费相等
        *
        * 注意:在自动签收开启,并且在回调函数里面有错误的时候,会造成消息丢失
        * 所以不能自动签收,需要手动签收
        * */
    }
}

 消费者2

package cn.itjim._01_hello._03_fanout;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;
import java.nio.file.FileSystemLoopException;

public class Consumer2 {
    //声明队列的名字
    private static final String FANOUT_QUEUE2 = "fanout_queue2";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //同时处理消息的数量
        channel.basicQos(1);
        //创建队列
        channel.queueDeclare(FANOUT_QUEUE2, true, false, false, null);
        //队列和交换机绑定
        channel.queueBind(FANOUT_QUEUE2, Sender.FANOUT_EXCHANGE, "");
        //匿名内部类,重写回调方法;手动接收消息
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body="+body);
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        //监听队列
        channel.basicConsume(FANOUT_QUEUE2, false, consumer);
    }
}

 生产者

package cn.itjim._01_hello._03_fanout;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

/**
 * 多个消费者都可以收到的模式
 * 1.不创建队列
 * 2.创建交换机
 * 3.给交换机发送消息
 */
public class Sender {
    //给交换机起名字
    public static final String FANOUT_EXCHANGE = "FANOUT_EXCHANGE";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //创建交换机,参数一:交换机名字,参数二:交换机类型,参数三:是否持久化
        channel.exchangeDeclare(FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT, true);
        //定义发送的内容
        String str = "在干嘛?";
        //发送消息
        //方法参数一:交换机的名字,使用默认的交换机就写空字符串,参数二:队列的名字routing key,参数三:其他属性,参数四:发送的内容
        channel.basicPublish(FANOUT_EXCHANGE, "", null,str.getBytes() );
        //关闭连接
        channel.close();
        connection.close();
    }
}

运行顺序,先开启生产者再开启消费者(下同)

direct模式

消费者1

package cn.itjim._01_hello._04_direct;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;
//消费类1
public class Consumer1 {
    private static final  String DIRECT_QUEUE1 = "direct_queue1";
    public static void main(String[] args) throws Exception {

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        channel.basicQos(1);

        channel.queueDeclare(DIRECT_QUEUE1, true, false, false, null);

        channel.queueBind(DIRECT_QUEUE1, Sender.DIRECT_EXCHANGE, "order");

        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(body);
                //手动消费
                channel.basicAck(envelope.getDeliveryTag(), false);
            }

        };
        channel.basicConsume(DIRECT_QUEUE1, false, consumer);

    }
}

消费者2

package cn.itjim._01_hello._04_direct;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

//消费类2
public class Consumer2 {

    private static final String DIRECT_QUEUE2 ="direct_queue2";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //每次处理消息数量
        channel.basicQos(1);
        channel.queueDeclare(DIRECT_QUEUE2, true, false, false, null);
        //队列和交换机绑定
        channel.queueBind(DIRECT_QUEUE2, Sender.DIRECT_EXCHANGE, "pay");
        //回调方法
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body="+body);
                //手动签收
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        //监听队列
        channel.basicConsume(DIRECT_QUEUE2, false, consumer);
    }
}

生产者

package cn.itjim._01_hello._04_direct;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

/**direct模型,指定由谁来消费消息
 * 1.在创建交换机的时候,指定类型为direct
 * 2.在发送消息的时候通过routingkey来指定由谁来接收消息
 *
 */
public class Sender {
    public static final String DIRECT_EXCHANGE = "DIRECT_EXCHANGE";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //创建交换机,参数一:交换机名字,参数二:交换机类型,参数三:是否持久化
        channel.exchangeDeclare(DIRECT_EXCHANGE, BuiltinExchangeType.DIRECT, true);

        //创建队列
        //方法参数一:队列的名字,参数二:是否持久化,参数三:是否独占,参数四:是否用完即删,参数五:其他属性,没有属性就写null
        // channel.queueDeclare(FANOUT_EXCHANGE, true, false, false, null);
         //定义发送的内容
        String str = "在干嘛?";
         //发送消息
        //方法参数一:交换机的名字,使用默认的交换机就写空字符串,参数二:队列的名字key,参数三:其他属性,参数四:发送的内容
        //参数二指定那个队列接收,就是那个队列接收
        channel.basicPublish(DIRECT_EXCHANGE, "order", null,str.getBytes() );//参数一:;参数二:
        //关闭连接
        channel.close();
        connection.close();
    }
}

topics模式

消费者1

package cn.itjim._01_hello._05_topics;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer1 {
    private static final String TOPICS_QUEUE1 = "TOPICS_QUEUE1";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.basicQos(1);
        channel.queueDeclare(TOPICS_QUEUE1, true, false, false, null);
        channel.queueBind(TOPICS_QUEUE1, Sender.TOPICS_EXCHANGE, "order.*");
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("=============");
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(TOPICS_QUEUE1, false, consumer);

    }
}

消费者2

package cn.itjim._01_hello._05_topics;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer2 {
    private static final String TOPICS_QUEUE2 = "TOPICS_QUEUE2";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.basicQos(1);
        channel.queueDeclare(TOPICS_QUEUE2, true, false, false, null);
        channel.queueBind(TOPICS_QUEUE2, Sender.TOPICS_EXCHANGE, "adopt.*");
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("=============");
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(TOPICS_QUEUE2, false, consumer);

    }
}

生产者

package cn.itjim._01_hello._05_topics;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

/**
 *
 */
public class Sender {
    public static final String TOPICS_EXCHANGE = "topics_exchange";

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(TOPICS_EXCHANGE, BuiltinExchangeType.TOPIC, true);
        String str = "heheheh";
        channel.basicPublish(TOPICS_EXCHANGE, "order.add", null, str.getBytes());
        channel.close();
        connection.close();
    }
}

workqueue模式

消费者1

package cn.itjim._01_hello._o2_workqueue;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumers1 {
    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //同时处理的消息数量
        channel.basicQos(1);
        //回调,重写回调方法,消费消息
        Consumer con  = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+new String(body));
                System.out.println("consumerTag="+consumerTag);
                System.out.println("envelope="+envelope);
                System.out.println("properties="+properties);
                //System.out.println(1/0);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("========================");
                //在所有业务说做完之后,手动签收
                channel.basicAck(envelope.getDeliveryTag(), false);//参数一: ,参数二:是否签收多个,false
            }
        };
        //监听队列
        //参数二:是否自动签收
        channel.basicConsume(Sender.WORK_QUEUE,false,con );
        /*
        *签收不能与消费相等
        *
        * 注意:在自动签收开启,并且在回调函数里面有错误的时候,会造成消息丢失
        * 所以不能自动签收,需要手动签收
        * */
    }
}

消费者2

package cn.itjim._01_hello._o2_workqueue;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumers2 {
    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //同时处理的消息数量
        channel.basicQos(1);
        //回调,重写回调方法,消费消息
        Consumer con  = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+new String(body));
                System.out.println("consumerTag="+consumerTag);
                System.out.println("envelope="+envelope);
                System.out.println("properties="+properties);
                //System.out.println(1/0);
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("========================");
                //在所有业务说做完之后,手动签收
                channel.basicAck(envelope.getDeliveryTag(), false);//参数一: ,参数二:是否签收多个,false
            }
        };
        //监听队列
        //参数二:是否自动签收
        channel.basicConsume(Sender.WORK_QUEUE,false,con );
        /*
        *签收不能与消费相等
        *
        * 注意:在自动签收开启,并且在回调函数里面有错误的时候,会造成消息丢失
        * 所以不能自动签收,需要手动签收
        * */
    }
}

生产者

package cn.itjim._01_hello._o2_workqueue;

import cn.itjim._01_hello.util.ConnectionUtil;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

/**
 * 一个生产者,多个消费者
 * 多个消费者监听同一个队列,消费者轮流执行消费,
 * 在消费者里面配置每次处理的消息数量: channel.basicQos(1);就是能者多劳模式
 */
public class Sender {
    public static final String WORK_QUEUE = "WORK_QUEUE";

    public static void main(String[] args) throws Exception {
        //创建连接
        Connection connection = ConnectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //创建交换机,这里使用默认的交换机,并没有创建
        //创建队列
        //方法参数一:队列的名字,参数二:是否持久化,参数三:是否独占,参数四:是否用完即删,参数五:其他属性,没有属性就写null
         channel.queueDeclare(WORK_QUEUE, true, false, false, null);
         //定义发送的内容
        String str = "在干嘛?";
         //发送消息
        //方法参数一:交换机的名字,使用默认的交换机就写空字符串,参数二:队列的名字key,参数三:其他属性,参数四:发送的内容
        channel.basicPublish("", "WORK_QUEUE", null,str.getBytes() );//参数一:;参数二:
        //关闭连接
        channel.close();
        connection.close();
    }
}

统一工具类

package cn.itjim._01_hello.util;

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

public class ConnectionUtil {
    /**
     * 建立与RabbitMQ的连接
     * @return
     * @throws Exception
     */
    public static Connection getConnection() throws Exception {
        //定义连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址
        factory.setHost("127.0.0.1");
        //端口
        factory.setPort(5672);
        //设置账号信息，用户名、密码、vhost
        factory.setVirtualHost("/");
        factory.setUsername("账号");
        factory.setPassword("密码");
        // 通过工程获取连接
        Connection connection = factory.newConnection();
        return connection;
    }
}

附带网页访问地址:http://localhost:15672/#/queues

RabbitMQ01 - 入门案例
qq_43350524的博客
04-23 446
RabbitMQ01 - 入门案例
RabbitMQ入门案例（简单模式）
weixin_45577058的博客
07-12 425
RabbitMQ入门案例（简单模式） RabbitMQ的简单模式 步骤： a.进行项目搭建，创建prom文件 b.生产者的创建 c.消费者的创建 d.测试的效果 e.进行工具的抽取 操作内容: a.进行项目搭建，创建prom文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/
RabbitMQ入门案例
05-15
AMQP(advanced message queuing protocol)是一个提供统一消息服务的应用层标准协议，基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不同产品，不同开发语言等条件的限制。RabbitMQ（支持更多语言，基于AMQP规范）
一、RabbitMQ入门案例
weixin_42030357的博客
08-18 190
创建SpringBoot项目，引入依赖，pom.xml如下 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://...
rabbitMQ代码案例 简单入门
10-31
这个“rabbitMQ代码案例 简单入门”的资料包为初学者提供了了解和学习RabbitMQ的基础知识。 首先，让我们了解一下RabbitMQ的基本概念： 1. **消息队列**：RabbitMQ的核心是消息队列，它负责存储和转发消息。生产者...
Java RabbitMQ入门案例：路由模式详解及运行代码
描述："RabbitMq入门案例，路由模式，配置好MQ运行代码即可" 所指的知识点 描述中提到了"RabbitMQ"，这是目前流行的消息队列中间件之一，它实现了高级消息队列协议（AMQP）。RabbitMQ是用Erlang编写的，并且遵循...
03 RabbitMQ入门
痞子王的博客
01-05 230
3. RabbitMQ入门 3.1. 搭建示例工程 3.1.1. 创建工程 3.1.2. 添加依赖 往heima-rabbitmq的pom.xml文件中添加如下依赖： <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactI...
03：入门案例（狂神说RabbitMQ）
qq_44858230的博客
03-16 1832
RabbitMQ入门案例 - Simple 简单模式 https://www.bilibili.com/video/BV1dX4y1V73G?p=44 实现步骤 jdk1.8 构建一个 maven工程 导入 rabbitmq的 maven依赖 启动 rabbitmq-server服务 定义生产者 定义消费者 观察消息的在 rabbitmq-server服务中的进程 构建一个maven工程 导入依赖 java原生依赖 <dependency> <groupId>com
Rabbitmq_Demo
04-30
Rabbitmq_Demo 0x01 SpringBoot集成RabbitMQ。包含的普通queue的消费，以及Dirct、Topic模式。 由阿里ons向RabbitMQ迁移，结合自己的理解，对二者进行了总结对比（图1，图2）： 0x02 死信队列 将报错后多次重试仍无法处理的消息置入死信队列。 流程： producer > Exchange > Queue -处-理-失-败-> DeadLetter Exchange > DeadLetter Queue 具体流程看图3和图4。 注：使用死信队列时，一定需要设置属性 spring.rabbitmq.listener.simple.default-requeue-rejected=false 0x03 最佳实践 仅供参考
rabbitmq_demo
03-02
rabbitmq_demo
rabbitmqdemo
06-01
rabbitmq 的demo。有普通版和基于spring版本的。对于学习rabbitmq有很大帮助
RabbitMQ Demo
03-08
RabbitMQDemo C#版，基本用法、主题发布订阅、高级特性及所需DLL
RabbitMq入门
weixin_45588345的博客
09-19 320
1. 消息队列MQ MQ全称为Message Queue，消息队列是应用程序和应用程序之间的通信方法。 为什么使用MQ 在项目中，可将一些无需即时返回且耗时的操作提取出来，进行异步处理，而这种异步处理的方式大大的节省 了服务器的请求响应时间，从而提高了系统的吞吐量。 ...
RabbitMQ——Hello World
前尘忆梦的博客
04-25 898
文章目录1、RabbitMQ四个核心概念1.1、四大核心概念1.2、各个名词介绍1.3、安装2、Hello World2.1、依赖2.2、消息生产者 1、RabbitMQ四个核心概念 RabbitMQ 是一个消息中间件：它接受并转发消息。你可以把它当做一个快递站点，当你要发送一个包裹时，你把你的包裹放到快递站，快递员最终会把你的快递送到收件人那里，按照这种逻辑 RabbitMQ 是一个快递站，一个快递员帮你传递快件。 RabbitMQ 与快递站的主要区别在于，它不处理快件而是接收，存储和转发消息数据。 1.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值