RabbitMQ基础

最新推荐文章于 2023-02-13 14:23:42 发布
最新推荐文章于 2023-02-13 14:23:42 发布
阅读量146 收藏
点赞数
分类专栏： 消息中间件 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40738693/article/details/114942124
版权

1、RabbitMQ

  1. 消息队列解决了什么问题
    • 异步处理
    • 应用解耦
    • 流量削锋
    • 日志处理

运行rabbitmq镜像

# docker run --name rabbitmq -tid -p 5672:5672 -p 15672:15672 -p 25672:25672 rabbitmq

修改rabbitmq设置

# docker exec -it 容器号 /bin/bash
新增用户
# rabbitmqctl add_user [user_name] [pwd]
查看用户
# rabbitmqctl list_users
Setting permissions for user “[user_name]” in vhost “/” …
# rabbitmqctl set_permissions -p "/" [user_name] ".*" ".*" ".*"

# rabbitmqctl list_permissions -p /
将[user_name]用户设置为administrator角色
# rabbitmqctl set_user_tags asdf administrator
删除guest用户
# rabbitmqctl delete_user guest

开启web界面

# rabbitmq-plugins enable rabbitmq_management

web访问

# http://IP:15672

  1. Java操作RabbitMQ

    1. simple 简单队列
    2. work queues 工作队列 公平分发 轮询分发
    3. publish/subscribe 发布订阅
    4. routing 路由选择 通配符模式
    5. Topics 主题
    6. 手动和自动确认消息
    7. 队列的持久化和非持久化
    8. rabbitMQ的延迟队列

    依赖

    <dependencies>
    <!-- 引入队列依赖 -->
    <dependency>
        <groupId>com.rabbitmq</groupId>
        <artifactId>amqp-client</artifactId>
        <version>4.0.2</version>
    </dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.10</version>
</dependency>

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.5</version>
</dependency>

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
</dependency>
    </dependencies>

2、简单队列

Y9U1G6.png

2.2、定义连接MQ的工具

public class connectionUtil {

    public static Connection getConnection() throws IOException, TimeoutException {
        //定义链接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置服务地址[运行rabbitMQ的地址]
        factory.setHost("192.168.168.130");
        //AMQ的端口号
        factory.setPort(5672);
        //vHost
        factory.setVirtualHost("lgz");
        factory.setUsername("lgz");
        factory.setPassword("pwd123456");
        return   factory.newConnection();
    }
}

2.3、生产者发送消息

//测试发送信息
public class ProducerSend {
    private static final String QUEUE_NAME="test_simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        System.out.println("cs");
        //获取链接
        Connection connection = connectionUtil.getConnection();
        //从链接中获取通道
        Channel channel = connection.createChannel();
        //队列声明
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        String msg="hello simple";
         channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
        System.out.println("test success");
         channel.close();
         connection.close();
    }

}

2.4、消费者获取信息

public class comsumerGain {

    private static final String QUE_NAME="test_simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //获取链接
        Connection connection = connectionUtil.getConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //定义消费者
        DefaultConsumer  consumer = new DefaultConsumer(channel) {
            //获取到达的消息
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg = new String(body, "utf-8");
                System.out.println(msg);
            }
        };
        //监听队列
        channel.basicConsume(QUE_NAME,true,consumer);

    }
}

2.5、简单队列的缺点

  1. 耦合性高：生产者一 一对应消费者

3、工作队列

3.1、工作队列模型

Y9U6sg.png

3.2、生产者演示

public class WorkQueue {
    public static  final  String QUEUE_NAME="work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //创建连接
        Connection connection = connectionUtil.getConnection();
        //获取channel链接
        Channel channel = connection.createChannel();
        //
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        for (int i = 0; i <50 ; i++) {
            String msg="No"+i;
            System.out.println(msg);
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            Thread.sleep(i*20);
        }
        channel.close();
        connection.close();


    }
}

3.3、消费者1

public class WorkRecv {
    private final static String QUEUE_NAME="work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取链接
        Connection connection = connectionUtil.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //定义一个消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //消息触发

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");

