一、问题背景
重构大量的if else代码肯定是要用策略模式的，这个问题主要想知道你是否了解策略模式。可能有一部分人觉得策略模式并不好好，还不如if else看着清晰。
用设计模式重构与否的关键是，每个分支的行数是否过多。如果一个分支的代码行数在几十行，确实没有必要重构。如果一个分支的代码行数在几百行，上千行（不用和我杠怎么能写出一个分支几百行的代码，是不是能力的问题，因为比较复杂的系统确实有这种情况），以某个项目对接微信聊天信息为例，有一部分业务逻辑是这样的：
String msgType=mssage.getMsgType();
if("文本".equals(msgType)){
//do something
}else if("图片".equals(msgType)){
//do something
}else if("视频".equals(msgType)){
//do something
}else{
//do something
}
就是根据消息的不同类型有不同的处理策略，每种消息的处理策略代码都很长，如果都放在这种if/else里使得代码逻辑非常臃肿。
策略模式的定义与特点
策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。
策略模式的主要优点如下。
- 1.多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句，如 if...else 语句、switch...case 语句。
- 2.策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。
- 3.策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。
- 4.策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。
- 5.策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。
其主要缺点如下。
- 1.客户端必须理解所有策略算法的区别，以便适时选择恰当的算法类。
- 2.策略模式造成很多的策略类，增加维护难度。
策略模式的结构与实现
策略模式是准备一组算法，并将这组算法封装到一系列的策略类里面，作为一个抽象策略类的子类。策略模式的重心不是如何实现算法，而是如何组织这些算法，从而让程序结构更加灵活，具有更好的维护性和扩展性，现在我们来分析其基本结构和实现方法。
- 1. 模式的结构
- 策略模式的主要角色如下。
- 抽象策略（Strategy）类：定义了一个公共接口，各种不同的算法以不同的方式实现这个接口，环境角色使用这个接口调用不同的算法，一般使用接口或抽象类实现。
- 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现。
环境（Context）类：持有一个策略类的引用，最终给客户端调用。
其结构图如图 1 所示。
2. 模式的实现
(1) 定义处理接口
import com.tang.learn.domain.MessageContext;
public interface MessageHandler {
void handle(MessageContext context);
}
其中MessageContext的定义如下：
package com.tang.learn.domain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class MessageContext {
private MessageTypeEnum messageType;
private String messageContent;
}
MessageTypeEnum的定义如下：根据枚举类型寻找对应的处理实现类
package com.tang.learn.domain;
public enum MessageTypeEnum {
TEXT,
IMAGE,
VIDIO
}
- (2) 编写接口实现类
先编写文本类型消息的处理实现类：
import com.tang.learn.domain.MessageContext;
import com.tang.learn.domain.MessageTypeEnum;
import com.tang.learn.domain.annotation.MessageTypeAnnotation;
import com.tang.learn.handler.MessageHandler;
import org.springframework.stereotype.Component;
@Component
@MessageTypeAnnotation(MessageTypeEnum.TEXT)
public class TextMessageHandler implements MessageHandler {
@Override
public void handle(MessageContext context) {
System.out.println("handle text message : " + context);
}
}
然后编写图片类型消息的处理实现类：
import com.tang.learn.domain.MessageContext;
import com.tang.learn.domain.MessageTypeEnum;
import com.tang.learn.domain.annotation.MessageTypeAnnotation;
import com.tang.learn.handler.MessageHandler;
import org.springframework.stereotype.Component;
@Component
@MessageTypeAnnotation(MessageTypeEnum.IMAGE)
public class ImageMessageHandler implements MessageHandler {
@Override
public void handle(MessageContext context) {
System.out.println("handle image message : " + context);
}
}
紧接着编写视频类型消息的处理实现类：
import com.tang.learn.domain.MessageContext;
import com.tang.learn.domain.MessageTypeEnum;
import com.tang.learn.domain.annotation.MessageTypeAnnotation;
import com.tang.learn.handler.MessageHandler;
import org.springframework.stereotype.Component;
@Component
@MessageTypeAnnotation(MessageTypeEnum.VIDIO)
public class VideoMessageHandler implements MessageHandler {
@Override
public void handle(MessageContext context) {
System.out.println("handle video message : " + context);
}
}
- (3) 定义（2）中所使用的MessageTypeAnnotation注解
import com.tang.learn.domain.MessageTypeEnum;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface MessageTypeAnnotation {
/** message type */
MessageTypeEnum value() default MessageTypeEnum.TEXT;
}
- (4) 编写消息处理器工厂类：
import com.tang.learn.domain.MessageTypeEnum;
import com.tang.learn.domain.annotation.MessageTypeAnnotation;
import com.tang.learn.handler.MessageHandler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
@Component
public class MessageHandlerFactory {
private Map<MessageTypeEnum, MessageHandler> handlerMap = new ConcurrentHashMap<>();
@Autowired
public MessageHandlerFactory(Map<String, MessageHandler> handlerMaps) {
handlerMap.clear();
handlerMaps.keySet().stream().forEach(beanName -> {
Class<? extends MessageHandler> clazz = handlerMaps.get(beanName).getClass();
MessageTypeAnnotation annotation = clazz.getAnnotation(MessageTypeAnnotation.class);
if (null != annotation) {
handlerMap.put(annotation.value(), handlerMaps.get(beanName));
}
}
);
}
public MessageHandler getMessageHandler(MessageTypeEnum typeEnum) {
return handlerMap.get(typeEnum);
}
}
- (5) 编写测试用例进行测试
package com.tang.learn;
import com.tang.learn.domain.MessageContext;
import com.tang.learn.domain.MessageTypeEnum;
import com.tang.learn.factory.MessageHandlerFactory;
import com.tang.learn.handler.MessageHandler;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
class LearnSpringApplicationTests {
@Autowired
private MessageHandlerFactory handlerFactory;
@Test
void testFactory(){
MessageContext context=new MessageContext(MessageTypeEnum.TEXT,"this is text message");
MessageHandler handler=handlerFactory.getMessageHandler(context.getMessageType());
handler.handle(context);
}
}
总结
策略模式的作用：就是把具体的算法实现从业务逻辑中剥离出来，成为一系列独立算法类，使得它们可以相互替换。
其实这是一种通用的解决方案，当你 if-else/switch-case 的分支超过 3 个、且分支代码相似且冗长的情况下就应该考虑这种模式。
