在开发过程中，通常会有一个接口被很多个上游调用或者Request里面有一个消息类型，我们需要根据具体的消息类型去做对应的处理，传统的做法是通过if-else去判断消息的类型，然后再做对应的处理，也可以通过策略模式去优化，让代码更有观赏性。

场景

我们的接口被上游调用，request里面有具体的topic，根据topic的不同做不同的处理
定义一个topic的枚举

import lombok.AllArgsConstructor;
import lombok.Getter;

@AllArgsConstructor
@Getter
public enum MessageTopicEnum {
    /**
     * tt 事件
     */
    TICKET_DATA("ticket_data"),

    /**
     * 工单日志
     */
    TICKET_PROCESS_LOG_CREATED("ticket_process_log_created"),

    String value;
}

• 上面定义了两个topic枚举以及get方法
  定义一个消息处理接口，接口里面的方法是获取消息的topic以及消息的处理

public interface MessageHandler {

    /**
     * topic
     */
    MessageTopicEnum getTopicEnum();

    /**
     * 处理topic
     *
     * @param message 消息
     * @return 处理结果
     */
    MessageHandleResult handle(MessageEntity message);
}

写多个类实现这个接口，做真正的消息处理

@Service
@Slf4j
public class AfterSafeHandler implements MessageHandler{

    @Resource
    private Gson gson;
    @Override
    public MessageTopicEnum getTopicEnum() {
        return null;
    }

    @Override
    public MessageHandleResult handle(MessageEntity message) {
        String msgContent = new String(message.getRequest().getValue());

        if (Strings.isNullOrEmpty(msgContent)) {
            return MessageHandleResult.success();
        }

        //setEnv();
        return handleMessage(msgContent);
    }

    public MessageHandleResult handleMessage(String msgContent) {
        log.info("after safe handler msgContent = {}", msgContent);
        AfterOrderMessageEntity afterOrderMessage = gson.fromJson(msgContent, AfterOrderMessageEntity.class);
        log.info("afterOrderMessage info = {}", afterOrderMessage);
        return MessageHandleResult.success();
    }
}

底层处理逻辑处理完成后，我们开发消息的转发

@Component
public class MessageDispatcher {
    private final ConcurrentHashMap<String, MessageHandler> handlerMap = new ConcurrentHashMap<>();

    @Autowired
    private List<MessageHandler> messageHandlerList;

    @PostConstruct
    private void init() {
        if (CollectionUtils.isEmpty(messageHandlerList)) {
            return;
        }
       // messageHandlerList.forEach(item -> handlerMap.put(item.getTopicEnum().getValue(), item));
        messageHandlerList.forEach(item -> handlerMap.put("aftersale", item));
    }


    // todo 在这里先写死topic
    public MessageHandler dispatchMessage(MessageEntity message) {
        return handlerMap.getOrDefault("aftersale", null);
        //return handlerMap.getOrDefault(message.getTopic(), null);
    }
}

• 服务启动时，将所有的实现类加载到Map中，然后根据topic获取对应的处理类
  在接口中做转发

MessageHandler messageHandler = dispatcher.dispatchMessage(message);
            if (Objects.isNull(messageHandler)) {
                log.warn("messageHandler not found,MessageCallback = {}", req);
                return response.setBaseResp(MessageHandleResult.success().getBaseResp());
            }