RabbitMQ+Springboot

最新推荐文章于 2024-08-24 14:38:34 发布
最新推荐文章于 2024-08-24 14:38:34 发布
阅读量1.1k 收藏 5
点赞数
分类专栏： springboot RabbitMq 消息队列 javaweb程序设计 文章标签： RabbitMQ+SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lianOwen/article/details/81202069
版权

RabbitMQ+Springboot

官方API

运行demo(https://github.com/HOwen123/rabbitmq)

springboot与rabbitmq整合参考https://www.cnblogs.com/xmzJava/p/8036591.html

rabbitMQ依赖

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

一、 简单队列

模型

image

创建连接
public class ConnectionUtil {

    public static Connection getConnection() throws IOException, TimeoutException {

        ConnectionFactory factory = new ConnectionFactory();
        //主机
        factory.setHost(your host);
        //协议端口号
        factory.setPort(port);
        //用户名
        factory.setUsername(your rabbitmqUserName);
        //密码
        factory.setPassword(your rabbitmqPassword);
        //虚拟主机路径（相当于数据库名）
        factory.setVirtualHost("***");
        //返回连接
        return factory.newConnection();
    }
}
发送信息队列
public class Send {

    private final static String Queue_Name="hello";

    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);
        String message = "我觉得也是";
        //发布信息
        channel.basicPublish("",Queue_Name,null,message.getBytes());
        System.out.println(" [x] Sent '" + message + "'");

        channel.close();
        connection.close();
    }
}
获取信息队列
public class Recv {
    private static final String QUEUE_NAME = "hello";

    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);
        System.out.println("请等待......");

        //消费者
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body,"UTF-8");
                System.out.println("[x] Received '"+message+"'");
            }
        };
        //监听队列
        channel.basicConsume(QUEUE_NAME,true,consumer);
        channel.close();
        connection.close();
    }
}
简单队列的不足

耦合性高，生产者一一对应消费者（如果有多个消费者想消费队列中的消息，就可能出现问题）。如果队列名改变，那么消费者队列名跟着改变。

二、Work queues 工作队列

模型

image

为什么要使用工作队列？

simple 队列中生产者和消费者是一一对应的。在我们实际的开发中，生产者发送消息是很快的，而消费者对消息进行消费是需要进行业务处理的，这是需要花费比较多的时间的。这时候队列就会挤压很多的消息。

常量类
package com.howen.rabbitmq.common;

public class Consts {
    public static final String SM_QUEUE_NAME = "simple_test";

    public static final String WQ_QUEUE_NAME = "work_queue";
}

连接工具类

package com.howen.rabbitmq.Utils;

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

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

public class ConnectionUtil {

    public static Connection getConnection() throws IOException, TimeoutException {

        ConnectionFactory factory = new ConnectionFactory();
        //主机
        factory.setHost(***);
        //协议端口号
        factory.setPort(***);
        //用户名
        factory.setUsername(****);
        //密码
        factory.setPassword(****);
        //虚拟主机路径（相当于数据库名）
        factory.setVirtualHost(****);
        //返回连接
        return factory.newConnection();
    }
}

轮询分发

生产者生产消息
package com.howen.rabbitmq.workqueue;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

