函数式编程让你忘记设计模式

jiezi

5 年前

本文是一篇《Java 8 实战》的阅读笔记，阅读大约需要 5 分钟。

有点标题党，但是这确实是我最近使用 Lambda 表达式的感受。设计模式是过去的一些好的经验和套路的总结，但是好的语言特性可以让开发者不去考虑这些设计模式。面向对象常见的设计模式有策略模式、模板方法、观察者模式、责任链模式以及工厂模式，使用 Lambda 表达式（函数式编程思维）有助于避免面向对象开发中的那些固定代码。下面我们挑选了策略模式和职责链模式两个案例进行分析。

当我们解决一个问题有不同的解法的时候，又不希望客户感知到这些解法的细节，这种情况下适合使用策略模式。策略模式包括三个部分：

解决问题的算法（上图中的 Strategy）；
一个或多个该类算法的具体实现（上图中的 ConcreteStrategyA、ConcreteStrategyB 和 ConcreteStrategyC）
一个或多个客户使用场景（上图中的 ClientContext）

首先定义策略接口，表示排序策略：

public interface ValidationStrategy {boolean execute(String s);
}

然后定义具体的实现类（即不同的排序算法）：

public class IsAllLowerCase implements ValidationStrategy {
    @Override
    public boolean execute(String s) {return s.matches("[a-z]+");
    }
}

public class IsNumberic implements ValidationStrategy {
    @Override
    public boolean execute(String s) {return s.matches("\\d+");
    }
}

最后定义客户使用场景，代码如下图所示。Validator 是为客户提供服务时使用的上下文环境，每个 Valiator 对象中都封装了具体的 Strategy 对象，在实际工作中，我们可以通过更换具体的 Strategy 对象来进行客户服务的升级，而且不需要让客户进行升级。

public class Validator {

    private final ValidationStrategy strategy;

    public Validator(ValidationStrategy strategy) {this.strategy = strategy;}

    /**
     * 给客户的接口
     */
    public boolean validate(String s) {return strategy.execute(s);
    }
}

public class ClientTestDrive {public static void main(String[] args) {Validator numbericValidator = new Validator(new IsNumberic());
        boolean res1 = numbericValidator.validate("7780");
        System.out.println(res1);

        Validator lowerCaseValidator = new Validator(new IsAllLowerCase());
        boolean res2 = lowerCaseValidator.validate("aaaddd");
        System.out.println(res2);
    }
}

如果使用 Lambda 表达式考虑，你会发现 ValidationStrategy 就是一个函数接口（还与 Predicate<String> 具有同样的函数描述），那么就不需要定义上面那些实现类了，可以直接用下面的代码替换，原因是 Lambda 表达式内部已经对这些类进行了一定的封装。

public class ClientTestDrive {public static void main(String[] args) {Validator numbericValidator = new Validator((String s) -> s.matches("\\d+"));
        boolean res1 = numbericValidator.validate("7789");
        System.out.println(res1);

        Validator lowerCaseValidator = new Validator((String s) -> s.matches("[a-z]+"));
        boolean res2 = lowerCaseValidator.validate("aaaddd");
        System.out.println(res2);
    }
}

在某些场景下，需要对一个对象做一系列的工作，这些工作分别是由不同的类完成的，这时候就比较适合使用责任链模式。责任链模式的主要组成部分包括三个：

管理操作序列的抽象类，在该抽象类里有会有一个对象记录当前对象的后继操作对象；
一些具体的操作对象，这些操作对象会以一个链表的形式组织起来
一个使用该模式的客户端组件，该组件只需要跟一个组件打交道就好，不需要跟很多个操作对象耦合在一起。

首先看下我们这里定义了一个抽象类 ProcessingObject，其中 successor 字段用于管理该对象的后继操作对象；handle 接口作为对外提供服务的接口；handleWork 作为实际处理对象的操作方法。

public abstract class ProcessingObject<T> {

    protected ProcessingObject<T> successor;
    
    public void setSuccessor(ProcessingObject<T> successor) {this.successor = successor;}

    public T handler(T input) {T r = handleWork(input);
        if (successor != null) {return successor.handler(r);
        }
        return r;
    }

    abstract protected T handleWork(T input);
}

接下来可以定义两个具体的操作对象，如下面代码所示。PS：这里《Java 8 实战》书中用的是 replaceAll 方法是不太合适的，这个点可以参考我们之前的文章——020：举几个 String 的 API 以及案例
)。

public class HeaderTextProcessing extends ProcessingObject<String> {
    @Override
    protected String handleWork(String input) {return "From Raoul, Mario and Alan:" + input;}
}

public class SpellCheckerProcessing extends ProcessingObject<String> {
    @Override
    protected String handleWork(String input) {return input.replace("labda", "lambda");
    }
}

最后，你就可以在 Client 中将这上面两个具体的操作类对象构成一个操作序列，参见下面的代码：

public class Client {public static void main(String[] args) {ProcessingObject<String> p1 = new HeaderTextProcessing();
        ProcessingObject<String> p2 = new SpellCheckerProcessing();

        p1.setSuccessor(p2);

        String result = p1.handler("Aren't labdas really sexy?!!");
        System.out.println(result);
    }
}

如果使用函数式编程思维，那么职责链模式就直接了——y=f(x) 和 z =g(x) 这两个方法都是要对 x 做处理，那么如果将这两个函数组合在一起，就会形成 r =f(g(x)) 的情况，也就是可以使用 Lambda 表达式中的 addThen 来串联起多个处理过程。

public class ClientWithLambda {public static void main(String[] args) {UnaryOperator<String> headerProcessing = (String text) -> "From Raoul, Mario and Alan:" + text;

        UnaryOperator<String> spellCheckProcessing = (String text) -> text.replace("labda", "lambda");

        Function<String, String> function = headerProcessing.andThen(spellCheckProcessing);

        String result = function.apply("Aren't labdas really sexy?!!");
        System.out.println(result);

        UnaryOperator<String> hhhhhProcessing = (String text) -> text.concat("hhhh");
        Function<String, String> function1 = function.andThen(hhhhhProcessing);
        String result1 = function1.apply("Aren't labdas really sexy?!!");
        System.out.println(result1);
    }
}

上面是利用 Java 原生的 Lambda 表达式实现的职责链模式，我们也可以使用前面一篇文章——vavr：让你像写 Scala 一样写 Java
) 中介绍过的 vavr 库来实现，代码如下所示：

public class ClientWithVavr {public static void main(String[] args) {Function1<String, String> headerProcessing = (String text) -> "From Raoul, Mario and Alan:" + text;
        Function1<String, String> specllCheckProcessing = (String text) -> text.replace("labda", "lambda");

        Function1<String, String> function = headerProcessing.compose(specllCheckProcessing);
        String result = function.apply("Aren't labdas really sexy?!!");
        System.out.println(result);
    }
}

可以看出，函数式编程思维跟面向对象编程思维的思考方式是不同的，表达力更强，因此，作为开发者是时候认真学习下函数式编程思维了，作为 Java 开发者，我准备先从 Lambda 表达式开始学起，然后尝试学习下 Scala 或 Kotlin 两门语言中的函数式变成特性。

《Java 编程实战》
《设计模式之禅》

本号专注于后端技术、JVM 问题排查和优化、Java 面试题、个人成长和自我管理等主题，为读者提供一线开发者的工作和成长经验，期待你能在这里有所收获。

函数式编程让你忘记设计模式

案例 1：策略模式

面向对象思路

函数式编程思路

案例 2：责任链模式

面向对象思路

函数式编程思路

总结

参考资料