RabbitMQ 五种基本模式demo（Java版本）

最新推荐文章于 2024-04-29 11:27:42 发布
最新推荐文章于 2024-04-29 11:27:42 发布
阅读量610 收藏 3
点赞数 1
分类专栏： MQ 文章标签： rabbitmq 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzh1378008099/article/details/108011046
版权

RabbitMQ 五种基本模式demo（Java版本）

代码非本人所写，只是将代码稍微做了些改动，在自己的环境中运行起来了，侵删
模型图是这种模式的模型图，并不是代码对应的模型图，仅供参考

目录

前三种模式需要引用的文件

ConnectionUtils.java
创建并设置factory的基本属性，并返回新创建的connection

package test.rabbitmq.rabbitmq.mq5s;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class ConnectionUtils {
    public static Connection getConnection() throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("127.0.0.1");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("guest");
        factory.setPassword("guest");
        return factory.newConnection();
    }
}

简单模式

模型图
在这里插入图片描述

发送端：Send.java

package test.rabbitmq.rabbitmq.mq5s.mq1;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import test.rabbitmq.rabbitmq.mq5s.ConnectionUtils;

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

/**简单队列
 * 生产者发送消息
 */
public class Send {

    private static final String QUEUE_NAME = "test_simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();

        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        String msg = "hello simple!!!!!!!!!!!";
        channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
        System.out.println("--send msg；" + msg);
        channel.close();
        connection.close();
    }
}

接收端：Receive.java

package test.rabbitmq.rabbitmq.mq5s.mq1;

import com.rabbitmq.client.*;
import test.rabbitmq.rabbitmq.mq5s.ConnectionUtils;

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

/**
 * 消费者获取消息
 */
public class Receive {

    private static final String QUEUE_NAME = "test_simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取链接
        Connection connection = ConnectionUtils.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //队列声明
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        DefaultConsumer consumer = new DefaultConsumer(channel) {
            //获取到达的消息
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg = new String(body, "utf-8");
                System.out.println("new api recv:" + msg);
            }
        };

        //监听队列
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

分发模式（轮询分发）

模型图
在这里插入图片描述

发送端：Send.java

package test.rabbitmq.rabbitmq.mq5s.mq2;

import com.rabbitmq.client.*;
import test.rabbitmq.rabbitmq.mq5s.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;


/**轮询分发
 * \---c1
 * p---Queue----\
 * \---c2
 */
public class Send {
    private static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取链接
        Connection connection = ConnectionUtils.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        for (int i = 0; i < 100; i++) {
            String msg = "hello" + i;

            System.out.println("[WQ ] send:" + msg);
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            Thread.sleep(i * 20);
        }
        channel.close();
        connection.close();
    }
}

接收端01：Receive1.java

package test.rabbitmq.rabbitmq.mq5s.mq2;

import com.rabbitmq.client.*;
import test.rabbitmq.rabbitmq.mq5s.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receive1 {
    public static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接
        Connection connection = ConnectionUtils.getConnection();
        //创建频道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //定义一个消费者
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "utf-8");
                System.out.println("[1] Recv msg :" + msg);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("[1] done");
                }
            }
        };
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }
}

接收端02：Receive2.java

package test.rabbitmq.rabbitmq.mq5s.mq2;

import com.rabbitmq.client.*;
import test.rabbitmq.rabbitmq.mq5s.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receive2 {
    public static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接
        Connection connection = ConnectionUtils.getConnection();
        //创建频道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //定义一个消费者
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "utf-8");
                System.out.println("[2] Recv msg :" + msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("[2] done");
                }
            }
        };
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }
}

分发模式（公平分发）

模型图

在这里插入图片描述

发送端：Send.java

package test.rabbitmq.rabbitmq.mq5s.mq3;

import com.rabbitmq.client.*;
import test.rabbitmq.rabbitmq.mq5s.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**公平分发
 * \---c1
 * p---Queue----\
 * \---c2
 */
public class Send {
    private static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取链接
        Connection connection = ConnectionUtils.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        /**
         * 每个消费者发送消费之前，消息队列不发送下一个消息到消费者，一次只处理一个消息
         * 限制发送给同一个消费者不得超过一个消息
         */
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);

        for (int i = 0; i < 50; i++) {
            String msg = "hello" + i;

            System.out.println("[WQ ] send:" + msg);
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());
            Thread.sleep(i * 5);
        }
        channel.close();
        connection.close();
    }
}

接收端01：Receive1.java

package test.rabbitmq.rabbitmq.mq5s.mq3;

