rabbitmq场景：发送消息的模版不一致时，怎么进行构建不同的消息模版

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里可以添加本文要记录的大概内容：

具体场景：当你发送消息时，如果设定重试五次后不成功就发送消息，通知开发人员
失败，需要后台赶快进行处理，但是消息发送给不同的人员或者不同的地方（比如：平台、钉钉）

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、发送消息的实体类构建

这边我只写比较重要的字段，其余不写

public class SendMessageVo{
	//消息内容
	private String Content ;
	//true：发送给钉钉， flase：发送给平台,如果不存在这个属性也就意味着不用进行消息构建了，就不用进行超过五次发送失败消息
	private boolean flag = false;
}

二、MessageRecoverHandler构建

public interface MessageRecoverHandler{
	//处理业务逻辑方法
	void handle(Message message);
	//消息处理类型，根据上面flag来选择的，统一发送SendMessageVo，然后通过flag选择发送给哪个地方
	RecoverHandlerTypeEnum type();
}

public enum RecoverHandlerTypeEnum{
	//钉钉
	DING_NOTICE;
	//平台
	PLATFORM_NOTICE
}

三、CommonRejectRequestRecover构建

public class CommonRejectRequestRecover implements MessageRecover{
	private IDTalkServiceApi talkService;
	private IPlateServiceApi plateService;
	Map<RecoverHandlerTypeEnum ,MessageRecoverHandler> messageRecoverHandlerMap;
	public CommonRejectRequestRecover (IDTalkServiceApi talkService,IPlateServiceApi plateService,Map<RecoverHandlerTypeEnum ,MessageRecoverHandler> messageRecoverHandlerMap){
		this.talkService = talkService;
		this.plateService = plateService;
		this.messageRecoverHandlerMap = messageRecoverHandlerMap;
	}
	@Override
	public void recover(Message message，Throwable cause){
	   String queueName = message.getMessageProperties().getConsumerQueue();
	   if(StringUtils.isNotBlank(queueName)){
	   		sendDiffrentMessage(message);
	   }
	}

	private void sendDiffrentMessage(Message message){
		Map<String,Object> map= JSONObject.parseObject(message.getBody(),Map.class);
		Boolean flag = MapUtils.getBoolean(map,flag);
		MessageRecoverHandler messageRecoverHandler = null;
		if(flag!=null){
			RecoverHandlerTypeEnum recoverHandlerTypeEnum = flag ?RecoverHandlerTypeEnum.DING_NOTICE : RecoverHandlerTypeEnum.PLATFORM_NOTICE ;
			//选取处理器
			messageRecoverHandler = messageRecoverHandlerMap.get(recoverHandlerTypeEnum)
		}
		if(messageRecoverHandler !=null){
			messageRecoverHandler.handle(message);
		}
	}
	
}

四、RabbitmqConfig构建

@Configuration
public class RabbitConfig implements Initiallizing{
	@Autowired
	private List<MessageRecoverHandler> messageRecoverHandler;

	//自定义监听容器工厂
	@Bean
	public RabbitListenerContainerFactory rabbitListenerContainerFactory (ConnectionFactory connectionFactory){
		SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
		factory.setContainerFactory(connectionFactory);
		//在发送没有实现序列化接口的类，这边使用一个转换器直接序列化了
		factory.setMessageConverter(new Jackson2JsonMessageConverter());
		factory.setAdviceChain(interceptor());
		factory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
		factory.setPrefetchCount(50);
		return factory;
	}
	
	@Bean
	public RetryOperationsInterceptor interceptor(){
		return RetryInterceptorBuilder.stateless().maxAttempts(5).backOffOptions().recovers(new CommonRejectRequestRecover(talkService,plateService,messageRecoverHandlerMap))
		.build();
	}
	
	
	@Override
	public class afterPropertiesSet(){
		messageRecoverHandlerMap= messageRecoverHandler.collect(Collctors.toMap(MessageRecoverHandler::type,Function.identify()));
	} 
}

处理器

public abstract class BaseMessageRecoverHandler implements MessageRecoverHandler,InitializingBean{
	@Autowired
	private List<MessageContentBuider>	contentBuilders;
	protected static Map<String,MessageContentBuilder> contentBuilderMaps = new HashMap<>();
	
	protected MessageHandlerBuilder selectBuilder(String queueName){
		return contentBuilderMaps.get(String.format("%s_%s",type(),queueName));
	}
	
	@Override
	public void afterPropertiesSet(){
		contentBuilders.forEach(builder -> { 
			builder.queueNames().forEach(queueName -> {
			contentBuilderMaps.put(String.format("%s_%s",contentBuilders.type(),queueName),builder);
			})
			
		})
	}
}

public class plateformMessageRecoverHandler extends BaseMessageRecoverHandler implements MessageRecoverHandler{
	@Autowired
	private IPlateServiceApi plateService;

	@Override
	public void handler(Message message){
		Object messageContent = selectBuilder(message.getMessageProperties().getConsumerQueue()).builder(message);
		//构建完之后发送消息
		plateService.sendMessage((List<平台类型>) messageContent);
	}
}

构建器

因为限定某些队列才可以进行发送消息

public interface MessageContentBuider{
	Object build(Message message);
	
	List<String> queueNames();
	
	RecoverHandlerTypeEnum type();
}


public class plateformMessageBuilder implements MessageContentBuider{
	@Override
	public Object build(Message message){
	//这里就是处理成平台发送消息的模版类型即可
	}
	@Override
	public List<String> queueNames(){
		return Arrays.asList("A","B");//随便设置两个队列
	}
	@Override
	public RecoverHandlerTypeEnum type(){
	 	return RecoverHandlerTypeEnum.PLATFORM_NOTICE
	}

//还有一个 钉钉消息构建器我就不写了，类似上上面
}