RabbitMQ——实战篇1（原生API）

最新推荐文章于 2024-08-22 22:37:03 发布
最新推荐文章于 2024-08-22 22:37:03 发布
阅读量1.3k 收藏 2
点赞数 1
分类专栏： 架构师-分布式框架 文章标签： rabbitmq java 队列 交换机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouhengzhe/article/details/113599970
版权

实战篇mu目录

其他文章地址

1、RabbitMQ——单机版安装（3.6.5）
2、RabbitMQ——入门篇
3、RabbitMQ——实战篇1（原生API）
4、RabbitMQ——实战篇2（Spring集成）
5、RabbitMQ——实战篇3（Spring集成高级特性：死信队列，消息丢失，延迟队列）
6、RabbitMQ——实战篇4（SpringBoot集成）

RabbitMQ实战

项目地址：https://gitee.com/zhouzhz/rabbitmq
注意：只要是exchange都需要自己在rabbitmq服务端配置，也就是界面上
依赖

<dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.3.0</version>
        </dependency>
        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.5</version>
        </dependency>
         <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
            <optional>true</optional>
        </dependency>
    </dependencies>

公共代码

package com.zhz.utils;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 公共静态变量
 **/
public class RabbitConstant {
    public static final String QUEUE_HELLOWORLD = "helloworld";
    public static final String QUEUE_SMS = "sms";
    public static final String EXCHANGE_WEATHER = "weather";
    public static final String EXCHANGE_WEATHER_ROUTING = "weather_routing";
    public static final String QUEUE_BAIDU = "baidu";
    public static final String QUEUE_SINA = "sina";
    public static final String EXCHANGE_WEATHER_TOPIC = "weather_topic";
}

package com.zhz.utils;

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

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description:公共类
 **/
public class RabbitUtils {
    private static ConnectionFactory connectionFactory = new ConnectionFactory();
    static {
        connectionFactory.setHost("192.168.0.66");
        connectionFactory.setPort(5672);
        connectionFactory.setUsername("zhzmq");
        connectionFactory.setPassword("zhzmq");
        connectionFactory.setVirtualHost("/zhztest");
    }
    public static Connection getConnection(){
        Connection conn = null;
        try {
            conn = connectionFactory.newConnection();
            return conn;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

1、简单模式 HelloWorld

1.1、生成者代码

package com.zhz.helloworld;


import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

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

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 生产者
 **/
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {

        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();

        //创建通信"通道"，相当于TCP中的虚拟连接
        Channel channel = connection.createChannel();

        //创建队列,声明并创建一个队列，如果队列已存在，则使用这个队列
        //第一个参数：队列名称ID
        //第二个参数：是否持久化，false对应不持久化数据，MQ停掉数据就会丢失
        //第三个参数：是否队列私有化，false则代表所有消费者都可以访问，true代表只有第一次拥有它的消费者才能一直使用，其他消费者不让访问
        //第四个：是否自动删除,false代表连接停掉后不自动删除掉这个队列
        //其他额外的参数, null
        channel.queueDeclare(RabbitConstant.QUEUE_HELLOWORLD,false,false,false,null);
        String message="zhz6dsad66";
        //四个参数
        //exchange 交换机，暂时用不到，在后面进行发布订阅时才会用到
        //队列名称
        //额外的设置属性
        //最后一个参数是要传递的消息字节数组
        channel.basicPublish("",RabbitConstant.QUEUE_HELLOWORLD,null,message.getBytes());
        channel.close();
        connection.close();
        System.out.println("======数据发送成功===");
    }
}

1.2、消费者代码

package com.zhz.helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class Consumer {
    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();

        //创建通信"通道"，相当于TCP中的虚拟连接
        Channel channel = connection.createChannel();

        //创建队列,声明并创建一个队列，如果队列已存在，则使用这个队列
        //第一个参数：队列名称ID
        //第二个参数：是否持久化，false对应不持久化数据，MQ停掉数据就会丢失
        //第三个参数：是否队列私有化，false则代表所有消费者都可以访问，true代表只有第一次拥有它的消费者才能一直使用，其他消费者不让访问
        //第四个：是否自动删除,false代表连接停掉后不自动删除掉这个队列
        //其他额外的参数, null
        channel.queueDeclare(RabbitConstant.QUEUE_HELLOWORLD, false, false, false, null);
        //从MQ服务器中获取数据

        //创建一个消息消费者
        //第一个参数：队列名
        //第二个参数代表是否自动确认收到消息，false代表手动编程来确认消息，这是MQ的推荐做法
        //第三个参数要传入DefaultConsumer的实现类
        channel.basicConsume(RabbitConstant.QUEUE_HELLOWORLD, false, new Receiver(channel));
    }
}

package com.zhz.helloworld;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/31
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 
 **/
public class Receiver extends DefaultConsumer {
    private Channel channel;