import com.rabbitmq.client.*;
import test.rabbitmq.rabbitmq.mq5s.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receive1 {
    public static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接
        Connection connection = ConnectionUtils.getConnection();
        //创建频道
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //保证一次只发送一个
        channel.basicQos(1);

        //定义一个消费者
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "utf-8");
                System.out.println("[1] Recv msg :" + msg);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("[1] done");
                    //手动回执
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }
}

接收端02：Receive2.java

package test.rabbitmq.rabbitmq.mq5s.mq3;

import com.rabbitmq.client.*;
import test.rabbitmq.rabbitmq.mq5s.ConnectionUtils;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Receive2 {
    public static final String QUEUE_NAME = "test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //创建链接
        Connection connection = ConnectionUtils.getConnection();
        //创建频道
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //保证一次只发送一个
        channel.basicQos(1);
        //定义一个消费者
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msg = new String(body, "utf-8");
                System.out.println("[2] Recv msg :" + msg);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    System.out.println("[2] done");
                    //手动回执
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };
        boolean autoAck = false;
        channel.basicConsume(QUEUE_NAME, autoAck, consumer);
    }
}

发布订阅模式

模型图

在这里插入图片描述

发送端：send.java

package test.rabbitmq.rabbitmq.mq5s.mq4;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 发送消息
 */
public class send {
    public static void main(String[] args) throws IOException, TimeoutException {

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("127.0.0.1");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/");//虚拟机 默认值/
        factory.setUsername("guest");//用户名 默认 guest
        factory.setPassword("guest");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();
       /*

       exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
       参数：
        1. exchange:交换机名称
        2. type:交换机类型
            DIRECT("direct"),：定向,把消息交给符合指定routing key 的队列。
            FANOUT("fanout"),：扇形（广播），发送消息到每一个与之绑定队列。
            TOPIC("topic"),通配符的方式
            HEADERS("headers");参数匹配

        3. durable:是否持久化
        4. autoDelete:自动删除
        5. internal：内部使用。 一般false
        6. arguments：参数
        */

        String exchangeName = "test_fanout";
        //5. 创建交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
        //6. 创建队列
        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);
        //7. 绑定队列和交换机
        /*
        queueBind(String queue, String exchange, String routingKey)
        参数：
            1. queue：队列名称
            2. exchange：交换机名称
            3. routingKey：路由键，绑定规则
                如果交换机的类型为fanout ，routingKey设置为""
         */
        channel.queueBind(queue1Name,exchangeName,"");
        channel.queueBind(queue2Name,exchangeName,"");

        String body = "日志信息：张三调用了findAll方法...日志级别：info...";
        //8. 发送消息
        channel.basicPublish(exchangeName,"",null,body.getBytes());

        //9. 释放资源
        channel.close();
        connection.close();

    }
}

接收端01：receive1.java

package test.rabbitmq.rabbitmq.mq5s.mq4;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

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

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("127.0.0.1");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/");//虚拟机 默认值/
        factory.setUsername("guest");//用户名 默认 guest
        factory.setPassword("guest");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();


        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";


        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象

         */
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){
            /*
                回调方法，当收到消息后，会自动执行该方法

                1. consumerTag：标识
                2. envelope：获取一些信息，交换机，路由key...
                3. properties:配置信息
                4. body：数据

             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
              /*  System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange："+envelope.getExchange());
                System.out.println("RoutingKey："+envelope.getRoutingKey());
                System.out.println("properties："+properties);*/
                System.out.println("body："+new String(body));
                System.out.println("将日志信息打印到控制台.....");
            }
        };
        channel.basicConsume(queue1Name,true,consumer);


        //关闭资源？不要

    }
}

接收端02：receive2.java

package test.rabbitmq.rabbitmq.mq5s.mq4;

import com.rabbitmq.client.*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

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

        //1.创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 设置参数
        factory.setHost("127.0.0.1");//ip  默认值 localhost
        factory.setPort(5672); //端口  默认值 5672
        factory.setVirtualHost("/");//虚拟机 默认值/
        factory.setUsername("guest");//用户名 默认 guest
        factory.setPassword("guest");//密码 默认值 guest
        //3. 创建连接 Connection
        Connection connection = factory.newConnection();
        //4. 创建Channel
        Channel channel = connection.createChannel();


        String queue1Name = "test_fanout_queue1";
        String queue2Name = "test_fanout_queue2";


        /*
        basicConsume(String queue, boolean autoAck, Consumer callback)
        参数：
            1. queue：队列名称
            2. autoAck：是否自动确认
            3. callback：回调对象

         */
        // 接收消息
        Consumer consumer = new DefaultConsumer(channel){
            /*
                回调方法，当收到消息后，会自动执行该方法

                1. consumerTag：标识
                2. envelope：获取一些信息，交换机，路由key...
                3. properties:配置信息
                4. body：数据

             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
              /*  System.out.println("consumerTag："+consumerTag);
                System.out.println("Exchange："+envelope.getExchange());
                System.out.println("RoutingKey："+envelope.getRoutingKey());
                System.out.println("properties："+properties);*/
                System.out.println("body："+new String(body));
                System.out.println("将日志信息保存数据库.....");
            }
        };
        channel.basicConsume(queue2Name,true,consumer);


        //关闭资源？不要

    }
}