                System.out.println("receive"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("结束");
                }
            }
        };

        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);

    }

3.4、消费者2

public class WorkRecv {
    private final static String QUEUE_NAME="work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取链接
        Connection connection = connectionUtil.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //定义一个消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //消息触发

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");

                System.out.println("receive"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("结束");
                }
            }
        };

        channel.basicConsume(QUEUE_NAME,true,defaultConsumer);

    }
}

3.5、总结

  1. 采用了轮询算法轮询机制

4、公平分发

4.1、生产者

public class WorkQueue {
    public static  final  String QUEUE_NAME="work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //创建连接
        Connection connection = connectionUtil.getConnection();
        //获取channel链接
        Channel channel = connection.createChannel();
        //
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        /*
        * 每个消费者发送确认消息之前，消息队列不发送下一个消息到消费者。【一次只处理一个消息】
        * */
        int prefetchCount=1;
        channel.basicQos(prefetchCount);


        for (int i = 0; i <50 ; i++) {
            String msg="No"+i;
            System.out.println(msg);
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            Thread.sleep(i*20);
        }
        channel.close();
        connection.close();


    }
}

4.2、消费者1

public class WorkRecv {
    private final static String QUEUE_NAME="work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取链接
        Connection connection = connectionUtil.getConnection();
        //获取channel
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        channel.basicQos(1); //一次只分发一个

        //定义一个消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //消息触发





            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");

                System.out.println("receive"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("结束");

                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);

    }
}

4.2、消费者2

public class WorkReceive {
    private final static String QUEUE_NAME="work_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        //获取链接
        Connection connection = connectionUtil.getConnection();
        //获取channel
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //保证每次只分发一个
        channel.basicQos(1);

        //定义一个消费者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            //消息触发

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");

                System.out.println("receive"+msg);

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("【start】:");

                    //手动回执一个消息
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        channel.basicConsume(QUEUE_NAME,false,defaultConsumer);

    }
}

4.3、疑难问题

  1. basicQos(1);用于限制rabbitMQ一次只分发一个消息
  2. 使用公平分发必须关闭自动应答ack，改成手动的

5、消息应答与消息持久化

5.1、消息应答

  1. boolean autoack=false （手动确认模式），如果有消费者宕机，则会将信息交付给其他的消费者。【rabbitmq支持消息应答，消费者发送一个消息确认，则rabbitmq会进行删除内存数据】
  2. Boolean autoAck=true （自动确认模式），一旦rabbitmq将消息分发给消费者就会从内存中删除

如果这种情况下，杀死正在执行的消费者，就会造成正在处理的信息丢失。

  1. 默认情况下是autoAck是false
  2. 如果rabbitMQ宕机，则服务器数据仍然丢失

5.2、消息持久化

//声明队列
channel.queueDeclare(QUEUE_NAME,[durable]false,false,false,null);
//durable：持久化，
  1. 将程序中的durable的false改称为true，也是不可以的。因为定义的QUEUE_NAME代表这个queue是未持久化的，rabbitmq不准重新定义一个已存在的队列
    • 在控制台【访问mq的界面】进行删除这个队列

6、订阅模式【fanout】

Y9UIzT.png

  1. 一个生产者，多个消费者
  2. 每个消费者都有自己的队列
  3. 生产者将消息发送到交换机【转发器】，而不是直接发送到队列中
  4. 每个队列都绑定在交换机
  5. 生产者发送的消息，经过交换机到达队列【实现一个消息被多个消费者消费】
  • 交换机中无法数据【只有队列具有存储能力】，如果想要进行存储

6.1、生产者

public class Send {
    public static final String EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");//分发

        String msg="hello_exchange";
        channel.basicPublish(EXCHANGE_NAME,"",null,msg.getBytes());
        System.out.println("send:"+msg);

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

6.2、消费者

public class Receive1 {
    public static final String QUEUE_NAME="test_queue_exchange";
    public static final String EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //绑定队列到交换机
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");