    /**
     *   重写构造函数,Channel通道对象需要从外层传入，在handleDelivery中要用到
     */
    public Receiver(Channel channel) {
        super(channel);
        this.channel = channel;
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
        String message=new String(body);
        System.out.println("消费者接收到的消息："+message);
        System.out.println("消息的TagId："+envelope.getDeliveryTag());
        //false只确认签收当前的消息，设置为true的时候则代表签收该消费者所有未签收的消息
        channel.basicAck(envelope.getDeliveryTag(),false);
    }
}

2、工作队列模式 Work Queue

2.1、生产者

package com.zhz.workqueue;

import com.google.gson.Gson;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

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

/**
 * @author ：zhz
 * @date ：Created in 2021/01/31
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 发送方（服务端/生产者）
 **/
public class OrderSystem {
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_SMS,false,false,false,null);
        for (int i = 1; i <= 100; i++) {
            Sms sms=new Sms("乘客"+i,"10086"+i,"您的车票已经预定");
            String json = new Gson().toJson(sms);
            channel.basicPublish("",RabbitConstant.QUEUE_SMS,null,json.getBytes());
        }
        System.out.println("发送数据成功");
        channel.close();
        connection.close();
    }
}

2.2、消费者

package com.zhz.workqueue;

import lombok.*;
import lombok.experimental.Accessors;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/31
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 短信实体类
 **/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class Sms {
    private String name;
    private String mobile;
    private String content;
}

