HAKUNA·MATATA

RabbitMQ详解以及spring对RabbitMQ的集成(附带部分源码解读)

一·简介

1丶为什么要使用消息队列

https://wenku.baidu.com/view/e297236f83c4bb4cf7ecd193.html

①异步处理(高并发)

②系统解耦

③流量削锋

2丶为什么使用RabbitMQ

①给予AMQP协议

②高并发

③高可用

④强大的社区支持，以及很多公司都在使用

⑤高性能

⑥支持插件(监控管理界面的插件，安装插件支持jms)

⑦支持多语言(PHP,Python,.net)

3丶为什么使用Spring AMQP

①基于Spring之上，社区活跃

②对AMQP协议进行了高度的封装

③极大简化了RabbitMQ的操作

④易用性，可扩展性

二·AMQP协议介绍

AMQP协议是一个二进制协议,一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准,为面向消息的中间件设计。并不受客户端/中间件不同产品，不同的开发语言等条件的限制。Erlang中的实现有 RabbitMQ等。

三·RabbitMQ安装

1丶特点

2丶Windows下安装

①安装Erlang

Erlang:是一种通用的面向并发的编程语言,Erlang是运行于虚拟机的解释性语言,Erlang支持脚本式解释器,Erlang属于多重范型编程语言，涵盖函数式、并发式及分布式。顺序执行的Erlang是一个及早求值, 单次赋值和动态类型的函数式编程语言。

下载地址:http://www.erlang.org/downloads

配置环境变量: ERLANG_HOME: D:\Develop\Erlang\erl9.3

Path:%ERLANG_HOME%\bin;

测试安装:

②安装RabbitMQ

下载地址: http://www.rabbitmq.com/install-windows.html(注意安装目录不要有空格)

Erlang与RabbitMQ版本兼容:

http://www.rabbitmq.com/which-erlang.html#unsupported versions

③安装插件

在D:\Develop\RabbitMQ\rabbitmq_server-3.7.6\sbin运行cmd:

rabbitmq-plugins enable rabbitmq_management

四·exchange详解

1丶exchange介绍

接受生产者的消息，根据路由键转发消息到绑定队列。

类型：

Direct exchange

Topic exchange

Fanout exchange

Headers exchange

属性：

Name: 名字(一个virtual host里面有若干个exchange，但是名字不能重复)

Type: exchange的类型

Durability: 是否持久化(保证消息的可靠性不会被丢失)

[(默认)Durable(持久化)，Transient(不持久化)]

Auto delete：当最后一个绑定消息被删除，exchange是否自动删除

[(默认)No,Yes]

Internal: 这个exchange只能被内部使用，生产者发送消息只能发送到internal为true的交换机上

[(默认)No,Yes]

Arguments: 在AMQP协议的参数(上面的那些属性)上进行扩展

例如:alternate-exchange : 当我们交换机不能通过路由键路由到指定的消息队列上去的时候，就可以把消息转发到另一个exchange上面去，保证消息不会被丢失

2丶Direct Exchange

将消息中的Routing Key(在发送一个消息的时候会指定routing key)与exchange中关联的所有binding中的Routing Key进行比较(exchange与queue进行binding的时候会指定一个routingkey)，如果相等，则发送到该binding对应的queue中。

一个routing key可以binding多个queue

一个exchange可以binding多个queue，在binding多个queue的时候可以指定相同的 routing key 也可以指定不同的routing key

默认交换隐式地绑定到每个队列，并使用与队列名相等的路由键。不可能显式地绑定到默认交换，或从默认交换中解除绑定。它也不能被删除。

不能进行binding操作
任何发送到该exchange中的消息都会被转发到Routing key指定的queue中(在发送消息时会指定一个routing key ，但是default exchange又没有与queue进行binding，那么发送到default exchange的消息就会发送到与发送消息相同的routing key的消息队列中)（这里routing key的名称即:queue的名称）；
如果vhost不存在routing key中指定的队列名，则该消息会被抛弃；

3丶topic Exchage

将消息中的Routing key与该Exchange 关联的所有binding中的Routing key进行比较，若果匹配上了，则发送到该binding对应的queue中。

特殊情况:

如果binding中的Routing key没有*/#，那就是相当于direct exchage(相等转发)

如果binding中的Routing key为#.#就相当于 fanout exchange(全转发 )

4丶fanout Exchang

直接将消息转发到所有binding的queue中，忽略Routing key.

特点：

效率最高

Fanout>direct>topic

5丶Headers Exchaneg

转发时，是让发送时的headers与binding时arguments进行比较，binding时至少要有两个参数其中一个必须是x-match=all/any，如果是all那么，发送的参数必须大于等于binding时的参数（参数类型也需要一致），如果没有设置x-match那么默认为all。

五·binding详解

六·queue详解

也称为Message Queue,消息队列，保存消息并将他们转发给消费者。

属性:

Virtualhost：指定是属于哪个vhost，一个vhost有很多queue,但名字是唯一的；

Name: queue的名字；

Durability：是否持久化，当rabbitmq重启或最后一个消息被消费者消费queue是否移除。 (durable：是,transient:否)

Auto delete：yes,当最后一个监听被移除后，该queue会自动删除；

七·message详解

服务器和应用程序之间发送的数据，由properties和payload（body）组成

属性：

Routing Key: 在消息转发时需要(fanout exchang,headers exchange不需要指定)

Delivery mode：消息是否持久化(1不持久化，2持久化)，（当消息发到queue中，当计算机宕机或者重启的时候消息就会丢失）

Header: 消息头(键值对)

Payload: 发送的消息

保证消息持久化:exchange,queue,message三者持久化

八·rabbitmq java client

1丶基本操作

①：创建工厂以及连接和信道

//创建工厂
ConnectionFactory cf=new ConnectionFactory();
cf.setHost("localhost");
cf.setPort(5672);
cf.setUsername("guest");
cf.setPassword("guest");

//另一种创建工厂的方式默认的vhost是"/"可以在5672后面指定vhost

cf.setUri("amqp://guest:guest@localhost:5672");

//创建连接
// Connection con=cf.newConnection();
Connection con=cf.newConnection("测试连接");

//创建信道
Channel channel = con.createChannel();

注：使用guest用户只能登陆localhost不能带ip(192.168...)

默认端口是5672而15672是可视化界面的端口

②：创建交换机

//创建交换机
Map map=new HashMap();
map.put("alternate-exchange","direct_test");
channel.exchangeDeclare("exchange-Test", BuiltinExchangeType.DIRECT, true, false, map);

//判断exchange是否存在(不存在就抛异常)
channel.exchangeDeclarePassive("exchange-Test");

//删除Exchange
channel.exchangeDelete("exchange-Test");

③：创建消息队列

//创建消息队列
/**
* exclusive：只允许当前connection访问,
* 如果当前connection(程序关闭)没有访问就会自动删除
*/
channel.queueDeclare("queue-Test", true, false, false, new HashMap());

//判断队列是否存在(不存在就抛异常)
channel.queueDeclarePassive("queue-Test");

④：binding

//exchange和queue进行binding
channel.queueBind("queue-Test","exchange-Test","test");

//exchange和exchange进行binding
/**
* 把resource交换机与destinatio交换机进行binding
* 当想source交换机发消息时消息会被转发到detination交换机上
*/
channel.exchangeBind("exchange-Test","direct_test","test");

//exchange与queue进行解绑
channel.queueUnbind("queue-Test","exchange-Test","test");
//exchange与exchange进行解绑
channel.exchangeUnbind("exchange-Test","direct_test","test");

⑤：关闭连接释放资源

channel.close();
con.close();

2丶消息的发送与消费

①：使用默认的exchange发送消息(default Exchange)

//向默认的exchange发送消息
/**
* BasicProperties设置消息的属性(propertis)
* Builder后面跟参数
*/
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder().deliveryMode(2).contentEncoding("UTF-8").build();

/**
* 默认的交换机发消息routing key的名称就是queue的名称
*/
channel.basicPublish("","queue-Test",props,"生成者发送消息".getBytes());

如果requeue选择为false在 getMessage过后消息就从消息队列中移除。

②：向topic exchange发送消息

//创建exchange
channel.exchangeDeclare("push", BuiltinExchangeType.TOPIC, true, false, null);
//binding
channel.queueBind("queue-Test","push","#");
//发送消息
AMQP.BasicProperties props = new AMQP.BasicProperties.Builder().deliveryMode(2).contentEncoding("UTF-8").build();
channel.basicPublish("push","我不管指定什么都会发送",props,"我又来了".getBytes());

③：消费者消费消息

//创建工厂
ConnectionFactory cf=new ConnectionFactory();
cf.setHost("localhost");
cf.setPort(5672);
cf.setUsername("guest");
cf.setPassword("guest");
//创建连接
Connection con=cf.newConnection();
//创建信道
Channel channel = con.createChannel();
//消费者消费消息
channel.basicConsume("queue-Test",true,new ConsumerService(channel));

Thread.sleep(30000);

channel.close();
con.close();

注：使用channel.basicConsume（“对列名称”，”是否确认消息”，”回调函数”）（要睡够才会出现效果）

回调函数：

public class ConsumerService extends DefaultConsumer {

    public ConsumerService(Channel channel) {
        super(channel);
    }

    /**
     * 获取消息后的回调函数
     * @param consumerTag
     * @param envelope
     * @param properties
     * @param body
     * @throws IOException
     */
    @Override
    public void handleDelivery(String consumerTag,Envelope envelope,AMQP.BasicProperties properties,byte[] body)
            throws IOException{
        System.out.println(consumerTag);
        System.out.println("消息接收到了");
        System.out.println("-------------------------");
        System.out.println("routing key:"+envelope.getRoutingKey()+"-----exchange:"+envelope.getExchange());
    }

}

九·Spring AMQP

1丶简介

依赖：

<dependency>
    <groupId>org.springframework.amqpgroupId>
    <artifactId>spring-rabbitartifactId>
    <version>1.7.3.RELEASEversion>
dependency>

2丶RabbitAdmin创建详解

①：使用

