软件设计重构秘笈11式-10使用策略类

软件设计重构秘笈11式-10使用策略类

概念

本文中的“使用策略类” 是指用设计模式中的策略模式来替换原来的switch case和if else语句，这样可以解开耦合，同时也使维护性和系统的可扩展性大大增强。

意图

策略类可以解开耦合，同时也使维护性和系统的可扩展性大大增强
如下面代码所示，ClientCode 类会更加枚举State的值来调用ShippingInfo 的不同方法，但是这样就会产生很多的判断语句，如果代码量加大，
类变得很大了的话，维护中改动也会变得很大，每次改动一个地方，都要对整个结构进行编译（假如是多个工程），所以我们想到了对它进行重构，剥开耦合。

案例

public class ShippingInfo {

    public double calculateShippingAmount(State shipToState)
    {
        switch (shipToState)
        {
            case Alaska:
                return getAlaskaShippingAmount();
            case NewYork:
                return getNewYorkShippingAmount();
            case Florida:
                return getFloridaShippingAmount();
            default:
                return 0;
        }
    }

    private double getAlaskaShippingAmount()
    {
        return 15;
    }

    private double getNewYorkShippingAmount()
    {
        return 10;
    }

    private double getFloridaShippingAmount()
    {
        return 3;
    }

}

public enum State {

    Alaska(1),
    NewYork(2),
    Florida(3);

    private final Integer code;

    State(Integer code) {
        this.code = code;
    }

    public Integer getCode() {
        return code;
    }
}

public class ClientCode {

    public double calculateShipping() {
        ShippingInfo shippingInfo = new ShippingInfo();
        return shippingInfo.calculateShippingAmount(State.Alaska);
    }

}

重构

重构后的代码如下所示，抽象出一个IShippingCalculation 接口，
然后把ShippingInfo 类里面的GetAlaskaShippingAmount、GetNewYorkShippingAmount、GetFloridaShippingAmount三个方法分别提炼成三个类，
然后继承自IShippingCalculation 接口，
这样在调用的时候就可以通过List 来解除之前的switch case语句，这和IOC的做法颇为相似。

public interface IShippingCalculation {

    State getState();

    double calculate();

}

public class AlaskShippingCalculation implements IShippingCalculation {

    @Override
    public State getState() {
        return State.Alaska;
    }

    @Override
    public double calculate() {
        return 15;
    }
}

public class FloridaShippingCalculation implements IShippingCalculation {

    @Override
    public State getState() {
        return State.Florida;
    }

    @Override
    public double calculate() {
        return 3;
    }
}

public class NewYorkShippingCalculation implements IShippingCalculation {

    @Override
    public State getState() {
        return State.NewYork;
    }

    @Override
    public double calculate() {
        return 10;
    }
}

public interface IShippingInfo {

    double calculateShippingAmount(State state);

}

public class ShippingInfo implements IShippingInfo{

    private Map<State,IShippingCalculation> shippingCalculations;

    public ShippingInfo(Map<State,IShippingCalculation> shippingCalculations) {
        this.shippingCalculations = shippingCalculations;
    }


    public double calculateShippingAmount(State shipToState)
    {
        IShippingCalculation iShippingCalculation= shippingCalculations.get(shipToState);
        return iShippingCalculation.calculate();
    }
}

public class ClientCode {

    public double calculateShipping() {
        Map<State,IShippingCalculation> map = new HashMap<>();
        map.put(State.Alaska,new AlaskShippingCalculation());
        map.put(State.NewYork,new NewYorkShippingCalculation());
        map.put(State.Florida,new FloridaShippingCalculation());
        IShippingInfo shippingInfo = new ShippingInfo(map);
        return shippingInfo.calculateShippingAmount(State.Alaska);
    }

}

总结

这种重构在设计模式当中把它单独取了一个名字——策略模式，
这样做的好处就是可以隔开耦合，以注入的形式实现功能，
这使增加功能变得更加容易和简便，
同样也增强了整个系统的稳定性和健壮性。