package com.zhz.workqueue;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/31
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class SmsSend1 {
    public static void main(String[] args) throws Exception {

        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();


        channel.queueDeclare(RabbitConstant.QUEUE_SMS, false, false, false, null);

        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        //basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的
        channel.basicQos(1);//处理完一个取一个
        channel.basicConsume(RabbitConstant.QUEUE_SMS, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String json = new String(body);
                System.out.println("SMS1-发送短信成功" + json);
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}


package com.zhz.workqueue;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/31
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class SmsSend2 {
    public static void main(String[] args) throws Exception {

        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();


        channel.queueDeclare(RabbitConstant.QUEUE_SMS, false, false, false, null);

        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        //basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的
        channel.basicQos(1);//处理完一个取一个
        channel.basicConsume(RabbitConstant.QUEUE_SMS, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String json = new String(body);
                System.out.println("SMS2-发送短信成功" + json);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}


package com.zhz.workqueue;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/31
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class SmsSend3 {
    public static void main(String[] args) throws Exception {

        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();


        channel.queueDeclare(RabbitConstant.QUEUE_SMS, false, false, false, null);

        //如果不写basicQos（1），则自动MQ会将所有请求平均发送给所有消费者
        //basicQos,MQ不再对消费者一次发送多个请求，而是消费者处理完一个消息后（确认后），在从队列中获取一个新的
        channel.basicQos(1);//处理完一个取一个
        channel.basicConsume(RabbitConstant.QUEUE_SMS, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String json = new String(body);
                System.out.println("SMS3-发送短信成功" + json);
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

3、发布订阅模式 Publish/subscribe

3.1、生产者

package com.zhz.pubsub;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.util.Scanner;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 生产者
 **/
public class WeatherBureau {


    public static void main(String[] args) throws Exception {
        Connection connection = RabbitUtils.getConnection();
        String input = new Scanner(System.in).next();
        Channel channel = connection.createChannel();

        //第一个参数交换机名字   其他参数和之前的一样
        channel.basicPublish(RabbitConstant.EXCHANGE_WEATHER,"" , null , input.getBytes());

        channel.close();
        connection.close();
    }
}

3.2、消费者

package com.zhz.pubsub;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class BiaDu {

    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //获取虚拟连接
        final Channel channel = connection.createChannel();
        //声明队列信息
        channel.queueDeclare(RabbitConstant.QUEUE_BAIDU, false, false, false, null);

        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key（暂时用不到)
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER, "");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_BAIDU , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }

}


package com.zhz.pubsub;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class Sina {

    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //获取虚拟连接
        final Channel channel = connection.createChannel();
        //声明队列信息
        channel.queueDeclare(RabbitConstant.QUEUE_SINA, false, false, false, null);

        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key（暂时用不到)
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER, "");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_SINA , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }

}

4、路由模式 Routing

4.1、生产者

package com.zhz.routing;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 生产者
 **/
public class WeatherBureau {


    public static void main(String[] args) throws Exception {

        Map area = new LinkedHashMap<String, String>();
        area.put("china.hunan.changsha.20201127", "中国湖南长沙20201127天气数据");
        area.put("china.hubei.wuhan.20201127", "中国湖北武汉20201127天气数据");
        area.put("china.hunan.zhuzhou.20201127", "中国湖南株洲20201128天气数据");
        area.put("us.cal.lsj.20201127", "美国加州洛杉矶20201127天气数据");

        area.put("china.hebei.shijiazhuang.20201128", "中国河北石家庄20201128天气数据");
        area.put("china.hubei.wuhan.20201128", "中国湖北武汉20201128天气数据");
        area.put("china.henan.zhengzhou.20201128", "中国河南郑州20201128天气数据");
        area.put("us.cal.lsj.20201128", "美国加州洛杉矶20201128天气数据");


        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        Iterator<Map.Entry<String, String>> itr = area.entrySet().iterator();
        while (itr.hasNext()) {
            Map.Entry<String, String> me = itr.next();
            //第一个参数交换机名字   第二个参数作为 消息的routing key
            channel.basicPublish(RabbitConstant.EXCHANGE_WEATHER_ROUTING,me.getKey() , null , me.getValue().getBytes());

        }

        channel.close();
        connection.close();
    }
}

4.2、消费者

package com.zhz.routing;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class Sina {

    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //获取虚拟连接
        final Channel channel = connection.createChannel();
        //声明队列信息
        channel.queueDeclare(RabbitConstant.QUEUE_SINA, false, false, false, null);

        //指定队列与交换机以及routing key之间的关系
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "us.cal.lsj.20201127");
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.hubei.wuhan.20201127");
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "us.cal.lsj.20201128");
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.henan.zhengzhou.20201128");

        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_SINA , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }

}


package com.zhz.routing;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class BiaDu {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_BAIDU, false, false, false, null);
        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.hunan.changsha.20201127");
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.hebei.shijiazhuang.20201128");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_BAIDU , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("百度天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });

    }

}

5、通配符模式 Topic

5.1、生产者

package com.zhz.topic;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 生产者
 **/
public class WeatherBureau {


    public static void main(String[] args) throws Exception {

        Map area = new LinkedHashMap<String, String>();
        area.put("china.hunan.changsha.20201127", "中国湖南长沙20201127天气数据");
        area.put("china.hubei.wuhan.20201127", "中国湖北武汉20201127天气数据");
        area.put("china.hunan.zhuzhou.20201127", "中国湖南株洲20201127天气数据");
        area.put("us.cal.lsj.20201127", "美国加州洛杉矶20201127天气数据");

        area.put("china.hebei.shijiazhuang.20201128", "中国河北石家庄20201128天气数据");
        area.put("china.hubei.wuhan.20201128", "中国湖北武汉20201128天气数据");
        area.put("china.henan.zhengzhou.20201128", "中国河南郑州20201128天气数据");
        area.put("us.cal.lsj.20201128", "美国加州洛杉矶20201128天气数据");


        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();

        Iterator<Map.Entry<String, String>> itr = area.entrySet().iterator();
        while (itr.hasNext()) {
            Map.Entry<String, String> me = itr.next();
            //第一个参数交换机名字   第二个参数作为 消息的routing key
            channel.basicPublish(RabbitConstant.EXCHANGE_WEATHER_TOPIC,me.getKey() , null , me.getValue().getBytes());

        }

        channel.close();
        connection.close();
    }
}

