RabbitMQ3-RabbitMQ消息类型

最新推荐文章于 2024-09-11 11:58:04 发布
最新推荐文章于 2024-09-11 11:58:04 发布
阅读量5.8k 收藏 4
点赞数 2
分类专栏： 总结 OPEN 文章标签： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bobshute/article/details/80386916
版权
总结 同时被 2 个专栏收录
88 篇文章 0 订阅
订阅专栏
OPEN
11 篇文章 0 订阅
订阅专栏

1.1 概述

http://www.rabbitmq.com/getstarted.html

1.2 simplest(简单队列)

1.2.1.概述

The simplest thing that does something
- 简单队列 生产消费一一对应,耦合性高.
- 生产消息快,消费消息慢.如果很多容易堵塞

simplest
P:消息生产者;红色的:队列;C:消费者.

1.2.2 示例

pom.xml

<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>

     <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit</artifactId>
        <version>1.7.5.RELEASE</version>
    </dependency>

</dependencies>
rabbitmq.util

public class ConnectionUtils {
    /**
     * 获取MQ的连接  
     * @return
     * @throws TimeoutException 
     * @throws IOException 
     */
    public static Connection  getConnection() throws IOException, TimeoutException{
        //定义一个连接工厂
        ConnectionFactory factory =new ConnectionFactory();

        //设置服务地址
        factory.setHost("127.0.0.1");

        //AMQP 5672
        factory.setPort(5672);

        //vhost 
        factory.setVirtualHost("/vhost_bobshute");

        //用户名 
        factory.setUsername("bobshute");

        //密码
        factory.setPassword("123456");
        return factory.newConnection();
    }

}

rabbitmq.simple

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

        //获取一个连接
        Connection connection = ConnectionUtils.getConnection();

        //从连接中获取一个通道
        Channel channel = connection.createChannel();
        //创建队列声明 
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String msg="hello simple !";

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

        System.out.println("--send msg:"+msg);

        channel.close();
        connection.close();
    }
}
public class Recv {

    private static final String QUEUE_NAME = "test_simple_queue";

    @SuppressWarnings("deprecation")
    public static void main(String[] args) throws IOException,
            TimeoutException, ShutdownSignalException,
            ConsumerCancelledException, InterruptedException {

        // 获取连接
        Connection connection = ConnectionUtils.getConnection();
        // 创建频道
        Channel channel = connection.createChannel();

        //队列声明  
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //定义消费者
        DefaultConsumer consumer = new DefaultConsumer(channel){
            //获取到达消息
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("new api recv:"+msg);
            }
        };

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

    private static void oldapiu() throws IOException, TimeoutException,
            InterruptedException {
        // 获取连接
        Connection connection = ConnectionUtils.getConnection();

        // 创建频道
        Channel channel = connection.createChannel();
        // 定义队列的消费者
        QueueingConsumer consumer = new QueueingConsumer(channel);
        // 监听队列
        channel.basicConsume(QUEUE_NAME, true, consumer);
        while (true) {
            Delivery delivery = consumer.nextDelivery();
            String msgString = new String(delivery.getBody());
            System.out.println("[recv] msg:" + msgString);
        }
    }
}

1.3 Work queues(工作队列)

1.3.1 概述

Work queues

生产消息快,消费消息慢. work queues支持多个消费者.

  • 公平分发. 手动返回结果 backQos 受到结果响应才下一条.

1.3.2 Work queues(轮询分发)

rabbitmq.work

public class Send {

    /*                  |---C1
     *   P-----Queue----|
     *  `               |---C2
     * 
     */

    private static final String  QUEUE_NAME="test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();

        //获取channel
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        for (int i = 0; i <50; i++) {

            String msg="hello "+i;
            System.out.println("[WQ ]send:"+msg);
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());

            Thread.sleep(i*20);
        }

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

}



public class Recv1 {
    private static final String  QUEUE_NAME="test_work_queue";

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

        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[1] Recv msg:"+msg);

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    System.out.println("[1] done ");
                }
            }
        };

        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }

}


public class Recv2 {
    private static final String  QUEUE_NAME="test_work_queue";

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

        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取channel
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[2] Recv msg:"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    System.out.println("[2] done ");
                }
            }
        };

        boolean autoAck=true;
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }

}