Java配置类

@Configuration
public class MQConfig {

    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory factory=new CachingConnectionFactory();
        factory.setUri("amqp://guest:guest@localhost:5672");
        return factory;
    }

    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        return rabbitAdmin;
    }
}

开启注解扫描

@ComponentScan
public class Start {
    public static void main(String[] args) {
        //开启注解扫描
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(Start.class);
        RabbitAdmin rabbitAdmin=context.getBean(RabbitAdmin.class);

        System.out.println(rabbitAdmin);
        context.close();
    }
}

使用rabbitAdmin创建与绑定

//创建exchange
rabbitAdmin.declareExchange(new DirectExchange("rabbitAdmin-TopicExchange",
                                true,false));
//创建queue
rabbitAdmin.declareQueue(new Queue("rabbitAdmin-queue",
                    true,false,false));
//exchange与queue进行binding
rabbitAdmin.declareBinding(new Binding("rabbitAdmin-queue",
        Binding.DestinationType.QUEUE,"rabbitAdmin-TopicExchange",
        "#",new HashMap()));

//使用bindingBuilder进行binding
rabbitAdmin.declareBinding

(BindingBuilder.bind(new Queue("rabbitAdmin-queue")).
to(new DirectExchange("rabbitAdmin-TopicExchange")).with("#"));

Exchange

Queue

Binding

BindingBuilder

注：

exchange与exchange进行binding

使用binding时需要修改String destination

Binding.DestinationType.EXCHANGE；

使用BingdingBuilder的时候:(exchange1).to(exchange2).with(“routingkey”)是exchange2绑定exchange1

②：exchange,binding,queue的自动声明

配置类

}

@Configuration
public class DecalreConfig {
    @Bean
    public Queue q1(){
        return new Queue("q1");
    }
    @Bean
    public Exchange e1(){
        return new TopicExchange("e1",true,false);
    }
    @Bean
    public Binding b1(){
        HashMap map = new HashMap();
        return new Binding("q1", Binding.DestinationType.QUEUE, "e1", "#",map);
    }
}

3丶RabbitTemplate进行消息发送

配置类

@Configuration
public class MQConfig {

@Bean
public ConnectionFactory connectionFactory(){
    CachingConnectionFactory factory=new CachingConnectionFactory();
    factory.setUri("amqp://guest:guest@localhost:5672");
    factory.setCacheMode(CachingConnectionFactory.CacheMode.CHANNEL);
    return factory;
}

@Bean
public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);

        //设置tempalte默认的Routingkey
        rabbitTemplate.setRoutingKey("anyKey");

        //设置template默认的exchange
        rabbitTemplate.setExchange("e1");

        return rabbitTemplate;
    }
}

使用send发送消息

AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(TemplateSatrt.class);
RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
System.out.println(rabbitTemplate);

//设置message对象
MessageProperties mp = new MessageProperties();

mp.setHeader("type","2");
mp.setHeader("id","haha");

Message message = new Message("hello".getBytes(), mp);

//向template默认的exchange和routingkey发消息
rabbitTemplate.send(message);

//向template默认的exchange，指定的routing key发消息
rabbitTemplate.send("test.anyKey",message);

//向指定的exchange和routingkey发消息
rabbitTemplate.send("","q1",message);

//设置唯一标识的消息
rabbitTemplate.send("e1","anykey",message,new CorrelationData("messageId"));

context.close();

使用convertAndSend发消息

//向template默认的exchange和routingkey发消息
rabbitTemplate.convertAndSend("anything");

//向template默认的exchange，指定的routing key发消息
rabbitTemplate.convertAndSend("test.anyKey","haha");

//向指定的exchange和routingkey发消息
rabbitTemplate.convertAndSend("","q1","haha");

//设置唯一标识的消息
rabbitTemplate.convertAndSend("e1","anykey","haha",new CorrelationData("messageId"));

//使用message后置处理器发送消息
rabbitTemplate.convertAndSend("", "q1", "hahhaaha", new MessagePostProcessor() {
    public Message postProcessMessage(Message message) throws AmqpException {
        System.out.println("我先对消息处理过后才会发消息");
        message.getMessageProperties().getHeaders().put("type","1");
        message.getMessageProperties().getHeaders().put("messageId","monitor");
        System.out.println(message);
        return message;
    }
});

4丶消息的消费

①：使用容器的方式进行创建消费者消费

首先需要一个MessageListenerContainer

选择它的实现类：SimpleMessageListenerContainer

创建SimpleMessageListenerContainer需要三个东西：

1.连接工厂：ConnectionFactory

2.监听队列的名称：setQueueName(可以是多个队列)

3.收到消息的回调函数

checkMessageListener:

创建

使用

@ComponentScan
public class Consumer {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(Consumer.class);
       context.getBean(SimpleMessageListenerContainer.class);
        //设置了不自动启动，这里就就要手动启动
//       context.getBean(SimpleMessageListenerContainer.class).start();
    }
}

注：

当同一个queue上有多个消息者时，一个消息发送过来只会有一个消费者收到消息

SimpleMessageListenerContainer支持一次监听多个queue

SimpleMessageListenerContainer支持运行时动态增加/移除queue

@Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer
            (ConnectionFactory connectionFactory, RabbitTemplate rb) {
        SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
        //是否自动启动
//        simpleMessageListenerContainer.setAutoStartup(f

        //设置从哪个队列取消息(可以取多个)
//        simpleMessageListenerContainer.setQueueNames("q1", "q2", "q3");
        simpleMessageListenerContainer.setQueueNames("q1");

        //设置接受消息后的回调
        simpleMessageListenerContainer.setMessageListener(new MessageListener() {
            public void onMessage(Message message) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("***********消费者接受到了" +
                        message.getMessageProperties().getConsumerQueue() +
                        "消息了**************");
                System.out.println(new String(message.getBody()));
            }
        });
        return simpleMessageListenerContainer;
    }

AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(Consumer.class);

        SimpleMessageListenerContainer bean = context.getBean(SimpleMessageListenerContainer.class);
        bean.setQueueNames("q2","q3");
        bean.setMessageListener(new MessageListener() {
            public void onMessage(Message message) {
                System.out.println("收到"+message.getMessageProperties().getConsumerQueue()+"的消息");
                System.out.println(new String(message.getBody()));
            }
        });

bean.removeQueueNames("q2","q3");
//设置了不自动启动，这里就就要手动启动
// context.getBean(SimpleMessageListenerContainer.class).start();

//设置多少个并发消费者一起消费
bean.setConcurrentConsumers(5);
//设置最大的并发消费者数
bean.setMaxConcurrentConsumers(10);

5丶MessageListenerAdaptor

①：基本操作

配置类

代理方法

public class MesageAdaptor {
    public void handleMessage(byte bytes[]){
        System.out.println("----------------handleMessage消息:"+new String(bytes)+"-------");
    }
    public void send2(byte bytes[]){
        System.out.println("----------------send2消息:"+new String(bytes)+"-------");
    }
    public void send3(byte bytes[]){
        System.out.println("----------------send3消息:"+new String(bytes)+"-------");
    }
}

启动类

@ComponentScan
public class Consumer {
public static void main(String[] args) throws Exception{
AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(Consumer.class);

}

②：MessageConvertor

MessageListenerAdaptor内部通过MessageConvertor把Message对象转换成java对象，然后去消息适配器内找到对应的方法(参数为转换后的java对象的类型)。

实现类：

public class MessageConvertorImpl implements MessageConverter{
    /**
     * 把Object转换为Message对象
     * @param object
     * @param messageProperties
     * @return
     * @throws MessageConversionException
     */
    public Message toMessage(Object object, MessageProperties messageProperties) throws MessageConversionException {
        System.out.println("----------toMessage----------");
        return new Message(object.toString().getBytes(),messageProperties);
    }

    /**
     * 把Message对象装换为object对象
     * @param message
     * @return
     * @throws MessageConversionException
     */
    public Object fromMessage(Message message) throws MessageConversionException {
        System.out.println("----------fromMessage----------");
        String contentType = message.getMessageProperties().getContentType();
        if(contentType!=null){
            if(contentType.startsWith("text")){
                return new String(message.getBody());
            }
        }
        return message.getBody();
    }
}

消息适配器类：

/**
* Converts from a AMQP Message to an Object.
*/
@Override
public Object fromMessage(Message message) throws MessageConversionException {
   Object content = null;
   MessageProperties properties = message.getMessageProperties();
   if (properties != null) {
      String contentType = properties.getContentType();
      if (contentType != null && contentType.startsWith("text")) {
         String encoding = properties.getContentEncoding();
         if (encoding == null) {
            encoding = this.defaultCharset;
         }
         try {
            content = new String(message.getBody(), encoding);
         }
         catch (UnsupportedEncodingException e) {
            throw new MessageConversionException(
                  "failed to convert text-based Message content", e);
         }
      }
      else if (contentType != null &&
            contentType.equals(MessageProperties.CONTENT_TYPE_SERIALIZED_OBJECT)) {
         try {
            content = SerializationUtils.deserialize(
                  createObjectInputStream(new ByteArrayInputStream(message.getBody()), this.codebaseUrl));
         }
         catch (IOException e) {
            throw new MessageConversionException(
                  "failed to convert serialized Message content", e);
         }
         catch (IllegalArgumentException e) {
            throw new MessageConversionException(
                  "failed to convert serialized Message content", e);
         }
         catch (IllegalStateException e) {
            throw new MessageConversionException(
                  "failed to convert serialized Message content", e);
         }
      }
   }
   if (content == null) {
      content = message.getBody();
   }
   return content;
}

③：Jackson2MessageConverter

生产者在发送json数据的时候，需要指定这个json是哪个对象，否则消费者收到消息之后，不知道要转换成哪个java对象。

指定方法在消息header中，增加一个__TypeId__，value就是具体的java对象全称（包名+类名）(一定要是消费者所在系统的java对象全称)

发送消息的时候，__TypeId__的值可以是java对象全称，也可以是映射的key，当消费者有配置映射key的时候，生产者既可以指定java对象全称，又可以是映射的key，如果消费者没有配置映射key，则只能指定java对象全称。

如果生产者发送的是list的json数据，则还需要增加一个__ContentTypeId__的header，用于指明List里面的具体的对象

如果生产者发送的是map的json数据，则需要指定__KeyTypeId__、__ContentTypeId__的header，用于指明map里面的key，value的具体对象

生产者：

配置文件

@Configuration
public class MQConfig {