5.2、消费者

package com.zhz.topic;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class BiaDu {

    public static void main(String[] args) throws IOException {
        Connection connection = RabbitUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_BAIDU, false, false, false, null);
        //queueBind用于将队列与交换机绑定
        //参数1：队列名 参数2：交互机名  参数三：路由key
        channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER_TOPIC, "*.*.*.20201127");
       // channel.queueBind(RabbitConstant.QUEUE_BAIDU, RabbitConstant.EXCHANGE_WEATHER_ROUTING, "china.hebei.shijiazhuang.20201128");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_BAIDU , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("百度天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });

    }

}


package com.zhz.topic;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/01/30
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class Sina {

    public static void main(String[] args) throws IOException {
        //获取TCP长连接
        Connection connection = RabbitUtils.getConnection();
        //获取虚拟连接
        final Channel channel = connection.createChannel();
        //声明队列信息
        channel.queueDeclare(RabbitConstant.QUEUE_SINA, false, false, false, null);

        //指定队列与交换机以及routing key之间的关系
        channel.queueBind(RabbitConstant.QUEUE_SINA, RabbitConstant.EXCHANGE_WEATHER_TOPIC, "us.#");

        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_SINA , false , new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪天气收到气象信息：" + new String(body));
                channel.basicAck(envelope.getDeliveryTag() , false);
            }
        });
    }

}

6、confirm机制

6.1、生产者

package com.zhz.confirm;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * @author ：zhz
 * @date ：Created in 2021/02/03
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 生产者=>不需要关闭，因为要监听
 **/
public class WeatherBureau {
    public static void main(String[] args) throws IOException {
        Map<String, String> area = new LinkedHashMap<>();
        area.put("china.hunan.changsha.20201127", "中国湖南长沙20201127天气数据");
        area.put("china.hubei.wuhan.20201127", "中国湖北武汉20201127天气数据");
        area.put("china.hunan.zhuzhou.20201127", "中国湖南株洲20201127天气数据");
        area.put("us.cal.lsj.20201127", "美国加州洛杉矶20201127天气数据");

        area.put("china.hebei.shijiazhuang.20201128", "中国河北石家庄20201128天气数据");
        area.put("china.hubei.wuhan.20201128", "中国湖北武汉20201128天气数据");
        area.put("china.henan.zhengzhou.20201128", "中国河南郑州20201128天气数据");
        area.put("us.cal.lsj.20201128", "美国加州洛杉矶20201128天气数据");
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();
        //开启confirm监听模式
        channel.confirmSelect();
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long l, boolean b) throws IOException {
                //第二个参数代表接收的数据是否为批量接收,一般不用
                System.out.println("消息已被Broker接收，Tag="+l);
            }

            @Override
            public void handleNack(long l, boolean b) throws IOException {
                System.out.println("消息已被Broker拒收,Tag:" + l);
            }
        });
        channel.addReturnListener(new ReturnCallback() {
            @Override
            public void handle(Return aReturn) {
                System.err.println("===========================");
                System.err.println("Return编码：" + aReturn.getReplyCode() + "-Return描述:" + aReturn.getReplyText());
                System.err.println("交换机:" + aReturn.getExchange() + "-路由key:" + aReturn.getRoutingKey() );
                System.err.println("Return主题：" + new String(aReturn.getBody()));
                System.err.println("===========================");
            }
        });
        Iterator<Map.Entry<String, String>> iterator = area.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry<String, String> map = iterator.next();
            channel.basicPublish(RabbitConstant.EXCHANGE_WEATHER_TOPIC,map.getKey(),true,null,map.getValue().getBytes());
        }
    }
}

6.2、消费者

package com.zhz.confirm;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/02/04
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description: 消费者
 **/
public class Sina {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_SINA,false,false,false,null);
        channel.queueBind(RabbitConstant.QUEUE_SINA,RabbitConstant.EXCHANGE_WEATHER_TOPIC,"us.#");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_SINA,false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("新浪收到的天气预报："+new String(body));
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}


