rabbit

gterouh

已于 2024-04-12 21:49:53 修改

阅读量222

点赞数 5

文章标签： java

于 2024-04-10 15:44:56 首次发布

本文链接：https://blog.csdn.net/qq_52869391/article/details/137595323

版权

1、rabbitmq启动

1、D:\rabbit\rabbitmq\rabbitmq_server-3.12.1\sbin

2、cmd rabbitmq-plugins enable rabbitmq_management

3、访问地址：http://127.0.0.1:15672
账号/密码：guest

2、maven->boot

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>demo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>publisher</module>
        <module>consumer</module>
    </modules>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.13</version>
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.6.13</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</project>

3、测试

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest


@SpringBootTest(classes = PublisherApplication.class)
public class PublisherApplicationTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

//生产者
    @Test
    void test01(){
        String queueName="test001";
        String msg="111";
        rabbitTemplate.convertAndSend(queueName,msg);
    }
}

//消费者
//    监听队列
    @RabbitListener(queues = "test001")
    //消费者
    public void listenerQueue(String str){
        System.out.println("收到消息:"+str);
    }

4、交换机类型

1、fanout广播，一个消息发送交换机发送给多个队列

@SpringBootTest(classes = PublisherApplication.class)
public class PublisherApplicationTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

//生产者
    @Test
    void test01(){
        String queueName="test001";
        String msg="111";
        rabbitTemplate.convertAndSend(queueName,msg);
    }
}

//消费者
//    监听队列
    @RabbitListener(queues = "test001")
    //消费者
    public void listenerQueue(String str){
        System.out.println("收到消息:"+str);
    }

  //生产者
   @Test
    void test02(){
        String excName="fanout001";
        String msg="333";
        rabbitTemplate.convertAndSend(excName,"",msg);
    }


    @RabbitListener(queues = "test001")
    //消费者
    public void listenerQueue1(String str){
        System.out.println("消费者1收到消息:"+str);
    }

    @RabbitListener(queues = "test002")
    //消费者
    public void listenerQueue2(String str){
        System.out.println("消费者2收到消息:"+str);
    }

2、direct指定，一个消息发送给交换机，通过路由key绑定到指定队列

//生产者
@Test
    void test03(){
        String excName="direct001";
        String msg="333";
        rabbitTemplate.convertAndSend(excName,"key1",msg);
    }


//消费者
        @RabbitListener(bindings = @QueueBinding(
                value = @Queue(name = "test001"),
                exchange = @Exchange(name = "direct001",type = ExchangeTypes.DIRECT),
                key = {"key1","key2"}

        ))
    //消费者
    public void listenerQueue2(String str){
        System.out.println("消费者2收到消息:"+str);
    }

3、topic匹配路由，一个消息发送给交换机，通过路由key匹配规则匹配相应队列

5、消息转换器（消息为一个Object对象）

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

//生产者
//配置消息转换器
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }

    @Test
    void test03(){
        String excName="direct33";
        Map<String, String> msg = new HashMap<>();
        msg.put("name","jack");
        msg.put("sex","男");
        rabbitTemplate.convertAndSend(excName,"key1",msg);
    }

//消费者
//配置消息转换器
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }

        @RabbitListener(bindings = @QueueBinding(
                value = @Queue(name = "test33",durable = "true"),
                exchange = @Exchange(name = "direct33",type = ExchangeTypes.DIRECT),
                key = {"key1","key2"}

        ))
    //消费者
    public void listenerQueue2(Map<String,String> map){
        System.out.println("收到消息:"+map.get("name"));
    }

@RequiredArgsConstructor注解相当与Autowired

private final FooService fooService;

6、发送的可靠性

（1）网络波动，链接mq异常，配置mq生产者重连机制

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        prefetch: 1 #每次获取一条消息，处理完在进行下一条，强的消费者处理多点，弱的少点

    #失败重试设置
    connection-timeout: 1s #设置mq的链接超时时间
    template:
      retry:
        enabled: true #开启超时重试机制
        initial-interval: 1000ms #失败后的初始等待时间
        multiplier: 1 #失败后的下次等待时长倍数 initial-interval*multiplier
        max-attempts: 3 #最大重试次数

（2）生产者确认机制

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        prefetch: 1 #每次获取一条消息，处理完在进行下一条，强的消费者处理多点，弱的少点
    connection-timeout: 1s #设置mq的链接超时时间
    #失败重试
    template:
      retry:
        enabled: true #开启超时重试机制
        initial-interval: 1000ms #失败后的初始等待时间
        multiplier: 1 #失败后的下次等待时长倍数 initial-interval*multiplier
        max-attempts: 3 #最大重试次数

    publisher-confirm-type: correlated  #开启confirm确认机制
    publisher-returns: true #开启生产者的return机制

配置回调

@Configuration
public class RabbitConfig implements ApplicationContextAware {

    //配置回调不管发送成功或失败
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //获取RabbitTemplate
        RabbitTemplate rabbitTemplate = applicationContext.getBean(RabbitTemplate.class);
        //设置returnCallback
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {
            @Override
            public void returnedMessage(ReturnedMessage returnedMessage) {
                System.out.println(returnedMessage.getMessage());
                System.out.println(returnedMessage.getExchange());
                System.out.println(returnedMessage.getReplyCode());
                System.out.println(returnedMessage.getRoutingKey());
                System.out.println(returnedMessage.getReplyText());
            }
        });
    }
}

