RabbitMQ七种工作模式实现测试代码

最新推荐文章于 2024-04-10 05:12:49 发布
最新推荐文章于 2024-04-10 05:12:49 发布
阅读量263 收藏
点赞数 1
分类专栏： Java微服务 JavaEE企业开发 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/William_TWG/article/details/109273199
版权
所有工作模式依赖都相同
    <dependencies>
        <!--RabbitMQ的客户端依赖-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.6.0</version>
        </dependency>
    </dependencies>


    <build>
        <plugins>
            <!--编译插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
一.简单工作模式代码

和RabbitMQ生产者消费者实列种的代码相同

生产者：

package cn.twgfs.rabbitmq.provider;

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

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

/**
 * @author willian
 * @date 2020/10/13 11:27
 */
public class ProducerHelloWorld {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
         connectionFactory.setHost("192.168.0.103");//设置注解
         connectionFactory.setPort(5672);//设置端口
         connectionFactory.setVirtualHost("/vm");//设置虚拟及
         connectionFactory.setUsername("tang");
         connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();
        //5 创建队列Queen
        /**参数介绍：
         * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         * queue：队列名称   durable：是否持久化   exclusive是否独占，只能有一个消费者监听队列。         * queue：队列名称   durable：是否持久化   exclusive是否独占，只能有一个消费者监听队列。
         * autoDelete:   当没有consumer时候是否删除队列     arguments：配置的基本参数
         */
        channel.queueDeclare("hello_world",true,false,false,null);
        //6 发送消息到队列
        /**参数介绍：
         * basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)
         *exchange： 交换机的名称，简单模式下交换机会使用默认的    routingKey：路由名称,如果使用默认交换机要和队列名相同
         *props 配置信息    body：真是发送的消息数据
         */
        String body = "hello_rabbitmq 发送消息";
        channel.basicPublish("","hello_world",null,body.getBytes());

        //7 释放连接资源
        channel.close();
        connection.close();
    }
}

消费者：

package cn.twgfs.rabbitmq.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author willian
 * @date 2020/10/13 14:17
 */