public class Send {

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

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.WQ_QUEUE_NAME,false,false,false,null);

        for (int i = 0; i <50 ; i++) {
            String sendMsg = "信息"+i;

            System.out.println(sendMsg);

            channel.basicPublish("",Consts.WQ_QUEUE_NAME,null,sendMsg.getBytes());

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                System.out.println("done");
            }
        }

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

    }

}
消费者 1 消费消息
package com.howen.rabbitmq.workqueue;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv1 {

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

       Channel channel = connection.createChannel();

       channel.queueDeclare(Consts.WQ_QUEUE_NAME,false,false,false,null);

       Consumer consumer = new DefaultConsumer(channel){
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

               String recvMsg = new String(body,"UTF-8");

               System.out.println("[1] Recv msg "+recvMsg);

               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       };

       boolean autoAck = true;

       channel.basicConsume(Consts.WQ_QUEUE_NAME,autoAck,consumer);
    }
}
消费者 2 消费消息
package com.howen.rabbitmq.workqueue;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv2 {

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

       Channel channel = connection.createChannel();

       channel.queueDeclare(Consts.WQ_QUEUE_NAME,false,false,false,null);

       Consumer consumer = new DefaultConsumer(channel){
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

               String recvMsg = new String(body,"UTF-8");

               System.out.println("[2] Recv msg "+recvMsg);

               try {
                   Thread.sleep(2000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       };

       boolean autoAck = true;

       channel.basicConsume(Consts.WQ_QUEUE_NAME,autoAck,consumer);
    }
}

WQ 总结

  1. 消费者1 和消费者2 处理的消息是一样的
  2. 消费者之间的消息是你一个我一个的

这种方式叫做轮询分发（round-robbin）结果就是不过谁比较清闲都好，任务消息的发送总是公平的。

公平分发（fair dispatch）

发送者发送消息
package com.howen.rabbitmq.workqueue;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

public class Send {

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

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

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

        /**
         * 每个消费者发送确认消息之前，消息队列只给消费者发送一条消息
         *
         * 限制发送给消费者不超过一条信息
         */
        int prefetchCount = 1;
        channel.basicQos(prefetchCount);

        for (int i = 0; i <50 ; i++) {
            String sendMsg = "信息"+i;

            System.out.println(sendMsg);

            channel.basicPublish("",Consts.WQ_QUEUE_NAME,null,sendMsg.getBytes());

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                System.out.println("done");
            }
        }

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

    }

}

要设置确认消息收到之前发多少消息。

消费者 3 消费消息
package com.howen.rabbitmq.workfair;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv3 {

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

       Channel channel = connection.createChannel();
       //声明队列
       channel.queueDeclare(Consts.WQ_QUEUE_NAME,false,false,false,null);
       //保证一次只分发一次
       channel.basicQos(1);

       Consumer consumer = new DefaultConsumer(channel){
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

               String recvMsg = new String(body,"UTF-8");

               System.out.println("[3] Recv msg "+recvMsg);

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

               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       };

       boolean autoAck = false;

       channel.basicConsume(Consts.WQ_QUEUE_NAME,autoAck,consumer);
    }
}
消费者 4 消费消息
package com.howen.rabbitmq.workfair;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv4 {

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

       Channel channel = connection.createChannel();

       channel.queueDeclare(Consts.WQ_QUEUE_NAME,false,false,false,null);

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

       Consumer consumer = new DefaultConsumer(channel){
           @Override
           public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

               String recvMsg = new String(body,"UTF-8");

               System.out.println("[4] Recv msg "+recvMsg);

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

               try {
                   Thread.sleep(3000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       };

       boolean autoAck = false;

       channel.basicConsume(Consts.WQ_QUEUE_NAME,autoAck,consumer);
    }
}

WF 总结

  1. 需要关闭自动应答
  2. 消息处理快的消费者能更快的获取消息

消息应答与消息持久化

boolean autoAck=false;``channel.basicConsume(Consts.WQ_QUEUE_NAME,autoAck,consumer);

boolean autoAck=true;(自动确认模式)一旦rabbitmq将消息分发给消费者，就会从内存中删除；

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

boolean autoAck=false(手动模式)，如果有一个消费者挂掉了，就会交付给其他消费者，rabbitmq支持消息应答，消费者发送一个消息应答，告诉rabbitmq这个消息我已经处理完成，你可以删了，然后rabbitmq就删除内存中的消息

消息应答默认是打开的

消息持久化
 channel.queueDeclare(Consts.WQ_QUEUE_NAME,false,false,false,null);

第二个参数 durable为boolean类型持久化参数

  • 在服务器端已经存在队列名，则不能直接修改durable为true，否则会报错。需要新建一个队列名或者在rabbitmq服务器端进行删除。

三、发布订阅模式（publish_subscribe）

模型

image

说明
1. 一个生产者，多个消费者。
2. 每个消费者都对应有自己的队列
3. 生产者不是把消息直接发送到队列中，而是发送到交换机上（exchange）
4. 每个队列都要绑定到交换机上
5. 生产者发送的消息净多交换机到达队列，就能实现一个消息被多个消费者消费

生产者
package com.howen.rabbitmq.publishSubscribe;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

public class Send {

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

       Channel channel = connection.createChannel();

       //声明分发
       channel.exchangeDeclare(Consts.PS_EXCHANGE_NAME,"fanout");

       String msg = "hello rabbit";

       //发布到交换机
       channel.basicPublish(Consts.PS_EXCHANGE_NAME,"",null,msg.getBytes());

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

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

    }

}
消费者 1
package com.howen.rabbitmq.publishSubscribe;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv1 {

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

        Channel channel = connection.createChannel();
        //队列声明
        channel.queueDeclare(Consts.PS_QUEUE_NAME_EMAIL,true,false,false,null);
        //队列与交换机绑定
        channel.queueBind(Consts.PS_QUEUE_NAME_EMAIL,Consts.PS_EXCHANGE_NAME,"");

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

        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String recvMsg = new String(body,"UTF-8");

                System.out.println("[1] Recv msg "+recvMsg);

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

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        boolean autoAck = false;

        channel.basicConsume(Consts.PS_QUEUE_NAME_EMAIL,autoAck,consumer);
    }

}
消费者 2
package com.howen.rabbitmq.publishSubscribe;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv2 {

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

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.PS_QUEUE_NAME_MSG,true,false,false,null);
        //队列与交换机绑定
        channel.queueBind(Consts.PS_QUEUE_NAME_MSG,Consts.PS_EXCHANGE_NAME,"");

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

        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String recvMsg = new String(body,"UTF-8");

                System.out.println("[2] Recv msg "+recvMsg);

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

                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        boolean autoAck = false;

        channel.basicConsume(Consts.PS_QUEUE_NAME_MSG,autoAck,consumer);
    }

}

