[设计模式] ------ 策略模式实战：java中替代if-else的大段逻辑

java中用策略模式替代if-else的大段逻辑

问题：

java本来是一门以面向对象为主的语言，但很多人嘴上说着java面向对象，然后除了表映射实体之外，其他的还是面向过程的思路。
就比如今天要说的，代码中大段大段的if-else判断，每个if-else代码块中又有很多复杂的逻辑，导致整个代码混乱不堪，让别人看到就感觉看到屎一样的代码一样。

那么，如何优雅的替代这些代码呢，其实有个设计模式（策略模式）就很好的解决了这个问题。

情景举例：

比如说订单处理，订单会有多个type状态，比如说
type=1的时候，就执行普通订单的逻辑；
type=2的时候，就执行满减促销订单的逻辑；
type=3的时候，就执行满返促销订单的逻辑；
等等，可能type会有数十种甚至更多种情况。

然后有些人就会开始if-else了，比如有如下的伪代码：

if(type=1){
	普通订单...（此处省略100多行处理逻辑）
}else if(type=2){
	满减促销订单...（此处省略100多行处理逻辑）
}else if(type=3){
	满返促销订单...（此处省略100多行处理逻辑）
}else if(type=n){
	...（此处省略几百上千行的逻辑）
}
1
2
3
4
5
6
7
8
9

做的好点的，会把if-else代码块中的逻辑，抽成一个个的方法，会稍微显的代码清晰许多，但这些都是面向过程的思想。
我认为，这种情况就应该用以下这种方式，即，用策略模式代替if-else，真正做到面向对象。
把每种不同类型的订单抽成一个个对象，然后通过不同的注解标识来区分调用。

用策略模式代替if-else:

首先，本次例子用的是Spring-Boot框架，亲测没问题。SpringMVC框架应该也是没问题的。
定义一个订单类，里面有type属性，type可以是"1"、“2”、“3”…
定义一个抽象类AbstractHandler，里面有个抽象方法handle，入参是订单类
定义一个注解HandlerType，有个value属性，value是几就代表这个注解注的这个类是什么类型的订单
定义普通类HandlerImpl01，实现AbstractHandler，代表普通订单，即@HandlerType(“1”)；
定义普通类HandlerImpl02，实现AbstractHandler，代表满减促销订单，即@HandlerType(“2”)；
定义普通类HandlerImpl03，实现AbstractHandler，代表满返促销订单，即@HandlerType(“3”)；
定义一个初始化类HandlerProcessor，实现BeanFactoryPostProcessor，过程如下：
1、找到带有注解@HandlerType的类，
2、以注解的值为key，对应的类为value，存在一个map中
3、将这个map作为构造函数的参数，初始化HandlerContext，将HandlerContext注册到spring中成为一个单例bean。
很明显，目的就是为了保存不同type对应的不同类。
定义类HandlerContext，有个map类型的属性叫handlerMap，有个getInstance的方法，入参是type，返回AbstractHandler。
最后使用的时候，是先调用handlerContext.getInstance方法，根据type获取对应的AbstractHandler。
然后再调用他的handle方法，执行对应订单类型的处理逻辑。

具体代码如下：

