在使用rabbitmq时,如何保证消息的可靠性投递【二】

本期主要讲述如何发送消息,首先看一下依赖:

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

其中关键依赖为 spring-boot-starter-amqp,发送依赖使用其中的org.springframework.amqp.rabbit。

发送消息关键有两步:

  1. 获取模板对象
  2. 调用模板对象的发送方法

先来看第一步,可以通过直接的依赖注入,直接获取模板对象:

import org.springframework.amqp.rabbit.core.RabbitTemplate;

@Autowired
RabbitTemplate rabbitTemplate;

第二步,调用对象的方法:

public void convertAndSend(String exchange, String routingKey, Object object, @Nullable CorrelationData correlationData) throws AmqpException {
        this.send(exchange, routingKey, this.convertMessageIfNecessary(object), correlationData);
    }
  1. 其中Object objec 即为发送的消息。
  2. String exchange 为 rabbitmq的交换器,若rabbitmq上不存在此交换器,则会发送失败,例如 rabbitqm上 只存在 exchang-1,而你传入的参数为 exchange-2,则会发送失败;
  3. String routingKey 为路由key,即交换器 必须绑定一个 路由key 才会接收 发送到这个路由key的消息。
  4. CorrelationData correlationData 为发送后触发回调函数的回传参数,一般包含消息体,发送时间,消息类型。

进阶一:模板容器

可使用 RabbitTemplate 构造方法获得模板对象,该构造方法有一个重载方法,如果使用默认,不传参数的方法,则会在内部使用默认的方法 initDefaultStrategies(); ,但是该构造方法处的注解告诉我们,依旧需要设置 ConnectionFactory 参数。

 Convenient constructor for use with setter injection. 
 Don't forget to set the connection factory.

该参数的作用为

An interface based ConnectionFactory for creating {@link com.rabbitmq.client.Connection Connections}.

在此,我们注入 ConnectionFactory 并设置

import org.springframework.amqp.rabbit.connection.ConnectionFactory;
@Autowired
 private ConnectionFactory connectionFactory;
RabbitTemplate newTemplate = new RabbitTemplate(connectionFactory);

使用默认构造器方法,默认设置了简单消息转换器

protected void initDefaultStrategies() {
        setMessageConverter(new SimpleMessageConverter());
    }

此消息转换器的作用是将消息对象序列化,即 java对象转换为传输对象(字节数组);或者反序列化,即 从rabbitmq上获取的信息(字节数组)转换为java对象。这里我们需要自己的转换器,即将转换的java对象确定为我们自定义的 Message 对象。

  1. 实现序列化工厂接口
package com.zk.rabbit.common.serializer.impl;

import com.zk.rabbit.api.Message; // 自定义消息对象
import com.zk.rabbit.common.serializer.Serializer;
import com.zk.rabbit.common.serializer.SerializerFactory;

public class SerializerFactoryImpl implements SerializerFactory {

    public static final SerializerFactory INSTANCE = new SerializerFactoryImpl();

    @Override
    public Serializer create() {
         // 自定义SerializerImpl序列化器
        return SerializerImpl.createParametricType(Message.class);
    }
}
  1. 自定义SerializerImpl序列化器,定义了具体序列化的步骤,这里我们用fastJson处理

    import com.fasterxml.jackson.core.JsonParser;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.DeserializationFeature;
    import com.fasterxml.jackson.databind.JavaType;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.fasterxml.jackson.databind.SerializationFeature;
    import com.zk.rabbit.common.serializer.Serializer;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.IOException;
    import java.lang.reflect.Type;
    
    public class SerializerImpl implements Serializer {
    
     private static final Logger log = LoggerFactory.getLogger(SerializerImpl.class);
     private static final ObjectMapper mapper = new ObjectMapper();
    
     static {
         mapper.disable(SerializationFeature.INDENT_OUTPUT);
         mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
         mapper.configure(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER, true);
         mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
         mapper.configure(JsonParser.Feature.ALLOW_NON_NUMERIC_NUMBERS, true);
         mapper.configure(JsonParser.Feature.ALLOW_NUMERIC_LEADING_ZEROS, true);
         mapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
         mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);
         mapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
     }
    
     private final JavaType type;
    
     public SerializerImpl(JavaType type) {
         this.type = type;
     }
    
     public SerializerImpl(Type type) {
         this.type = mapper.getTypeFactory().constructType(type);
     }
    
     public static Serializer createParametricType(Class<?> clz) {
         return new SerializerImpl(mapper.getTypeFactory().constructType(clz));
     }
    
     @Override
     public byte[] serializeRaw(Object content) {
         try {
             return mapper.writeValueAsBytes(content);
         } catch (JsonProcessingException e) {
             log.error("序列化出错", e);
         }
         return null;
     }
    
     @Override
     public String serialize(Object content) {
         try {
             return mapper.writeValueAsString(content);
         } catch (JsonProcessingException e) {
             log.error("序列化出错", e);
         }
         return null;
     }
    
     @Override
     public <T> T deserialize(String content) {
         try {
             return mapper.readValue(content, type);
         } catch (IOException e) {
             log.error("反序列化出错", e);
         }
         return null;
     }
    
     @Override
     public <T> T deserialize(byte[] content) {
         try {
             return mapper.readValue(content, type);
         } catch (IOException e) {
             log.error("反序列化出错", e);
         }
         return null;
     }
    }
    
  2. 设置确认回调方法,即继承 RabbitTemplate.ConfirmCallback 接口,实现 confirm 方法
@Override
    public void confirm(CorrelationData correlationData, boolean b, String s) {        
        /* 注意此处的 correlationData 就是发送消息时传入的
            new CorrelationData(String.format("%s#%s#%s",
                            message.getMessageId(),
                            System.currentTimeMillis(),
                            message.getMessageType()));
        */
        String id = correlationData.getId();
        List<String> strings = splitter.splitToList(id);
        String messageId = strings.get(0);
        long timeStamp = Long.parseLong(strings.get(1));
        int messageType = Integer.parseInt(strings.get(2));
        if (b) {
            if (MessageType.RELIANT == messageType) {
                // 此处为投递成功后,在数据库中修改该数据的状态
                rabbitProducerService.success(messageId);
            }
            log.error("#RabbitTemplateContainer.confirm# send success, messageId: {}, ACK: {}, timeStamp: {}", messageId, b, timeStamp);
        } else {
            log.error("#RabbitTemplateContainer.confirm# send fail, messageId: {}, ACK: {}, timeStamp: {}", messageId, b, timeStamp);
        }
    }
  1. 定义Map对象,exchange为key,template为value,为template容器,每次发送消息时,都从此容器中获取模板对象。
private static final Map<String, RabbitTemplate> container = Maps.newConcurrentMap();

    public RabbitTemplate getTemplate(Message message) throws MessageRuntimeException {
        Preconditions.checkNotNull(message);
        String topic = message.getTopic();
        RabbitTemplate template = container.get(topic);
        if (template != null) {
            return template;
        }
        log.info("#RabbitTemplateContainer.getTemplate# topic: {} is not exists, create one", topic);
        RabbitTemplate newTemplate = new RabbitTemplate(connectionFactory);
        newTemplate.setExchange(topic);
        newTemplate.setRoutingKey(message.getRoutingKey());

        RabbitMessageConverter converter = new RabbitMessageConverter(new GenericMessageConverter(serializer));
        newTemplate.setMessageConverter(converter);

        if (message.getMessageType() != MessageType.RAPID) {
            newTemplate.setConfirmCallback(this);
        }

        container.put(topic, newTemplate);
        return newTemplate;
    }

评论

暂无评论