        channel.basicQos(1);//保证每次只能分发一个

        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");
                System.out.println("Receive1"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[ok]");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,defaultConsumer);
    }
}

6.3、消费者2

public class Receive2{
    public static final String QUEUE_NAME="email_queue_exchange";
    public static final String EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //绑定队列到交换机
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"");

        channel.basicQos(1);//保证每次只能分发一个

        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");
                System.out.println("Receive2"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[ok2]");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,defaultConsumer);
    }
}

7、Routing【direct】

一方面接收生产者的消息，另一方面向队列发送消息

Fanout（不处理路由键）

Y9U7yF.png

Direct（处理路由键）

7.1、路由模式

Y9ULw9.png

7.2、生产者

public class Send {
    public static final String EXCHANGE_NAME="test_exchange_direct";

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

        //声明交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"direct");

        String msg=new String("Hello direct");

        String routingKey="warning";
        channel.basicPublish(EXCHANGE_NAME,routingKey,null,msg.getBytes());
        System.out.println("send"+msg);

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

7.3、消费者1

public class Receive1 {
    public static final String EXCHANGE_NAME="test_exchange_direct";
    public static final String QUEUE_NAME="queue_direct_1";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        final Channel channel = connection.createChannel();

        //
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        channel.basicQos(1);
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"error");

        //定义一个消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");


                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[done]"+msg);
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;//自动应答false
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}

7.3、消费者2

public class Receive2 {
    public static final String EXCHANGE_NAME="test_exchange_direct";
    public static final String QUEUE_NAME="queue_direct_1";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        final Channel channel = connection.createChannel();

        //
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        channel.basicQos(1);
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"error");
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"warning");
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"info");

        //定义一个消费者
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");


                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[done]"+msg);
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };
        boolean autoAck=false;//自动应答false
        channel.basicConsume(QUEUE_NAME,autoAck,consumer);
    }
}

8、Topics Exchange

类似于sql中的模糊查询，

将路由键routing key和某个模式盘匹配

  1. #匹配一个或者多个
  2. *匹配一个

Y9UOoR.png

8.1、生产者

public class Send {

    private static final String EXCHANGE_NAME="test_exchange_topic";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME,"topic");

        String msg="商品";
        channel.basicPublish(EXCHANGE_NAME,"goods.delete",null,msg.getBytes());
        System.out.println("---send"+msg);


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

}

8.2、消费者1

public class Receive1 {
    public static final String QUEUE_NAME="test_queue_topic_1";
    private static final String EXCHANGE_NAME="test_exchange_topic";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //绑定队列到交换机
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"goods.add");



        channel.basicQos(1);//保证每次只能分发一个

        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");
                System.out.println("Receive1"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[ok]");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,defaultConsumer);
    }
}

8.2、消费者2

public class Receive2 {
    public static final String QUEUE_NAME="test_queue_topic_1=2";
    private static final String EXCHANGE_NAME="test_exchange_topic";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);

        //绑定队列到交换机
        channel.queueBind(QUEUE_NAME,EXCHANGE_NAME,"goods.#");
        channel.basicQos(1);//保证每次只能分发一个

        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                String msg=new String(body,"utf-8");
                System.out.println("Receive1"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    System.out.println("[ok]");
                    channel.basicAck(envelope.getDeliveryTag(),false);
                }
            }
        };

        boolean autoAck=false;
        channel.basicConsume(QUEUE_NAME,autoAck,defaultConsumer);
    }
}

9、消息确认机制

在MQ中可以通过持久化数据解决rabbitmq服务器异常的数据丢失问题

  1. 生产者将消息发送出去以后，如何知道消息到底有没有到达rabbitmq服务器?
    • 方式一：AMQP实现事务机制
    • 方式二：Confirm模式

9.1、事务机制

txSelect ：用户将当前channel设置成transaction模式

txCommit：用于提交事务

txRollback：回滚事务

生产者

public class TxSend {
    private static final String QUEUE_NAME="tx_queue";

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


        Channel channel = connection.createChannel();

        String msg="hello autoCommit";
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);



        try {
            channel.txSelect();
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
            channel.txCommit();
            int i=1/0;
            System.out.println(msg);
        } catch (IOException e) {
            channel.txRollback();
            System.out.println("error");
            e.printStackTrace();
        }

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

