九.springboot+rabbitmq（文章写的比较好）以及 java版详细例子

蔚落 2022-05-22 03:55 102阅读 0赞

RabbitMq写的比较好的：[https://www.cnblogs.com/vipstone/p/9275256.html][https_www.cnblogs.com_vipstone_p_9275256.html]

Springboot+rabbotMq的：[https://blog.csdn.net/ztx114/article/details/78410727][https_blog.csdn.net_ztx114_article_details_78410727]

package com.tiglle.producer.main;
    
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    /** * Created by Administrator on 2018/7/15 0015. */
    public class ProducerMain { 
    
        public static void main(String[] args) throws Exception {
            fanoutExchange();
    
        }
    
        //默认交换机
        public static void defauleExchange()throws Exception {
            //通过连接工程获取连接(长连接，如果不关闭，会一直连接)
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("tiglle");
            factory.setPassword("hateyou75");
            //指定虚拟机，不指定默认为"/"这个虚拟机(TiglleHost 不等于 /TiglleHost)
            factory.setVirtualHost("TiglleHost");
            //从连接中获取信道
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            /** *声明一个列队queue * 1.queue:列队名称 * 2.durable：是否持久化 * 3.exclusive：是否排他性： * 只有 首次声明它的连接 （假如为A Connection）可见，A Connection的不同通道是可见的。其他连接不可访问和声明此相同的列队 * 如果试图在一个不同的连接中重新声明或访问（如publish，consume）该排他性队列，会得到资源被锁定的错误：ESOURCE_LOCKED - cannot obtain exclusive access to locked queue 'DefauleQueue1' * 会在其连接断开的时候自动删除(A Connection连接close或者客户端程序退出了)，不管这个队列是否被声明成持久性的（Durable =true)。 * exclusive列队只能消费者声明，消费者断开就删除。（因为消费者的Connection直接和Queue通信，提供者的Connection是和Exchange通信的。） * 4..autoDelete：当所有消费者断开连接后，自动删除，对于持久化的列队 * autoDelete的列队刚开始创建，没有消费者连接的时候，一直存在。一旦有消费者连接，并且所有消费者断开后，会自动删除 * 5. */
            channel.queueDeclare("DefauleQueue2",true,false,true,null);
            /** * 1.exchange：为""的时候使用默认的交换机 * 默认交换机为direct 类型：通过消息的routingKey，与列队和交换机的bindingKey（有些也叫做列队和交换机的routingKey）对比，相同则发送到该列队 * 2.routingKey：消息的属性，在默认交换机中，消息的routingKey和queue的name进行比较（bindingKey为消息的名称） * 3. * 4.body：消息主体 */
            byte[] body = "first message1".getBytes();
            /** * 发送消息 * 1.exchange 列队的名称，默认direct的列队名称为"" * 2.routingKey 路右键的名称，需要和目queue队绑定exchange的bindingKey相同 * 3. * 4.消息体 */
            channel.basicPublish("","DefauleQueue2",null,body);
    
            channel.close();
            connection.close();
        }
    
    
        //direct类型的交换机
        public static void directExchange() throws Exception {
            //通过连接工程获取连接(长连接，如果不关闭，会一直连接)
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("tiglle");
            factory.setPassword("hateyou75");
            //指定虚拟机，不指定默认为"/"这个虚拟机(TiglleHost 不等于 /TiglleHost)
            factory.setVirtualHost("TiglleHost");
            //从连接中获取信道
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
    
            /** * 声明direct类型的exchange (根据消息的routingKey和列队与交换机绑定的时候的bindingKey对比，来路由消息) * 1.exchange 交换机的名称 * 2.BuiltinExchangeType 交换机的类型(枚举) direct、fanout、topic、header */
            channel.exchangeDeclare("direct-exchange1", BuiltinExchangeType.DIRECT);
            /** *声明一个列队queue * 1.queue:列队名称 * 2.durable：是否持久化 * 3.exclusive：是否排他性： * 只有 首次声明它的连接 （假如为A Connection）可见，A Connection的不同通道是可见的。其他连接不可访问和声明此相同的列队 * 如果试图在一个不同的连接中重新声明或访问（如publish，consume）该排他性队列，会得到资源被锁定的错误：ESOURCE_LOCKED - cannot obtain exclusive access to locked queue 'DefauleQueue1' * 会在其连接断开的时候自动删除(A Connection连接close或者客户端程序退出了)，不管这个队列是否被声明成持久性的（Durable =true)。 * exclusive列队只能消费者声明，消费者断开就删除。（因为消费者的Connection直接和Queue通信，提供者的Connection是和Exchange通信的。） * 4..autoDelete：当所有消费者断开连接后，自动删除，对于持久化的列队 * autoDelete的列队刚开始创建，没有消费者连接的时候，一直存在。一旦有消费者连接，并且所有消费者断开后，会自动删除 * 5. */
            channel.queueDeclare("direct-queue1",true,false,false,null);
            /** * 列队和交换机的绑定 * 1. queue 列队的名称 * 2. exchange 交换机的名称 * 3.routingKey 绑定标识，可以叫bandingKey */
            channel.queueBind("direct-queue1","direct-exchange1","direct-routingkey1");
    
            byte[] body = "第一条消息".getBytes();
            /** * 发送消息 * 1.exchange 列队的名称 * 2.routingKey 路右键的名称，需要和目queue队绑定exchange的bindingKey相同 * 3. * 4.消息体 */
            channel.basicPublish("direct-exchange1","direct-routingkey1",null,body);
    
            channel.close();
            connection.close();
        }
    
        //topic类型的交换机
        public static void topicExchange() throws Exception {
            //通过连接工程获取连接(长连接，如果不关闭，会一直连接)
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("tiglle");
            factory.setPassword("hateyou75");
            //指定虚拟机，不指定默认为"/"这个虚拟机(TiglleHost 不等于 /TiglleHost)
            factory.setVirtualHost("TiglleHost");
            //从连接中获取信道
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
    
            /** * 声明topic类型的exchange (相当于有通配符 * 一个单词 #0个或多个单词，用 . 隔开的direct交换机) 注意是单词不是字母 * 1.exchange 交换机的名称 * 2.BuiltinExchangeType 交换机的类型(枚举) direct、fanout、topic、header */
            channel.exchangeDeclare("topic-exchange1", BuiltinExchangeType.TOPIC);
    
            /** *声明一个列队queue * 1.queue:列队名称 * 2.durable：是否持久化 * 3.exclusive：是否排他性： * 只有 首次声明它的连接 （假如为A Connection）可见，A Connection的不同通道是可见的。其他连接不可访问和声明此相同的列队 * 如果试图在一个不同的连接中重新声明或访问（如publish，consume）该排他性队列，会得到资源被锁定的错误：ESOURCE_LOCKED - cannot obtain exclusive access to locked queue 'DefauleQueue1' * 会在其连接断开的时候自动删除(A Connection连接close或者客户端程序退出了)，不管这个队列是否被声明成持久性的（Durable =true)。 * exclusive列队只能消费者声明，消费者断开就删除。（因为消费者的Connection直接和Queue通信，提供者的Connection是和Exchange通信的。） * 4..autoDelete：当所有消费者断开连接后，自动删除，对于持久化的列队 * autoDelete的列队刚开始创建，没有消费者连接的时候，一直存在。一旦有消费者连接，并且所有消费者断开后，会自动删除 * 5. */
            channel.queueDeclare("topic.queue1",true,false,false,null);
            /** * 列队和交换机的绑定 * 1. queue 列队的名称 * 2. exchange 交换机的名称 * 3.routingKey 绑定标识，可以叫bandingKey，可以使用通配符 * 一个单词 # 0个或多个单词，用 . 隔开 */
            channel.queueBind("topic.queue1","topic-exchange1","topic.routingkey.*");
    
            byte[] body = "第一条消息".getBytes();
            /** * 发送消息 * 1.exchange 列队的名称 * 2.routingKey 路右键的名称，需要和目queue队绑定exchange的bindingKey相同 * 3. * 4.消息体 */
            channel.basicPublish("topic-exchange1","topic.routingkey.test",null,body);//（此处可以通配topic.routingkey.* ，*为一个单词）
            channel.basicPublish("topic-exchange1","topic.routingkey.test.nihao",null,body);//（此处不能通配topic.routingkey.* ，因为有多个单词）
    
            channel.close();
            connection.close();
        }
    
        //fanout类型的交换机
        public static void fanoutExchange() throws Exception {
            //通过连接工程获取连接(长连接，如果不关闭，会一直连接)
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("localhost");
            factory.setPort(5672);
            factory.setUsername("tiglle");
            factory.setPassword("hateyou75");
            //指定虚拟机，不指定默认为"/"这个虚拟机(TiglleHost 不等于 /TiglleHost)
            factory.setVirtualHost("TiglleHost");
            //从连接中获取信道
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
    
            /** * 声明fanout类型的exchange 发送给所有绑定的列队，忽略bindingKey * 1.exchange 交换机的名称 * 2.BuiltinExchangeType 交换机的类型(枚举) direct、fanout、topic、header */
            channel.exchangeDeclare("fanout-exchange1", BuiltinExchangeType.FANOUT);
    
            /** *声明一个列队queue * 1.queue:列队名称 * 2.durable：是否持久化 * 3.exclusive：是否排他性： * 只有 首次声明它的连接 （假如为A Connection）可见，A Connection的不同通道是可见的。其他连接不可访问和声明此相同的列队 * 如果试图在一个不同的连接中重新声明或访问（如publish，consume）该排他性队列，会得到资源被锁定的错误：ESOURCE_LOCKED - cannot obtain exclusive access to locked queue 'DefauleQueue1' * 会在其连接断开的时候自动删除(A Connection连接close或者客户端程序退出了)，不管这个队列是否被声明成持久性的（Durable =true)。 * exclusive列队只能消费者声明，消费者断开就删除。（因为消费者的Connection直接和Queue通信，提供者的Connection是和Exchange通信的。） * 4..autoDelete：当所有消费者断开连接后，自动删除，对于持久化的列队 * autoDelete的列队刚开始创建，没有消费者连接的时候，一直存在。一旦有消费者连接，并且所有消费者断开后，会自动删除 * 5. */
            channel.queueDeclare("fanout-queue1",true,false,false,null);
            channel.queueDeclare("fanout-queue2",true,false,false,null);
    
            /** * 列队和交换机的绑定 * 1. queue 列队的名称 * 2. exchange 交换机的名称 * 3.routingKey 绑定标识，可以叫bandingKey，可以使用通配符 * 一个单词 # 0个或多个单词，用 . 隔开 */
            channel.queueBind("fanout-queue1","fanout-exchange1","DoNotUse1");
            channel.queueBind("fanout-queue2","fanout-exchange1","DoNotUse2");
    
    
            byte[] body = "第一条消息".getBytes();
            /** * 发送消息 * 1.exchange 列队的名称 * 2.routingKey 路右键的名称，需要和目queue队绑定exchange的bindingKey相同 * 3. * 4.消息体 */
            channel.basicPublish("fanout-exchange1","DoNotUse1",null,body);
    
            channel.close();
            connection.close();
        }
    
    
    
    
    
    
    
    
    }

[https_www.cnblogs.com_vipstone_p_9275256.html]: https://www.cnblogs.com/vipstone/p/9275256.html
[https_blog.csdn.net_ztx114_article_details_78410727]: https://blog.csdn.net/ztx114/article/details/78410727