在使用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。
发送消息关键有两步:
- 获取模板对象
- 调用模板对象的发送方法
先来看第一步,可以通过直接的依赖注入,直接获取模板对象:
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);
}- 其中Object objec 即为发送的消息。
- String exchange 为 rabbitmq的交换器,若rabbitmq上不存在此交换器,则会发送失败,例如 rabbitqm上 只存在 exchang-1,而你传入的参数为 exchange-2,则会发送失败;
- String routingKey 为路由key,即交换器 必须绑定一个 路由key 才会接收 发送到这个路由key的消息。
- 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 对象。
- 实现序列化工厂接口
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);
}
}自定义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; } }- 设置确认回调方法,即继承
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);
}
}- 定义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;
}
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论