消费者

public class TxReceive1 {
    private static final String QUEUE_NAME="tx_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

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

        channel.basicConsume(QUEUE_NAME,true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                super.handleDelivery(consumerTag, envelope, properties, body);
                System.out.println("receive"+new String(body,"utf-8"));
            }
        });

    }
}

9.2、生产者Confirm模式

9.2.1、发送单条

public class Send1 {
    private static final String QUEUE_NAME="tx_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {

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

        //设置为confirm模式
        channel.confirmSelect();

        String msg="confirm_text";

        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());

        if (!channel.waitForConfirms()){
            System.out.println("send message failed");
        }else {
            System.out.println("success");
        }
        channel.close();
        connection.close();
    }
}

9.2.2、批量发送

public class SendMore {
    private static final String QUEUE_NAME="confirm_queue";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {

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

        //设置为confirm模式
        channel.confirmSelect();

        String msg="confirm_text";

        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
		//主要进行遍历发送，串行的【发送完之后在进行确认】
        for (int i = 0; i <10 ; i++) {
            channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
        }
        if (!channel.waitForConfirms()){
            System.out.println("send message failed");
        }else {
            System.out.println("success");
        }
        channel.close();
        connection.close();
    }
}

9.3、异步模式

10、参数详解

10.1、queueDeclare

//绑定channel与消息队列
//参数一:队列名称【如果不存在该队列，则自动创建】
//参数二:durable【是否要进行持久化】
//参数三:exclusive【是否独占队列】
//参数四:是否在消费完成之后是否要立即删除队列【true：自动删除】【false：不自动删除】
//参数五：额外参数
channel.QueueDeclare(name, durable, autoDelete, exclusive, noWait, args);

channel.queueDeclare("helloWorld",false,false,false,null);

10.2、basicPublish

//发布消息
/*
* 参数1:【exchange】交换机名称
* 参数2：【routingKey】队列名称
* 参数3：【props】传递消息的额外设置
* 参数4：传递消息的具体内容【byte类型】
*
* */
channel.basicPublish("","helloWorld",null,"hello rabbitMQ".getBytes());

10.3、basicConsume

//消费信息
/*
 * 参数一:队列名称
 * 参数二：开启消息的自动确认机制
 * 参数三：消费时的回调接口
 * */
channel.basicConsume("helloWorld",true,consumer);

11、整合Boot

11.1、依赖导入

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-amqp</artifactId>
     <version>2.2.6.RELEASE</version>
</dependency>

11.2、yml

spring:
  application:
    name: rabbit-springboot
  rabbitmq:
    host: 192.168.168.130
    port: 5672
    virtual-host: /
    username: lgz
    password: pwd123456

11.3boottest

@Autowired
private RabbitTemplate rabbitTemplate;

@Test
void contextLoads() {

    rabbitTemplate.convertAndSend("hello","helloWorld");
    System.out.println(1);
}

11.4、

@SpringBootTest
class BootRabbitmqApplicationTests {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void contextLoads() {

        rabbitTemplate.convertAndSend("hello","helloWorld");
        System.out.println(1);
    }



    @Test
    public void testWork(){
        for (int i = 0; i <5 ; i++) {
            rabbitTemplate.convertAndSend("work","work模型");

        }
    }

    @Test
    public void testFanout(){
        rabbitTemplate.convertAndSend("logs","","Fanout model");
    }


    @Test
    public void testRouting(){
        rabbitTemplate.convertAndSend("directs","info","info_key_routing_information");
    }


    @Test
    public  void  testTopic(){
        rabbitTemplate.convertAndSend("topics","user.save","user.save exchange");
    }
}

11.5、测试topic[消费者]

@RabbitListener(bindings = {
        @QueueBinding(
                value = @Queue,
                exchange = @Exchange(type = "topic",name = "topics"),
                key = {"product.save","product.*"}
        )
})
public  void  receive(String msg){

    System.out.println("consumer1"+msg);
}

