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

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

Springboot+rabbotMq的：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();
    }








}