    @Bean
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setUri("amqp://guest:guest@localhost:5672");
        factory.setCacheMode(CachingConnectionFactory.CacheMode.CHANNEL);
        return factory;
    }

    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);

        //设置tempalte默认的Routingkey
        rabbitTemplate.setRoutingKey("q2.aaa");

        //设置template默认的exchange
        rabbitTemplate.setExchange("e1");

        return rabbitTemplate;
    }

}

实体

public class Order {
    private Integer id;
    private Integer userId;
    private double amount;
    private String time;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    public double getAmount() {
        return amount;
    }
    public void setAmount(double amount) {
        this.amount = amount;
    }
    public String getTime() {
        return time;
    }
    public void setTime(String time) {
        this.time = time;
    }
    @Override
    public String toString() {
        return "Order [id=" + id + ", userId=" + userId + ", amount=" + amount + ", time=" + time + "]";
    }
}

启动类

@ComponentScan
public class Productor {
    public static void main(String[] args) throws Exception{
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(Productor.class);
        RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
        Order order = new Order();
        order.setId(1);
        order.setUserId(1000);
        order.setAmount(88d);
        order.setTime(LocalDateTime.now().toString());

        Order order1 = new Order();
        order1.setId(1);
        order1.setUserId(1000);
        order1.setAmount(88d);
        order1.setTime(LocalDateTime.now().toString());

        HashMap orderMap = new HashMap();
        orderMap.put("order",order);
        List list= Arrays.asList(order,order1);
        ObjectMapper objectMapper = new ObjectMapper();

        String jsonList = objectMapper.writeValueAsString(list);
        String jsonMap=objectMapper.writeValueAsString(orderMap);
        String jsonOrder = objectMapper.writeValueAsString(order);

        MessageProperties messageProperties = new MessageProperties();
        //设置contentType
        messageProperties.setContentType("application/json");

        //消费者实体对象的全称
                //对象
//        messageProperties.setHeader("__TypeId__", "springAMQP.Order");
        messageProperties.setHeader("__TypeId__", "order");
                //List
//         messageProperties.setHeader("__TypeId__","java.util.List");
//         messageProperties.setHeader("__ContentTypeId__","order");
                 //map
//        messageProperties.setHeader("__TypeId__","java.util.Map");
//        messageProperties.setHeader("__KeyTypeId__","java.lang.String");

//        rabbitTemplate.send(new Message(jsonList.getBytes(),messageProperties));
//        rabbitTemplate.send(new Message(jsonMap.getBytes(),messageProperties));
        rabbitTemplate.send(new Message(jsonOrder.getBytes(),messageProperties));

        context.close();
    }
}

消费者

配置类

@Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory) {
        SimpleMessageListenerContainer simpleMessageListenerContainer =
                new SimpleMessageListenerContainer(connectionFactory);
        simpleMessageListenerContainer.setQueueNames("q1", "q2", "q3");

        //使用MessageListeneradaptor适配器来代理消息监听器
        MessageListenerAdapter adapter = new MessageListenerAdapter(new MesageAdaptor());

        //设置jackson接受消息
        Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();

        DefaultJackson2JavaTypeMapper javaTypeMapper = new DefaultJackson2JavaTypeMapper();
        //配置映射key(这样生产者在发送消息的时候就不用指定全类名)
        HashMap> idClassMap = new HashMap>();
        idClassMap.put("order",Order.class);
        javaTypeMapper.setIdClassMapping(idClassMap);

        jackson2JsonMessageConverter.setJavaTypeMapper(javaTypeMapper);

        //设置消息转换器
        adapter.setMessageConverter(jackson2JsonMessageConverter);

        //设置默认方法
//        adapter.setDefaultListenerMethod("send2");
        //把不同的消息交给不同的方法来处理
        HashMap map = new HashMap();
        map.put("q1", "handleMessage");
        map.put("q2", "send2");
        map.put("q3", "send3");
        adapter.setQueueOrTagToMethodName(map);
        simpleMessageListenerContainer.setMessageListener(adapter);

        return simpleMessageListenerContainer;
    }
}

对应生产者的实体

适配器类

public class MesageAdaptor {
    public void handleMessage(byte bytes[]){
        System.out.println("----------------handleMessage消息(bytes[]):"+new String(bytes)+"-------");
    }

    /**
     * 接受String类型
     * @param bytes
     */
    public void send2(String bytes){
        System.out.println("----------------send2消息(String):"+new String(bytes)+"-------");
    }

    /**
     * 接受字节类型
     * @param bytes
     */
    public void send2(byte bytes[]){
        System.out.println("----------------send2消息(bytes[]):"+new String(bytes)+"-------");
    }
    /**
     * 接受字节类型
     * @param order
     */
    public void send2(List order){
        System.out.println("----------------send2消息(List order):"+order.get(0)+"-------");
    }
    /**
     * 接受字节类型
     * @param order
     */
    public void send2(Order order){
        System.out.println("----------------send2消息(Order order):"+order.toString()+"-------");
    }
    /**
     * 接受字节类型
     * @param order
     */
    public void send2(Map order){
        System.out.println("----------------send2消息(Map order):"+order.toString()+"-------");
    }

    public void send3(byte bytes[]){
        System.out.println("----------------send3消息:"+new String(bytes)+"-------");
    }
}

启动类

}
}

④：ContentTypeDelegatingMessageConverter

ContentTypeDelegatingMessageConverter 是一个代理的MessageConverter。

ContentTypeDelegatingMessageConverter本身不做消息转换的具体动作，而是把消息转换委托给具体的MessageConverter，我们可以设置ContentType和MessageConverter的映射关系。

ContentTypeDelegatingMessageConverter还有一个默认的MessageConverter，

也就是说当根据ContentType没有找到映射的MessageConverter的时候，就会使用默认的MessageConverter。

@Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory) {
        SimpleMessageListenerContainer simpleMessageListenerContainer =
                new SimpleMessageListenerContainer(connectionFactory);
        simpleMessageListenerContainer.setQueueNames("q1", "q2", "q3");

        //使用MessageListeneradaptor适配器来代理消息监听器
        MessageListenerAdapter adapter = new MessageListenerAdapter(new MesageAdaptor());

        //设置jackson接受消息
        Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
        DefaultJackson2JavaTypeMapper javaTypeMapper = new DefaultJackson2JavaTypeMapper();
        //配置映射key(这样生产者在发送消息的时候就不用指定全类名)
        HashMap> idClassMap = new HashMap>();
        idClassMap.put("order",Order.class);
        javaTypeMapper.setIdClassMapping(idClassMap);
        jackson2JsonMessageConverter.setJavaTypeMapper(javaTypeMapper);

        //使用ContentTypeDelegatingMessageConverter代理MessageConvertor
        ContentTypeDelegatingMessageConverter converter = new ContentTypeDelegatingMessageConverter();
        //json的convertor
        converter.addDelegate("json",jackson2JsonMessageConverter);
        //字符串的convertor
        converter.addDelegate("",new MessageConvertorImpl());

        //设置消息转换器
        adapter.setMessageConverter(converter);

        //设置默认方法
//        adapter.setDefaultListenerMethod("send2");
        //把不同的消息交给不同的方法来处理
        HashMap map = new HashMap();
        map.put("q1", "handleMessage");
        map.put("q2", "send2");
        map.put("q3", "send3");
        adapter.setQueueOrTagToMethodName(map);
        simpleMessageListenerContainer.setMessageListener(adapter);

        return simpleMessageListenerContainer;
    }

6丶RabbitListenerConfigurer进行消费

1：实现RabbitListenerConfigurer接口，并把实现类托管到spring容器中

2：在spring容器中，托管一个RabbitListenerContainerFactory的bean（SimpleRabbitListenerContainerFactory）
3：在启动类上面加上@EnableRabbit

配置类

@Configuration
public class MQconfig {

    @Bean
    /**
     * 连接工厂
     */
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory factory = new CachingConnectionFactory();
        factory.setUri("amqp://guest:guest@localhost:5672");
        factory.setCacheMode(CachingConnectionFactory.CacheMode.CHANNEL);
        return factory;
    }

    @Bean
    /**
     * 连接以及binding
     */
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;
    }

    @Bean
    /**
     * 发送消息
     */
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);

        //设置tempalte默认的Routingkey
//        rabbitTemplate.setRoutingKey("anyKey");

        //设置template默认的exchange
//        rabbitTemplate.setExchange("e1");
        return rabbitTemplate;
    }

    @Bean
    public RabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        return factory;
    }

    @Bean
    /**
     * 接收消息
     */
    public RabbitListenerConfigurer rabbitListenerConfigurer() {
        return new RabbitListenerConfigurer() {
            public void configureRabbitListeners(RabbitListenerEndpointRegistrar registrar) {

                SimpleRabbitListenerEndpoint endpoint1 = new SimpleRabbitListenerEndpoint();
                endpoint1.setId("aaa");
                endpoint1.setQueueNames("q1");
                //接受消息后的回调
                endpoint1.setMessageListener(new MessageListener() {
                    public void onMessage(Message message) {
                        System.out.println("-------接收到消息了："+new String(message.getBody())+"--------");
                    }
                });

                SimpleRabbitListenerEndpoint endpoint2 = new SimpleRabbitListenerEndpoint();
                endpoint2.setId("bbb");
                endpoint2.setQueueNames("q2","q3");
                endpoint2.setMessageListener(new MessageListenerAdapter(new MesageAdaptor()));

                registrar.registerEndpoint(endpoint1);
                registrar.registerEndpoint(endpoint2);
            }
        };
    }
}

消息适配器

启动类

