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)

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服务器。这可以确保在消息消费完成前，不会
Node.js 中使用 RabbitMQ 海上彼尚 node.js node.js rabbitmq 分布式
目录一、RabbitMQ简介二、核心概念解析三、环境搭建（以Ubuntu为例）四、Node.js实战：生产者与消费者1.安装依赖2.生产者代码（发送消息）3.消费者代码（处理消息）五、高级配置与最佳实践六、常见问题与解决方案七、总结一、RabbitMQ简介RabbitMQ是一个基于AMQP协议的开源消息代理工具，专为分布式系统设计。它通过解耦生产者和消费者实现异步通信，支持流量削峰、任务队列、服务
docker 部署 RabbitMQ 嗑瓜子儿溜茶水儿 docker docker rabbitmq 容器
命令dockerrun-d--name=rabbitmq\-p5671:5671-p5672:5672-p4369:4369\-p15671:15671-p15672:15672-p25672:25672\-eRABBITMQ_DEFAULT_USER=username\-eRABBITMQ_DEFAULT_PASS=password\-v/usr/local/rabbitmq/data:/var
docker部署rabbitMQ 人间有清欢 docker docker rabbitmq
docker部署rabbitMQ如果用目录挂载会启动失败，要用数据卷挂载。dockerpullrabbitmq:3.8-management#挂载数据卷-vmq-plugins:/plugins\#设置主机名--hostnamemq\dockerrun\-eRABBITMQ_DEFAULT_USER=rabbitmq\-eRABBITMQ_DEFAULT_PASS=1234\-vmq-plugin
Docker 部署RabbitMQ 逢生博客 docker rabbitmq 容器 spring boot
文章目录镜像docker-compose.yml访问控制台SpringBoot批量声明队列镜像https://hub.docker.com/_/rabbitmqdockerpullrabbitmq:managementdockerpullrabbitmq:4.0.7-managementdocker-compose.ymlservices:rabbitmq:image:rabbitmq:3.9.5
RabbitMQ 和 Redis 的选择一条小小yu rabbitmq redis
在处理大规模消息场景时，RabbitMQ和Redis的选择需根据具体需求权衡。大规模消息场景的关键考量吞吐量需求：Redis：更适合超高频写入（如百万级/秒），但需牺牲部分可靠性。RabbitMQ：稳定吞吐（数十万级/秒），适合长期高负载但无需极限性能的场景。消息可靠性：必须持久化→选RabbitMQ（内置持久化+多节点集群）。可容忍丢失→Redis（依赖AOF/RDB，但集群部署需注意一致性）。
使用 .NET Core 实现 RabbitMQ 消息队列的详细教程江沉晚呤时 Net core 开发语言后端 c#.netcore
RabbitMQ是一个流行的消息队列中间件，它允许应用程序通过异步消息的方式进行通信。RabbitMQ支持AMQP协议，可以通过多种方式与应用程序交互。在本教程中，我们将深入探讨如何在.NETCore环境中使用RabbitMQ来实现消息队列。我们将学习如何在生产者端发送消息，消费者端接收消息，并确保消息的可靠性。目录安装和配置RabbitMQ安装RabbitMQ客户端库创建生产者（Producer
RabbitMQ应用问题大全（精心整理版） ngioig RabbitMQ microsoft spring rabbitmq 分布式
前言其实这部分知识我是整理在语雀上了，这里是直接复制粘贴过来的。不是很好阅读，可以直接点下方链接去语雀看，那个看的会舒服很多。https://www.yuque.com/g/ngioig/upbg6b/fkarhyo8fpgrtyq8/collaborator/join?token=GvlO0di8KaIfO8aF&source=doc_collaborator#《RabbitMQ常见问题知识库》
【.NET 6】RabbitMQ延迟消息指南人生短几个秋 .net core rabbitmq .net
背景最近遇到一个比较特殊需求，需要修改一个的RabbitMQ消费者，以实现在消费某种特定的类型消息时，延迟1小时再处理，几个需要注意的点：延迟是以小时为单位不是所有消息都延迟消费，只延迟特定类型的消息只在第一次消费时延迟1小时，容错机制产生的重新消费（也即消息消费失败，多次进入延迟队列重试），则不再延迟1小时消费者消费过程中可能会重启考虑到这几点，我们需要一个标识以及持久化，不能简单使用Threa
MQ和ActiveMQ浅析星星都没我亮 ActiveMQ activemq
文章目录什么是JMSMQ消息中间件应用场景异步通信缓冲解耦冗余扩展性可恢复性顺序保证过载保护数据流处理常用消息队列（ActiveMQ、RabbitMQ、RocketMQ、Kafka）比较JMS中的一些角色BrokerproviderConsumerp2ppub/subPTP和PUB/SUB简单对QueueTopicConnectionFactoryConnectionDestinationSess
消息队列的特性与使用场景：Kafka、ActiveMQ、RabbitMQ与RocketMQ的深度剖析啊sen丶 kafka activemq rabbitmq rocketmq 分布式消息队列
在分布式系统和微服务架构中，消息队列是实现服务间通信和解耦的核心组件。Kafka、ActiveMQ、RabbitMQ和RocketMQ是当前最受欢迎的消息队列解决方案，它们各自具有独特的特性和适用场景。本文将从特性和使用场景两个维度进行对比分析，帮助读者更好地理解它们的差异，并根据实际需求选择合适的消息队列。一、特性对比（一）吞吐量与延迟-Kafka：以高吞吐量著称，适合大规模数据的批量处理。延迟
RabbitMQ在Spring Boot中的使用 VioletAmaranth java-rabbitmq rabbitmq spring
在SpringBoot中使用RabbitMQ涉及多个步骤，包括配置、创建监听器和发送消息。以下是详细的使用指南：1.添加依赖需要在项目的pom.xml文件中添加spring-boot-starter-amqp依赖：org.springframework.bootspring-boot-starter-amqp这将触发自动配置。2.配置文件在application.properties或applic
在Spring Boot中使用RabbitMQ实现延迟队列 angen2018 #spring boot rabbitMQ java-rabbitmq spring boot rabbitmq
要在SpringBoot中使用RabbitMQ实现延迟队列，有两种主要的方法：1.**使用TTL（TimeToLive）和DLX（DeadLetterExchange）**：这种方法不需要安装额外的插件，通过设置消息的TTL或者队列的TTL属性来实现延迟效果。当消息达到设定的TTL时间且未被消费时，它会变成死信（DeadLetter），并根据DLX和死信路由键转发到指定的延迟消费队列。这种方式的一
Spring Boot中使用RabbitMQ实现简单的消息发送与接收 Takumilovexu MQ java-rabbitmq rabbitmq spring boot
文章目录环境准备1.RabbitMQ的基础配置2.实现消息发送功能3.实现消息接收功能4.总结在微服务架构和分布式系统中，消息队列是实现异步通信和解耦的重要工具。RabbitMQ作为一种常见的消息中间件，广泛应用于消息传递、任务分发等场景。本文将带你一步步实现如何在SpringBoot应用中使用RabbitMQ进行消息的发送和接收。我们将构建一个消息发送者（Publisher）和一个消息接收者（C
RabbitMQ 高级特性：从 TTL 到消息分发的全面解析（下） ngioig RabbitMQ ruby 开发语言后端
RabbitMQ高级特性RabbitMQ高级特性解析：RabbitMQ消息可靠性保障（上）-CSDN博客RabbitMQ高级特性：从TTL到消息分发的全面解析（下）-CSDN博客引言RabbitMQ作为一款强大的消息队列中间件，在分布式系统中发挥着至关重要的作用。除了基本的消息收发功能外，它还具备许多高级特性，如TTL、死信队列、延迟队列、事务和消息分发等。本文将详细介绍这些高级特性。1.TTL（
RabbitMQ相关的面试题努力的搬砖人. java rabbitmq 后端
以下是150道RabbitMQ相关的面试题及简洁回答：RabbitMQ基础概念1.什么是RabbitMQ？RabbitMQ是一个开源的AMQP（高级消息队列协议）实现，用于在分布式系统中进行消息传递和通信。它允许应用程序通过网络发送和接收消息，实现异步处理、解耦合和扩展性。RabbitMQ使用Erlang语言开发，具有高可用性和容错性，适用于各种规模的应用程序。2.RabbitMQ的核心组件有哪些
Rabbitmq踩坑---删掉.erlang.cookie后重新启动服务报错原子一式 Rabbitmq
集群部署的时候，自己笔记本安装3台centos7服务器【102，103，104】，各种前期准备好后，执行rabbitmqctlcluster_status发现报错，第一个想到的是cookie可能不对，检查发现三台.erlang.cookie都是一样的，仔细一看是103我改过hostname，重启后，从102拷贝过来发现还是报错，我就直接删掉了.erlang.cookie,然后又从102拷贝过来，启
Spring Boot整合RabbitMQ极简教程 Cloud_. java-rabbitmq spring boot rabbitmq
一、消息队列能解决什么问题？异步处理：解耦耗时操作（如发短信、日志记录）流量削峰：应对突发请求，避免系统过载应用解耦：服务间通过消息通信，降低依赖二、快速整合RabbitMQ1.环境准备安装RabbitMQ（推荐Docker一键部署）：dockerrun-d--namerabbitmq-p5672:5672-p15672:15672rabbitmq:management访问管理界面：http://
RocketMQ、Kafka、RabbitMQ，如何选型？大梦谁先觉i 中间件 Spring boot Spring Cloud rocketmq kafka rabbitmq
如何根据应用场景选择合适的消息中间件?分布式、微服务、高并发架构中，消息队列（MessageQueue，简称MQ）扮演着至关重要的角色。消息队列用于实现系统间的异步通信、解耦、削峰填谷等功能。目前常见的MQ实现包括RabbitMQ、RocketMQ和Kafka。RocketMQ、Kafka、RabbitMQ如何选择？三大MQ的简单对比特性RabbitMQRocketMQKafka公司/社区Rabb
《架构300讲》学习笔记（201-250） newProxyInstance 笔记架构
前言内容来自B站IT老齐架构300讲内容。201小心selectforupdate，有效规避索引选择性锁表202设计模式之建造者模式的用途20320分钟上手ELK日志监控系统分类：【ELK】204设计模式之门面模式Facade205设计模式之适配器模式Adapter206经典设计！如何让RabbitMQ支持消息延迟投递207Docker容器基于NFS实现跨容器文件共享208数据向上追溯场景该如何优
kafka rocketmq rabbitmq 都是怎么实现顺序消费的 C18298182575 kafka rocketmq rabbitmq
Kafka、RocketMQ和RabbitMQ都支持顺序消费，但它们的实现机制有所不同。以下是这三种消息队列实现顺序消费的方式：1.Kafka的顺序消费实现机制分区内有序：Kafka保证单个分区（Partition）内的消息是有序的。消息按照写入分区的顺序存储，消费者按照相同的顺序消费。分区间无序：不同分区之间的消息顺序是不保证的。例如，消息A写入分区0，消息B写入分区1，消费者可能会先消费到消息
Java面试精选：Kafka+Zookeeper+redis+JVM+RabbitMQ，最全总结我叫小迁W：bjmsb2019 Java 架构面试数据库 java redis mysql 分布式
大家开始准备金九银十了吗？不知是跳槽还是找工作的朋友，趁现在增进一下自己的技术何尝不是一件好事呢？一、RabbitMQ1.rabbitmq的使用场景有哪些？2.rabbitmq有哪些重要的角色？3.rabbitmq有哪些重要的组件？4.rabbitmq中vhost的作用是什么？5.rabbitmq的消息是怎么发送的？6.rabbitmq怎么保证消息的稳定性？7.rabbitmq怎么避免消息丢失？8
SpringBoot整合RabbitMQ z小天才b RabbitMQ ruby 开发语言后端
1、添加依赖org.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-amqporg.projectlomboklomboktrue2.配置文件(application.yml)spring:rabbitmq:host:localhostport:5672username:g
SpringBoot整合RabbitMq qq_45923849 java-rabbitmq spring boot rabbitmq
1.引入依赖org.springframework.bootspring-boot-starter-amqp2.application.yml文件配置spring:rabbitmq:host:192.168.101.129port:5672username:adminpassword:adminvirtual-host:/3.编写配置类主要是声明RabbitTemplate，创建交换机和队列并进行
RabbitMQ实战（二）-消息持久化策略、事务以及Confirm消息确认方式 Java思享汇 RabbitMQ学习 RabbitMQ 消息持久化事务 confirm ack
「扫码关注我，面试、各种技术（mysql、zookeeper、微服务、redis、jvm）持续更新中～」RabbitMQ学习列表：RabbitMQ实战（一）-消息通信基本概念·在上一篇学习完RabbitMQ通信的基本概念后，我们来继续学习消息的持久化以及代码实现RabbitMQ通信。在正常生产环境运维过程中无法避免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节点最多