rabbitmq各种模式java实现

最新推荐文章于 2022-03-11 20:45:00 发布
最新推荐文章于 2022-03-11 20:45:00 发布
阅读量918 收藏 1
点赞数
分类专栏： rabbitmq 文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42691149/article/details/120994336
版权

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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zoomy</groupId>
    <artifactId>rabbitmq</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rabbitmq</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--rabbitmq依赖-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <scope>5.10.0</scope>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

一、简单模式simple

在这里插入图片描述

在这里插入图片描述

Producer:

package com.zoomy.rabbitmq.simple;

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

/**
 * @description: 生产者
 * @author: zmh
 * @date: 2021-10-27 00:13
 */
public class Producer {


    public static void main(String[] args) {
        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();
            // 4.通过创建交换机，声明队列，绑定关系，路由Key，发送消息，和接收消息
            String queueName = "queue1";
            /*
             * @params1 队列名称
             * @params2 是否要持久化durable=false 所谓持久化消息是否存盘，如果false，非持久化ture是持久化？非持久化会存盘吗？会存盘，但是会随着服务器重启丢失
             * @params3 排他性，是否独占独立
             * @params4 队列名称是否自动删除，随着最后一个消费者消息完毕以后是否把队列自动删除
             * @params5 携带附属参数
             */
            channel.queueDeclare(queueName, false, false, false, null);
            // 5.准备消息内容
            String message = "Hello rabbitmq!!!";
            // 6.发送消息给队列queue
            channel.basicPublish("", queueName, null, message.getBytes());
            System.out.println("消息发送成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 7.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 8.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }


}

Consumer:

package com.zoomy.rabbitmq.simple;


import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @description: 消费者
 * @author: zmh
 * @date: 2021-10-27 00:12
 */
public class Consumer {

    public static void main(String[] args) {
        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("*******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();
            // 4.通过创建交换机，声明队列，绑定关系，路由Key，发送消息，和接收消息



            channel.basicConsume("queue1", true, new DeliverCallback() {
                        @Override
                        public void handle(String consumerTag, Delivery message) throws IOException {
                            System.out.println("收到信息是" + new String(message.getBody(), "utf-8"));
                        }
                    }, new CancelCallback() {
                        @Override
                        public void handle(String consumerTag) throws IOException {
                            System.out.println("接受消息失败");
                        }
                    }
            );
            System.out.println("开始接收消息");
            System.in.read();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 7.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 8.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }


}

首先执行生产者producer得main方法：

在这里插入图片描述

登录rabbitmq：看到queue1生产了一条队列信息

在这里插入图片描述
然后使用消费者消费掉：
在这里插入图片描述

看到ready变成0，被成功消费掉
在这里插入图片描述

二、fanout

在这里插入图片描述

1.复制simple模式的producer,consumer
在这里插入图片描述
2.rabbitmq添加交换机，创建队列，绑定关系

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

3.修改producer

package com.zoomy.rabbitmq.routing;

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

/**
 * @description: 生产者
 * @author: zmh
 * @date: 2021-10-27 00:13
 */
public class Producer {


    public static void main(String[] args) {
        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();

            // 4.准备消息内容
            String message = "Hello rabbitmq!!!";

            //5.准备交换机
            String exchange = "fanout-exchange";

            // 6.定义routing key
            String routekey = "";

            // 7.指定交换机类型
            String type = "fanout";

            //8.发送消息给队列queue
            /*
             * @params1 交换机(没有写就是用默认的交换机)
             * @params2 队列、路由key
             * @params3 消息的状态控制
             * @params4 消息主题
             */
            channel.basicPublish(exchange, routekey, null, message.getBytes());
            System.out.println("消息发送成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 9.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 10.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }


}

4.修改consumer

package com.zoomy.rabbitmq.routing;


import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @description: 消费者
 * @author: zmh
 * @date: 2021-10-27 00:12
 */
public class Consumer {

    public static Runnable runnable = new Runnable() {
        @Override
        public void run() {

            // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
            // ip port

            // 1.创建连接工程
            ConnectionFactory connectionFactory = new ConnectionFactory();
            connectionFactory.setHost("********");
            connectionFactory.setPort(5672);
            connectionFactory.setUsername("admin");
            connectionFactory.setPassword("admin");
            connectionFactory.setVirtualHost("/");
            //获取队列名称
            final String queueName = Thread.currentThread().getName();

            Connection connection = null;
            Channel channel = null;
            try {
                // 2.创建连接Connection
                connection = connectionFactory.newConnection("生产者");
                // 3.通过连接获取通道Channel
                channel = connection.createChannel();
                // 4.通过创建交换机，声明队列，绑定关系，路由Key，发送消息，和接收消息


                channel.basicConsume(queueName, true, new DeliverCallback() {
                            @Override
                            public void handle(String consumerTag, Delivery message) throws IOException {
                                System.out.println(queueName + "收到信息是" + new String(message.getBody(), "utf-8"));
                            }
                        }, new CancelCallback() {
                            @Override
                            public void handle(String consumerTag) throws IOException {
                                System.out.println("接受消息失败");
                            }
                        }
                );
                System.in.read();

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                // 7.关闭连接
                if (channel != null && channel.isOpen()) {
                    try {
                        channel.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                // 8.关闭通道
                if (connection != null && connection.isOpen()) {
                    try {
                        connection.close();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    };

    //创建三个消费者
    public static void main(String[] args) {
        new Thread(runnable, "queue1").start();
        new Thread(runnable, "queue2").start();
        new Thread(runnable, "queue3").start();
    }
}

5.测试：
运行producer
在这里插入图片描述

队列信息都增加一条
在这里插入图片描述
运行consumer，发现队列123都进行了消费
在这里插入图片描述
在这里插入图片描述

三、direct

在这里插入图片描述

1、创建交换机,绑定关系
在这里插入图片描述
在这里插入图片描述
2.复制fanout的producer，和consumer，给producer做修改

package com.zoomy.rabbitmq.direct;

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

/**
 * @description: 生产者
 * @author: zmh
 * @date: 2021-10-27 00:13
 */
public class Producer {


    public static void main(String[] args) {
        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("*****");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();

            // 4.准备消息内容
            String message = "Hello rabbitmq!!!";

            //5.准备交换机
            String exchange = "direct-exchange";

            // 6.定义routing key
            String routekey = "email";

            // 7.指定交换机类型
            String type = "direct";

            //8.发送消息给队列queue
            /*
             * @params1 交换机(没有写就是用默认的交换机)
             * @params2 队列、路由key
             * @params3 消息的状态控制
             * @params4 消息主题
             */
            channel.basicPublish(exchange, routekey, null, message.getBytes());
            System.out.println("消息发送成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 9.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 10.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }


}

运行producer
在这里插入图片描述

运行consumer,看到routing key是 email的队列1 ，3 进行了消费

在这里插入图片描述

四、topic模式

在这里插入图片描述

复制direct代码
在这里插入图片描述

1、创建交换机，并绑定关系

在这里插入图片描述

在这里插入图片描述

2.修改producer

package com.zoomy.rabbitmq.topics;

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

/**
 * @description: 生产者
 * @author: zmh
 * @date: 2021-10-27 00:13
 */
public class Producer {


    public static void main(String[] args) {
        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("**********");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();

            // 4.准备消息内容
            String message = "Hello rabbitmq!!!";

            //5.准备交换机
            String exchange = "topic-exchange";

            // 6.定义routing key
            String routekey = "com.order.test.xxxx";

            // 7.指定交换机类型
            String type = "topic";

            //8.发送消息给队列queue
            /*
             * @params1 交换机(没有写就是用默认的交换机)
             * @params2 队列、路由key
             * @params3 消息的状态控制
             * @params4 消息主题
             */
            channel.basicPublish(exchange, routekey, null, message.getBytes());
            System.out.println("消息发送成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 9.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 10.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }


}

3.运行producer
在这里插入图片描述

4.运行consumer,队列1 3成功消费
在这里插入图片描述

五、上面都是通过图形化界面进行创建交换机，下面是纯代码实现

1.创建producer

package com.zoomy.rabbitmq.all;

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

/**
 * @description: 生产者
 * @author: zmh
 * @date: 2021-10-27 00:13
 */
public class Producer {


    public static void main(String[] args) {
        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("********");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();

            // 4.准备消息内容
            String message = "Hello rabbitmq!!!";

            //5.准备交换机
            String exchange = "direct_message_exchange";

            // 6.定义routing key
            String routekey = "order";

            // 7.指定交换机类型
            String type = "direct";

            //8.声明交换机，true是 持久化，交换机不会随着服务器重启造成丢失
            channel.exchangeDeclare(exchange,type,true);

            //9.声明队列
            channel.queueDeclare("queue5",true,false,false,null);
            channel.queueDeclare("queue6",true,false,false,null);
            channel.queueDeclare("queue7",true,false,false,null);

            //10.绑定队列和交换机关系
            channel.queueBind("queue5",exchange,"order");
            channel.queueBind("queue6",exchange,"order");
            channel.queueBind("queue7",exchange,"course");

            //8.发送消息给队列queue
            /*
             * @params1 交换机(没有写就是用默认的交换机)
             * @params2 队列、路由key
             * @params3 消息的状态控制
             * @params4 消息主题
             */
            channel.basicPublish(exchange, routekey, null, message.getBytes());
            System.out.println("消息发送成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 9.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 10.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }


}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
2.运行consumer
在这里插入图片描述

六、工作模式work(轮询分发模式，公共分发模式)

在这里插入图片描述
6.1轮训分发

1.procuder

package com.zoomy.rabbitmq.work.lunxun;

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

/**
 * @description: 生产者
 * @author: zmh
 * @date: 2021-10-27 00:13
 */
public class Producer {


    public static void main(String[] args) {
        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();

            //4.准备发送消息的内容
            for (int i = 0; i < 20; i++) {
                //消息内容
                String msg = "rabbitmq" + i;

                channel.basicPublish("", "queue1", null, msg.getBytes());
            }


            System.out.println("消息发送成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 9.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 10.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }


}

2.Work1，Work2

package com.zoomy.rabbitmq.work.lunxun;


import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @description: 消费者
 * @author: zmh
 * @date: 2021-10-27 00:12
 */
public class Work1 {

    public static void main(String[] args) {

        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        //获取队列名称
        final String queueName = Thread.currentThread().getName();

        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("消费者-Work1");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();


            //4定义接受消息的回调
            Channel finalChannel = channel;
//                finalChannel.basicQos(1);
            // 5.通过创建交换机，声明队列，绑定关系，路由Key，发送消息，和接收消息


            finalChannel.basicConsume("queue1", true, new DeliverCallback() {
                        @Override
                        public void handle(String consumerTag, Delivery message) throws IOException {
                            try {
                                System.out.println("Work1-收到信息是" + new String(message.getBody(), "utf-8"));
                                Thread.sleep(2000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }, new CancelCallback() {
                        @Override
                        public void handle(String consumerTag) throws IOException {
                            System.out.println("接受消息失败");
                        }
                    }
            );
            System.out.println("Work1-开始接受消息");
            System.in.read();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 7.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

}


package com.zoomy.rabbitmq.work.lunxun;


import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @description: 消费者
 * @author: zmh
 * @date: 2021-10-27 00:12
 */
public class Work2 {

    public static void main(String[] args) {

        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        //获取队列名称
        final String queueName = Thread.currentThread().getName();

        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("消费者-Work2");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();


            //4定义接受消息的回调
            Channel finalChannel = channel;
//                finalChannel.basicQos(1);
            // 5.通过创建交换机，声明队列，绑定关系，路由Key，发送消息，和接收消息


            finalChannel.basicConsume("queue1", true, new DeliverCallback() {
                        @Override
                        public void handle(String consumerTag, Delivery message) throws IOException {
                            try {
                                System.out.println("Work2-收到信息是" + new String(message.getBody(), "utf-8"));
                                Thread.sleep(2000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }, new CancelCallback() {
                        @Override
                        public void handle(String consumerTag) throws IOException {
                            System.out.println("接受消息失败");
                        }
                    }
            );
            System.out.println("Work2-开始接受消息");
            System.in.read();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 7.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.分别运行work1,work2
在这里插入图片描述

4.运行producer

在这里插入图片描述
5.看到是轮询
在这里插入图片描述

在这里插入图片描述

6.2公平分发

1.复制lunxun到fair
在这里插入图片描述

package com.zoomy.rabbitmq.work.fair;

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

/**
 * @description: 生产者
 * @author: zmh
 * @date: 2021-10-27 00:13
 */
public class Producer {


    public static void main(String[] args) {
        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("*******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("生产者");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();

            //4.准备发送消息的内容
            for (int i = 0; i < 20; i++) {
                //消息内容
                String msg = "rabbitmq" + i;

                channel.basicPublish("", "queue1", null, msg.getBytes());
            }


            System.out.println("消息发送成功！！！");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 9.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 10.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

    }


}


package com.zoomy.rabbitmq.work.fair;


import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @description: 消费者
 * @author: zmh
 * @date: 2021-10-27 00:12
 */
public class Work1 {

    public static void main(String[] args) {

        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("*******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        //获取队列名称
        final String queueName = Thread.currentThread().getName();

        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("消费者-Work1");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();


            //4定义接受消息的回调
            Channel finalChannel = channel;
            finalChannel.basicQos(1);
            // 5.通过创建交换机，声明队列，绑定关系，路由Key，发送消息，和接收消息


            finalChannel.basicConsume("queue1", false, new DeliverCallback() {
                        @Override
                        public void handle(String consumerTag, Delivery message) throws IOException {
                            try {
                                System.out.println("Work1-收到信息是" + new String(message.getBody(), "utf-8"));
                                Thread.sleep(2000);
                                finalChannel.basicAck(message.getEnvelope().getDeliveryTag(), false);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }, new CancelCallback() {
                        @Override
                        public void handle(String consumerTag) throws IOException {
                            System.out.println("接受消息失败");
                        }
                    }
            );
            System.out.println("Work1-开始接受消息");
            System.in.read();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 7.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

}


package com.zoomy.rabbitmq.work.fair;


import com.rabbitmq.client.*;

import java.io.IOException;

/**
 * @description: 消费者
 * @author: zmh
 * @date: 2021-10-27 00:12
 */
public class Work2 {

    public static void main(String[] args) {

        // 所有的中间件技术都是基于htp/ip协议之上构建新型的协议规范，只不过rabbitmq遵循的是amqp
        // ip port

        // 1.创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("*******");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");
        connectionFactory.setVirtualHost("/");
        //获取队列名称
        final String queueName = Thread.currentThread().getName();

        Connection connection = null;
        Channel channel = null;
        try {
            // 2.创建连接Connection
            connection = connectionFactory.newConnection("消费者-Work2");
            // 3.通过连接获取通道Channel
            channel = connection.createChannel();


            //4定义接受消息的回调
            Channel finalChannel = channel;
            finalChannel.basicQos(1);
            // 5.通过创建交换机，声明队列，绑定关系，路由Key，发送消息，和接收消息


            finalChannel.basicConsume("queue1", false, new DeliverCallback() {
                        @Override
                        public void handle(String consumerTag, Delivery message) throws IOException {
                            try {
                                System.out.println("Work2-收到信息是" + new String(message.getBody(), "utf-8"));
                                Thread.sleep(200);
                                finalChannel.basicAck(message.getEnvelope().getDeliveryTag(),false);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }, new CancelCallback() {
                        @Override
                        public void handle(String consumerTag) throws IOException {
                            System.out.println("接受消息失败");
                        }
                    }
            );
            System.out.println("Work2-开始接受消息");
            System.in.read();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 6.关闭连接
            if (channel != null && channel.isOpen()) {
                try {
                    channel.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 7.关闭通道
            if (connection != null && connection.isOpen()) {
                try {
                    connection.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.修改work1,work2，改为手动应答，work1的thread.sleep改为2000，work2的改为200
在这里插入图片描述

3.测试：work2执行比较快，所以大部分都是work2执行
在这里插入图片描述
在这里插入图片描述

21-夜一
关注
专栏目录
消息模式1
Zhangrunhong的博客
12-06 449
文章目录1、消息如何保证100%的投递？2、幂等性概念3、Confirm确认消息4、Return返回消息5、自定义消费者 1、消息如何保证100%的投递？ 消息如何保障100%的投递成功？ 什么是生产端的可靠性投递？ 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行补偿机制 BAT/TMD互联网大厂的解决方案： 消息落库，对消息状态进...
java直接消费rabbitmq_JAVA语言之RabbitMQ拉模式批量消费消息
weixin_42517406的博客
02-27 907
本文主要向大家介JAVA语言之RabbitMQ拉模式批量消费消息绍了，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。实现RabbitMQ的消费者有两种模式，推模式(Push)和拉模式(Pull)。实现推模式推荐的方式是继承DefaultConsumer基类，也可以使用Spring AMQP的SimpleMessageListenerContainer。推模式是最常用的，但是...
rabbitmq 主题java 实现
08-25
rabbitmq 主题java 实现
RabbitMq模式
weixin_44244088的博客
03-10 348
RabbitMq模式 本文资料 来自于官网 https://www.rabbitmq.com/tutorials/tutorial-two(one/two/three)-java(注: 可以修改语言).html 1. 工作队列模式 work [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MqIJnjzO-1583772571626)(C:\Users\SFF\Ap...
RabbitMQ工作模式以及java代码实现
weixin_45820447的博客
03-11 527
RabbitMQ5中工作模式
RabbitMQ工作模式
qq_38116774的博客
03-03 326
rabbitMQ的工作模式有以下几种： 1、Work queues 2、Publish/Subscribe 3、Routing 4、Topics 5、Header 6、RPC 此外还有一个入门程序也是一种模式链接 Work queues 图示： work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。 使用场景 对于任务过重或任务较多情况使用工作队列可以提...
rabbitmq 7种队列实现java版
01-20
文章目录rabbitmq7种实现方式搭建maven项目引入依赖创建连接简单队列消息生产者消息消费者work queues 工作队列生产者消费者能者多劳（公平分发）：消费能力强则消费更多消息Publish/Subscribe 发布订阅模式生产者...
java rabbitmq动态注册，监听实现
最新发布
09-22
需要理解RabbitMQ的各种工作模式，如Direct、Fanout、Topic和Header，以选择适合业务需求的模式。例如，Direct模式适用于一对一消息传递，Topic模式则支持多对多的路由策略。 7. **异常处理**： 当消费者处理消息...
rabbitmq RPC java 实现
08-26
本篇文章将深入探讨如何使用Java实现基于RabbitMQ的RPC。 首先，我们要理解RabbitMQ的基本概念。RabbitMQ是一个开源的消息代理，它遵循AMQP（Advanced Message Queuing Protocol）协议，负责接收和转发消息。在RPC...
rabbitmq 工作队列 java 实现
08-23
要使用Java实现RabbitMQ的工作队列，你需要引入`rabbitmq-client`的依赖。在Maven项目中，可以在pom.xml中添加如下依赖： ```xml <groupId>com.rabbitmq</groupId> <artifactId>amqp-client <version>5.x.x ``...
rabbitmq 发布/订阅 java 实现
08-24
rabbitmq 发布/订阅 java 实现
java集成rabbitmq多种消费模式
06-06
该项目包括两个子工程，生产者（rabbitmqProvider），消费者（rabbitmqConsumer），采用了direct，fanout，topic三种方式发布及消费。以及持久化分批消费等。工程中rabbitMQ.xml，rabbitMQ1.xml，rabbitMQChanel.xml对象三种模式的配置。
RabbitMQ之消息模式(一)
qq_44847231的博客
12-06 224
文章目录消息100%的投递幂等性概念Confirm确认消息Return返回消息自定义消费者 消息100%的投递 消息如何保障100%的投递成功？ 什么是生产端的可靠性投递？ 保障消息的成功发出 保障MQ节点的成功接收 发送端收到MQ节点（Broker）确认应答 完善的消息进行补偿机制 BAT/TMD互联网大厂的解决方案： 消息落库，对消息状态进行打标 消息的延迟投递，做二次确认，回调检查 ...
RabbitMQ入门教程 For Java【5】 - Topic
大大的微笑的专栏
01-14 7450
RabbitMQ入门教程 For Java【1】 - Topic Topic模式         匹配模式，如果按照百度翻译和百度百科，直接叫主题或者话题就得了，但是如果你真的明白它在RabbitMQ中代表什么，就不能这么直接的翻译成中文了。如果要用中文理解它的意思，先了解它在RabbitMQ中用来做什么：topic类型的交换器允许在RabbitMQ中使用模糊匹配来绑定自己感兴趣的信息。
RabbitMq工作模式
@王某人
11-10 2488
rabbitMq工作模式 Work queues工作队列模式 模式说明 Work Queues 与入门程序的 简单模式 相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。 订阅模式概述 订阅模式示例图： 前面2个案例中，只有3个角色： P：生产者，也就是要发送消息的程序 C：消费者：消息的接受者，会一直等待消息到来。 queue：消息队列，图中红色部分 而在订阅模型中，多了一个exchange角色，而且过程略有变化
Rabbitmq常见的模式
qq_29860591的博客
07-03 253
1. AMQP 1.1. 相关概念介绍 AMQP 一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。 AMQP是一个二进制协议，拥有一些现代化特点：多信道、协商式，异步，安全，扩平台，中立，高效。 RabbitMQ是AMQP协议的Erlang的实现。 概念 说明 连接Connection 一个网络连接，比如TCP/IP套接...
rabbitmq 工作模式 一
qq_40794266的博客
11-28 412
学习工作模式前,先看一下rabbitmq 给的helloworld案例       这是传统的一对一,,,,  也就是一台机器生产,一台机器接收....   为了更好的了解代码....我这里演示的话用底层的代码来演示....不整合框架了 &lt;dependency&gt; &lt;groupId&gt;com.rabbitmq&lt;/groupId&gt; ...
RabbitMQ教程：Java实现FanOut交换与Pub/Sub模式
RabbitMQ是一个跨平台、多语言支持的消息中间件，它的Java库在企业级应用中扮演着重要的角色，用于消息的生产和消费。 FanOut交换机是课程的核心概念之一。当需要确保消息被多个消费者处理时，FanOut交换机制非常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值