@EnableRabbit
@ComponentScan
public class Start {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Start.class);
//        context.close();
    }
}

7丶使用@rabbitlistener注解进行消费

①：实现步骤

在启动类里加一个@EnableRabbit的注解

在spring容器中托管一个RabbitListenerContanierFactory的Bean(默认的实现是SimpleRabbitListenerContaninerFactory)

写一个消息处理类托管到spring容器中,然后在具体方法上加上注解@RabbitListenner

启动类：

配置类：

    @Bean
    public RabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        return factory;
    }
}

消息处理类：

@Component
public class MesageAdaptor {
    @RabbitListener(queues={"q1"})
    public void handleMessage(byte bytes[]){
        System.out.println("----------------handleMessage消息(bytes[]):"+new String(bytes)+"-------");
    }

    /**
     * 接受String类型
     * @param bytes
     */
    @RabbitListener(queues = {"q1"})
    public void sendString(String bytes){
        System.out.println("----------------handleMessage(String):"+new String(bytes)+"-------");
    }
}

/**
* 与适配器不同的是可以接受参数为Message
* @param message
*/
@RabbitListener(queues = {"q1"})
public void handleMessage(Message message){
System.out.println(message.getMessageProperties());
System.out.println("----------handleMessage消息:"+new String(message.getBody()));
}

可以在接受的消息前打上注解@Payload说明他是是个消息，也可以打上注解@Headers Map map来接受消息头。

②：进阶用法

使用读取配置文件的方式监听队列

配置文件(queueName.properties)：

test.QueueName=q1

消息处理类：

@Component
public class MesageAdaptor {

    /**
     * 与适配器不同的是可以接受参数为Message
     * @param message
     */
    @RabbitListener(queues = {"${test.QueueName}"})
    public void handleMessage(Message message){
        System.out.println(message.getMessageProperties());
        System.out.println("----------handleMessage消息:"+new String(message.getBody()));
    }

}

启动类：

@EnableRabbit
@ComponentScan
@PropertySource("classpath:queueName.properties")
public class Start {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Start.class);
    }
}

使用bindings实现自动声明

配置类：

@Configuration
public class MQconfig {
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory cachingConnectionFactory=new CachingConnectionFactory();
        cachingConnectionFactory.setUri("amqp://guest:guest@localhost:5672");
        cachingConnectionFactory.setCacheMode(CachingConnectionFactory.CacheMode.CHANNEL);
        return cachingConnectionFactory;
    }

    /**
     * 使用自动申明的条件就是要有Rabbitadmin
     * @param connectionFactory
     * @return
     */
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
//        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;
    }
    @Bean
    public RabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        return factory;
    }
}

消息处理类：

@Component
public class MesageAdaptor {

/**
     * 自动申明与监听
     * @param message
     */
    @RabbitListener(bindings =@QueueBinding(value = @Queue(value = "listenerQueue",durable = "true"), exchange = @Exchange(value = "listenerExchange",durable = "true",type = ExchangeTypes.TOPIC),key = "test.#"))
    public void declare(Message message){
        System.out.println(message.getMessageProperties());
        System.out.println("----------handleMessage消息:"+new String(message.getBody()));
    }
}

启动类：

@EnableRabbit
@ComponentScan
public class Start {
    public static void main(String[] args) throws Exception{
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Start.class);

    }
}

@RabbitListenner写在类上面

消息处理类

@Component
@RabbitListener(queues={"q1"})
public class MesageAdaptor {

@RabbitHandler
    public void handleMessage(@Payload byte bytes[]){
        System.out.println("----------------handleMessage消息(bytes[]):"+new String(bytes)+"-------");
    }

    @RabbitHandler
    public void handleMessage(String bytes){
        System.out.println("----------------handleMessage(String):"+new String(bytes)+"-------");
    }

注：写在类上@RabbitListenner注解要配合@RabbitHandler一起使用

@RabbitListenner注解设置containerfactory

配置类:

@Configuration
public class MQconfig {
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory cachingConnectionFactory=new CachingConnectionFactory();
        cachingConnectionFactory.setUri("amqp://guest:guest@localhost:5672");
        cachingConnectionFactory.setCacheMode(CachingConnectionFactory.CacheMode.CHANNEL);
        return cachingConnectionFactory;
    }
       @Bean
    public RabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        return factory;
    }
    @Bean
    public RabbitListenerContainerFactory rabbitListenerContainerFactory2(ConnectionFactory connectionFactory){
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory);
        //设置消息转换器
        factory.setMessageConverter(new MessageConverter() {
            public Message toMessage(Object object, MessageProperties messageProperties) throws MessageConversionException {
                return null;
            }
            //把message对象装换为user对象
            public Object fromMessage(Message message) throws MessageConversionException {
                return new User(1,new String(message.getBody()));
            }
        });
        return factory;
    }
}

消息处理类：

@Component
@RabbitListener(queues={"q1"},containerFactory="rabbitListenerContainerFactory2")
public class MesageAdaptor {

    @RabbitHandler
    public void handleMessage(@Payload byte bytes[]){
        System.out.println("----------------handleMessage消息(bytes[]):"+new String(bytes)+"-------");
    }

    @RabbitHandler
    public void handleMessage(String bytes){
        System.out.println("----------------handleMessage(String):"+new String(bytes)+"-------");
    }

    @RabbitHandler
    public void xxxxx(User u){
        System.out.println(u.toString());
    }
}

注：@RabbitListenner里默认的containerfactory是rabbitListenerContainerFactory

(名字必须是这个)如果有特殊需求就可以修改这个名字但是在对应的配置文件里必须有对应名字的containerfactory.

十一·消息确认(可靠消息)

1丶Publisher Confirms(发送者确认消息)

Publisher Confirms机制用于解决生产者与RabbitMQ服务器之间消息可靠传输。它在消息服务器持久化消息后通知消息生产者发送成功

生产者：

public class ConfirmSend {
    static Long id = 0L;

    static TreeSet tags = new TreeSet();

    private static Long send(Channel channel, byte[] body) throws Exception {
        //设置消息属性
        BasicProperties props = new BasicProperties.Builder().deliveryMode(2).contentEncoding("UTF-8").build();
        //发送消息
        channel.basicPublish("", "q1", props, body);
        return ++id;
    }

    public static void main( String[] args ) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setUri("amqp://guest:guest@localhost:5672");

        Connection conn = factory.newConnection();

        Channel channel = conn.createChannel();

        //使当前Channel处于确认模式（处于事务模式的Channel，不能设置为确认模式）
        channel.confirmSelect();

        channel.addConfirmListener(new ConfirmListener() {
            /**
             * deliveryTag 消息ID
             * multiple 是否批量
             *   如果是true，就意味着，小于等于deliveryTag的消息都处理成功了
             *   如果是false，就意味着，只是成功了deliveryTag这一条消息
             */
            public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                //消息处理成功触发该方法
                System.out.println("+++++++++++++消息处理成功++++++++++");
                System.out.println("deliveryTag: " + deliveryTag);
                System.out.println("   multiple: " + multiple);
                try {
                    //处理成功发送的消息
                    if(multiple) {//是否批量确认
                        //批量确认
                        for(Long _id : new TreeSet(tags.headSet(deliveryTag+1))) {
                            tags.remove(_id);
                        }
                    } else {
                        //单个确认
                        tags.remove(deliveryTag);
                    }
                }catch(Exception e) {
                    e.printStackTrace();
                }
                System.out.println("未确认的：" + tags);
            }

            /**
             * deliveryTag 消息ID
             * multiple 是否批量
             *   如果是true，就意味着，小于等于deliveryTag的消息都处理失败了
             *   如果是false，就意味着，只是失败了deliveryTag这一条消息
             */
            public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                //消息处理失败触发该方法
                System.out.println("+++++++++++++失败了++++++++++");
                System.out.println("deliveryTag: " + deliveryTag);
                System.out.println("   multiple: " + multiple);
                //处理发送失败的消息
            }
        });

        Long id = send(channel, "123".getBytes());
        //ID是需要入库或者保存的
        tags.add(id);

        id = send(channel, "123".getBytes());
        //ID是需要入库或者保存的
        tags.add(id);

        id = send(channel, "123".getBytes());
        //ID是需要入库或者保存的
        tags.add(id);

        channel.waitForConfirmsOrDie();

        TimeUnit.SECONDS.sleep(2);

        channel.close();
        conn.close();
        System.out.println(tags.toString());
    }
}

消费者：

public class Consume {

    public static void main( String[] args ) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirtualHost("/");

        Map clientProperties = new HashMap();
        clientProperties.put("desc", "移动支付系统V2.0");
        clientProperties.put("author", "zhangsan");
        clientProperties.put("user", "[email protected]");

        factory.setClientProperties(clientProperties);

//     Connection conn = factory.newConnection();
        Connection conn = factory.newConnection("q1队列的消费者");

        Channel channel = conn.createChannel(10);

        String consumerTag = channel.basicConsume("q1", true, "pay_all_log_consumer", new SimpleConsumer(channel));
        System.out.println(consumerTag);

        TimeUnit.SECONDS.sleep(120);

        channel.close();
        conn.close();
    }
}

回调函数：

2丶springAMQP发送可靠的消息

配置类：

@Configuration
public class MQConfig {
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
        cachingConnectionFactory.setUri("amqp://guest:guest@localhost:5672");
        cachingConnectionFactory.setPublisherConfirms(true);
        return cachingConnectionFactory;
    }
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
        return rabbitAdmin;
    }
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        //设置确认后的回调函数
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             * correlationData唯一标识
             * 有了这个唯一标识，我们就知道可以确认（失败）哪一条消息了
             */
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("-------------收到消息确认啦-----------");
                if(ack) {
                    System.out.println(correlationData.getId() + " 已经成功发送");
                } else {
                    System.out.println(correlationData.getId() + " 发送失败，原因为：" + cause);
                }
                System.out.println(correlationData.toString());
            }
        });
        return rabbitTemplate;
    }
}

启动类：

