策略模式(Strategy)
一、问题背景
重构大量的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 个、且分支代码相似且冗长的情况下就应该考虑这种模式。