if (msgType = "文本") {// dosomething
} else if(msgType = "图片") {// doshomething
} else if(msgType = "视频") {// doshomething
} else {// doshomething
}

就是根据消息的不同类型有不同的处理策略，每种消息的处理策略代码都很长，如果都放在这种if else代码快中，代码很难维护也很丑，所以我们一开始就用了策略模式来处理这种情况。

策略模式还挺简单的，就是定义一个接口，然后有多个实现类，每种实现类封装了一种行为。然后根据条件的不同选择不同的实现类。

实现过程
消息对象，当然真实的对象没有这么简单，省略了很多属性

@Data
@AllArgsConstructor
public class MessageInfo {// 消息类型private Integer type;// 消息内容private String content;}

定义一个消息处理接口

public interface MessageService {void handleMessage(MessageInfo messageInfo);
}

有2个消息处理接口，分别处理不同的消息

处理文本消息

@Service
@MsgTypeHandler(value = MSG_TYPE.TEXT)
public class TextMessageService implements MessageService {@Overridepublic void handleMessage(MessageInfo messageInfo) {System.out.println("处理文本消息 " + messageInfo.getContent());}
}

处理图片消息

@Service
@MsgTypeHandler(value = MSG_TYPE.IMAGE)
public class ImageMessageService implements MessageService {@Overridepublic void handleMessage(MessageInfo messageInfo) {System.out.println("处理图片消息 " + messageInfo.getContent());}
}

文章写到这，可能大多数人可能会想到要需要如下一个Map, Map<消息类型，消息处理对象>，这样直接根据消息类型就能拿到消息处理对象，调用消息处理对象的方法即可。我们就是这样做的，但是我们不想手动维护这个Map对象，因为每次增加新的消息处理类，Map的初始化过程就得修改

我们使用了注解+ApplicationListener来保存这种映射关系，来看看怎么做的把

定义一个消息类型的枚举类

public enum MSG_TYPE {TEXT(1, "文本"),IMAGE(2, "图片"),VIDEO(3, "视频");public final int code;public final String name;MSG_TYPE(int code, String name) {this.code = code;this.name = name;}
}

定义一个注解

@Documented
@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MsgTypeHandler {MSG_TYPE value();
}

不知道你注意到了没，前面的代码中，每种消息处理类上面都有一个@MsgTypeHandler注解，表明了这个处理类
处理哪种类型的消息

@Service
@MsgTypeHandler(value = MSG_TYPE.TEXT)
public class TextMessageService implements MessageService {@Overridepublic void handleMessage(MessageInfo messageInfo) {System.out.println("处理文本消息 " + messageInfo.getContent());}
}

用一个context对象保存了消息类型->消息处理对象的映射关系

@Component
public class MessageServiceContext {private final Map<Integer, MessageService> handlerMap = new HashMap<>();public MessageService getMessageService(Integer type) {return handlerMap.get(type);}public void putMessageService(Integer code, MessageService messageService) {handlerMap.put(code, messageService);}}

最精彩的部分到了

@Component
public class MessageServiceListener implements ApplicationListener<ContextRefreshedEvent> {@Overridepublic void onApplicationEvent(ContextRefreshedEvent event) {Map<String, Object> beans = event.getApplicationContext().getBeansWithAnnotation(MsgTypeHandler.class);MessageServiceContext messageServiceContext = event.getApplicationContext().getBean(MessageServiceContext.class);beans.forEach((name, bean) -> {MsgTypeHandler typeHandler = bean.getClass().getAnnotation(MsgTypeHandler.class);messageServiceContext.putMessageService(typeHandler.value().code, (MessageService) bean);});}
}

在spring的启动过程中，通过解析注解，将消息类型->消息处理对象的映射关系保存到MessageServiceContext对象中

@Autowired
MessageServiceContext messageServiceContext;@Test
public void contextLoads() {// 构建一个文本消息MessageInfo messageInfo = new MessageInfo(MSG_TYPE.TEXT.code, "消息内容");MessageService messageService = messageServiceContext.getMessageService(messageInfo.getType());// 处理文本消息 消息内容// 可以看到文本消息被文本处理类所处理messageService.handleMessage(messageInfo);
}