package com.zhz.confirm;

import com.rabbitmq.client.*;
import com.zhz.utils.RabbitConstant;
import com.zhz.utils.RabbitUtils;

import java.io.IOException;

/**
 * @author ：zhz
 * @date ：Created in 2021/02/05
 * @version: V1.0
 * @slogan: 天下风云出我辈，一入代码岁月催
 * @description:
 **/
public class Baidu {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(RabbitConstant.QUEUE_BAIDU,false,false,false,null);
        channel.queueBind(RabbitConstant.QUEUE_BAIDU,RabbitConstant.EXCHANGE_WEATHER_TOPIC,"*.*.*.20201127");
        channel.basicQos(1);
        channel.basicConsume(RabbitConstant.QUEUE_BAIDU,false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("百度收到的天气预报："+new String(body));
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

我是小白弟弟，一个在互联网行业的小白，立志成为一名架构师
https://blog.csdn.net/zhouhengzhe?t=1

zhz小白
关注
专栏目录
Golang微服务实践——用Golang开发一个商品推荐系统
AI天才研究院
08-07 1206
本文将会通过构建一个基于Golang开发的商品推荐系统，深入阐述Golang微服务化开发模式及相关技术方案。我们在本系列教程中，只从工程角度进行讨论，主要关注Golang提供的各种优秀特性及编程模式，以及这些特性和模式如何帮助我们更加高效地开发出可靠、可伸缩、可扩展的微服务应用。因此，读者需要对Go语言有一定了解，对容器、云原生等概念有基本了解。随着互联网的快速发展，网站流量越来越多，用户行为也在不断变化。作为电商网站的忠实用户，每一次交易都意味着一笔交易金额。
rabbitMq实战
02-27
RabbiMQ消息队列的介绍和在各个场景下的使用
RabbitMQ实战
InterceptWall的博客
08-28 2186
解耦：在项目启动之初来预测将来会碰到什么需求是极其困难的。消息中间件在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口，这允许你独立地扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束即可冗余〈存储) 有些情况下，处理数据的过程会失败。消息中间件可以把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。在把 个消息从消息中间件中删除之前，需要你的处理系统明确地指出该消息己经被处理完成，从而确保你的数据被安全地保存直到你使用完毕。...
RabbitMQ 从原理到实战—golang版本
最新发布
小张编程旅途的博客
08-22 1519
RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开发中应用非常广泛。特点：基于AMQP协议来实现。主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。AMQP协议更多用在企业系统内，对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。可靠性：采用一系列机制来确保消息的可靠性，如持久化、传输确认和发布确认等方法。
NET下RabbitMQ实践[实战篇]
weixin_33699914的博客
10-25 124
     之前的文章中，介绍了如何将RabbitMQ以WCF方式进行发布。今天就介绍一下我们产品中如何使用RabbitMQ的！          在Discuz!NT企业版中，提供了对HTTP错误日志的记录功能，这一点对企业版非常重要，另外存储错误日志使用了MongoDB，理由很简单，MongoDB的添加操作飞快，即使数量过亿之后插入速度依旧不减。          在开始正文之前，先说明一下本文...
05-RabbitMQ之原生API使用
qq_39234967的博客
08-11 640
使用RabbitMQ提供的原生客户端API进行交互 一、Maven依赖 二、创建连接以及声明队列 1、首先创建连接，获取Channel 2、声明queue队列 三、Producer根据应用场景发送消息到queue 四、Consumer消费消息 五、关闭连接，释放资源...
Rabbitmq的原生javaAPI讲解
qq_40837310的博客
10-12 474
说明 实际生产中一般是使用springboot封装的Template等组件来操作Rabbitmq的，但是如果了解了原生的API的使用，可以更好的理解Rabbitmq的特性和对springboot封装的组件的使用原理有一定了解。 关键的类 ConnectionFactory 从字面上看是连接工厂的意思，实际上该对象就是一个连接工厂对象，主要用于创建一个连接到Rabbitmq服务器的tcp连接。 基本的方法： ConnectionFactory factory = new ConnectionFactory()
监控之美——Prometheus云原生监控
中生代技术
11-14 2776
朱政科读完需要25分钟速读仅需 3 分钟本文摘自于朱政科撰写的《Prometheus 云原生监控：运维与开发实战》，介绍了监控的概念、监控的分类、MDD 理念、Google 四大黄金指标...
字节跳动3-3力荐，RabbitMQ实战指南：消息队列面试必刷手册
JHIII的博客
08-27 202
RabbitMQ是目前非常热门的一款消息中间件，不管是互联网大厂还是中小企业都在大量使用。作为一名合格的开发者，有必要对RabbitMQ有所了解。以熟悉的电商场景为例，如果商品服务和订单服务是两个不同的微服务，在下单的过程中订单服务需要调用商品服务进行扣库存操作。按照传统的方式，下单过程要等到调用完毕之后才能返回下单成功，如果网络产生波动等原因使得商品服务扣库存延迟或者失败，会带来较差的用户体验，如果在高并发的场景下，这样的处理显然是不合适的，那怎么进行优化呢？这就需要消息队列登场了。...
RabbitMQ
weixin_38380811的博客
03-13 2426
RabbitMQ
云原生Java架构师（KubeSphere实战）中间件部署
DreamsArchitects的博客
11-22 1165
目录一、简介二、部署MySQL创建MySQL配置集（ConfigMap）需要安装nfs-server 配置动态供应的默认存储类（如果已经操作过则略）配置nfs-client（选做）配置动态供应的默认存储类创建存储卷（PVC）创建有状态副本集创建网络三、部署Redis创建配置集创建有状态副本集创建网络四、部署Elasticsearch首先使用Docker方式启动Es创建Es配置集(ConfgiMap)创建有状态副本集五、从应用商店部署RabbitMQ六、从应用仓库部署Zookeeper 一、简介 使用Kube
rabbitMQ实战
10-10
这是牧码人王老师讲的，里面的rabbitMQ下载、安装、六种消息类型都很全，代码我也都试过了，直接复制粘贴就可以使用，希望可以帮助到大家
Rabbit MQ实战
zhj52666的博客
05-13 540
消息队列是一种应用之间的通信方式，消息发送后可以立即返回，由消息系统保证消息的可靠传递。可以用于分布式的削峰限流，通过异步解耦，可以实现分布式事务
rabbitmq实战
农码一生
01-21 196
原理： 消息生产者 -> 交换机 ->消息队列 -> 消息消费者 交换机(Exchanges) 消息队列(Quences) 交换机和消息队列 之间需要绑定 Bind 消息队列发消息给消息消费者，是通过TCP/IP 管道模式发送 创建交换机(Add exchange) name:起一个名字 Type: direct单点模式、 fanout全部发送、 topi...
RabbitMQ实战（一）
qq_34800986的博客
04-07 211
RabbitMQ 是一个消息代理：它接受并转发消息。你可以将其视为邮局：当你将要发布的邮件放在邮箱中时，您可以确信 Postman 先生最终会将邮件发送给收件人。在这个比喻中，RabbitMQ 是一个邮箱，邮局和邮递员。 RabbitMQ 和邮局之间的主要区别在于它不处理纸张，而是接受，存储和转发二进制数据块的消息。
RabbitMQ 实战
GitChat
04-12 1518
作为主流的消息中间件之一，RabbitMQ 广泛应用于互联网行业。本场 Chat，通过深入浅出的分析阐述，期望能够帮助读者获取 RabbitMQ 相关的基础知识，主要包括以下内容： RabbitMQ 基础概念 RabbitMQ 安装 & 管理 实战：RabbitMQ 生产者、消费者、编程模型 确保 RabbitMQ 高可用的基本方法 RabbitMQ 内部原理概述 本场 Chat 适用...
RabbitMQ项目实战：常用API与操作流程解析
该实例深入探讨了RabbitMQ的核心API使用方法，并对操作流程进行了详细注解，使得即使是初学者也能跟随项目实例轻松理解和掌握RabbitMQ的工作原理和使用方法。项目内容涵盖了消息队列的基本概念、RabbitMQ的安装与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhz小白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值