public class ConsumerHelloWorld {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
        connectionFactory.setHost("192.168.0.103");//设置注解
        connectionFactory.setPort(5672);//设置端口
        connectionFactory.setVirtualHost("/vm");//设置虚拟及
        connectionFactory.setUsername("tang");
        connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();
        //5 创建队列Queen
        /**参数介绍：
         * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         * queue：队列名称   durable：是否持久化   exclusive是否独占，只能有一个消费者监听队列。         * queue：队列名称   durable：是否持久化   exclusive是否独占，只能有一个消费者监听队列。
         * autoDelete:   当没有consumer时候是否删除队列     arguments：配置的基本参数
         */
        channel.queueDeclare("hello_world",true,false,false,null);
        //6 从消息队列中消费
        /**参数介绍：
         *basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue: 消费的队列名称    autoAck：是否自动消费确认，收到消息确认
         * callback：回调对象
         */
        Consumer consumer = new DefaultConsumer(channel){
            //这是一个回调方法，当收到消息后会自动执行该方法
            /**
             * @param consumerTag ：标识
             * @param envelope： 获取交换机，路由等信息
             * @param properties：配置信息
             * @param body：真是的数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(""+consumerTag);
                System.out.println("getExchange+"+envelope.getExchange());
                System.out.println("getRoutingKey+"+envelope.getRoutingKey());
                System.out.println("properties"+properties);
                System.out.println("body"+body);
            }
        };
        channel.basicConsume("hello_world",true,consumer);

        //7 消费者不关闭连接
    }
}
二.工作队列模式代码

创建两个类名不同但是，但是代码完全相同的两个消费者
WorkQueens1，WorkQueens1

package cn.twgfs.rabbitmq.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author willian
 * @date 2020/10/13 14:17
 */
public class WorkQueens1 {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
        connectionFactory.setHost("192.168.0.103");//设置注解
        connectionFactory.setPort(5672);//设置端口
        connectionFactory.setVirtualHost("/vm");//设置虚拟及
        connectionFactory.setUsername("tang");
        connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();
        //5 创建队列Queen
        /**参数介绍：
         * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         * queue：队列名称   durable：是否持久化   exclusive是否独占，只能有一个消费者监听队列。         * queue：队列名称   durable：是否持久化   exclusive是否独占，只能有一个消费者监听队列。
         * autoDelete:   当没有consumer时候是否删除队列     arguments：配置的基本参数
         */
        channel.queueDeclare("work_queens",true,false,false,null);
        //6 从消息队列中消费
        /**参数介绍：
         *basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue: 消费的队列名称    autoAck：是否自动消费确认，收到消息确认
         * callback：回调对象
         */
        Consumer consumer = new DefaultConsumer(channel){
            //这是一个回调方法，当收到消息后会自动执行该方法
            /**
             * @param consumerTag ：标识
             * @param envelope： 获取交换机，路由等信息
             * @param properties：配置信息
             * @param body：真是的数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+body);
            }
        };
        channel.basicConsume("work_queens",true,consumer);

        //7 消费者不关闭连接
    }
}

生产者代码如下WorkQueens

package cn.twgfs.rabbitmq.provider;

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

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

/**
 * @author willian
 * @date 2020/10/13 11:27
 */
public class WorkQueens {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
         connectionFactory.setHost("192.168.0.103");//设置注解
         connectionFactory.setPort(5672);//设置端口
         connectionFactory.setVirtualHost("/vm");//设置虚拟及
         connectionFactory.setUsername("tang");
         connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();
        //5 创建队列Queen
        /**参数介绍：
         * queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments)
         * queue：队列名称   durable：是否持久化   exclusive是否独占，只能有一个消费者监听队列。         * queue：队列名称   durable：是否持久化   exclusive是否独占，只能有一个消费者监听队列。
         * autoDelete:   当没有consumer时候是否删除队列     arguments：配置的基本参数
         */
        channel.queueDeclare("workqueen_model",true,false,false,null);
        //6 发送消息到队列
        /**参数介绍：
         * basicPublish(String exchange, String routingKey, boolean mandatory, BasicProperties props, byte[] body)
         *exchange： 交换机的名称，简单模式下交换机会使用默认的    routingKey：路由名称,如果使用默认交换机要和队列名相同
         *props 配置信息    body：真是发送的消息数据
         */
        for (int i = 0; i < 10; i++) {
            String body = i+"hello_rabbitmq 发送消息";
            channel.basicPublish("","workqueen_model",null,body.getBytes());
        }
        //7 释放连接资源
        channel.close();
        connection.close();
    }
}
三.Pub/Sub发布订阅模式代码

生产者类：ProducerPubSub

public class ProducerPubSub {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
         connectionFactory.setHost("192.168.0.103");//设置注解
         connectionFactory.setPort(5672);//设置端口
         connectionFactory.setVirtualHost("/vm");//设置虚拟及
         connectionFactory.setUsername("tang");
         connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //5.创建交换机
        /**参数详细解释
         * exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
         * exchange：交换机名称       type：交换机的类型  DIRECT("direct"),定向  FANOUT("fanout"),扇形   TOPIC("topic"),通配符的方式  HEADERS("headers");参数匹配
         *durable：  是否持久化        autoDelete： 自动删除      internal：内部使用，一般都是false
         *arguments:   参数
         * durable：  是否持久化
         */
        String exchange = "test_exechange";
        channel.exchangeDeclare(exchange, BuiltinExchangeType.FANOUT,true,false,false,null);
        //6.创建两个队列
        String queen1Name = "test_fanout_queen1";
        String queen2Name = "test_fanout_queen2";
        channel.queueDeclare(queen1Name,true,false,false,null);
        channel.queueDeclare(queen2Name,true,false,false,null);
        //7.绑定队列和交换机
        /**参数详解
         * queueBind(String queue, String exchange, String routingKey, Map<String, Object> arguments)
         * queue：队列名称     exchange：交换机名称      routingKey：路由键，绑定规则：如果交换机类型为FANOUT，routingKey设置为”“
         */
        channel.queueBind(queen1Name,exchange,"");
        channel.queueBind(queen2Name,exchange,"");
        //8.发送消息
        String body = "日志记录：方法";
        channel.basicPublish(exchange,"",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();

    }
}

消费者1:PubSubModel1就是将前面的频道更改为现在带有交换机的频道即可

public class PubSubModel1 {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
        connectionFactory.setHost("192.168.0.103");//设置注解
        connectionFactory.setPort(5672);//设置端口
        connectionFactory.setVirtualHost("/vm");//设置虚拟及
        connectionFactory.setUsername("tang");
        connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //6 从消息队列中消费
        /**参数介绍：
         *basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue: 消费的队列名称    autoAck：是否自动消费确认，收到消息确认
         * callback：回调对象
         */
        Consumer consumer = new DefaultConsumer(channel){
            //这是一个回调方法，当收到消息后会自动执行该方法
            /**
             * @param consumerTag ：标识
             * @param envelope： 获取交换机，路由等信息
             * @param properties：配置信息
             * @param body：真是的数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+body);
                System.out.println("将信息打印到控制台");
            }
        };
        String queen1Name = "test_fanout_queen1";
        channel.basicConsume(queen1Name,true,consumer);
        //7 消费者不关闭连接
    }
}

消费者2:PubSubModel2就是将前面的频道更改为现在带有交换机的频道即可

package cn.twgfs.rabbitmq.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author willian
 * @date 2020/10/13 14:17
 */
public class PubSubModel2 {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
        connectionFactory.setHost("192.168.0.103");//设置注解
        connectionFactory.setPort(5672);//设置端口
        connectionFactory.setVirtualHost("/vm");//设置虚拟及
        connectionFactory.setUsername("tang");
        connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //6 从消息队列中消费
        /**参数介绍：
         *basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue: 消费的队列名称    autoAck：是否自动消费确认，收到消息确认
         * callback：回调对象
         */
        Consumer consumer = new DefaultConsumer(channel){
            //这是一个回调方法，当收到消息后会自动执行该方法
            /**
             * @param consumerTag ：标识
             * @param envelope： 获取交换机，路由等信息
             * @param properties：配置信息
             * @param body：真是的数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+body);
                System.out.println("将信息存储到数据库");
            }
        };
        String queen2Name = "test_fanout_queen2";
        channel.basicConsume(queen2Name,true,consumer);
        //7 消费者不关闭连接
    }
}
四.Routing路由模式

生产者

package cn.twgfs.rabbitmq.provider;

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

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

/**
 * @author willian
 * @date 2020/10/13 11:27
 */
public class ProducerRouting {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
         connectionFactory.setHost("192.168.0.103");//设置注解
         connectionFactory.setPort(5672);//设置端口
         connectionFactory.setVirtualHost("/vm");//设置虚拟及
         connectionFactory.setUsername("tang");
         connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //5.创建交换机
        /**参数详细解释
         * exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
         * exchange：交换机名称       type：交换机的类型  DIRECT("direct"),定向  FANOUT("fanout"),扇形   TOPIC("topic"),通配符的方式  HEADERS("headers");参数匹配
         *durable：  是否持久化        autoDelete： 自动删除      internal：内部使用，一般都是false
         *arguments:   参数
         * durable：  是否持久化
         */
        String exchange = "test_direct";
        channel.exchangeDeclare(exchange, BuiltinExchangeType.DIRECT,true,false,false,null);
        //6.创建两个队列
        String queen1Name = "test_direct_queen1";
        String queen2Name = "test_direct_queen2";
        channel.queueDeclare(queen1Name,true,false,false,null);
        channel.queueDeclare(queen2Name,true,false,false,null);
        //7.绑定队列和交换机
        /**参数详解
         * queueBind(String queue, String exchange, String routingKey, Map<String, Object> arguments)
         * queue：队列名称     exchange：交换机名称      routingKey：路由键，绑定规则：如果交换机类型为FANOUT，routingKey设置为”“
         */
        //1.队列1绑定
        channel.queueBind(queen1Name,exchange,"error");
        //2.队列2的三个绑定
        channel.queueBind(queen2Name,exchange,"info");
        channel.queueBind(queen2Name,exchange,"error");
        channel.queueBind(queen2Name,exchange,"warning");
        //8.发送消息，这里需要携带routingkey后面交换机转发的时候才知道发送到那个队列s1就是路由键
        String body = "日志记录：方法";
        channel.basicPublish(exchange,"info",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();

    }
}

消费者1

package cn.twgfs.rabbitmq.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author willian
 * @date 2020/10/13 14:17
 */
public class Routing1 {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
        connectionFactory.setHost("192.168.0.103");//设置注解
        connectionFactory.setPort(5672);//设置端口
        connectionFactory.setVirtualHost("/vm");//设置虚拟及
        connectionFactory.setUsername("tang");
        connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //6 从消息队列中消费
        /**参数介绍：
         *basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue: 消费的队列名称    autoAck：是否自动消费确认，收到消息确认
         * callback：回调对象
         */
        Consumer consumer = new DefaultConsumer(channel){
            //这是一个回调方法，当收到消息后会自动执行该方法
            /**
             * @param consumerTag ：标识
             * @param envelope： 获取交换机，路由等信息
             * @param properties：配置信息
             * @param body：真是的数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+body);
                System.out.println("将信息打印到控制台");
            }
        };
        String queen1Name = "test_direct_queen1";
        channel.basicConsume(queen1Name,true,consumer);
        //7 消费者不关闭连接
    }
}

消费者2

package cn.twgfs.rabbitmq.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author willian
 * @date 2020/10/13 14:17
 */
public class Routing2 {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
        connectionFactory.setHost("192.168.0.103");//设置注解
        connectionFactory.setPort(5672);//设置端口
        connectionFactory.setVirtualHost("/vm");//设置虚拟及
        connectionFactory.setUsername("tang");
        connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //6 从消息队列中消费
        /**参数介绍：
         *basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue: 消费的队列名称    autoAck：是否自动消费确认，收到消息确认
         * callback：回调对象
         */
        Consumer consumer = new DefaultConsumer(channel){
            //这是一个回调方法，当收到消息后会自动执行该方法
            /**
             * @param consumerTag ：标识
             * @param envelope： 获取交换机，路由等信息
             * @param properties：配置信息
             * @param body：真是的数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+body);
                System.out.println("将信息存储到数据库");
            }
        };
        String queen1Name = "test_direct_queen2";
        channel.basicConsume(queen1Name,true,consumer);
        //7 消费者不关闭连接
    }
}
Topic模式

生产者

package cn.twgfs.rabbitmq.provider;

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

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

/**
 * @author willian
 * @date 2020/10/13 11:27
 */
public class ProducerTopic {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
         connectionFactory.setHost("192.168.0.103");//设置注解
         connectionFactory.setPort(5672);//设置端口
         connectionFactory.setVirtualHost("/vm");//设置虚拟及
         connectionFactory.setUsername("tang");
         connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //5.创建交换机
        /**参数详细解释
         * exchangeDeclare(String exchange, String type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
         * exchange：交换机名称       type：交换机的类型  DIRECT("direct"),定向  FANOUT("fanout"),扇形   TOPIC("topic"),通配符的方式  HEADERS("headers");参数匹配
         *durable：  是否持久化        autoDelete： 自动删除      internal：内部使用，一般都是false
         *arguments:   参数
         * durable：  是否持久化
         */
        String exchange = "test_topic";
        channel.exchangeDeclare(exchange, BuiltinExchangeType.TOPIC,true,false,false,null);
        //6.创建两个队列
        String queen1Name = "test_topic_queen1";
        String queen2Name = "test_topic_queen2";
        channel.queueDeclare(queen1Name,true,false,false,null);
        channel.queueDeclare(queen2Name,true,false,false,null);
        //7.绑定队列和交换机
        /**参数详解
         * queueBind(String queue, String exchange, String routingKey, Map<String, Object> arguments)
         * queue：队列名称     exchange：交换机名称      routingKey：路由键，绑定规则：如果交换机类型为FANOUT，routingKey设置为”“
         */

        //routing key由两部分组成 系统名称 日志级别
        //需求：所有error级别存数据库 order级别打印到控制台
        channel.queueBind(queen1Name,exchange,"#.error");
        channel.queueBind(queen1Name,exchange,"order.*");
        channel.queueBind(queen2Name,exchange,"*.*");
        //8.发送消息
        String body = "日志记录：方法";
        channel.basicPublish(exchange,"order.info",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();

    }
}

消费者1

package cn.twgfs.rabbitmq.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author willian
 * @date 2020/10/13 14:17
 */
public class Topic1 {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
        connectionFactory.setHost("192.168.0.103");//设置注解
        connectionFactory.setPort(5672);//设置端口
        connectionFactory.setVirtualHost("/vm");//设置虚拟及
        connectionFactory.setUsername("tang");
        connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //6 从消息队列中消费
        /**参数介绍：
         *basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue: 消费的队列名称    autoAck：是否自动消费确认，收到消息确认
         * callback：回调对象
         */
        Consumer consumer = new DefaultConsumer(channel){
            //这是一个回调方法，当收到消息后会自动执行该方法
            /**
             * @param consumerTag ：标识
             * @param envelope： 获取交换机，路由等信息
             * @param properties：配置信息
             * @param body：真是的数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+body);
                System.out.println("将信息存储到数据库");
            }
        };
        String queen1Name = "test_topic_queen1";
        channel.basicConsume(queen1Name,true,consumer);
        //7 消费者不关闭连接
    }
}

消费者2

package cn.twgfs.rabbitmq.consumer;

import com.rabbitmq.client.*;

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

/**
 * @author willian
 * @date 2020/10/13 14:17
 */
public class Topic2 {

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

        //1 创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //2 设置参数
        connectionFactory.setHost("192.168.0.103");//设置注解
        connectionFactory.setPort(5672);//设置端口
        connectionFactory.setVirtualHost("/vm");//设置虚拟及
        connectionFactory.setUsername("tang");
        connectionFactory.setPassword("123");
        //3 创建连接
        Connection connection = null;
        connection = connectionFactory.newConnection();
        //4 创建channel
        Channel channel = null;
        channel = connection.createChannel();

        //6 从消息队列中消费
        /**参数介绍：
         *basicConsume(String queue, boolean autoAck, Consumer callback)
         * queue: 消费的队列名称    autoAck：是否自动消费确认，收到消息确认
         * callback：回调对象
         */
        Consumer consumer = new DefaultConsumer(channel){
            //这是一个回调方法，当收到消息后会自动执行该方法
            /**
             * @param consumerTag ：标识
             * @param envelope： 获取交换机，路由等信息
             * @param properties：配置信息
             * @param body：真是的数据
             * @throws IOException
             */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("body"+body);
                System.out.println("将信息打印到控制台");
            }
        };
        String queen2Name = "test_topic_queen2";
        channel.basicConsume(queen2Name,true,consumer);
        //7 消费者不关闭连接
    }
}
唐微港
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
RabbitMQ简单测试（JAVA）
xushuai2333333的博客
10-08 1974
RabbitMQ简单测试（JAVA）
RabbitMQ七种工作模式
weixin_40877204的博客
01-04 1623
概念 RabbitMQ的一个消息代理：它接受并转发消息。 你可以把它当成一个邮局：当你想邮寄信件的时候，你会把信件放在投递箱中，并确信邮递员最终会将信件送到收件人的手里。在这个例子中，RabbitMQ就相当于投递箱、邮局和邮递员。 AMQP协议中的核心思想就是生产者和消费者隔离，生产者从不直接将消息发送给队列。生产者通常不知道是否一个消息会被发送到对队列中，只是将消息发送到一个交...
rabbitMq 5种消息模型测试代码
07-18
rabbitMq 5种消息模型测试代码
RabbitMQ 快速入门七种简单模式
Cey_Tao的博客
11-29 1361
RabbitMQ 中有几种概念，分别是：虚拟主机（virtualHost），通道（channel），队列（queue），还有一个交换机（exchanges）的概念在之后会遇到。上面的例子可以看出，大多数代码是重复的，所以 SpringAMQP 中封装了 RabbitTemplate 以便于进行消息队列的操作。服务先与虚拟主机建立连接，然后创建通道，声明或创建队列之后发送或接收消息，消息最终会在队列中传输。如此启动项目时，bean 被创建，就会创建一个队列（若已存在则不再创建）
rabbitMq 简单代码测试，2024年最新软件测试基础入门教程
04-10 886
ApiOperation(value = “测试发送消息”, notes = “测试发送消息”)@ApiOperation(value = “测试获取消息”, notes = “测试获取消息”)return Result.ok(“测试获取消息:”+s1);return Result.ok(“测试发送消息成功！s1 = “消息读取完毕”;//进行交换机和队列的绑定。//ttl队列绑定交换机。
RabbitMQ 七种队列模式应用场景案例分析（通俗易懂）
Java知音
04-06 583
作者：我思知我在blog.csdn.net/qq_32828253/article/details/110450249七种模式介绍与应用场景简单模式（Hello World）做最简单的事情...
Rabbitmq手动应答代码实现与测试
qq_45790384的博客
03-19 1927
rabbitmq作为现在流行的消息队列，它拥有流量削峰、应用解耦、异步处理等优点，使用数量也是较多的。其中重要的特性也就是手动应答避免消息丢失的特点更是使其更上一层楼。消息队列基础的处理流程是：生产者—》队列—》消费者。 rabbitmq的自动应答会导致在消息的分发途中，如果一台消费者角色的服务器宕机了，其处理的消息在自动应答模式下就会丢失，而手动应答则不会，而且退回队列分发给下一个消费者进行处理，有效的规避了因服务器宕机而造成的消息丢失。接下来进行代码演示： 首先我们进行创建一个生产者进行消息的输入： p
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
java实现rabbitMQ 5种工作方式的demo
08-04
代码简洁明了，附带测试类，可以直接运行查看效果，实现了rabbitMq的简单模式、工作模式、路由模式、广播模式、topic模式5种demo，欢迎下载查看，一起学习
RabbitMQ测试fanout.pdf
10-09
这段代码展示了如何使用RabbitMQ进行Fanout模式的发布/订阅。测试过程中，发送一次消息，然后接收10次，每次都在不同的队列中。这样的设计有助于验证Fanout交换器是否能正确地将消息广播到所有绑定的队列。 总结...
RabbitMQ测试代码
03-22
https://blog.csdn.net/HLY1234560/article/details/88734125测试代码
充电桩Saas云平台完整源代码.zip
03-10
技术栈：SpringCloud、MySQL、Redis、RabbitMQ，前后端管理系统（管理后台、小程序），支持互联互通协议、市政协议、一对多方平台支持。支持高并发业务 微信小程序是腾讯公司基于微信平台推出的一种轻量级应用形态...
Spring Boot 整合 RabbitMQ 多数据 测试用例
qq_42697946的博客
05-12 390
大千世界，奇葩需求千千万，为应对开发中可能会遇到到业务场景，需要我们连接多个MQ，因此本篇文章应运而生，希望能得到....
RabbitMq七种工作模式详解，别再说你不会！
weixin_45985053的博客
07-25 615
有一点要注意是在direct下，必须是Exchange（交换机）已经存在，消费端的队列才能绑定到Exchange，否则会报错。也就说上面的程序第一次运行时，需先启Sender，才能成功启动Reciver。
中间件RabbitMQ-了解RabbitMQ七种工作队列模式
Thinkingcao的专栏
04-25 465
RabbitMQ是实现了高级消息队列协议AMQP的开源消息代理软件（亦称面向消息的中间件），主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全，并且RabbitMQ服务器是使用Erlang语言编写的。 支持多种客户端，如：Python、Ruby、.NET、Java、JMS、C、PHP、ActionScript、XMPP、STOMP等，支持AJAX。用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。
RabbitMq五种模式代码案例及使用详解
m0_58709145的博客
10-14 3832
RabbitMQ是一个实现了AMQP（Advanced Message Queuing Protocol）高级消息队列协议的消息队列服务，用Erlang语言。是面向消息的中间件。
rabbitmq测试代码
masuwen博客
08-23 661
import java.io.IOException; import java.util.concurrent.TimeoutException; import com.rabbitmq.client.AMQP; import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; import com.rabbit
RabbitMQ的入门程序test测试代码
苏凯的博客
01-14 1647
RabbitMQ有以下几种工作模式 ： 1、Work queues  工作队列 2、Publish/Subscribe 发布订阅 3、Routing      路由 4、Topics        通配符 5、Header      Header 转发器 6、RPC     远程调用 进入浏览器，输入：http://localhost:15672 初始账号和密码：guest/gue...
RabbitMQ五种工作模式
最新发布
06-02
以下是RabbitMQ的五种工作模式： 1. 简单模式(Simple Mode)：生产者发送消息到队列，消费者从队列中获取消息并处理。 2. 工作队列模式(Work Queue Mode)：多个消费者共享同一个队列，竞争消费队列中的消息。 3. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值