Exchange(交换机 转发器)

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

匿名装发 “”

Fanout(不处理路由键(routing key))

image

Direct(处理(routing key))

image

四、路由模式

模型

image

生产者
package com.howen.rabbitmq.routing;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

public class Send {

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

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        channel.exchangeDeclare(Consts.RT_EXCHANGE_NAME,"direct");

        String msg = " message: hello routing to info";

        System.out.println(msg);

        String routingKey = Consts.RT_ROUTING_INFO;

        channel.basicPublish(Consts.RT_EXCHANGE_NAME,routingKey,null,msg.getBytes());

        channel.close();

        connection.close();
    }

}
消费者1
package com.howen.rabbitmq.routing;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv5 {

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

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.RT_QUEUE_NAME_1,false,false,false,null);

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

        channel.queueBind(Consts.RT_QUEUE_NAME_1,Consts.RT_EXCHANGE_NAME,Consts.RT_ROUTING_ERROR);

        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String recvMsg = new String(body,"UTF-8");

                System.out.println("[5] Recv msg "+recvMsg);

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

        boolean autoAck = true;

        channel.basicConsume(Consts.RT_QUEUE_NAME_1,autoAck,consumer);
    }
}
消费者2
package com.howen.rabbitmq.routing;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv6 {

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

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.RT_QUEUE_NAME_2,false,false,false,null);

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

        channel.queueBind(Consts.RT_QUEUE_NAME_2,Consts.RT_EXCHANGE_NAME,Consts.RT_ROUTING_ERROR);
        channel.queueBind(Consts.RT_QUEUE_NAME_2,Consts.RT_EXCHANGE_NAME,Consts.RT_ROUTING_INFO);
        channel.queueBind(Consts.RT_QUEUE_NAME_2,Consts.RT_EXCHANGE_NAME,Consts.RT_ROUTING_WARNING);


        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String recvMsg = new String(body,"UTF-8");

                System.out.println("[6] Recv msg "+recvMsg);

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

            }
        };

        boolean autoAck = true;

        channel.basicConsume(Consts.RT_QUEUE_NAME_2,autoAck,consumer);
    }
}

五、topic 主题模式

模型

image

实例图

image

发送者
package com.howen.rabbitmq.topic;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

public class Send {

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

        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        channel.exchangeDeclare(Consts.TP_EXCHANGE_NAME,"topic");

        String msg = " 帅哥一枚。。。。";

        channel.basicPublish(Consts.TP_EXCHANGE_NAME,"boys.add",null,msg.getBytes());