//@Data是lombok的注解，为了省略不写get/set方法
@Data
public class OrderDTO {
    private String code;
    private BigDecimal price;
    /**
     * 订单类型
     * 1：普通订单
     * 2：满减订单
     * 3：满返订单
     */
    private String type;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

public abstract class AbstractHandler {
    abstract public String handle(OrderDTO orderDTO);
}
1
2
3

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface HandlerType {
    String value();
}
1
2
3
4
5
6
7

@Component
@HandlerType("1")
public class HandlerImpl01 extends AbstractHandler {
    @Override
    public String handle(OrderDTO orderDTO) {
        System.out.println("处理type为1的订单,orderDTO.type="+orderDTO.getType());
        return "success";
    }
}
1
2
3
4
5
6
7
8
9

@Component
@HandlerType("2")
public class HandlerImpl02 extends AbstractHandler {
    @Override
    public String handle(OrderDTO orderDTO) {
        System.out.println("处理type为2的订单,orderDTO.type="+orderDTO.getType());
        return "success";
    }
}
1
2
3
4
5
6
7
8
9

@Component
@HandlerType("3")
public class HandlerImpl03 extends AbstractHandler {
    @Override
    public String handle(OrderDTO orderDTO) {
        System.out.println("处理type为3的订单,orderDTO.type="+orderDTO.getType());
        return "success";
    }
}
1
2
3
4
5
6
7
8
9

@Component
@SuppressWarnings("unchecked")
public class HandlerProcessor implements BeanFactoryPostProcessor {
	//这里是具体的handler策略类的包的位置，为了后面的包扫描
    private static final String HANDLER_PACKAGE = "com.zs.handler";
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        Map<String, Class> handlerMap = new HashMap<>();
		//包扫描
        ClassScaner.scan(HANDLER_PACKAGE,HandlerType.class).forEach(clazz ->{
            Annotation annotation = clazz.getAnnotation(HandlerType.class);
            HandlerType handlerType = (HandlerType) annotation;
            String type = handlerType.value();
            System.out.println(type);
            handlerMap.put(type,clazz);
        });
        HandlerContext handlerContext = new HandlerContext(handlerMap);
		//注册单例
        beanFactory.registerSingleton(HandlerContext.class.getName(),handlerContext);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public class HandlerContext {
    private Map<String,Class> handlerMap;

    public HandlerContext(Map<String, Class> handlerMap) {
        this.handlerMap = handlerMap;
    }

    public AbstractHandler getInstance(String type){
        Class clazz = handlerMap.get(type);
        if(clazz == null){
            throw new IllegalArgumentException("没有type对应的处理器，type："+type);
        }
        return (AbstractHandler)SpringContextUtils.getBean(clazz);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

定义接口：

public interface OrderService {
    /**
     * 根据订单类型处理订单
     * @param orderDTO
     * @return
     */
    String handle(OrderDTO orderDTO);
}
1
2
3
4
5
6
7
8

实现接口：

@Service
public class OrderServiceImpl implements OrderService {

    @Resource
    private HandlerContext handlerContext;

    @Override
    public String handle(OrderDTO orderDTO) {
        System.out.println("OrderServiceImpl handle 方法开始执行===");
        AbstractHandler handler = handlerContext.getInstance(orderDTO.getType());
        return handler.handle(orderDTO);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

包扫描的工具类：

public class ClassScaner implements ResourceLoaderAware {

    private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver();

    private final List<TypeFilter> includeFilters = new LinkedList<TypeFilter>();

    private final List<TypeFilter> excludeFilters = new LinkedList<TypeFilter>();

    private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(this.resourcePatternResolver);

    public ClassScaner() {

    }

    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
        this.metadataReaderFactory = new CachingMetadataReaderFactory( resourceLoader);
    }

//    public final ResourceLoader getResourceLoader() {
//        return this.resourcePatternResolver;
//    }

    public void addIncludeFilter(TypeFilter includeFilter) {
        this.includeFilters.add(includeFilter);
    }

//    public void addExcludeFilter(TypeFilter excludeFilter) {
//        this.excludeFilters.add(0, excludeFilter);
//    }

//    public void resetFilters(boolean useDefaultFilters) {
//        this.includeFilters.clear();
//        this.excludeFilters.clear();
//    }

    public static Set<Class> scan(String basePackage, Class<? extends Annotation>... annotations) {
        ClassScaner cs = new ClassScaner();
        for (Class anno : annotations)
            cs.addIncludeFilter(new AnnotationTypeFilter(anno));
        return cs.doScan(basePackage);
    }

//    public static Set<Class> scan(String[] basePackages, Class<? extends Annotation>... annotations) {
//        ClassScaner cs = new ClassScaner();
//        for (Class anno : annotations)
//            cs.addIncludeFilter(new AnnotationTypeFilter(anno));
//        Set<Class> classes = new HashSet<Class>();
//        for (String s : basePackages)
//            classes.addAll(cs.doScan(s));
//        return classes;
//    }

    public Set<Class> doScan(String basePackage) {
        Set<Class> classes = new HashSet<Class>();
        try {
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                    + org.springframework.util.ClassUtils
                    .convertClassNameToResourcePath(SystemPropertyUtils
                            .resolvePlaceholders(basePackage))
                    + "/**/*.class";
            Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);

            for (int i = 0; i < resources.length; i++) {
                Resource resource = resources[i];
                if (resource.isReadable()) {
                    MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                    if ((includeFilters.size() == 0 && excludeFilters.size() == 0)
                            || matches(metadataReader)) {
                        try {
                            classes.add(Class.forName(metadataReader.getClassMetadata().getClassName()));
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }

                    }
                }
            }
        } catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                    "I/O failure during classpath scanning", ex);
        }
        return classes;
    }

    protected boolean matches(MetadataReader metadataReader) throws IOException {
        for (TypeFilter tf : this.excludeFilters) {
            if (tf.match(metadataReader, this.metadataReaderFactory)) {
                return false;
            }
        }
        for (TypeFilter tf : this.includeFilters) {
            if (tf.match(metadataReader, this.metadataReaderFactory)) {
                return true;
            }
        }
        return false;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

spring工具类，为了获取bean

@Component
public class SpringContextUtils implements ApplicationContextAware {
    private static ApplicationContext applicationContext = null;
    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String beanId) {
        return (T) applicationContext.getBean(beanId);
    }
    public static <T> T getBean(Class<T> requiredType) {
        return (T) applicationContext.getBean(requiredType);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextUtils.applicationContext = applicationContext;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19