@ComponentScan
public class App {
    private static Order createOrder() {
        Order order = new Order();
        order.setUserId(1);
        order.setCreateDate(LocalDateTime.now().toString());
        order.setPrice(100d);
        return order;
    }

    private static void save(Order order) {
        //入库操作
        order.setId(UUID.randomUUID().toString());
    }

    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(App.class);
        RabbitTemplate rabbit = context.getBean(RabbitTemplate.class);

        Order order = createOrder();
        save(order);

        ObjectMapper mapper = new ObjectMapper();
        byte[] body = mapper.writeValueAsBytes(order);

        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setContentType("json");

        Message message = new Message(body, messageProperties);

        System.out.println("id : " + order.getId());
        rabbit.send("", "q1", message, new CorrelationData(order.getId()));

        TimeUnit.SECONDS.sleep(2);
        context.close();
    }
}

消息类：

public class Order {
    private String id;
    private Integer userId;
    private double price;
    private String createDate;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public String getCreateDate() {
        return createDate;
    }
    public void setCreateDate(String createDate) {
        this.createDate = createDate;
    }

    @Override
    public String toString() {
        return "Order{" +
                "id='" + id + '\'' +
                ", userId=" + userId +
                ", price=" + price +
                ", createDate='" + createDate + '\'' +
                '}';
    }
}

注:

1：CachingConnectionFactory.setPublisherConfirms(true);

2：RabbitTemplate.setConfirmCallback() 设置回调方法

3：发送消息的时候，需要指定CorrelationData，用于标识该次发送的唯一ID

比较：

1：Spring AMQP不支持批量确认，底层的RabbitMQ Java client方式支持批量

2：Spring AMQP提供的方式非常简单明了

3丶Consumer Acknowledgements(消费者确认消息)

消费者：

public class Consume {

    public static void main( String[] args ) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setUsername("guest");
        factory.setPassword("guest");
        factory.setVirtualHost("/");

        Map clientProperties = new HashMap();
        clientProperties.put("desc", "移动支付系统V2.0");
        clientProperties.put("author", "zhangsan");
        clientProperties.put("user", "[email protected]");

        factory.setClientProperties(clientProperties);

//     Connection conn = factory.newConnection();
        Connection conn = factory.newConnection("q1队列的消费者");
        Channel channel = conn.createChannel(10);
        //把自动确认消息(autoAck)设置为false
        String consumerTag = channel.basicConsume("q1", false, "pay_all_log_consumer", new SimpleConsumer(channel));
        System.out.println(consumerTag);

        TimeUnit.SECONDS.sleep(120);

        channel.close();
        conn.close();
    }
}

消息处理回调函数：

public class SimpleConsumer extends DefaultConsumer {

    public SimpleConsumer(Channel channel) {
        super(channel);
    }

    @Override
    public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)
            throws IOException {
        if(properties.getHeaders().get("type")!=null){
            //拒绝消息(最后一个参数:是否把消息放回队列)支持批量拒绝
            this.getChannel().basicNack(envelope.getDeliveryTag(),false,false);

            //只支持拒绝单条消息
            this.getChannel().basicReject(envelope.getDeliveryTag(), false);

            System.out.println("消息属性为：" + properties);
            System.out.println("拒绝消息了");

            System.out.println(new String(body));
        }else{
            //确认消息第一个参数：消息id号，第二个参数：是否批量确认
            this.getChannel().basicAck(envelope.getDeliveryTag(),false);
            System.out.println("----------收到消息啦----------");
            System.out.println("消息属性为：" + properties);
            System.out.println("消息内容为：" + new String(body));
        }

    }
}

4丶springAMQP消费者确认消息

配置类：

@Configuration
public class MQConfig {
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
        cachingConnectionFactory.setUri("amqp://guest:guest@localhost:5672");
        return cachingConnectionFactory;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        return rabbitTemplate;
    }

    /**
     * 消息转换器
     * @param connectionFactory
     * @return
     */
    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
        simpleMessageListenerContainer.setQueueNames("q1");
        //设置手动确认消息
        simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL);
        simpleMessageListenerContainer.setMessageListener(new ChannelAwareMessageListener() {
            public void onMessage(Message message, Channel channel) throws Exception {
                Object type = message.getMessageProperties().getHeaders().get("type");
                if(type==null){
                    //参数1:消息id,参数2：是否把消息返回队列
         channel.basicReject(message.getMessageProperties().getDeliveryTag(),false);
                    //参数1：消息id，参数2:是否批量拒绝，参数3：是否把消息返回队列
//                    channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,false);
                    System.out.println("消息拒绝了");
                }else{
                    System.out.println("消息已确认");
                    //参数1：消息id,参数2：是否批量确认
                    channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
                }
                System.out.println(new String(message.getBody()));
                System.out.println(message.getMessageProperties());
            }
        });
        return simpleMessageListenerContainer;
    }
}

启动类：

/**
* AcknowledgeMode.NONE 自动确认，等效于 autoAck=true
*
* AcknowledgeMode.MANUAL 手动确认，等效于 autoAck=false
*
*/

@ComponentScan
public class App {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(App.class);
    }
}

注：AcknowledgeMode.NONE 自动确认，等效于 autoAck=true

AcknowledgeMode.MANUAL 手动确认，等效于 autoAck=false
使用spring默认的AcknowledgeMode.AUTO

配置类：

@Configuration
public class MQConfig {
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
        cachingConnectionFactory.setUri("amqp://guest:guest@localhost:5672");
        return cachingConnectionFactory;
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        return rabbitTemplate;
    }

    /**
     * 消息转换器
     * @param connectionFactory
     * @return
     */
    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
        simpleMessageListenerContainer.setQueueNames("q1");
        //设置拒绝消息切消息不会被放回队列
        simpleMessageListenerContainer.setDefaultRequeueRejected(false);

        simpleMessageListenerContainer.setMessageListener(new ChannelAwareMessageListener() {
            public void onMessage(Message message, Channel channel) throws Exception {
                System.out.println(new String(message.getBody()));
                System.out.println(message.getMessageProperties());
                //消息会被确认
//                throw new ImmediateAcknowledgeAmqpException("consume fail");

                //消息会被拒绝，且requeue=false
//                throw new AmqpRejectAndDontRequeueException("consume fail");

                //其他异常消息会被拒绝，且requeue=true
                //requeue=true可以通过setDefaultRequeueRejected（默认为true）去设置
                throw new Exception("");

            }
        });
        return simpleMessageListenerContainer;
    }
}

启动类：

/**
* AcknowledgeMode.NONE 自动确认，等效于 autoAck=true
*
* AcknowledgeMode.MANUAL 手动确认，等效于 autoAck=false
*
* AcknowledgeMode.AUTO 根据方法的执行情况来决定是否是确认还是拒绝（是否重新入queue）
* 1: 如果消息成功被消费了，则自动确认
* 2：
*    (1)当抛出AmqpRejectAndDontRequeueException异常的时候，则消息会被拒绝，且requeue=false
*    (2)当抛出ImmediateAcknowledgeAmqpException异常，则消息会被确认
*    (3)其他的异常，则消息会被拒绝，且requeue=true（如果此时只有一个消费者监听该队列，则有发生死循环的风险）
*       其中，requeue=true可以通过setDefaultRequeueRejected（默认为true）去设置
*
*    要想了解更新详细的代码，则可以分析SimpleMessageListenerContainer.doReceiveAndExecute方法
*
*/
@ComponentScan
public class App {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(App.class);
    }
}

注：

当抛出AmqpRejectAndDontRequeueException异常的时候，则消息会被拒绝，且requeue=false

当抛出ImmediateAcknowledgeAmqpException异常，则消息会被确认

其他的异常，则消息会被拒绝，且requeue=true

private boolean doReceiveAndExecute(BlockingQueueConsumer consumer) throws Throwable { //NOSONAR
   Channel channel = consumer.getChannel();
   for (int i = 0; i < this.txSize; i++) {
      logger.trace("Waiting for message from consumer.");
      Message message = consumer.nextMessage(this.receiveTimeout);
      if (message == null) {
         break;
      }
      try {
         executeListener(channel, message);
      }
      catch (ImmediateAcknowledgeAmqpException e) {
         if (this.logger.isDebugEnabled()) {
            this.logger.debug("User requested ack for failed delivery: "
                  + message.getMessageProperties().getDeliveryTag());
         }
         break;
      }
      catch (Throwable ex) { //NOSONAR
         if (causeChainHasImmediateAcknowledgeAmqpException(ex)) {
            if (this.logger.isDebugEnabled()) {
               this.logger.debug("User requested ack for failed delivery: "
                     + message.getMessageProperties().getDeliveryTag());
            }
            break;
         }
         if (this.transactionManager != null) {
            if (this.transactionAttribute.rollbackOn(ex)) {
               RabbitResourceHolder resourceHolder = (RabbitResourceHolder) TransactionSynchronizationManager
                     .getResource(getConnectionFactory());
               if (resourceHolder != null) {
                  consumer.clearDeliveryTags();
               }
               else {
                  /*
                   * If we don't actually have a transaction, we have to roll back
                   * manually. See prepareHolderForRollback().
                   */
                  consumer.rollbackOnExceptionIfNecessary(ex);
               }
               throw ex; // encompassing transaction will handle the rollback.
            }
            else {
               if (this.logger.isDebugEnabled()) {
                  this.logger.debug("No rollback for " + ex);
               }
               break;
            }
         }
         else {
            consumer.rollbackOnExceptionIfNecessary(ex);
            throw ex;
         }
      }
   }
   return consumer.commitIfNecessary(isChannelLocallyTransacted(channel));
}

消费者拒绝消息并不代表消息没被确认所以生产的ack还是会为true

（把生产者当做卖家，消费者当做买家，rabbitmq当做快递公司，卖家拒绝收货卖家不能怪快递公司没发货，说明卖家还是受到货物了的）

十二·alternate exchange

当我们交换机不能通过路由键路由到指定的消息队列上去的时候，就可以把消息转发到alternate exchange设置的exhcange上面去，保证消息不会被丢失。

配置类：