1.3.3 Work queues(轮询分发)总结

接受消息的逻辑是一样的,支持处理时间不一样,会发现这种模式不管消费的时间,每个消费端各接受一次.

这种方式叫Round-robin（轮询分发)

  • 消费者接受消息个数一样的,每个接受一次.如50条消息.2个消费,那就一个接受奇数,一个接受偶书. 如果3个消费者,那就模3,每个消费端接受个数一样多.

1.3.4 Fair dispatch（公平分发）

rabbitmq.workfair


public class Send {

    /*                  |---C1
     *   P-----Queue----|
     *  `               |---C2
     * 
     */

    private static final String  QUEUE_NAME="test_work_queue";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //获取连接
        Connection connection = ConnectionUtils.getConnection();

        //获取channel
        Channel channel = connection.createChannel();

        //声明队列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        /**
         * 每个消费者 发送确认消息之前,消息队列不发送下一个消息到消费者,一次只处理一个消息
         * 
         * 限制发送给同一个消费者 不得超过一条消息
         */
        int prefetchCount=1;
        channel.basicQos(prefetchCount);        //Fair dispatch 注意点



        for (int i = 0; i <50; i++) {

            String msg="hello "+i;
            System.out.println("[WQ ]send:"+msg);
            channel.basicPublish("", QUEUE_NAME, null, msg.getBytes());

            Thread.sleep(i*5);
        }

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

}



public class Recv1 {
    private static final String  QUEUE_NAME="test_work_queue";

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

        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取channel
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        channel.basicQos(1);//保证一次只分发一个     //Fair dispatch 注意点

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[1] Recv msg:"+msg);

                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    System.out.println("[1] done ");

                    channel.basicAck(envelope.getDeliveryTag(), false); //手动回执 Fair dispatch 注意点
                }
            }
        };

        boolean autoAck=false;//自动应答 false  //Fair dispatch 注意点
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }

}


public class Recv2 {
    private static final String  QUEUE_NAME="test_work_queue";

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

        //获取连接
        Connection connection = ConnectionUtils.getConnection();
        //获取channel
        final Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.basicQos(1);//保证一次只分发一个  //Fair dispatch 注意点


        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[2] Recv msg:"+msg);

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally{
                    System.out.println("[2] done ");

                    channel.basicAck(envelope.getDeliveryTag(), false); //手动回执 Fair dispatch 注意点
                }
            }
        };

        boolean autoAck=false;//Fair dispatch 注意点
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }

}

1.3.5 Fair dispatch(公平分发) 总结

  • 现象:处理快的接收消息多,处理慢的接受消息少
  • 原理:一次发送一条,不自动应答,自动应答,收到应答后就发送新消息
  • 代码区别处
//channel注意出,消费和接受都写
channel.basicQos(1);//保证一次只分发一个  //Fair dispatch 注意点

//消费端注意
channel.basicAck(envelope.getDeliveryTag(), false); // 手动回执 Fair dispatch 注意点

boolean autoAck=false;//自动应答 false  //Fair dispatch 注意点
channel.basicConsume(QUEUE_NAME,autoAck , consumer);

1.4 Publish/Subscribe

1.4.1 概述

PublishSubscribe

  • 生产者不是直接把消费发送到队列,而是发到了Exchange(交换机,转发器)
  • 生产者发送的消息,经过交换机,到达队列,然后实现一个队列被多个消费者消费.
  • 每一个消费者都有自己的队列
  • 每个队列都要绑到交换机上

  • 一个生产者,多个消费者消费同样的消息

  • 应用场景
    比如一个消息又要发到短信,又要发到邮件.

  • exchange type(exchange类型) : fanout(分发)

  • 启动时需要先启动消费端

1.4.2 示例

rabbitmq.ps

public class Send {

    private static final String  EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = ConnectionUtils.getConnection();

        Channel channel = connection.createChannel();

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

        //发送消息
        String msg="hello ps";

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

        System.out.println("Send :"+msg);

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



public class Recv1 {

    private static final String QUEUE_NAME="test_queue_fanout_email";
    private static final String  EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        final Channel channel = connection.createChannel();

        //队列声明
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

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


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

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[1] Recv msg:"+msg);

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

