利用策略模式消除分支

在实际的开发过程中，我们经常会遇到对于不同的对象采用不同的算法或者策略的场景。

一个真实的例子是这样的：

假设现在要将一个Student对象存入数据库。在逻辑层，需要对对象的字段进行合法性判断，比如ID是否超过某个阈值，名字长度是否超长。

public class Student {
    
    private Integer id;
    
    private String name;
    
    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getFirstName() {
        return name;
    }

    public void setFirstName(String firstName) {
        this.name = firstName;
    }
}

1. if else分支方法

最常见的做法，是将参数的类型进行分类。提供一个方法，对传入的参数，根据不同的参数类型进行校验。

package com.huawei.khlin.strategy;

public class App {

    public static void validateField(Object param, FieldType type)
            throws Exception {
        if (type == FieldType.INTEGER) {
            // do something....
        } else if (type == FieldType.DOUBLE) {
            // do something....
        } else if (type == FieldType.CHAR) {
            // do something....
        } else if (type == FieldType.STRING) {
            // do something...
        }
    }

    public static enum FieldType {
        INTEGER, DOUBLE, CHAR, STRING;
    }
    
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setId(Integer.valueOf(1));
        student.setName("kingsley");
        
        validateField(student.getId(), FieldType.INTEGER);
        validateField(student.getName(), FieldType.STRING);
        
        //dao层操作
    }
}

上面的if else分支换成switch效果是一样的。

可以预见的是，当字段的类型越来越多（包括同样类型但阈值不同，例如String 32长度和64长度），validateField方法将会越来越臃肿，分支数量分分钟超过最大圈复杂度15.

2. 策略模式拯救烂代码

策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

个人理解，策略模式实际上就是利用了类的多态性，通过不同的实现类，在不同的场景下使用不同的算法处理事务。

那么，什么时候就要使用策略模式呢？我认为，当某个算法比较复杂，并且你头脑里第一个闪现的想法是用if else来做分支处理，那么就是使用策略模式的时候。

策略模式的结构图如下：

主要有三个组件

Context：持有Strategy对象

Stragety: 抽象的策略类，提供统一的操作方法

ConcretStrategy:具体的策略类，封装了一些行为或算法

具体到上述的场景中，Context就是调用的客户端，即main方法。而根据不同的类型进行参数校验，则是不同的ConcreteStrategy.

这样，我们的代码就可以改成如下：

抽象的策略类

public interface Validator {
    
    public void validate(Object value) throws Exception;

}

具体的策略类

public class IntegerValidator implements Validator {

    private int maxCount = Integer.MAX_VALUE;

    private int minCount = 0;

    public IntegerValidator() {

    }

    public IntegerValidator(int minCount, int maxCount) {
        this.minCount = minCount;
        this.maxCount = maxCount;
    }

    @Override
    public void validate(Object value) throws Exception {

        int realValue = 0;

        if (null == value) {

            realValue = 0;

        } else {
            if (!(value instanceof Integer)) {
                throw new Exception("field is NOT String Type.");
            }

            Integer valueInteger = Integer.valueOf(value.toString());

            realValue = valueInteger.intValue();

        }

        if (!(realValue >= minCount && realValue <= maxCount)) {
            throw new Exception("integer value out of range.");
        }
    }

}

public class StringValidator implements Validator {
    
    private int maxCount = 1024;

    private int minCount = 0;

    public StringValidator() {

    }

    public StringValidator(int minCount, int maxCount) {
        this.minCount = minCount;
        this.maxCount = maxCount;
    }

    @Override
    public void validate(Object value) throws Exception {
        int charNumber = 0;

        if (null == value) {
            
            charNumber = 0;
            
        } else {
            if (!(value instanceof String)) {
                throw new Exception("field is NOT String Type.");
            }

            String valueStr = (String) value;

            charNumber = valueStr.length();

        }
        
        if(!(charNumber >= minCount && charNumber <= maxCount)) {
            throw new Exception("value out of range.");
        }

    }
}

Context环境

public class ValidatorContext {
    
    private Validator validator;
    
    public ValidatorContext(Validator validator) {
        this.validator = validator;
    }
    
    public void operate(Object param) throws Exception {
        validator.validate(param);
    }
}

main方法调用

public class App {

    private static final Validator DEFAULT_STRING_VALIDATOR = new StringValidator(0, 1024);
    
    private static final Validator DEFAULT_INTEGER_VALIDATOR = new IntegerValidator(0, 100);
    
    public static void main(String[] args) throws Exception {
        Student student = new Student();
        student.setId(Integer.valueOf(1));
        student.setName("kingsley");
        
        ValidatorContext idContext = new ValidatorContext(DEFAULT_INTEGER_VALIDATOR);
        ValidatorContext nameContext = new ValidatorContext(DEFAULT_STRING_VALIDATOR);
        
        idContext.validate(student.getId());
        nameContext.validate(student.getName());
        // dao层操作
    }
}

策略模式的优点是可以动态地改变对应的算法，并且在算法扩展时，可以不修改原有代码，而扩展出新的算法（即符合开闭原则）。同时可以有效地减少多条分支的判断，增加代码可读性。

缺点是会产生比较多的策略类，并且客户端需要知道都有哪些策略。