路由模式

模型图
在这里插入图片描述

发送端：Send.java

package test.rabbitmq.rabbitmq.mq5s.mq5;


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

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

public class Send {
    private static final String EXCHANGE_NAME = "logs2";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        //debug日志
        for (int i = 1; i <= 3; i++) {
            String message = "debug_message" + i;
            channel.basicPublish(EXCHANGE_NAME, "debug", null, message.getBytes());
        }
        //info日志
        for (int i = 1; i <= 3; i++) {
            String message = "info_message" + i;
            channel.basicPublish(EXCHANGE_NAME, "info", null, message.getBytes());
        }
        //error日志
        for (int i = 1; i <= 3; i++) {
            String message = "error_message" + i;
            channel.basicPublish(EXCHANGE_NAME, "error", null, message.getBytes());
        }
        channel.close();
        connection.close();
    }
}

接收端01：Receive1.java

package test.rabbitmq.rabbitmq.mq5s.mq5;

import com.rabbitmq.client.*;

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

public class Receive1 {
    private static final String EXCHANGE_NAME = "logs2";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "debug");
        Consumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(message);
            }
        };
        channel.basicConsume(queueName,true,consumer);
    }
}

接收端02：Receive2.java

package test.rabbitmq.rabbitmq.mq5s.mq5;

import com.rabbitmq.client.*;


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

public class Receive2 {
    private static final String EXCHANGE_NAME = "logs2";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "info");

        DefaultConsumer consumer=new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(message);
            }
        };
        channel.basicConsume(queueName,true,consumer);
    }
}

接收端03：Receive3.java

package test.rabbitmq.rabbitmq.mq5s.mq5;

import com.rabbitmq.client.*;

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

