【再学一次系列】新玩法，用Lambda重构设计模式

哈喽大家好，我是卡诺，一名致力于成为全栈的全粘工程师！

前面三章通过理论+案例的方式对Lambda的描述，应该能基本上解决大家日常开发中所遇到的Lambda问题，为了更好的展现Lambda魅力，和加深巩固Lambda知识点，今天咱们讨论Lambda如何重构设计模式！

众所周知，设计模式是一群大佬程序员将对程序设计的经验归纳总结起来的方案。它不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。

本文不会对设计模式过度讲解，默认大家对设计模式有一定的了解（后面我会针对所有的设计模式单独进行讲解）

接下来列举常用的几个设计模式，通过传统和lambda形式对比写法，让大家感受不一样的、Lambda版本的设计模式！

简单工厂模式因为内部方法常被定义为静态，所以又叫做静态工厂方法（Static Factory Method）模式，是由一个工厂对象通过客户端需要的类型创建出某个产品类的实例，简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

案例：水果工厂

包含橘子、香蕉、苹果

传统写法

public class FruitFactory {
    public static Fruit getFruit(String fruitName) {
        Fruit fruit = null;
        switch (fruitName) {
            case "Banana":
                fruit = new Banana();
                break;
            case "Apple":
                fruit = new Apple();
                break;
        }
        return fruit;
    }
}
复制代码

工厂模式的本质就是调用的时候返回一个对象，仔细回想一下，Java内置的函数式接口中Supplier似乎就是干这个事的，话不多说直接改写吧，

lambda写法

public class FruitLambdaFactory {
    
    private static Map> FRUIT_FACTORY = new HashMap>(){{
       put("Banana", Banana::new);
       put("Apple", Apple::new);
    }};

    public static Fruit getLambdaFruit(String fruit) {
        Supplier fruitSupplier = FRUIT_FACTORY.get(fruit);
        return Objects.nonNull(fruitSupplier) ? fruitSupplier.get() : null;
    }
}
复制代码

题外话： 上述写法其实存在瑕疵，比如：再新增一个水果品类，就必须改动工厂的静态方法，违背了开闭原则，而且通过传入字符串的形式也很容易导致拼错问题，实际业务中我们可以使用反射来解决这个问题。

反射写法

public class FruitReflectFactory {

    public static  T getLambdaFruit(Class fruitCls) {
        try {
            return fruitCls.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}
复制代码

策略模式就是封装一系列算法，让这些算法之间可以在运行时相互替换，可以很好的解决过多使用if...else if...else的问题!

案例：多种发送信息的通道

包含：邮件通道、websocket通道

传统模式

public interface SendChannelStrategy {
    
    void send(String msg);
}


public class EmailChannelStrategy implements SendChannelStrategy{
    @Override
    public void send(String msg) {
        System.out.println("使用email发送：" + msg);
    }
}


public class WebSocketChannelStrategy implements SendChannelStrategy{
    @Override
    public void send(String msg) {
        System.out.println("使用websocket发送：" + msg);
    }
}

@AllArgsConstructor
@Getter@Setter
public class SendService {
    private SendChannelStrategy sendChannelStrategy;
    
    public void send(String msg) {
        sendChannelStrategy.send(msg);
    }
}
// 使用方式如下
public void test(){
    SendService sendService = new SendService(new EmailChannelStrategy());
    sendService.send("卡诺"); // 使用email发送：卡诺
    sendService.setSendChannelStrategy(new WebSocketChannelStrategy());
    sendService.send("卡诺"); // 使用websocket发送：卡诺
}
复制代码

这里我们可以发现上面的策略模式接口其实是个函数式接口（只有一个抽象方法哦），方法拥有一个入参，无返回值，是不是一下子就想到了Java的内置函数式接口Consumer呢？下面我们就来看看Lambda的处理方式把！

lambda写法

public void testLambda(){
    SendService sendService = new SendService(msg -> System.out.println("使用lambda email发送：" + msg));
    sendService.send("卡诺"); // 使用email发送：卡诺
    
    sendService.setSendChannelStrategy(msg -> System.out.println("使用websocket发送：" + msg));
    sendService.send("卡诺"); // 使用websocket发送：卡诺
}
复制代码

代码如所想，使用Consumer进行替换，我们可以直接省略掉EmailChannelStrategy和WebSocketChannelStrategy类的定义!

模版方法模式指：父类定义好流程，允许子类实现流程中的一个或多个步骤。这样就可以保证整体流程不变的情况下，子类实现自己的个性化操作。

案例：游戏的过程

选择一个游戏的姿势玩（躺着/坐着）、开始游戏、游戏结束

传统写法

public abstract class Game {

    public void play(String posture) {
        selectPlayPosture(posture);
        System.out.println("开始游戏");
        System.out.println("结束游戏");
    }

    
    public abstract void selectPlayPosture(String posture);
}

public class LieGame extends Game{
    @Override
    public void selectPlayPosture(String posture) {
        System.out.println("沙发上：" + posture);
    }
}

public class SitGame extends Game{
    @Override
    public void selectPlayPosture(String posture) {
        System.out.println("板凳上：" + posture);
    }
}
// 测试
public void test(){
    Game game = new LieGame();
    game.play("躺着");
    game = new SitGame();
    game.play("坐着");
}
复制代码

通过上述的代码，我们可以发现模版模式中需要被子类实现的抽象接口是一个入参，无返回值的抽象方法，Java内置函数式接口Consumer与之恰好匹配，我们可以将需要子类实现的方法，通过Consumer提取作为游戏流程的参数，即可大幅度减少代码，如下：

Lambda写法

public class LambdaGame {

    public void play(String posture, Consumer consumer) {
        consumer.accept(posture);
        System.out.println("开始游戏");
        System.out.println("结束游戏");
    }
}

// 使用方式
public void testLambda(){
    LambdaGame game = new LambdaGame();
    game.play("躺着", System.out::println);
    game.play("坐着", System.out::println);
}
复制代码

通过Lambda的改写是不是看起来简单了许多呢？

源码请点击这里访问 总结

本章通过使用Lambda重构设计模式的形式展现Lambda给代码编写带来的便捷；

本次仅列出了几个常用的设计模式改写，小伙伴们有兴趣可以一起讨论其他模式的改写哦；

案例中代码比较简单，实际开发时还是得依托业务的需求，并不能一味的为了简洁而简洁。

【再学一次系列】Lambda必知必会【再学一次系列】Lambda内置函数式接口【再学一次系列】Lambda方法引用，你一定能搞懂！ 最后

感谢铁子们耐心看到最后，如果大家感觉本文有所帮助，麻烦给个赞或关注➕；

由于本人技术有限，文章和代码可能存在错误，希望大家评论指出，万分感激；

同时也欢迎大家V我一起讨论学习前端、Java知识，一起卷一起进步。