(策略模式+工厂模式+map)套餐 Kill 项目中的switch case

接手新任务：接入第三家存证机构，看以前的代码使用了swith case判断使用哪家存证机构，每家存证机构的实现逻辑不同 代码的坏味道：多层swich case。多层swich case很差维护，是时候应该重构了，

优化前的代码

为了便于理解，举个没有业务逻辑的例子，基于这个例子上进行优化。 如今是12:47，举个饭后吃水果的例子哈哈哈（逃 假设咱们能够选择的水果有香蕉、西瓜和苹果。吃香蕉的话咱们得先剥皮，吃西瓜的话得先用水果刀切一下，若是是苹果的话就直接吃了。将这个场景转化为代码：

public class EatFruit {
    private static final String APPLE = "apple";
    private static final String BANANA = "banana";
    private static final String WATERMELON = "watermelon";

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //选择的水果种类
        String fruitType = scanner.nextLine();

        switch (fruitType) {
            case APPLE:
                eatApple();
                break;
            case BANANA:
                eatBanana();
                break;
            case WATERMELON:
                eatWatermelon();
                break;
        }
    }

    private static void eatBanana() {
        System.out.println("吃香蕉了，须要先剥下皮");
    }

    private static void eatApple() {
        System.out.println("是苹果，能够直接吃");
    }

    private static void eatWatermelon() {
        System.out.println("吃西瓜了，可是还得弄把水果刀切一下先");
    }
}
复制代码

这个例子代码量不是很大，可是实际项目中的场景确定没有这么简单，多重swich case很差维护，而且万一又加了同样水果，还得继续加一层case...

很容易想到策略模式(简单的理解就是多态)，水果都有吃的一个动做，可是每种水果的吃法不同

使用策略模式进行优化

Fruit.java

public interface Fruit {
    void eat();
}

复制代码

Apple.java

public class Apple implements Fruit {
    @Override
    public void eat() {
        System.out.println("是苹果，能够直接吃");
    }
}
复制代码

Banana.java

public class Banana implements Fruit {
    @Override
    public void eat() {
        System.out.println("吃香蕉了，须要先剥下皮");
    }
}
复制代码

Watermelon.java

public class Watermelon implements Fruit {
    @Override
    public void eat() {
        System.out.println("吃西瓜了，可是还得弄把水果刀切一下先");
    }
}
复制代码

可是发现即便用了策略模式也难逃类型判断 EatFruit.java

public class EatFruit {
    private static final String APPLE = "apple";
    private static final String BANANA = "banana";
    private static final String WATERMELON = "watermelon";

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //选择的水果种类
        String fruitType = scanner.nextLine();
        Fruit fruit = null;

        switch (fruitType) {
            case APPLE:
                fruit = new Apple();
                break;
            case BANANA:
                fruit = new Banana();
                break;
            case WATERMELON:
                fruit = new Watermelon();
                break;
        }

        fruit.eat();
    }
}
复制代码

使用策略模式具备良好的扩展性，兵来将挡，再给我添加十种水果都不怕，水果种类太多会使水果的实现类暴增。如今来一种水果无需在原先的业务类(EatFruit)里修改不少的代码逻辑，只要实现接口并加个条件判断就行了。可是使用策略模式时，咱们须要知道具体的实现类，具体的实现类须要对外暴露

使用工厂模式

将类型判断放到工厂类中 工厂模式：在建立对象时不会对客户端暴露建立逻辑，而且是经过使用一个共同的接口来指向新建立的对象，这里共同的接口就是Fruit。粗暴的讲，工厂模式就是把建立同一类型对象逻辑写在了一个方法里 FruitFactory .java

public class FruitFactory {
    public static Fruit getFruit(String fruitType) {
        if ("apple".equals(fruitType)) {
            return new Apple();
        }

        if ("banana".equals(fruitType)) {
            return new Banana();
        }

        return new Watermelon();
    }
}
复制代码

EatFruit .java

public class EatFruit {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        //选择的水果种类
        String fruitType = scanner.nextLine();
        Fruit fruit = FruitFactory.getFruit(fruitType);
        fruit.eat();
    }
}
复制代码

到如今为止EatFruit中的业务代码已经很清晰了。 使用工厂模式具备良好的封装性，这下妈妈不再用关系建立类的过程，甚至连建立的实际类的都无需关心，实现了解耦，实际类的修改变化都不会影响上层业务
可是工厂类中仍是有不少if的，革命还没有成功，仍须要进行优化。

map奥特曼来了

FruitFactory.java

public class FruitFactory {
    private static Map<String, Fruit> fruitMap = new HashMap<>();

    static {
        fruitMap.put("apple", new Apple());
        fruitMap.put("banana", new Banana());
        fruitMap.put("watermelon", new Watermelon());
    }

    public static Fruit getFruit(String fruitType) {
       return fruitMap.get(fruitType);
    }
}
复制代码

经过使用map，fruitType与<T extend Fruit>进行一一映射，和条件判断说byebye~，代码也很优雅 最终项目结构类图：

========================如下内容更新于2018.11.12======================

有网友评论能够用反射替代map，若是传进来的是Class类型的值就能够用反射。用反射的好处是在添加多种水果，工厂类的代码都无需进行变更 经过反射替代map: FruitFactory2.java

public class FruitFactory2 {
    public static <T extends Fruit> T getFruit(Class<T> fruitClass) throws IllegalAccessException, InstantiationException {
        return fruitClass.newInstance();
    }
}
复制代码