        System.out.println("发送： "+msg);

        channel.close();

        connection.close();
    }

}
消费者1
package com.howen.rabbitmq.topic;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv7 {

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

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.TP_QUEUE_NAME_1,false,false,false,null);

        channel.queueBind(Consts.TP_QUEUE_NAME_1,Consts.TP_EXCHANGE_NAME,"boys.#");

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

        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String recvMsg = new String(body,"UTF-8");

                System.out.println("[7] 接收： "+recvMsg);

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

        boolean autoAck = true;

        channel.basicConsume(Consts.TP_QUEUE_NAME_1,autoAck,consumer);
    }
}
消费2
package com.howen.rabbitmq.topic;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.*;

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

public class Recv8 {

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

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.TP_QUEUE_NAME_2,false,false,false,null);

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

        channel.queueBind(Consts.TP_QUEUE_NAME_2,Consts.TP_EXCHANGE_NAME,"*.add.*");


        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {

                String recvMsg = new String(body,"UTF-8");

                System.out.println("[8] 接收： "+recvMsg);

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

            }
        };

        boolean autoAck = true;

        channel.basicConsume(Consts.TP_QUEUE_NAME_2,autoAck,consumer);
    }
}

Rabbitmq的消息确认机制（事物+confirm）

在rabbitmq中，我们可以通过持久化数据，解决rabbitmq服务器异常的数据丢失。

两种方式：

AMQP实现了事务机制

Confirm模式

事务机制

txSelect:开启事务；txCommit:提交事务；txRollback:事务回滚；

缺点: 耗时，降低了吞吐量

package com.howen.rabbitmq.tx;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DefaultConsumer;

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

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

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.TX_QUEUE_NAME,false,false,false,null);

        String msg="事务";
        //开启事务
        channel.txSelect();

        try{
            channel.basicPublish("",Consts.TX_QUEUE_NAME,null,msg.getBytes());
            System.out.println(msg);
            //提交事务
            channel.txCommit();
        }catch (Exception e){
            System.out.println("msg rollback");
            //事务回滚
            channel.txRollback();
        }finally {
            channel.close();
            connection.close();
        }

    }
}

Confirm 模式

Confirm模式最大的好处在于他是异步的

开始confirm模式

将channel.select 修改为channel.confirmSelect()

编程模式：

  1. 普通： 发一条 waitForConfirms()
  2. 批量的：waitForConfirms();所有发完后确认
  3. 异步confirm模式：提供一个回调方法
批量调用
package com.howen.rabbitmq.confirm;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;

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

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

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.CF_QUEUE_NAME, false, false, false, null);

        String msg = "confirm模式";
        //开启事务
        channel.confirmSelect();
        //批量
        for (int i = 0; i <10 ; i++) {
            channel.basicPublish("", Consts.CF_QUEUE_NAME, null, msg.getBytes());
        }

        if (!channel.waitForConfirms()){
            System.out.println("消息发送失败！");
        }else{
            System.out.println("消息发送成功！");
        }
        System.out.println(msg);
        channel.close();
        connection.close();


    }
}
异步调用
package com.howen.rabbitmq.confirm;

import com.howen.rabbitmq.Utils.ConnectionUtil;
import com.howen.rabbitmq.common.Consts;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;

import java.io.IOException;
import java.util.Collections;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.TimeoutException;


public class Send2 {

    /**
     * @author 
     * @TODO (注：异步调用)
     * @param
     * @DATE: 2018/7/12 16:51
     */
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        Connection connection = ConnectionUtil.getConnection();

        Channel channel = connection.createChannel();

        channel.queueDeclare(Consts.CF_QUEUE_NAME, false, false, false, null);

        String msg = "confirm模式";
        //开启confirm模式
        channel.confirmSelect();
        //未确认的消息标识
        final SortedSet<Long> confirmSet = Collections.synchronizedSortedSet(new TreeSet<Long>());