@Configuration
public class MQConifg {
    @Bean
    public ConnectionFactory connectionFactory(){
        CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
        cachingConnectionFactory.setUri("amqp://guest:guest@localhost:5672");
        //设置消息回复
        cachingConnectionFactory.setPublisherConfirms(true);
        return cachingConnectionFactory;
    }
    @Bean
    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory){
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);
        rabbitAdmin.setAutoStartup(true);
//        binding
        rabbitAdmin.declareBinding(new Binding("alternate-queue", Binding.DestinationType.QUEUE,
                "warn","test",new HashMap()));
        rabbitAdmin.declareBinding(BindingBuilder.bind(new Queue("alternate-queue")).to
                (new FanoutExchange("debug",true,false)));

        return rabbitAdmin;
    }

    @Bean
    public Exchange exchange(){
        HashMap arguments = new HashMap();
        arguments.put("alternate-exchange","debug");
        return new TopicExchange("warn",true,false,arguments);
    }
    @Bean
    public Queue queue(){
       return new Queue("alternate-queue");
    }

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory){
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);

        //消息确认后的回调函数
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){
            public void confirm(CorrelationData correlationData, boolean ack, String cause){
                if(ack){
                    System.out.println("生产者消息发送成功");
                }else{
                    System.out.println("消息发送失败");
                    System.out.println(cause);
                }
            }
        });
        return rabbitTemplate;
    }

    /**
     * 消息转换器
     * @param connectionFactory
     * @return
     */
    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer(ConnectionFactory connectionFactory){
        SimpleMessageListenerContainer simpleMessageListenerContainer = new SimpleMessageListenerContainer(connectionFactory);
        simpleMessageListenerContainer.setQueueNames("alternate-queue");
        simpleMessageListenerContainer.setAcknowledgeMode(AcknowledgeMode.MANUAL);

        simpleMessageListenerContainer.setMessageListener(new ChannelAwareMessageListener(){
            public void onMessage(Message message, Channel channel) throws Exception{
                try {
                    System.out.println("消费者收到消息了");
                    channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
                    System.out.println("消息："+new String(message.getBody()));
                    System.out.println("消息id："+message.getMessageProperties().getDeliveryTag());

                }catch (IOException e){
                    channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,false);
                    channel.basicReject(message.getMessageProperties().getDeliveryTag(),false);
                    System.out.println("出现错误返回消息到队列");
                }

            }
        });
        return simpleMessageListenerContainer;
    }
}

启动类：

@ComponentScan
public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(App.class);
        RabbitTemplate rabbitTemplate = context.getBean(RabbitTemplate.class);
        //发送消息(warn根据xxx不能路由消息就向alternate指定的excahnge发)
        rabbitTemplate.send("warn","xxx",
                new Message("测试alternate".getBytes(),new MessageProperties()));
    }
}

注：错误demo,不要把生产者和消费者放在一个服务端。要想去启动这个demo需要注释bingding和send。然后再启动打开binding，然后再启动打开send.

注：根据视频资料以及网上零散资料的整合，仅供参考。

你可能感兴趣的:(RabbitMQ)