public class Receive3 {
    private static final String EXCHANGE_NAME = "logs2";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, EXCHANGE_NAME, "error");
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                FileUtil.save(message);
                System.out.println("添加记录到文件!");
            }
        };
        channel.basicConsume(queueName,true,consumer);
    }
}
Ember_Sky
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitMQ JAVA开发 demo文件
12-22
rabbitMQ JAVA开发 demo文件 rabbitMQ JAVA开发 demo文件
RabbitMQ快速入门Java Demo
Jews
04-25 1931
RabbitMQ快速入门Demo快速入门Demodirect：fanout 快速入门Demo 引入依赖(版本自选)： <!-- https://mvnrepository.com/artifact/com.rabbitmq/amqp-client --> <dependency> <groupId>com.rabbitmq</groupId> &...
RabbitMQ读写消息的Java Demo
yzh_1346983557的博客
07-25 3734
一。maven中添加依赖： &lt;dependency&gt; &lt;groupId&gt;com.rabbitmq&lt;/groupId&gt; &lt;artifactId&gt;amqp-client&lt;/artifactId&gt; &lt;version&gt;3.6.5&lt;/version&gt;
RabbitMQ 快速入门（带有javaDemo）
来自菜鸟的摸索
07-11 428
1.0 MQ的基本概念 1.1 MQ概述 MQ全称Message Queue (消息队列)，是在消息的传输过程中保存信息的容器。多用于分布式系统之间进行通信。 1.2 MQ的应用场景 用于消息中间件，生产者将信息加入到MQ中，消费者再从MQ中拉取相应的信息。实现类生产者到消费者之间的解耦 1.3 MQ的优势 1、应用解耦 2、异步提速 提升用户体验 3、削峰填谷 4、小结 立用解耦:提高系统容错性和可维护性 异步提速:提升用户体验和系统吞吐量 削峰填谷:提高系统稳定性 2.0 六种MQ的运行模
【RabbitMQ】Java操作RabbitMQ之入门Demo
qq_61903414的博客
04-14 776
由之前文章里我们了解到RabbitMQ的通信如下图，我们要想将生产者生产的消息存入队列，我们就一个先获得Connection（连接）然后通过连接获取到channel，然后选择虚拟机交换机以及队列等最后关闭连接。此时我们需要去在MQ里创建队列，通过channel里的queueDelclare方法来创建该方法有以下参数。此时我们就可以通过channel里的basicPublish方法进行发送消息，该方法有以下参数。我们获取连接是通过连接工厂进行获取的所以此时我们先要去创建连接工厂并给他配置相应的信息。
rabbitmq.java demo_RabbitMQ入门级示例Demo
weixin_39998541的博客
02-13 49
【实例简介】【实例截图】【核心代码】package com.rabbitmq.test;import com.rabbitmq.client.Channel;import com.rabbitmq.client.Connection;import com.rabbitmq.client.ConnectionFactory;public class ProducerTest {private fin...
RabbitMQ Java实现demo
梅林's hat
10-07 629
代码运行需先安装环境依赖 windows环境下: 先安装Erlang 页面:https://www.erlang.org/downloads 下载链接:https://erlang.org/download/otp_win64_24.1.exe 安装完配置环境变量 ERLANG_HOME C:\Program Files\erl-24.1 然后在path变量里添加 %ERLANG_HOME%/bin 然后打开cmd命令框，输入erl Eshell V12.1 (abort with ^G) ..
RabbitMQ学习笔记：高级特性TTL（过期时间）
OceanSky的专栏
10-26 1675
TTL，Time To Live的简称，即消息过期时间，可以对消息和队列设置TTL。 目前有两种方式可以设置消息的TTL。第一种是通过队列的属性设置，队列中的所有消息都有相同的过期时间。第二种方法是对消息本身进行单独设置，每条消息的TTL可以不同。如果两种方法同时设置，则TTL以两者之间较小的那个数值为准。消息在队列中的生存时间一旦超过设置的TTL值时，就会变成“死信”（Dead Messag...
java编写RabbitMQ 的demo
han_xiaoxue的博客
11-02 510
maven 项目 pom.xml配置文件 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> 4.0.0 com.zjk myRabbitMQ 0.0.1-SNAPSHOT http://maven.apache.org com.
消息中间件rabbitmq(2)
weixin_34313182的博客
12-03 106
介绍 主要演示生产者和消费如何传递消息的 生产者 public static void main(String[] args) throws IOException, TimeoutException { // TODO Auto-generated method stub ConnectionFactory factory = new Connect...
java连接rabbitmq测试Demo和参数分析
bainiao1996的博客
04-11 461
1.pom文件引入jar包 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <version>5.6.0</version>...
springboot+rabbitmq项目demo(亲测,可正常运行)
02-21
使用springboot+rabbitmq搭建一个简单的消息队列项目。
Java使用RabbitMQ完整项目源码.rar
12-28
此项目是java使用RabbitMQ的demo源码，其中详细的展示了java如何使用rabbitMQ。包括连接RabbitMQ服务器，发送消息，处理消息，发送监听，返回监听等。
java实现rabbitMQ 5种工作方式的demo
08-04
代码简洁明了，附带测试类，可以直接运行查看效果，实现了rabbitMq的简单模式、工作模式、路由模式、广播模式、topic模式5种demo，欢迎下载查看，一起学习
Rabbitmq_Demo
04-30
Rabbitmq_Demo0x01SpringBoot集成RabbitMQ。包含的普通queue的消费，以及Dirct、Topic模式。由阿里ons向RabbitMQ迁移，结合自己的理解，对二者进行了总结对比（图1，图2）：0x02 死信队列将报错后多次重试仍无法处理...
java集成rabbitmq中间件
10-03
demo中主要包括直连、扇出、主题三种模式，配合java实现，本人注解还是很到位的，有需要的可以看看
RabbitMQ学习简单demo项目源码
10-30
RabbitMQ学习过程中，写的一个简单完整的demo项目源码，各种模式的MQ都有一个简单的例子，喜欢实践学习的人看看
积分管理系统java源码-rabbitmq-demo:消息队列RabbitMQdemo
06-06
积分管理系统java源码 参考： 目录 [TOC] 消息队列简介 选择衡量指标： 1）服务性能 2）数据存储 3）集群架构 几种常见消息队列的对比： ActiveMQ 功能强劲但是并发性能不够好，不适用于高并发的复杂的项目。 架构...
消息队列 RabbitMQ python实战
最新发布
jacke121的专栏
04-29 1116
消息队列 RabbitMQ python实战
rabbitmq demo java
06-08
好的，这里是一个 RabbitMQ 的 Java demo，使用 RabbitMQ 的 Java 客户端编写。 首先，需要在项目中引入 RabbitMQ 的 Java 客户端依赖，可以在 pom.xml 文件中加入以下内容： ```xml <groupId>com.rabbitmq</...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值