生产者

    @Test
    void test03(){
        //创建cd cd对象里有消息的唯一标识（消息id），用来确定某个消息
        CorrelationData cd = new CorrelationData(UUID.randomUUID().toString());
        cd.getFuture().addCallback(new ListenableFutureCallback<CorrelationData.Confirm>() {
            @Override
            public void onFailure(Throwable ex) {
                //app内部异常，通常不会发生
            }

            @Override
            public void onSuccess(CorrelationData.Confirm result) {
                //收到Confirm的回执信息
                if (result.isAck()){
                    //ack发送消息成功
                }else {
                    //nack发送消息失败，可以进行重发消息
                    //失败原因
                    System.out.println(result.getReason());
                }
            }
        });

        String excName="direct33";
        Map<String, String> msg = new HashMap<>();
        msg.put("name","jack");
        msg.put("sex","男");
        rabbitTemplate.convertAndSend(excName,"key1",msg,cd);
    }

7、mq的可靠性

mq会把消息存在内存中，降低消息收发的延迟;

问题：mq宕机消息会丢失，内存大小有限，出现消息阻塞（超过mq的内存mq会把消息存入磁盘所以会阻塞），堆积；

解决：

（1）数据持久化（durable = "true"），重启mq服务数据不会丢失（消息保存在磁盘中）；

交换机持久化和队列持久化

（2）lazy Queue惰性队列（常用）

消息直接存入内存，读取会优化（消费者消费消息时才会从磁盘中读取数据并加载到内存中）arguments配置

 @RabbitListener(bindings = @QueueBinding(
                value = @Queue(name = "test33",durable = "true",
                arguments = @Argument(name = "x-queue-mode",value = "lazy")),
                exchange = @Exchange(name = "direct33",type = ExchangeTypes.DIRECT),
                key = {"key1","key2"}

        ))
    //消费者
    public void listenerQueue2(Map<String,String> map){
        System.out.println("收到消息:"+map.get("name"));
    }

7、消费者可靠性

（1）消费者确认机制(配置acknowledge-mode)

消费者处理完消息后向mq发送回执，告知mq消息处理的状态；情况分为三种：

ack：成功处理消息，mq删除队列中的消息

nack：处理失败，mq再次投递消息，进行处理

reject：消息处理失败并拒绝该消息，mq从队列中删除该消息

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        prefetch: 1 #每次获取一条消息，处理完在进行下一条，强的消费者处理多点，弱的少点
        acknowledge-mode: auto #自动处理消息处理的ack,nack,reject

（2）消息处理失败重试

开启失败重试配置enabled: true

spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    listener:
      simple:
        prefetch: 1 #每次获取一条消息，处理完在进行下一条，强的消费者处理多点，弱的少点
        acknowledge-mode: auto #自动处理消息处理的ack,nack,reject
        retry:
          enabled: true #开启消息处理失败重试

如果重试还是失败的话，可以把此消息放入一个单独的交换机中，人工处理消息

@Configuration
//这个注解表示：配置文件中enabled的值为true时这个配置类才生效
@ConditionalOnProperty(prefix ="spring.rabbitmq.listener.simple.retry",name = "enabled",havingValue = "true")
public class RabbitConfig {

    @Bean
    public DirectExchange errorExchange(){
        return new DirectExchange("error.direct");
    }
    @Bean
    public Queue errorQueue(){
        return new Queue("error.queue");
    }
    @Bean
    public Binding binding(Queue queue,DirectExchange directExchange){
        return BindingBuilder.bind(queue).to(directExchange).with("error");
    }

    @Bean
    public MessageRecoverer messageRecoverer(RabbitTemplate rabbitTemplate){
        return new RepublishMessageRecoverer(rabbitTemplate,"error.direct","error");
    }
}

8、消息幂等性

（1）设置唯一标识

@Bean
    public MessageConverter messageConverter(){
        Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
        jackson2JsonMessageConverter.setCreateMessageIds(true);
        return jackson2JsonMessageConverter;
    }

（2）根据逻辑进行幂等性处理

9、消息处理性能优化

可以定时任务获取消息的处理状态

10、延迟消息

生产者发送一个消息并指定一个时间，消费者不会立刻收到消息，而是指定时间之后收到消息；

（1）死信交换机-创建一个交换机（以下三种情况会把消息存入死信）

消息处理返回nack,reject

消息过期，无人消费

队列消息存满，最早的消息

设置队列的Arguments的值为s-dead-letter-exchange=dlx.direct(死信交换机)

@Test
    void test05(){
        String excName="direct33";
        Map<String, String> msg = new HashMap<>();
        msg.put("name","jack");
        msg.put("sex","男");
        rabbitTemplate.convertAndSend(excName, "key1", msg, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //设置消息过期时间，3秒后会进入私信队列
                message.getMessageProperties().setExpiration("3000");
                return message;
            }
        });
    }

（2）延迟消息插件，用于消息延迟时间较短的情况

消息发送到交换机后会存放一段时间，然后在发送到队列中

rabbitmq_delayed_message_exchange.ez插件

配置：//发送setDelay(3000) //接收delayed = "true"

//发送setDelay(3000)
@Test
    void test05(){
        String excName="direct33";
        Map<String, String> msg = new HashMap<>();
        msg.put("name","jack");
        msg.put("sex","男");
        rabbitTemplate.convertAndSend(excName, "key1", msg, new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //设置消息过期时间，3秒后会进入私信队列
                message.getMessageProperties().setDelay(3000);
                return message;
            }
        });
    }

//接收delayed = "true"
@RabbitListener(bindings = @QueueBinding(
            value = @Queue(name = "test33",durable = "true",
                    arguments = @Argument(name = "x-queue-mode",value = "lazy")),
            exchange = @Exchange(name = "direct33",type = ExchangeTypes.DIRECT,delayed = "true"),
            key = {"key1","key2"}

    ))
    //消费者
    public void listenerQueue2(Map<String,String> map){
        System.out.println("收到消息:"+map.get("name"));
    }