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报错：Shutdown Signal channel error； protocol method m0_74825093 面试学习路线阿里巴巴 rabbitmq 分布式
报错信息：ShutdownSignal:channelerror;protocolmethod:#method(reply-code=406,reply-text=PRECONDITION_FAILED-unknowndeliverytag1,class-id=60,method-id=80)原因默认情况下RabbitMQ是自动ACK（确认签收）机制，就意味着MQ会在消息发送完毕后，自动帮我们去A
clickhouse去重复数据解决方案追梦者123 clickhouse
原因出现问题因为我们的maxwell对接rabbitmqrabbitmq监听的是mysql的belog日志文件，所以mysql数据的实时操作都会同步数据到maxwell中从而导致新增插入一条，修改插入一条，删除插入一条，导致同一条数据有大量的重复数据。解决方案在仪表板调用统计相关接口之前，先将重复数据处理掉OPTIMIZETABLEtable_nameFINAL这样就可以根据orderby(uui
RabbitMQ高级特性--持久性小五Z RabbitMQ rabbitmq 分布式
我们在前面讲了消费端处理消息时,消息如何不丢失,但是如何保证当RabbitMQ服务停掉以后,生产者发送的消息不丢失呢.默认情况下,RabbitMQ退出或者由于某种原因崩溃时,会忽视队列和消息,除非告知他不要这么做.RabbitMQ的持久化分为三个部分:交换器的持久化、队列的持久化和消息的持久化一、交换机持久化交换器的持久化是通过在声明交换机时是将durable参数置为true实现的.相当于将交换机
Rabbitmq从入门到精通 XJzz3 消息中间件 rabbitmq
文章目录1.RabbitMQ简介1.2组件介绍1.1消息队列的选择1.2Docker安装rabbitmq1.4消息应答机制2.1交换机类型2.1direct2.2fanout2.3topic：2.4header3RabbitMQ集群搭建3.1docker搭建rabbitmq集群4死信队列4.1ttl消息过期：生产者添加延迟生产4.2队列最大长度4.35.延迟队列6.发布确认机制6.1发布确认原理1
VEC系列-RabbitMQ 入门笔记怎么又抽烟 VEC教程系列 rabbitmq .netcore c#
消息队列（MQ）对于开发者来说是一个经常听到的词汇，但在实际开发中，大多数人并不会真正用到它。网上已经有很多关于MQ概述和原理的详细讲解，官网文档和技术博客也都介绍得很深入，因此，我在这里就不再赘述。我一直认为，学习一项技术不仅要知道它是什么，更重要的是知道怎么用，以及在哪些场景下应该用。所以这篇文章主要就是站在一个新手的角度进行描述以及实现MQ的实际运用。使用MQ的常见情景系统解耦：比如电商系统
RabbitMQ error : cannot_delete_plugins_expand_dir dev-tang java-rabbitmq rabbitmq 分布式
通过命令rabbitmq-server前台启动RabbitMQ报错...Startingbroker...BOOTFAILED===========Errorduringstartup:{error,{cannot_delete_plugins_expand_dir,["/var/lib/rabbitmq/mnesia/rabbit@centos7-plugins-expand",{cannot_
RabbitMQ知识点梳理 java1224 rabbitmq 分布式
1.RabbitMQ逻辑架构有哪些？分为server端（也称为Broker）和client端server端：Broker：RabbitMQ服务器，用于对外提供服务。客户端（生产者及消费者）使用RabbitMQ消息中间件均需要连接到Broker，使用Rabbit的消息队列服务。VirtualHost：Broker的虚拟机，提供多租户功能，实现租户的权限分离。Exchange：消息交换器，指定消息发送
【从0到1构建高并发后端系统：Spring Boot + Redis + RabbitMQ实战指南】小怪兽9699 spring boot
一、架构演进路径图图1：从单体架构到微服务集群的演进过程二、核心优化策略与落地实践1.数据库优化方案分库分表实践：//ShardingSphere分片策略配置spring:shardingsphere:datasource:names:ds0,ds1rules:sharding:tables:order:actual-data-nodes:ds$->{0..1}.order_$->{0..3}ta
ABP框架综合示例代码及消息队列(MQ)集成教程 KX-EZ
本文还有配套的精品资源，点击获取简介：ABP框架是一个基于.NET的企业级应用程序开发框架，它集成了领域驱动设计、模块化、分层架构、依赖注入、CQRS、事件溯源等最佳实践。本教程包含所有ABP核心功能和模块的示例代码，展示如何利用ABP开发不同类型的项目，并详细讲解了ABP支持的消息队列（如RabbitMQ）的集成方法。开发者可以利用这些示例深入学习ABP的使用和扩展，从而在构建企业级应用程序时提
Kafka、RabbitMQ、RocketMQ的区别种豆走天下 kafka rabbitmq rocketmq
Kafka、RabbitMQ、和RocketMQ都是广泛使用的消息中间件，它们各自有不同的特点、架构设计和应用场景。下面是它们之间的主要区别：1.架构设计Kafka：Kafka是一个分布式流处理平台，最初由LinkedIn开发，主要用于处理大规模数据流。Kafka的架构包括Producer（生产者）、Consumer（消费者）、Broker（代理）和Topic（主题）。Kafka使用分区和副本来提
RabbitMQ之交换机 CodePanda@GPF RabbitMQ rabbitmq 分布式
文章目录1.交换机概念2.fanout交换机3.direct交换机4.topic交换机1.交换机概念RabbitMQ消息传递模型的核心思想是:生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何
消息队列MQ（RabbitMQ） MiniFlyZt rabbitmq 分布式 spring boot 微服务
在现代软件架构中，消息队列（MessageQueue，简称MQ）是一种非常重要的中间件，广泛应用于分布式系统、微服务架构以及异步通信场景中。消息队列通过允许应用程序之间通过消息进行通信，从而实现解耦、提高系统的可扩展性和可靠性。本文将介绍消息队列的基本概念、常见实现方式，并通过一个简单的Java示例来展示如何使用消息队列。消息Broker，目前常见的实现方案就是消息队列（MessageQueue）
监听 RabbitMQ 延时交换机的消息数、OpenFeign 路径参数传入斜杠无法正确转义 s:103 后端进阶实践 rabbitmq 分布式 openfeign
背景【MQ】一套为海量消息和高并发热点消息，提供高可用精准延时服务的解决方案我现在有一个需求，就是监听RabbitMQ一个延时交换机的消息数，而RabbitTemplate是不存在对应的方法来获取的。而我们在RabbitMQ的控制台却可以发现延时交换机的消息数，所以其开放的http-api里存在我们需要的数据，通过抓包可得：而我们查看这个包，构造请求（抓包+分析的技巧这里不做介绍）当然你完全可以去
消息队列RabbitMQ 北执南念工作中开发总结中间件 rabbitmq 分布式
文章目录一RabbitMQ介绍1消息队列2RabbitMQ3基本概念4结构图5通讯方式二RabbitMQ安装拉取镜像运行登录新建用户新建virtualhost三RabbitMQ用法常规套路1新建springboot项目2简单队列3工作队列4发布订阅模式5路由模式6主题模式四消息的可靠性处理1消息的持久化2消息的确认机制第二种是消费接收确认配置：3防止消息重复消费五延迟队列1TTL+死信队列TTL通
Springboot整合RabbitMQ-MQ交换机、队列工厂初始化工厂 panlupeng RabbitMQ rabbitmq spring boot java
1.场景案例项目过程中我们应用到的MQ比较多一些例如设备之间的实时通信、后台服务向前端WEB实时传输消息，不过我们在项目初期要定义一些MQ的交换机绑定队列，可以在页面控制台上进行添加，但是我们产品部署现场的时候可不能给甲方进行一步一步的操作所以要做初始化工厂作为数据总线来维护我们项目中的所有MQ管理。2.实例应用-建表操作我们用数据库作为存储，将来WEB端也可以给我们提供页面进行增加删除MQ的控制
springboot Rabbit MQ topic 配置文件绑定队列和交换机 c137范特西 java java-rabbitmq spring boot 微服务
SpringBoot中如何将队列和交换机绑定（含实例讲解）在使用SpringBoot开发高并发的秒杀系统或者其他场景时，RabbitMQ是常用的消息队列中间件之一。本文将详细讲解如何在配置类中通过代码将队列与交换机绑定，并指定路由键来实现消息路由。一、RabbitMQ中的关键概念Exchange（交换机）：交换机负责接收消息，并根据路由规则分发给绑定的队列。常见的交换机类型有Direct、Fano
rabbitmq 学习之 mirror queue cluster 搭建（26） xiaoliuliu2050 rabbitmq
官网:https://www.rabbitmq.com/ha.html高可用（镜像）队列默认情况下，queues存放在RabbitMQ集群的单个节点之上。exchanges和bindings恰恰相反，在集群中的所有节点中都有存档。queues可以配置镜像以此可以在多个节点中有备份。每个镜像队列包含一个master节点和一个或者多个slave节点。如果master节点由于某种原因失效，那么“资历最老
关于SpringCloud整合RabbitMQ的应用详解（ack，限流，幂等）何须低眉 java rabbitmq
安装RabbitMQ安装Eralng与RabbitMQ导包org.springframework.cloudspring-cloud-starter-stream-rabbit生产者配置关于spring.rabbitmq.template.mandatory与spring.rabbitmq.publisher-returnsspring.rabbitmq.template.mandatory属性的
k8s service type_RabbitMQ(k8s)-随手笔记 weixin_39873325 k8s service type
介绍基于Erlang开发消息队列(AMQP)在分布式系统中,有一些功能我们希望能够提高系统稳定性,比如说支付、订单功能,服务后移,长时间操作的功能,同步数据我们通过监听数据变化实现功能联动特点分布式各节点互相冗余元数据(erlang.cookie,队列、交换机、绑定元数据、vhost元数据)实现分布式集群(类似于session),通过转发达到集群任意节点进入都是集群主节点可以任意增加节点实现集群水
Spring Boot 消息队列（以RabbitMQ为例）珠峰日记 java-rabbitmq spring boot rabbitmq
文章目录RabbitMQ简介与安装1.RabbitMQ简介2.RabbitMQ安装SpringBoot集成RabbitMQ1.创建SpringBoot项目2.配置RabbitMQ3.定义消息队列和交换机4.发送消息5.接收消息6.测试消息发送和接收RabbitMQ简介与安装1.RabbitMQ简介RabbitMQ是一个开源的消息代理和队列服务器，基于AMQP（高级消息队列协议）实现。它具有以下特点
分分钟搞定分布式技术专题面试——Nginx+ZK+ActiveMQ+Kafka+RabbitMQ+MongoDB+Redis！独孤球球 java 开发语言
前些日子听很多朋友说面试跪在分布式，所以今天特地来总结一波分布式技术专题面试，限流、通讯、缓存：01分布式限流：Nginx+ZooKeeper1.1分布式限流之Nginx请解释一下什么是Nginx?请列举xNginx的一些特性。请列举xNginx和和Apache之间的不同点请解释xNginx如何处理PHTTP请求。在xNginx中，如何使用未定义的服务器名称来阻止处理请求?使用“反向代理服务器”请
【面试题】MQ部分[2025/1/13 ~ 2025/1/19] 5faith rabbitmq kafka rocketmq 面试 java
MQ部分[2025/1/13~2025/1/19]1.如何处理重复消息？2.如何保证消息的有序性？3.如何处理消息堆积？4.如何保证消息不丢失？5.[RabbitMQ]RabbitMQ怎么实现延迟队列？6.[RabbitMQ]RabbitMQ中消息什么时候会进入死信交换机？7.[RabbitMQ]RabbitMQ中无法路由的消息会去到哪里？8.[RocketMQ]为什么RocketMQ不使用Zoo
springboot整合rabbitMQ twx95 java-rabbitmq spring boot rabbitmq
安装rabbitMQ虚拟机或者服务器上安装我这里使用的是vm虚拟机做演示第一步：安装docker参考linux安装docker-CSDN博客第二步：拉取rabbitMQ镜像3-management（镜像版本）dockerpullrabbitmq:3-management查看镜像是否拉取成功dockerimages第三步：运行rabbitMQdockerrun\-eRABBITMQ_DEFAULT_
rabbitmq 手动提交_第四章----SpringBoot+RabbitMQ发送确认和消费手动确认机制 weixin_39622178 rabbitmq 手动提交
1.配置RabbitMQ#发送确认spring.rabbitmq.publisher-confirms=true#发送回调spring.rabbitmq.publisher-returns=true#消费手动确认spring.rabbitmq.listener.simple.acknowledge-mode=manual2.生产者发送消息确认机制其实这个也不能叫确认机制，只是起到一个监听的作用，监
rabbitmq-amqp事务消息+消费失败重试机制+prefetch限流執迷王二 rabbitmq 分布式
1.安装和配置org.springframework.bootspring-boot-starter-amqpcom.fasterxml.jackson.corejackson-databind1.2yml配置###生产端的配置spring:rabbitmq:host:localhostport:5672virtual-host:/#虚拟主机username:guestpassword:guest
RabbitMQ如何保证消息的幂等性、可靠性、顺序性 zw791029369 消息队列MQ rabbitmq
如何保证消息的幂等性所谓的幂等性其实就是保证同一条消息不会重复或者重复消费了也不会对系统数据造成异常。出现消息重复消费的情况拿RabbitMQ来说的话，消费者在消费完成一条消息之后会向MQ回复一个ACK（可以配置自动ACK或者手动ACK）来告诉MQ这条消息已经消费了。假如当消费者消费完数据后，准备回执ACK时，系统挂掉了，MQ是不知道该条消息已经被消费了。所以重启之后MQ会再次发送该条消息，导致消
RabbitMQ四种交换机以及在管理页面中创建交换机、队列和绑定关系，代码示例 QAQalone idea linux java rabbitmq 中间件 java
RabbitMQ是目前应用非常广泛的一种消息队列之一，今天就来简单说一下RabbitMQ的四种交换机以及在管理页面中创建交换机、队列、绑定关系一、RabbitMQ中的几个关键字的概念开始讲之前先来简单描述一下RabbitMQ中的几个关键的概念：Broker：可以简单的理解为安装了RabbitMQ服务的这台机器就可以称为一个BrokerExchange：交换机，消息经由它，通过路由键来判断并决定把消
RabbitMQ 可靠性、重复消费、顺序性、消息积压解决方案一堆土豆33 java-rabbitmq rabbitmq java
前言为什么引入消息队列？引入MQ给我们解决了一些问题，但同时又引入了一些复杂的问题，这些问题是大型项目中必须解决的重点，更重要的是，面试也经常问。实际上消息队列可以说是没法百分之百保证可靠性的！RabbitMQ提供的相关机制也只是在于缩小消息丢失的概率，或者说提供了消息丢失后的我们可以记录日志的功能。在解决这些问题时有必要明白一点，其实小公司业务量不大，并发量不高的情况下这些问题是几乎不会发生的.
剖析RabbitMQ消息可靠投递 Answer-2296 Java杂谈 rabbitmq mq
文章目录剖析RabbitMQ消息可靠投递1.RabbitMQ的工作流程2.消息可靠性投递2.1剖析消息可靠发送（上半场）2.2剖析消息可靠消费（下半场）2.3剖析消息幂等性保障2.4Redis消息幂等设计剖析RabbitMQ消息可靠投递1.RabbitMQ的工作流程针对协议AMQP0-9-1（开发常用协议）消息队列工作原理分三个角色：消息生产者、消息队列服务器、消息消费者RabbitMQ服务器内部
使用docker部署RabbitMQ Java码农也是农 docker rabbitmq 消息队列 springcloud
docker搭建RabbitMQ1.拉取RabbitMQ镜像dockerpullrabbitmq:management注意：要拉取rabbitmq:management，如果直接pullrabbitmq,创建对应容器后可能无法通过浏览器访问页面，好像还需要下插件...2.创建rabbitmq容器dockerrun-d--namerabbit-eRABBITMQ_DEFAULT_USER=admin
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节点最多