        boolean autoAck=false;//自动应答 false
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }
}



public class Recv2 {

    private static final String QUEUE_NAME="test_queue_fanout_sms";
    private static final String  EXCHANGE_NAME="test_exchange_fanout";
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        final Channel channel = connection.createChannel();

        //队列声明
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

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

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[2] Recv msg:"+msg);

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

        boolean autoAck=false;//自动应答 false
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }
}

1.5 Routing

1.5.1 概述

Routing

* 匹配1个
# 匹配一个或多个

1.5.2 示例

packagerabbitmq.routing;

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

import com.mmr.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class Send {

    private static final String EXCHANGE_NAME="test_exchange_direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        //exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "direct");

        String  msg="hello direct!";

        String routingKey="info";
        channel.basicPublish(EXCHANGE_NAME, routingKey, null, msg.getBytes());

        System.out.println("send "+msg);
        channel.close();
        connection.close();
    }
}




public class Recv1 {
    private static final String EXCHANGE_NAME = "test_exchange_direct";
    private static final String QUEUE_NAME = "test_queue_direct_1";

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

        Connection connection = ConnectionUtils.getConnection();
        final Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "error");
        channel.basicQos(1);

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[1] Recv msg:"+msg);

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

        boolean autoAck=false;//自动应答 false
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }
}




public class Recv2 {
    private static final String EXCHANGE_NAME = "test_exchange_direct";
    private static final String QUEUE_NAME = "test_queue_direct_2";

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

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

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);

        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "error");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "info");
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "warning");

        channel.basicQos(1);

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[2] Recv msg:"+msg);

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

1.6 Topics

1.6.1 概述

Topics

1.6.2 示例

package rabbitmq.topic;

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

import com.mmr.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

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


        Connection connection = ConnectionUtils.getConnection();

        Channel channel = connection.createChannel();

        //exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "topic");//topic注意

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

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



public class Recv1 {
    private static final String EXCHANGE_NAME = "test_exchange_topic";
    private static final String QUEUE_NAME = "test_queue_topic_1";

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

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

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "goods.add"); //topic注意
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "goods.update");//topic注意

        channel.basicQos(1);

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[1] Recv msg:"+msg);

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

        boolean autoAck=false;//自动应答 false
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }

}



public class Recv2 {
    private static final String EXCHANGE_NAME = "test_exchange_topic";
    private static final String QUEUE_NAME = "test_queue_topic_2";

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

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

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, "goods.#");//topic注意

        channel.basicQos(1);

        //定义一个消费者
        Consumer consumer=new DefaultConsumer(channel){
            //消息到达 触发这个方法
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {

                String msg=new String(body,"utf-8");
                System.out.println("[2] Recv msg:"+msg);

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

        boolean autoAck=false;//自动应答 false
        channel.basicConsume(QUEUE_NAME,autoAck , consumer);
    }
}

1.7 RPC

RPC

1.8 重要源码分析

public class ConnectionFactory implements Cloneable {

     public Connection newConnection() throws IOException, TimeoutException {
        return newConnection(this.sharedExecutor, Collections.singletonList(new Address(getHost(), getPort())));
    }

}



public interface Channel extends ShutdownNotifier {

    Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                 Map<String, Object> arguments) throws IOException;


    void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body) throws IOException;        

    void basicQos(int prefetchCount) throws IOException;


    Exchange.DeclareOk exchangeDeclare(String exchange, String type) throws IOException;


}

1.9 常用API

1.9.1 autoAck及basicAck (自动应答及手工回执)

channel中

//自动应答 ture,如果消息分发给消费者就从内存中删除,这种如果杀死正在处理的消费者,那么数据就丢了,默认为true
boolean autoAck=true;                  
//自动应答 false,需要手动回执确认收到消息,如果没有收到回执,则会再发送给其它消费者
boolean autoAck=false;                 
channel.basicConsume(QUEUE_NAME,autoAck , consumer);//设置是否自动应答
//ack Message acknowledgment

//消费时
channel.basicAck(envelope.getDeliveryTag(), false); // 手动回执

1.9.2 durable(消息持久化)

//申明队列是时 
Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
                                 Map<String, Object> arguments) throws IOException;