rabbitmq + minio +python 上传文件伶星37 rabbitmq python ruby
功能实现RabbitMq接收hello里面传来的消息根据消息在MobileFile里面新建文件新建文件上传到miniopython新建文件importospath='./MobileFile'file_path=os.path.join(path,"new_file.txt")withopen(file_path,"w")asfile:pass转换成函数格式importosdefcreatefil
RabbitMQ基本原理码农小伙消息队列 rabbitmq 分布式
一、基本结构所有中间件技术都是基于TCP/IP协议基础之上进行构建新的协议规范，RabbitMQ遵循的是AMQP协议（AdvancedMessageQueuingProtocol-高级消息队列协议）。生产者发送消息流程：1、生产者和Broker建立TCP连接；2、生产者和Broker建立通道；3、生产者通过通道消息发送给Broker，由Exchange将消息进行转发；4、Exchange将消息转发
使用Docker部署RabbitMQ 九思x docker rabbitmq 容器
第一步：安装RabbitMQ#1.拉取镜像dockerpullrabbitmq:3.12.0-management#2.启动容器（开放端口+数据持久化）dockerrun-d\--name=share_rabbitmq\-p5672:5672\#AMQP协议端口-p15672:15672\#管理界面端口-v/opt/rabbitmq/data:/var/lib/rabbitmq\#数据持久化目录r
Spring Boot 整合 RabbitMQ：注解声明队列与交换机详解 Cloud_. java-rabbitmq spring boot rabbitmq MQ 消息队列
RabbitMQ作为一款高性能的消息中间件，在分布式系统中广泛应用。SpringBoot通过spring-boot-starter-amqp提供了对RabbitMQ的无缝集成，开发者可以借助注解快速声明队列、交换机及绑定规则，极大简化了配置流程。本文将通过代码示例和原理分析，详细介绍如何用注解实现RabbitMQ的集成，并深入解析交换机的作用与类型。一、环境准备1.添加依赖在pom.xml中引入S
mysql的数据如何进kafka_MySQL数据实时增量同步到Kafka IT巫师
一、go-mysql-transfergo-mysql-transfer是一款MySQL实时、增量数据同步工具。能够实时解析MySQL二进制日志binlog，并生成指定格式的消息，同步到接收端。go-mysql-transfer具有如下特点：1、不依赖其它组件，一键部署2、集成多种接收端，如：Redis、MongoDB、Elasticsearch、RabbitMQ、Kafka、RocketMQ，不
PHP框架为基础的购物平台设计思路分步骤说明星糖曙光后端语言（node javascript vue等等）学习课程设计 vue.js python php
以下是以PHP框架为基础的购物平台设计思路分步骤说明：一、技术选型阶段技术栈={后端框架：Laravel/Yii2（提供ORM、路由、中间件支持）前端框架：Vue.js/React（可选SPA方案）数据库：MySQL8.0+（事务型数据存储）缓存：Redis（会话/商品缓存）队列：RabbitMQ（异步处理订单）\text{技术栈}=\begin{cases}后端框架：Laravel/Yii2（提
rabbitmq笔记 java
消息可靠性rabbitmq向消费者投递消息后，有可能会丢失，有可能会重复投递。比如：投递过程网络故障消费者收到消息后宕机消费者接收到消息后处理不当导致异常...rabbitmq需要做的事：机制消费者确认机制消费者处理成功后需要通知发幂等性幂等性指同一个业务，执行一次或多次对业务状态的影响是一致的例如唯一消息id业务状态判断但是数据的更新往往不是幂等的，所以需要确保幂等性确保幂等性方法有两种方案唯一
RabbitMQ之主题模式（topic）谁对谁错重要吗 RabbitMQ的使用
RabbitMQ之主题模式（topic）简介主题（Topic）：可理解为消息的key，用于匹配某条消息的生产者和消费者将路由键和某种匹配模式一起使用#表示多个*表示1个代码参考生产者/***topic队列**将路由键和某种匹配模式一起使用**#表示多个*表示1个**@authorzhang**/publicclassTopicSend{publicstaticfinalStringTOPIC_NA
RabbitMQ--topic模式浮休383 rabbitmq 分布式
目录1.topic模式2.通配符的使用3.举例4.生产者代码示例5.消费者代码示例1.topic模式Topic模式与Direct模式相比，他们都可以根据Routingkey把消息路由到对应的队列上，但是Topic模式相较于Direct来说，它可以基于多个标准进行路由。也就是在队列绑定Routingkey的时候使用通配符。使我们相较于Direct模式灵活性更大。2.通配符的使用 "*"
【RabbitMQ】超详细Windows系统下RabbitMQ的安装配置 m0_74825074 面试学习路线阿里巴巴 rabbitmq windows 分布式
RabbitMQ是一个开源的消息队列中间件，广泛用于分布式系统中的异步消息传递。它支持多种消息协议，易于扩展，功能强大。本文将详细介绍如何在Windows系统下安装和配置RabbitMQ，包括所需的依赖项、安装步骤、基本配置和常见问题解决方案。目录什么是RabbitMQ？安装前的准备2.1系统要求2.2安装ErlangRabbitMQ的安装步骤3.1下载RabbitMQ3.2安装RabbitMQ配
Spring系列学习之Spring Messaging消息支持 m0_74825488 面试学习路线阿里巴巴 spring linq java
英文原文：https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-messaging.html目录JMSActiveMQ支持Artemis支持使用JNDIConnectionFactory发送消息接收消息AMQPRabbitMQ支持发送消息接收消息ApacheKafka支持发送消息接收消息Kafka流
5、Spring Boot 3.x 集成 RabbitMQ Kenny.志 java-rabbitmq spring boot rabbitmq
一、前言本篇主要是围绕着SpringBoot3.x与RabbitMQ的集成，这边文章比较简单，RabbitMQ的集成没有太大的变化，这篇文章主要是为了后续的RabbitMQ的动态配置做铺垫。1、Docker安装RabbitMQ2、SpringBoot3.x集成RabbitMQ二、Docker安装RabbitMQ1、创建docker-network#创建docker网络，方便后续连通多个容器dock
spring boot 三步集成rabbitmq PXM的算法星球 Java后端 java-rabbitmq spring boot rabbitmq
引入依赖org.springframework.bootspring-boot-starter-amqp编写config类@ConfigurationpublicclassRabbitmqConfig{publicstaticfinalStringRECORD_QUEUE="teaching-assistant-record_queue";@BeanpublicJackson2JsonMessag
在Ubuntu 20.04离线环境中轻松部署RabbitMQ 贡驰赞Powerful
在Ubuntu20.04离线环境中轻松部署RabbitMQ【下载地址】Ubuntu20.04离线安装RabbitMQ指南Ubuntu20.04离线安装RabbitMQ指南欢迎来到Ubuntu20.04系统下离线安装RabbitMQ的教程项目地址:https://gitcode.com/open-source-toolkit/2b1f7在当今快速发展的技术世界里，离线安装开源软件仍然是某些特定场景下
RabbitMQ-死信交换机和死信队列 ui99tew1 rabbitmq 分布式
在RabbitMQ的使用过程中，死信交换机（DeadLetterExchange，简称DLX）和死信队列（DeadLetterQueue，简称DLQ）是解决消息处理失败的一种高效机制。这套机制不仅能帮助系统保证消息的可靠性，还能在消息处理出现问题时提供有效的错误处理和消息追踪方式。接下来，我将详细解释什么是死信队列和死信交换机，以及它们是如何工作的。死信队列和死信交换机的定义死信交换机是一种特殊的
docker compose部署dragonfly java初学者分享 docker 容器运维
整个工具的代码都在Gitee或者Github地址内gitee：solomon-parent:这个项目主要是总结了工作上遇到的问题以及学习一些框架用于整合例如:rabbitMq、reids、Mqtt、S3协议的文件服务器、mongodbgithub：GitHub-ZeroNing/solomon-parent:这个项目主要是总结了工作上遇到的问题以及学习一些框架用于整合例如:rabbitMq、rei
SpringBoot整合通用xxl-job,自动注册任务 java初学者分享 spring boot 后端 java
整个工具的代码都在Gitee或者Github地址内gitee：solomon-parent:这个项目主要是总结了工作上遇到的问题以及学习一些框架用于整合例如:rabbitMq、reids、Mqtt、S3协议的文件服务器、mongodbgithub：GitHub-ZeroNing/solomon-parent:这个项目主要是总结了工作上遇到的问题以及学习一些框架用于整合例如:rabbitMq、rei
SpringBoot整合阿里云、腾讯云、minio、百度云、华为云、天翼云、金山云、七牛云、移动云、网易数帆等等有关于S3协议下文分布式对象存储接口 java初学者分享阿里云腾讯云华为云
前提：在可运行的SpringBoot的项目内引用以下JAR包整个工具的代码都在Gitee或者Github地址内gitee：solomon-parent:这个项目主要是总结了工作上遇到的问题以及学习一些框架用于整合例如:rabbitMq、reids、Mqtt、S3协议的文件服务器、mongodbgithub：GitHub-ZeroNing/solomon-parent:这个项目主要是总结了工作上遇到
SpringBoot整合多租户MongoBD java初学者分享 SaaS多租户专栏 spring boot 后端 java mongodb
前提：在可运行的SpringBoot的项目内引用以下JAR包整个工具的代码都在Gitee或者Github地址内gitee：solomon-parent:这个项目主要是总结了工作上遇到的问题以及学习一些框架用于整合例如:rabbitMq、reids、Mqtt、S3协议的文件服务器、mongodbgithub：GitHub-ZeroNing/solomon-parent:这个项目主要是总结了工作上遇到
消息中间件：RabbitMQ、Kafka 和 Redis如何选择？一文让您了解！写bug如流水架构设计 rabbitmq kafka redis 中间件
RabbitMQ、Kafka和Redis是三种常见的消息中间件，它们各自具有不同的特点和适用的场景。以下是对它们使用场景及选择的分析：1.RabbitMQRabbitMQ是一个基于AMQP（AdvancedMessageQueuingProtocol）的消息队列系统，主要用于消息传递和任务分发，具有可靠的消息传递机制。使用场景：复杂的路由机制：RabbitMQ支持多种交换器类型（如fanout、d
消息中间件选型: kafka与rabbitmq的对比 HS_Henry 消息中间件 rabbitmq kafka 消息中间件选型
RabbitMQ总结_陈海龙的格物之路-CSDN博客https://blog.csdn.net/chl87783255/article/details/122606212kafka总结_陈海龙的格物之路-CSDN博客kafka，仅支持拉取的分布式流式平台。本文从简介、使用场景、设计、实现四个方面阐述kafka。https://blog.csdn.net/chl87783255/article/de
RabbitMQ常见面试题及解析 chi_666 面试 RabbitMQ 面试
1、什么是RabbitMQ？RabbitMQ是一个开源的消息队列系统，它实现了高级消息队列协议（AMQP）。它允许不同的应用程序之间进行异步通信，通过将消息发送到队列中，让消费者从队列中获取消息并进行处理，从而实现解耦、异步和削峰填谷等功能。2、核心组件与流程**Producer：**发送消息的应用。**Exchange：**接收消息并路由到队列（类型：Direct，Fanout，Topic，He
RabbitMQ 与 Kafka：消息中间件的终极对比与选型指南海上彼尚 node.js rabbitmq kafka 分布式 node.js
引言在分布式系统架构中，消息中间件是异步通信的核心组件。RabbitMQ和Kafka作为两大主流技术，常被开发者拿来比较。本文深入解析两者的设计哲学、性能差异和典型场景，助你做出精准技术选型。目录引言一、核心设计差异1.定位与数据模型二、性能与架构对比1.吞吐量与延迟2.集群与扩展三、功能特性对决1.消息可靠性2.消息路由四、典型场景与选型决策1.优先选择Kafka的场景2.优先选择RabbitM
RabbitMQ z小天才b RabbitMQ rabbitmq 分布式
一、MQ相关的概念1.1、MQ的基本概念什么是MQMQ（MessageQueue，消息队列）是一种应用程序对应用程序的通信方法。应用程序通过写入和检索出入队列的针对性消息来通信，这些消息可以存储在内存或磁盘中。消息队列允许应用程序独立地运行，并以可靠的方式相互通信。为啥要用MQ解耦:允许系统独立开发、部署和运行，减少系统间的直接依赖异步处理:非阻塞操作，请求处理与响应分离削峰填谷:缓冲突发请求，防
3.16RabbitMQ入门实战 plusk rabbitmq 分布式
RabbitMQ基本概念：RabbitMQ是遵循AMQP（AdvancedMessageQueueProtocol）协议，即高级消息队列协议实现的，AMQP协议是一个标准协议，如果想写一个原生的消息队列的话也可以遵守该协议去开发。结合AMQP协议的模型图我们可以去理解RabbitMQ的运行机制：生产者（Publisher，图中最左边）：发送消息到交换机交换机（Exchange）：接收消息，并决定转
RabbitMQ 集群降配 Hover_Z_快跑 rabbitmq 分布式
这里写自定义目录标题摘要检查状态1.检查RabbitMQ服务状态2.检查RabbitMQ端口监听3.检查RabbitMQ管理插件是否启用4.检查开机自启状态5.确认集群高可用性6.检查使用该集群的服务是否做了断开重连实操1.负载均衡配置2.逐个节点降配（滚动操作）2.1停止RabbitMQ服务2.2调整ECS配置2.3恢复节点并重新加入集群2.4恢复负载均衡流量3.全局监控与验证4.降配后优化（可
【RabbitMQ】RabbitMQ中死信交换机是什么？延迟队列呢？有哪些应用场景？熏鱼的小迷弟Liu 中间件 rabbitmq ruby 分布式
1.死信交换机(DeadLetterExchangeDLX)1.1什么是死信交换机？死信：在RabbitMQ中，无法被消费者正常处理的消息称为死信(DeadLetter)。死信交换机：用于接收死信的交换机。当消息成为死信时，RabbitMQ会将其重新路由到死信交换机，再由死信交换机根据绑定规则路由到死信队列。1.2消息成为死信的条件1.消息被拒绝：消费者调用basic.reject或basic.n
【RabbitMQ】RabbitMQ如何保证消息不丢失？熏鱼的小迷弟Liu 中间件 rabbitmq 分布式
为了保证消息不丢失，需要在生产者、RabbitMQ本身和消费者三个环节采取相应措施。1.生产者端：确保消息发送成功1.1开启消息确认机制(PublisherConfirms)原理：生产者发送消息后，RabbitMQ会返回一个确认(ACK),表示消息已成功接收。1.2开启事务机制(Transactions)原理：生产者发送信息后，可以通过事务机制确保信息被成功接收。注意：事务机制性能较低，推荐消息确
RabbitMQ支持的复杂的消息交换模式啊sen丶 rabbitmq 分布式
RabbitMQ支持多种复杂的消息交换模式，这些模式通过不同的交换机类型和队列特性实现，能够满足多样化的业务需求。以下是RabbitMQ支持的主要复杂消息交换模式：1.DirectExchange（直连交换机）直连交换机根据消息的路由键（RoutingKey）将消息路由到与该路由键绑定的队列。如果一个队列绑定了多个路由键，它将接收所有匹配的消息。-特点：简单直接，一对一匹配。-适用场景：适用于消息
RabbitMQ中如何确保你的消息只被消费一次昔我往昔 MQ rabbitmq ruby 分布式
在SpringBoot项目中，确保RabbitMQ消息只被消费一次是一个常见且重要的问题。为了确保消息在RabbitMQ中只被消费一次，我们通常依赖于消息确认机制（acknowledgment），以及幂等性设计。以下是一些常见的做法来实现这一目标。1.使用消息确认机制（Ack）RabbitMQ提供了消息确认机制，允许消费者在成功处理消息后通知RabbitMQ服务器。这可以确保在消息消费完成前，不会
C/C++Win32编程基础详解视频下载择善Zach 编程 C++Win32
课题视频：C/C++Win32编程基础详解视频知识：win32窗口的创建 windows事件机制主讲：择善Uncle老师学习交流群：386620625 验证码：625 --
Guava Cache使用笔记 bylijinnan java guava cache
1.Guava Cache的get/getIfPresent方法当参数为null时会抛空指针异常我刚开始使用时还以为Guava Cache跟HashMap一样，get(null)返回null。实际上Guava整体设计思想就是拒绝null的，很多地方都会执行com.google.common.base.Preconditions.checkNotNull的检查。 2.Guava
解决ora-01652无法通过128（在temp表空间中） 0624chenhong oracle
解决ora-01652无法通过128（在temp表空间中）扩展temp段的过程一个sql语句后，大约花了10分钟，好不容易有一个结果，但是报了一个ora-01652错误，查阅了oracle的错误代码说明：意思是指temp表空间无法自动扩展temp段。这种问题一般有两种原因：一是临时表空间空间太小，二是不能自动扩展。分析过程：既然是temp表空间有问题，那当
Struct在jsp标签不懂事的小屁孩 struct
非UI标签介绍：控制类标签： 1：程序流程控制标签 if elseif else <s:if test="isUsed"> <span class="label label-success">True</span> </
按对象属性排序换个号韩国红果果 JavaScript 对象排序
利用JavaScript进行对象排序，根据用户的年龄排序展示 <script> var bob={ name;bob, age:30 } var peter={ name;peter, age:30 } var amy={ name;amy, age:24 } var mike={ name;mike, age:29 } var john={
大数据分析让个性化的客户体验不再遥远蓝儿唯美数据分析
顾客通过多种渠道制造大量数据，企业则热衷于利用这些信息来实现更为个性化的体验。分析公司Gartner表示，高级分析会成为客户服务的关键，但是大数据分析的采用目前仅局限于不到一成的企业。挑战在于企业还在努力适应结构化数据，疲于根据自身的客户关系管理（CRM）系统部署有效的分析框架，以及集成不同的内外部信息源。然而，面对顾客通过数字技术参与而产生的快速变化的信息，企业需要及时作出反应。要想实
java笔记4 a-john java
操作符 1，使用java操作符操作符接受一个或多个参数，并生成一个新值。参数的形式与普通的方法调用不用，但是效果是相同的。加号和一元的正号（+）、减号和一元的负号（-）、乘号（*）、除号（/）以及赋值号（=）的用法与其他编程语言类似。操作符作用于操作数，生成一个新值。另外，有些操作符可能会改变操作数自身的
从裸机编程到嵌入式Linux编程思想的转变------分而治之：驱动和应用程序 aijuans 嵌入式学习
笔者学习嵌入式Linux也有一段时间了，很奇怪的是很多书讲驱动编程方面的知识，也有很多书将ARM9方面的知识，但是从以前51形式的（对寄存器直接操作，初始化芯片的功能模块）编程方法，和思维模式，变换为基于Linux操作系统编程，讲这个思想转变的书几乎没有，让初学者走了很多弯路，撞了很多难墙。笔者因此写上自己的学习心得，希望能给和我一样转变
在springmvc中解决FastJson循环引用的问题 asialee 循环引用 fastjson
我们先来看一个例子： package com.elong.bms; import java.io.OutputStream; import java.util.HashMap; import java.util.Map; import co
ArrayAdapter和SimpleAdapter技术总结百合不是茶 android SimpleAdapter ArrayAdapter 高级组件基础
ArrayAdapter比较简单，但它只能用于显示文字。而SimpleAdapter则有很强的扩展性，可以自定义出各种效果 ArrayAdapter;的数据可以是数组或者是队列 // 获得下拉框对象 AutoCompleteTextView textview = (AutoCompleteTextView) this
九封信 bijian1013 人生励志
有时候，莫名的心情不好，不想和任何人说话，只想一个人静静的发呆。有时候，想一个人躲起来脆弱，不愿别人看到自己的伤口。有时候，走过熟悉的街角，看到熟悉的背影，突然想起一个人的脸。有时候，发现自己一夜之间就长大了。 2014，写给人
Linux下安装MySQL Web 管理工具phpMyAdmin sunjing PHP Install phpMyAdmin
PHP http://php.net/ phpMyAdmin http://www.phpmyadmin.net Error compiling PHP on CentOS x64 一、安装Apache 请参阅http://billben.iteye.com/admin/blogs/1985244 二、安装依赖包 sudo yum install gd
分布式系统理论 bit1129 分布式
FLP One famous theory in distributed computing, known as FLP after the authors Fischer, Lynch, and Patterson, proved that in a distributed system with asynchronous communication and process crashes,
ssh2整合(spring+struts2+hibernate)-附源码白糖_ eclipse spring Hibernate mysql 项目管理
最近抽空又整理了一套ssh2框架，主要使用的技术如下： spring做容器，管理了三层(dao,service,actioin)的对象 struts2实现与页面交互(MVC)，自己做了一个异常拦截器，能拦截Action层抛出的异常 hibernate与数据库交互 BoneCp数据库连接池，据说比其它数据库连接池快20倍，仅仅是据说 MySql数据库项目用eclipse
treetable bug记录 braveCS table
// 插入子节点删除再插入时不能正常显示。修改： //不知改后有没有错，先做个备忘 Tree.prototype.removeNode = function(node) { // Recursively remove all descendants of +node+ this.unloadBranch(node); // Remove
编程之美-电话号码对应英语单词 bylijinnan java 算法编程之美
import java.util.Arrays; public class NumberToWord { /** * 编程之美电话号码对应英语单词 * 题目： * 手机上的拨号盘，每个数字都对应一些字母，比如2对应ABC，3对应DEF.........，8对应TUV，9对应WXYZ， * 要求对一段数字，输出其代表的所有可能的字母组合
jquery ajax读书笔记 chengxuyuancsdn jQuery ajax
1、jsp页面 <%@ page language="java" import="java.util.*" pageEncoding="GBK"%> <% String path = request.getContextPath(); String basePath = request.getScheme()
JWFD工作流拓扑结构解析伪码描述算法 comsci 数据结构算法工作活动 J#
对工作流拓扑结构解析感兴趣的朋友可以下载附件，或者下载JWFD的全部代码进行分析 /* 流程图拓扑结构解析伪码描述算法 public java.util.ArrayList DFS(String graphid, String stepid, int j)
oracle I/O 从属进程 daizj oracle
I/O 从属进程　　I/O从属进程用于为不支持异步I/O的系统或设备模拟异步I/O.例如，磁带设备(相当慢)就不支持异步I/O.通过使用I/O 从属进程，可以让磁带机模仿通常只为磁盘驱动器提供的功能。就好像支持真正的异步I/O 一样，写设备的进程(调用者)会收集大量数据，并交由写入器写出。数据成功地写出时，写入器(此时写入器是I/O 从属进程，而不是操作系统)会通知原来的调用者，调用者则会
高级排序:希尔排序 dieslrae 希尔排序
public void shellSort(int[] array){ int limit = 1; int temp; int index; while(limit <= array.length/3){ limit = limit * 3 + 1;
初二下学期难记忆单词 dcj3sjt126com english word
kitchen 厨房 cupboard 厨柜 salt 盐 sugar 糖 oil 油 fork 叉；餐叉 spoon 匙；调羹 chopsticks 筷子 cabbage 卷心菜；洋白菜 soup 汤 Italian 意大利的 Indian 印度的 workplace 工作场所 even 甚至；更 Italy 意大利 laugh 笑 m
Go语言使用MySQL数据库进行增删改查 dcj3sjt126com mysql
目前Internet上流行的网站构架方式是LAMP，其中的M即MySQL, 作为数据库，MySQL以免费、开源、使用方便为优势成为了很多Web开发的后端数据库存储引擎。MySQL驱动Go中支持MySQL的驱动目前比较多，有如下几种，有些是支持database/sql标准，而有些是采用了自己的实现接口,常用的有如下几种: http://code.google.c...o-mysql-dri
git命令 shuizhaosi888 git
---------------设置全局用户名： git config --global user.name "HanShuliang" //设置用户名 git config --global user.email "[email protected]" //设置邮箱 ---------------查看环境配置 git config --li
qemu-kvm 网络 nat模式 (四) haoningabc kvm qemu
qemu-ifup-NAT #!/bin/bash BRIDGE=virbr0 NETWORK=192.168.122.0 GATEWAY=192.168.122.1 NETMASK=255.255.255.0 DHCPRANGE=192.168.122.2,192.168.122.254 TFTPROOT= BOOTP= function check_bridge()
不要让未来的你，讨厌现在的自己 jingjing0907 生活奋斗工作梦想
故事one 　23岁，他大学毕业，放弃了父母安排的稳定工作，独闯京城，在家小公司混个小职位，工作还算顺手，月薪三千，混了混，混走了一年的光阴。　　　　24岁，有了女朋友，从二环12人的集体宿舍搬到香山民居，一间平房，二人世界，爱爱爱。偶然约三朋四友，打扑克搓麻将，日子快乐似神仙；　　　　25岁，出了几次差，调了两次岗，薪水涨了不过百，生猛狂飙的物价让现实血淋淋，无力为心爱银儿购件大牌
枚举类型详解一路欢笑一路走 enum 枚举详解 enumset enumMap
枚举类型详解一.Enum详解 1.1枚举类型的介绍 JDK1.5加入了一个全新的类型的”类”—枚举类型，为此JDK1.5引入了一个新的关键字enum,我们可以这样定义一个枚举类型。 Demo:一个最简单的枚举类 public enum ColorType { RED
第11章动画效果（上） onestopweb 动画
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Eclipse中jsp、js文件编辑时，卡死现象解决汇总 ljf_home eclipse jsp卡死 js卡死
使用Eclipse编辑jsp、js文件时，经常出现卡死现象，在网上百度了N次，经过N次优化调整后，卡死现象逐步好转，具体那个方法起到作用，不太好讲。将所有用过的方法罗列如下： 1、取消验证 windows–>perferences–>validation 把除了manual 下面的全部点掉，build下只留 classpath dependency Valida
MySQL编程中的6个重要的实用技巧 tomcat_oracle mysql
每一行命令都是用分号(;)作为结束对于MySQL，第一件你必须牢记的是它的每一行命令都是用分号(;)作为结束的，但当一行MySQL被插入在PHP代码中时，最好把后面的分号省略掉，例如： mysql_query("INSERT INTO tablename(first_name,last_name)VALUES('$first_name',$last_name')");
zoj 3820 Building Fire Stations(二分+bfs) 阿尔萨斯 Build
题目链接：zoj 3820 Building Fire Stations 题目大意：给定一棵树，选取两个建立加油站，问说所有点距离加油站距离的最大值的最小值是多少，并且任意输出一种建立加油站的方式。解题思路：二分距离判断，判断函数的复杂度是o(n)，这样的复杂度应该是o(nlogn)，即使常数系数偏大，但是居然跑了4.5s，也是醉了。判断函数里面做了3次bfs，但是每次bfs节点最多