@RabbitListener(bindings = {
        @QueueBinding(
                value = @Queue,
                exchange = @Exchange(type = "topic",name = "topics"),
                key = {"user.save","user.*"}
        )
})
public  void  receive2(String msg){

    System.out.println("consumer2"+msg);
}

11.5、测试routing

@RabbitListener(bindings = {
        @QueueBinding(
                value = @Queue,
                exchange = @Exchange(value = "directs",type = "direct"),
                key = {"info","error"}
        )
})
public void receive1(String msg){
    System.out.println(msg);
}

11.6、普通的work

@RabbitListener(queuesToDeclare = @Queue("work"))
public void receive(String message){
    System.out.println("message:["+message+"]");
}

11.7、Fanout模式

@RabbitListener(bindings = {
        @QueueBinding(
                value = @Queue, //创建临时队列
                exchange =@Exchange(value = "logs", type = "fanout")    //绑定的交换机
        )
})
public void receive1(String msg){

    System.out.println("["+msg+"]");
}

11.8、Simple

@Component
@RabbitListener(queuesToDeclare = @Queue("hello"))
public class Hello {
    @RabbitHandler
    public void receive1(String message){
        System.out.println("message"+message);
    }
}
榴莲味的猕猴桃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Rabbitmq 基础
weixin_43571751的博客
08-30 173
Rabbitmq 消息队列 MQ（Message Queue）即消息队列，是一种应用程序间的通信方法。 MQ是生产者—消费者模式的一个典型代表，一端往消息队列中写入数据，另一端从消息队列中读取消息。 生产者—消费者模式 生产者—消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。 生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理
RabbitMQ基础讲解
kevin_1027的博客
02-28 82
RabbitMQ简介 AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。 RabbitMQ是一个开源的AMQP实现，服务器端用Erla...
RabbitMQ手册之rabbitmqctl
进击的豌豆的博客
01-28 3934
RabbitMQ手册之rabbitmqctl
rabbitmq常用命令
单的格子
11-08 1221
启动方式1 systemctl start rabbitmq-server 启动方式2 rabbitmq-server -detached 集群模式启动 rabbitmqctl start_app 开启web管理插件 rabbitmq-plugins enable rabbitmq_management 查看集群 rabbitmqctl cluster_status 查看所有用户 rabbitmqctl list_users 添加一个新用户 rabbitmq
rabbitmq 安装以及一些常用命令（非容器）并修复rabbitmq的AMQP漏洞
weixin_44646065的博客
12-21 2149
** 由于容器安装的mq配置文件挂载不进去处理不了AMQP漏洞，故采用以下的方式本文仅提供单机的rabbitmq的安装和漏洞的修复配置 ** 1.安装rabbitMQ 由于RabbitMQ依赖Erlang， 所以在安装rabbitMQ之前需要先安装Erlang 你可以直接执行yum install erlang，但是这种安装方法安装的Erlang版本可能不是最新的，有时候不能满足RabbitMQ需要的最低版本，所以本文推荐使用Erlang Solution安装的方式。 新建一个erlang-solution
RabbitMQ用户增删及权限控制
chuanyuzi4979的博客
12-12 521
RabbitMQ用户增删及权限控制 用户角色分类 none：无法登录控制台 不能访问 management plugin，通常就是普通的生产者和消费者。 management：普通管理者。 仅可登陆管理控制台(启用management plugin的情况下)，无法看到节点信息，也无法...
RabbitMQ学习笔记：虚拟主机（Virtual Hosts）
热门推荐
OceanSky的专栏
10-26 1万+
简介 RabbitMQ是一个多租户系统，connetions、exchange、queues、bindings、user permissions、policies和其它一些属于虚拟主机的东西； Virtual vhost 虚拟主机（vhost）提供逻辑分组和资源分离。每一个vhost本质上是一个mini版的RabbitMQ服务器，拥有自己的connection、exchange、queue、bin...
rabbitmq基础入门
04-01
RabbitMQ基础入门主要涵盖了MQ的基本概念、使用MQ的原因、MQ的分类以及RabbitMQ的详细知识。MQ，即Message Queue，是一种基于FIFO（先进先出）原则的消息队列服务，用于不同进程间的通信，尤其在互联网架构中，它起...
rabbitmq基础+springboot集成rabbitmq
10-14
**RabbitMQ基础** RabbitMQ是一个开源的消息代理和队列服务器，用于在分布式系统中进行消息传递。它是基于AMQP（Advanced Message Queuing Protocol）协议实现的，提供了高可用性、可扩展性和稳定性。RabbitMQ的...
RabbitMq 基础知识.docx
05-25
以下是对RabbitMQ基础知识的详细解释： 1. **消息持久化** - 消息持久化是确保即使RabbitMQ服务重启，消息也不会丢失的关键特性。这包括交换机(exchange)、队列(queue)和消息(message)的持久化。 - 在声明交换机...
RabbitMQ基础.pptx
01-10
RabbitMQ是一款广泛使用的开源消息队列系统，基于Erlang语言开发，支持多种协议，如AMQP、XMPP、SMTP和STOMP等。由于其稳定性和丰富的功能，RabbitMQ在很多场景下被选作消息中间件。 **常见MQ产品比较** 除了...
rabbitmq基础介绍.pptx
03-03
RabbitMQ是一个开源的消息代理系统，它基于AMQP（Advanced Message Queuing Protocol）协议，用于在分布式系统中实现可靠的消息传递。RabbitMQ的核心功能是作为消息中间件，它允许不同应用之间通过消息进行通信，...
RabbitMQ基础教程
04-19
可以让你从基础到巅峰的RabbMQ的成长之路
SpringBoot整合RabbitMQ基础学习Exchange源码
03-03
在本文中，我们将深入探讨如何在SpringBoot应用中整合RabbitMQ，并重点解析Exchange的相关源码。RabbitMQ是一款开源的消息代理和队列服务器，它使用AMQP（Advanced Message Queuing Protocol）协议，广泛应用于...
rabbitMQ的基础
最新发布
07-20
rabbitMQ的基础
Rabbitmq项目遇到的问题记录
boyjqk的博客
02-13 348
在改为上述方式之后，连接数不会暴涨了，程序也运行正常了，我以为也就这样了，其实当消息过多，同时消费者处理能力不足的时候，弊端也就显现出来了，这也是我们当前线上出现的一个非常隐晦的问题，我的服务器是当收到一条消息之后就会给客户端回执一条消息，当消息队列消息过多，我想提高消费者处理消息的速度，于是我给消费这增加了处理消息的线程大概在十个线程那增加线程消费的处理能力是高了，于此同时回执消息也增加了，但是紧接着程序就报错了显示 mq连接失败。VirtualHost = "/", // 虚拟主机。
linux下安装Rabbitmq消息中间件
感冒石头的博客
12-24 1715
1.安装erlang环境 以root身份执行下面命令 yum install erlang yum install erlang xmlto 2.安装epel源(补充完善需要erlang的环境) rpm -ivh http://download.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm wget -O
rabbitmq建立通道时发生错误
tinysakura的博客
09-11 5755
具体错误码 Channel shutdown: channel error; protocol method: #method&lt;channel.close&gt;(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80) 排查了一下发现是我在r...
RabbitMq报错解决
有一颗前端心的后端开发小哥
04-02 5795
RabbitMq报错解决错误一：java远程连接rabbitMQ服务报错com.rabbitmq.client.ShutdownSignalException: connection error错误二：ShutdownSignalException:channel error； protocol method 最近想搭建mq服务器，自己玩一下，结果惨不忍睹，在此记录下出现的问题以及解决方案。❥(^_-) 本篇博文参考大佬，链接如下： https://www.freesion.com/article/3977
RabbitMQ基础教程-中文版
"这篇教程是RabbitMQ开发的中文翻译，主要针对初学者，涵盖了从基础的`HelloWorld`示例到更高级的概念，如工作队列、发布/订阅、路由以及Topics类型交换机和远程过程调用(RPC)。教程以Java语言为例，讲解如何使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值