【Java Lambda系列】新玩法，用Lambda重构设计模式

前言

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

关于设计模式

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

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

Lambda重构设计模式

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

简单工厂模式

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

案例：水果工厂

包含橘子、香蕉、苹果

• 传统写法

/**
 * 简单工厂
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20
 */
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写法

/**
 * Lambda形式工厂模式
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20
 */
public class FruitLambdaFactory {
    /**
     * 初始化工厂数据
     */
    private static Map<String, Supplier<Fruit>> FRUIT_FACTORY = new HashMap<String, Supplier<Fruit>>(){{
       put("Banana", Banana::new);
       put("Apple", Apple::new);
    }};

    public static Fruit getLambdaFruit(String fruit) {
        Supplier<Fruit> fruitSupplier = FRUIT_FACTORY.get(fruit);
        return Objects.nonNull(fruitSupplier) ? fruitSupplier.get() : null;
    }
}

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

• 反射写法

/**
 * 反射形式的工厂模式
 *
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20
 */
public class FruitReflectFactory {

    public static <T extends Fruit> T getLambdaFruit(Class<T> fruitCls) {
        try {
            return fruitCls.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

策略模式

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

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

包含：邮件通道、websocket通道

• 传统模式

/**
 * 发送通道策略
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20  20:18
 */
public interface SendChannelStrategy {
    /**
     * 发送接口
     * @param msg
     */
    void send(String msg);
}

/**
 * 邮箱策略
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20  20:19
 */
public class EmailChannelStrategy implements SendChannelStrategy{
    @Override
    public void send(String msg) {
        System.out.println("使用email发送：" + msg);
    }
}

/**
 * websocket策略
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20  20:19
 */
public class WebSocketChannelStrategy implements SendChannelStrategy{
    @Override
    public void send(String msg) {
        System.out.println("使用websocket发送：" + msg);
    }
}
/**
 * 消息服务，使用发送策略
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20
 */
@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类的定义!

模版方法模式

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

案例：游戏的过程

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

• 传统写法

/**
 * 游戏
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20  20:49
 */
public abstract class Game {

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

    /**
     * 选择游戏姿势
     */
    public abstract void selectPlayPosture(String posture);
}
/**
 * 躺着玩
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20  20:53
 */
public class LieGame extends Game{
    @Override
    public void selectPlayPosture(String posture) {
        System.out.println("沙发上：" + posture);
    }
}
/**
 * 坐着玩
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20  20:52
 */
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写法

/**
 * Lambda形式的模版方法
 * @author : uu
 * @version : v1.0
 * @Date 2022/1/20  20:49
 */
public class LambdaGame {

    public void play(String posture, Consumer<String> 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给代码编写带来的便捷；
• 本次仅列出了几个常用的设计模式改写，小伙伴们有兴趣可以一起讨论其他模式的改写哦；
• 案例中代码比较简单，实际开发时还是得依托业务的需求，并不能一味的为了简洁而简洁。