1.9.3 exchange type(exchange类型)

    • fanout 分发
      Routing-type-fanout

    不处理,直接转发.

    • direct 处理
      Routing-type-direct
    • topic 模糊匹配,归类
      Routing-type-topic

* 匹配1个
# 匹配一个或多个

1.9.4 tx(事务)

能够进行事务管理,但是由于是同步的, 会降低吞吐量. 

package com.mmr.rabbitmq.tx;

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

import com.mmr.rabbitmq.util.ConnectionUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

public class TxSend {

    private static final String QUEUE_NAME="test_queue_tx";

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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        String msgString="hello tx message!";

        try {
            channel.txSelect();     //事务注意
            channel.basicPublish("", QUEUE_NAME, null,msgString.getBytes());
            int xx=1/0;
            System.out.println("send "+msgString);
            channel.txCommit(); //事务注意
        } catch (Exception e) {
            channel.txRollback();//事务注意
            System.out.println(" send message txRollback");
        }

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



public class TxRecv {

    private static final String QUEUE_NAME="test_queue_tx";


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

        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        channel.basicConsume(QUEUE_NAME, true,new DefaultConsumer(channel){

            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {
                System.out.println("recv[tx] msg:"+new String(body,"utf-8"));
            }
        });
    }

}

1.9.5 confirm(确认模式)

public class Recv {

    private static final String QUEUE_NAME="test_queue_confirm3";

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        channel.basicConsume(QUEUE_NAME, true,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                    BasicProperties properties, byte[] body) throws IOException {
                System.out.println("recv[confirm] msg:"+new String(body,"utf-8"));
            }
        });
    }

}


/**
 *普通模式,发一条(同步)
 */