        //添加通道监听
        channel.addConfirmListener(new ConfirmListener() {
            //没有问题的handleAck
            @Override
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                if (multiple){
                    System.out.println("---handleAck-----multiple");
                    confirmSet.headSet(deliveryTag+1).clear();
                }else {
                    System.out.println("---handleAck-----multiple false");
                    confirmSet.remove(deliveryTag);
                }
            }
            //handleNack 回执有问题的
            @Override
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                if (multiple){
                    System.out.println("---handleNack-----multiple");
                    confirmSet.headSet(deliveryTag+1).clear();
                }else {
                    System.out.println("---handleNack-----multiple false");
                    confirmSet.remove(deliveryTag);
                }
            }
        });

        while(true){
            long seqNo = channel.getNextPublishSeqNo();
            channel.basicPublish("",Consts.CF_QUEUE_NAME,null,msg.getBytes());
            confirmSet.add(seqNo);
        }


    }
}
HowenLian
关注
专栏目录
RabbitMQ与 spring 整合
贵在坚持
10-13 327
rabbitmq 与 spring 整合，熟悉 RabbitAdmin、 RabbitTemplate、SimpleMessageListenerContainer、MessageListenerAdapter 和 MessageConverter 几个类（接口）的用法。
RabbitMQ+Spring配置
ccccrj博客
06-29 231
pom.xml <dependencies> <!--rabbitmq--> <dependency> <groupId>org.springframework.amqp</groupId> <artifactId>spring-rabbit</artifactId> <version>2.2.7.RELEASE</version>
spring整合RabbitMQ（2020年7月26日）
weixin_44376261的博客
07-26 205
生产者 导入依赖和插件 <dependency> <groupId>org.springframework.amqp</groupId> <artifactId>spring-rabbit</artifactId> <version>2.1.8.RELEASE</version> </dependency>
RabbitMQ介绍以及基本使用
2301_76621359的博客
08-19 1162
文章目录一、什么是消息队列？二、消息队列的作用（优点）1、解耦2、流量削峰3、异步4、顺序性三、RabbitMQ基本结构四、RabbitMQ队列模式1、简单队列模式2、工作队列模式3、发布/订阅模式4、路由模式5、主题模式6、RPC模式7、发布者确认模式五、RabbitMQ相关属性描述一、什么是消息队列？消息队列是一种用于在分布式系统中进行通信的技术。它是一种存储和转发消息的中间件，可以用于将应用程序之间的通信解耦，从而实现高效的异步通信。
RabbitMQ 和 Spring 的整合
Ark方舟
12-21 516
重要的类： RabbitAdmin 可以很好的处理交换机和队列，修改，删除并且可以注解到spring里 RabbitTemplate类负责收发消息 第一章、RabbitAdmin管理交换机/队列/绑定 1.1 创建SpringBoot工程 添加包依赖
channel rabbitmq 配置_Spring Boot + RabbitMQ 配置参数解释
weixin_34943809的博客
01-14 373
最近生产RabbitMQ出了几次问题，所以抽时间整理了一份关于Spring Boot 整合RabbitMQ环境下的配置参数解释，通过官网文档和网上其他朋友一些文章参考归纳整理而得，有错误之处还请指正~★RabbitMQ★Version: 1.5.13.RELEASE★属性文件：org.springframework.boot.autoconfigure.amqp.RabbitProperties★...
RabbitMq+springboot
04-20
在本文中，我们将深入探讨如何将RabbitMQ与SpringBoot集成，以实现高效的消息队列系统。RabbitMQ是一款开源的消息代理和队列服务器，它使用AMQP（Advanced Message Queuing Protocol）协议，广泛应用于分布式系统中...
springboot+rabbitMQ+websocket
07-28
而RabbitMQ作为一款强大的消息中间件，常用于处理异步任务和消息队列。WebSocket协议则为双向通信提供了可能，使得服务器可以主动向客户端推送信息。接下来，我们将深入探讨如何利用Spring Boot、RabbitMQ和...
rabbitmq基础+springboot集成rabbitmq
10-14
**RabbitMQ基础** ...通过以上介绍，我们可以看到这个项目不仅涵盖了RabbitMQ的基础知识，还展示了如何在SpringBoot应用中集成和测试RabbitMQ，对于学习和实践RabbitMQ与SpringBoot的结合使用非常有帮助。
前后端分离Uniapp+SpringBoot即时通讯安卓APP源码
10-13
SpringBoot可以通过WebSocket或者RabbitMQ等技术实现即时通讯功能。 4. **Android APP**：这部分指的是源码可以打包为安卓应用。在Android平台上，开发者需要对UI界面、网络请求、权限管理等进行适配，UniApp可以将...
RabbitMQ+springboot用延迟插件实现延迟消息的发送
weixin_43360488的博客
08-27 678
延迟队列：其实就是死信队列中消息过期的特殊情况延迟队列应用场景：可以用死信队列来实现，不过死信队列要等上一个消息消费成功，才会进行下一个消息的消费，这时候就需要用到延迟插件了，不过要线在docker上装一个插件前置条件是在Docker中部署过RabbitMq。1、打开你的远程工具，首先查看docker中已有的容器，主要是为了查看rabbitmq的容器ID2、将本地下载好的压缩包传到服务器某文件夹下，然后将其复制到Docker中的RabbitMq容器中的plugins文件夹下。
Springboot+rabbitmq集成
10-25
文件内包含了rabbit安装的必需文件以及springboot整合rabbitmq的完整代码，代码里包含了原生的rabbitmq使用代码和整合springboot后的使用代码，还有rabbit队列的所有消息队列模式，代码简单易懂，解压打开就可以使用
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,自己写的方法比较简陋,参考下原理即可.
SpringBoot整合MQ
最新发布
weixin_55772633的博客
08-24 1455
springboot整合ActiveMQ提供了JmsMessagingTemplate对象作为客户端操作消息队列操作ActiveMQ需要配置ActiveMQ服务器地址，默认端口61616企业开发时通常使用监听器来处理消息队列中的消息，设置监听器使用注解@JmsListener配置jms的pub-sub-domain属性可以在点对点模型和发布订阅模型间切换消息模型。
RabbitMQ+SpringBoot
Pratik_shiku的博客
09-23 1734
RabbitMQ 文章目录`RabbitMQ`一、简介1. 是什么2. 消息模型3. 应用场景二、`Docker`部署和配置1. 拉取镜像2. 跑3. 访问4. 创建新用户5. 创建`virtual host`三、`Springboot`整合`rabbitMQ`1. `Hello World`① 编写一个消息提供者`Provider`：② 编写一个消息消费者`Consumer`：2. `Work`队列① 编写一个消息提供者`WorkProvider`② 编写两个消息消费者`WorkConsumer1和Wor
RabbitMQ详细教程以及SpringBoot集成RabbitMQ
m0_52208135的博客
03-07 6302
RabbitMQ详细教程、SpringBoot集成RabbitMQ、RabbitMQ Windows、Mac、Linux搭建以及Linux搭建RabbitMQ集群模式
RabbitMq整合Springboot超全实战案例+图文演示+源码自取_rabbitmq springboot 实战
2401_84182578的博客
04-12 2422
RabbitMQ是一种开源的消息队列软件，它实现了高级消息队列协议（AMQP），提供了可靠的消息传递机制以及支持分布式应用程序之间的通信。RabbitMQ支持多种编程语言，如Java、Python、Ruby、PHP等等，并且可以在不同的操作系统上运行，如Windows、Linux、Mac OS等。RabbitMQ的核心理念是分离应用程序之间的通信，允许开发人员将其应用程序解耦，从而使它们更加容易理解、扩展和维护。
Spring中使用RabbitMQ
fxtxz2的专栏
07-20 1725
rabbitMQ使用
SpringBoot RabbitMQ 集群模式
架构师老狼
10-19 2928
springBoot出现是soa开发模式的一次革命，把javaer从xml配置中解放出来，这也是微服务流行起来的重要原因，使分布式成为主流。同时无缝连接springcloud提供服务治理、服务网关、配置热启动刷新、断路由、服务监听等，接下来记录曾经的点点滴滴！
rabbitmq+springboot+websocket实现前端可发送和接收消息
07-15
您可以使用RabbitMQ、Spring Boot和WebSocket来实现前端可发送和接收消息的功能。下面是一个基本的实现步骤： 1. 首先，确保您的Spring Boot项目中已经添加了RabbitMQ和WebSocket的依赖。 2. 在Spring Boot应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值