策略模式&lambda重构策略模式

1、概念以及背景

策略模式(Strategy Pattern):定义一系列算法类，将每个算法封装起来，并让它们能够相互替换，策略模式让算法独立于使用它的客户端而变化，也称为政策模式(Policy)。

简而言之，策略模式是客户端在运行时选择某种解决方案（策略，方法，算法）来解决问题，而解决方案（策略，方法，算法）的定义与使用是分开的，即解决方案与客户端的调用中间有个类能够针对不一样的问题，采起不一样的解决方案，该中间类中持有一个对策略类接口的引用实例，用于定义所采用的策略。

本文涉及的代码在github上，点击 连接 可查看源码。

文章会用两种方式来实现策略模式，一种是Java8以前经过本身写接口的方式实现策略模式，另外一种是采用Java8提供的函数式接口来实现策略模式，也用了lambda表达式，使代码看起来更加简洁，使咱们能更专一于业务逻辑的处理。

文章所用的场景是这样的：根据快递包裹的重量计算快递公司的邮费，不一样的快递公司有不一样的邮费计算方式，如京东，申通，圆通等快递公司的邮费计算都是不同的。

2、策略模式

策略模式须要一个策略接口，定义一个待实现的方法，不一样的解决方案（方法）实现该策略接口，以实现不一样的解决方法，接着为了让客户端和策略解耦，即解决方案的定义与使用是分开的，咱们须要有一个中间类，咱们先看一下上面提到的场景下的UML类图：

CalculateStrategy是策略接口，有一个待实现的calculate方法，计算邮费，根据传入的包裹重量，返回计算好的邮费。JdCalculateStrategy、StoCalculateStrategy、YtoCalculateStrategy分别为京东、申通、圆通不一样的计算邮费方式，实现了CalculateStrategy接口的calculate方法。

CalculateStrategy策略接口代码以下：

public interface CalculateStrategy {
    Double calculate(Integer weight);
}

JdCalculateStrategy类：

public class JdCalculateStrategy implements CalculateStrategy {
    @Override
    public Double calculate(Integer weight) {
        return 10 + weight * 1.2;
    }
}

StoCalculateStrategy类：

public class StoCalculateStrategy implements CalculateStrategy {
    @Override
    public Double calculate(Integer weight) {
        return 12 + weight * 0.8;
    }
}

YtoCalculateStrategy类：

public class YtoCalculateStrategy implements CalculateStrategy {
    @Override
    public Double calculate(Integer weight) {
        return 8 + weight * 1.5;
    }
}

咱们能够看到不一样的快递公司有不一样的策略来计算邮费。为了不在日后邮费计算须要修改的时候，也须要修改客户调用方代码，也为了进一步解耦，咱们须要有一个中间类，来把策略封装起来，持有策略接口。
中间类CalculateContext代码以下：

public class CalculateContext {
    //持有策略接口
    private CalculateStrategy calculateStrategy;
    public void setCalculateStrategy(CalculateStrategy calculateStrategy) {
        this.calculateStrategy = calculateStrategy;
    }
    public Double calculate(Integer weigth) {
        return calculateStrategy.calculate(weigth);
    }
}

在运行时选择某种解决方案，客户端代码以下：

public class Client {
    public static void main(String[] args) {
        Integer weight = 15;
        CalculateContext context = new CalculateContext();
        CalculateStrategy calculateStrategy = new JdCalculateStrategy();
        context.setCalculateStrategy(calculateStrategy);
        System.out.println("运行时指定策略，计算邮费以下：" + context.calculate(weight));
    }
}

3、lambda重构策略模式

仔细思考，不难发现，不一样的策略实际上是不一样的方法，那么有没有一种办法，在运行时要选择某种方法，咱们能够直接提供方法呢？固然不是if else 不一样分支里面调用咱们写好的不一样方法啦，这样的话代码结构比较乱，高度耦合了，分支也比较多，这里采用的是Java8提供的一个内置函数式接口：

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
}

该接口的用法，咱们能够看apply方法，入参是T泛型类，返回值是R泛型类，仔细想一想是否是符合咱们的要求，计算邮费的方法：入参是Integer类型的包裹重量，返回参数是Double型的邮费，这里咱们就能够这样用该接口，Function<Integer, Double>，计算邮费的方法用lambda表达式去实现apply接口方法。光是这样仍是不行的，由于咱们要怎么根据快递公司来方便地调用lambda表达式呢？答案是：用Map集合，key是快递公司，value是函数式接口的lambda表达式便可。
快递公司枚举类，做为map的key：

public enum ParcelCompanyEnum {
    ZTO("中通快递"),YTO("圆通快递"),STO("申通快递"),JD("京东快递");
    String name;
    ParcelCompanyEnum(String name) {
        this.name = name;
    }
}

CalculatePostage类有一个Map成员变量，在类对象初始化的时候初始化该map，map设置lambda表达式，实现函数式接口，

public class CalculatePostage {
     Map<ParcelCompanyEnum, Function<Integer, Double>> map = new HashMap<>(5);

    {
        map.put(ParcelCompanyEnum.JD, this::calculateJd);
        map.put(ParcelCompanyEnum.STO, this::calculatSto);
        map.put(ParcelCompanyEnum.YTO, this::calculateYto);
        map.put(ParcelCompanyEnum.ZTO, this::calculateZto);
    }
    public Double calculateJd(Integer weight) {
        return 10 + weight * 1.2;
    }
    public Double calculatSto(Integer weight) {
        return 12 + weight * 0.8;
    }
    public Double calculateYto(Integer weight) {
        return 8 + weight * 1.5;
    }
    public Double calculateZto(Integer weight) {
        return 9 + weight * 1.1;
    }
}

接着，在客户端是这样子来调用的：

public class Client {
    public static void main(String[] args) {
        ParcelCompanyEnum company = ParcelCompanyEnum.JD;
        Integer weight = 15;
        CalculatePostage calculatePostage = new CalculatePostage();
        System.out.println("Java8 lambda + 策略模式 计算邮费：" + calculatePostage.map.get(company).apply(weight));
    }
}

先根据快递公司来获取不一样的策略，而后传入包裹重量，最后返回计算结果。
若是你对函数式接口、lambda表达式不熟悉或者不了解的话，我推荐《Java8实战》这本书，能够留个邮箱我发电子书。

3、拓展Java8提供的内置函数式接口