public class Send1 {
    private static final String QUEUE_NAME="test_queue_confirm1";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {

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

        //生产者调用confirmSelect 将channel设置为confirm模式 注意
        channel.confirmSelect();        //confirm注意

        String msgString="hello confirm message!";
        channel.basicPublish("", QUEUE_NAME, null,msgString.getBytes());

        if(!channel.waitForConfirms()){ //confirm注意
            System.out.println("message send failed");
        }else {
            System.out.println("message send ok");
        }

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





/**
 *普通模式-发批量(同步)
 */
public class Send2 {
    private static final String QUEUE_NAME="test_queue_confirm1";

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

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

        //生产者调用confirmSelect 将channel设置为confirm模式 注意
        channel.confirmSelect(); //confirm注意

        String msgString="hello confirm message batch!";
        //批量发送
        for (int i = 0; i < 10; i++) {
            channel.basicPublish("", QUEUE_NAME, null,msgString.getBytes());
        }

        //确认
        if(!channel.waitForConfirms()){
            System.out.println("message send failed");
        }else {
            System.out.println("message send ok");
        }

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




/**
 * 确认模式-异步模式
 */
public class Send3 {
    private static final String QUEUE_NAME="test_queue_confirm3";

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

        //生产者调用confirmSelect 将channel设置为confirm模式 注意
        channel.confirmSelect();//confirm注意

        //未确认的消息标识 
        final SortedSet<Long> confirmSet=Collections.synchronizedSortedSet(new TreeSet<Long>());

        //通道添加监听
        channel.addConfirmListener(new ConfirmListener() {

            //没有问题的handleAck,成功的调这里.
            public void handleAck(long deliveryTag, boolean multiple)
                    throws IOException {
                if(multiple){//多条
                    System.out.println("----handleAck----multiple");
                    confirmSet.headSet(deliveryTag+1).clear();  //headSet是返回此有序集合中小于(deliveryTag+1)的所有元素,clear是并清除
                }else{//单条
                    System.out.println("----handleAck-----multiple false");
                    confirmSet.remove(deliveryTag);
                }
            }

            //handleNack,失败的调这里.
            public void handleNack(long deliveryTag, boolean multiple)
                    throws IOException {
                if(multiple){//多条
                    System.out.println("---handleNack------multiple");
                    confirmSet.headSet(deliveryTag+1).clear();//headSet是返回此有序集合中小于(deliveryTag+1)的所有元素,clear是并清除
                }else{//单条
                    System.out.println("--handleNack-------multiple false");
                    confirmSet.remove(deliveryTag);
                }
            }
        });

        String msgStr="ssssss";

        while(true){
            long seqNo = channel.getNextPublishSeqNo();//消息编号,序列
            channel.basicPublish("", QUEUE_NAME, null, msgStr.getBytes());
            confirmSet.add(seqNo);      //边发,边存.
        }

    }

}

1.10 注意

  • 已经申明过的队列,不能修改队列属性(rabbitmq不允许用不同参数重新定义的已存在的队列)

注:根据牧马人老王整理.

bobshute
关注
专栏目录
rabbitMQ五种消息模型
weixin_45099622的博客
08-06 4378
rabbitMQ提供了6种消息模型，但是第六种其实是RPC(远程过程调用)，并不是MQ，所以是5种模式。 其中5种消息模型分为两类： 第一种和第二种是点对点 第三，四，五种是一对多，都属于订阅模型，只不过是进行路由的方式不同。 第六种RPC远程调用也可不算做模式 本文参照网站：https://www.rabbitmq.com/getstarted.html 一，一对一简单模式 概念 生产者将消息发送到“ hello”队列。使用者从该队列接收消息。 图解 “ P”是我们的生产者 “
RabbitMQ五种消息类型
weixin_35787722的博客
05-08 5064
大体分为两类：1和2属于点对点；3、4、5属于发布订阅模式（一对多） 点对点模式：P2P（point to point）模式包含三个角色： 消息队列（queue），发送者（sender），接收者（receiver） 每个消息发送到一个特定的队列中，接收者从中获得消息 队列中保留这些消息，直到他们被消费或超时 特点： 1. 每个消息只有一个消费者，一旦消费，消息就不在队列中了 2. 发送者和接收者之间没有依赖性，发送者发送完成，不管接收者是否运行，都不会影响 消息发送到队列中（我给你发微信，不
RabbitMQ的五种消息模型
qq_39095899的博客
10-09 1279
RabbitMQ的五种消息模型 RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，那么也就剩下5种。但是其实3、4、5这三种都属于订阅模型，只不过进行路由的方式不同。 基本消息模型 RabbitMQ是一个消息代理：它接受和转发消息。 你可以把它想象成一个邮局：当你把邮件放在邮箱里时，你可以确定邮差先生最终会把邮件发送给你的收件人。 在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。 生产者，一个发送消息的用户应用程序。 消费者，消费和接收有类似的意思，消费者是一个主要用来等待接
rabbitmq
最新发布
qq_48501521的博客
09-11 1314
消息服务概述：大多数应用中，可通过消息服务中间件来提升系统异步通信，扩展解耦能力两个重要概念：消息代理(message broker)和目的地(destination)。当消息发送者者发出消息后，将由消息代理接管，消息代理保证将消息传递至目的地两种形式的目的地：队列(queue):点对点的消息通信(point-to-point)主题(topic):发布(publish)/订阅(subscribe)的消息通信。
RabbitMQ的五种消息类型介绍
weixin_53390559的博客
09-20 7014
Rabbit的五种消息类型
5.RabbitMQ消息队列类型（7个）详细使用
相互学习 共同进步
05-22 2983
RabbitMQ是消息代理：接受并转发消息。可以将其视为邮局 将要发布的邮件放在邮箱中时，可以确保邮递员最终将邮件传递给收件人。以此类推，RabbitMQ是一个邮箱、一个邮局和一个邮递员 RabbitMQ与邮局之间的主要区别在于，它不处理纸张。只是做接收、存储和转发数据消息的二进制码 AMQP（Advanced Message Queuing Protocol，高级消息队列协议） 应用层协议的一个开放标准，为面向消息的中间件设计。AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性
rabbitmq-message-deduplication:RabbitMQ插件，用于过滤消息重复项
05-02
[sudo] rabbitmq-plugins enable rabbitmq_message_deduplication 从源头建造 请参阅RabbitMQ插件开发指南。 要构建插件： git clone https://github.com/noxdafox/rabbitmq-message-deduplication.git cd ...
rabbitmq-c-master.rar_RabbitMQ c lib_cmake编译_rabbitmq_rabbitmq-c
09-23
在使用`rabbitmq-c`时，开发者需要理解AMQP协议的基础知识，包括交换机、队列、绑定和消息路由策略。同时，熟悉C编程和错误处理技巧也是必要的，因为`rabbitmq-c`的API是C语言风格的，需要手动管理内存和错误检查。 ...
RabbitMQ安装包，版本：rabbitmq-server-3.9.11.exe
12-05
rabbitmq-server-3.9.11.exe
rabbitmq-server-3.10.5-1.el8.noarch.rpm
07-01
rabbitmq-server-3.10.5-1.el8.noarch.rpm
rabbitmq-server-generic-unix-latest-toolchain-3.12.13
04-15
rabbitmq-server-generic-unix-latest-toolchain-3.12.13.tar.xz
RabbitMQ 消息类型
19：30的博客
01-06 1193
RabbitMQ 的消息类型
RabbitMQ消息类型
weixin_34194317的博客
04-17 6336
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ的常见基本类型
AI天才研究院
01-18 1181
1.背景介绍 RabbitMQ是一种开源的消息代理服务，它使用AMQP(Advanced Message Queuing Protocol)协议来传输消息。AMQP是一种开放标准，用于在分布式系统中传输消息。RabbitMQ可以用于构建分布式系统，实现异步处理，提高系统性能和可靠性。 RabbitMQ支持多种消息类型，包括基本类型和扩展类型。基本类型包括：Direct、Topic、Fanout...
RabbitMQ 五种消息模型
凉快
04-09 4426
1、基本模型 一个发送者，一个队列，一个消费者 2、工作模型 一个发送者，一个列队，多个消费者 3、发布订阅模式之fanout 此时，就有交换机的事了。 这种模式，交换机和列队直接绑定，不需要指定routingkey，所以他的消息传输速度是发布订阅模式中最快的。 注意：其实之前的两种模式（基本模式和工作模式），也都是把消息发送给交换机，但是由于队列只有一个，而且我...
rabbitMQ学习笔记(六) topic类型消息。
is_zhoufeng的专栏
08-18 6123
上一节中使用了消息路由，消费者可以选择性的接收消息。 但是这样还是不够灵活。  比如某个消费者要订阅娱乐新闻消息 。 包括新浪、网易、腾讯的娱乐新闻。那么消费者就需要绑定三次，分别绑定这三个网站的消息类型。 如果新闻门户更多了，那么消费者将要绑定个更多的消息类型， 其实消费者只是需要订阅娱乐新闻，不管是哪个网站的新闻，都需要。 那么在rabbitMQ中可以使用topic类型。 模糊匹配消息类型。
RabbitMQ之五种消息模型
qq_57907966的博客
02-11 2034
虚拟主机：类似于mysql中的database。他们都是以“/”开头。
【消息队列】RabbitMQ五种消息模式
weixin_62513677的博客
04-30 2999
Spring AMQP是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息，包含两部分，其中Spring-amqp是基础抽象，spring-rabbit是底层的默认实现。这是为了防止消息队列中的队列不存在，在进行消息队列初始化的时候不知道是先建立消费者，还是先建立生产者，所以都执行创建函数，但是创建的队列只有一个不会重复。发布者发送消息时，指定消息的RoutingKey，Exchange将消息路由到BindingKey与消息RoutingKey一致的队列。Work queue，工作队列。
RabbitMQ的使用及其支持的消息类型
qq_34896730的博客
08-04 4647
RabbitMQ的使用及其支持的消息类型1、RabbitMQ的初使用1.1、创建一个用户1.2、创建虚拟主机1.3、绑定虚拟主机和用户2、RabbitMQ支持的消息模式2.1、AMQP协议的回顾2.2、官方RabbitMQ所支持的消息模式2.3、 在使用RabbitMQ时，我们会先创建一个用户，然后创建一个虚拟主机，给用户添加权限。 1、RabbitMQ的初使用 1.1、创建一个用户 上面的Tags选项，其实是指定用户的角色，可选的有以下几个： 超级管理员(administrator) 可登陆管理控制
CentOS 7中使用Docker部署RabbitMQ 3-management的详细教程
接下来，使用`docker pull rabbitmq:3-management`下载RabbitMQ的管理版本镜像，这里的`3-management`表示选择的是3.x版本的RabbitMQ管理插件，便于管理和监控。 通过`docker images`查看已下载的镜像列表，确认...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值