基于lambda简化设计模式

前言

虽说使用设计模式可以让复杂的业务代码变得清晰且易于维护，但是某些情况下，开发可能会遇到我为了简单的业务逻辑去适配设计模式的情况，本文笔者就以四种常见的设计模式为例，演示如何基于lambda来简化设计模式的实现。

策略模式

我们的项目中会涉及各种各样的校验，可能是校验电话号码、单双数、字符串长度等，为此我们希望通过策略模式来封装这些校验规则。

第一步自然是通过接口来定义策略，编写一个名为execute方法，让用户传入字符串，返回校验结果的布尔值：

/*** 定义策略模式的接口*/
public interface ValidationStrategy {/*** 校验该字符串是否符合要求，若符合则返回true* @param str* @return*/boolean execute(String str);
}

然后将这个策略接口聚合到我们的校验器中，后续我们就可以按照需求传入对应的校验策略即可：

/*** 校验工具，将策略接口成员成员属性，起到依赖抽象的作用*/
public class Validator {private ValidationStrategy strategy;public Validator() {}public Validator(ValidationStrategy strategy) {this.strategy = strategy;}public boolean validate(String str) {return strategy.execute(str);}
}

假如我们需要校验这个字符串是否全为字符串小写，那么我们就可以封装这样一个类:

/*** 判断是否全为小写*/
public class IsAllLowerCase implements ValidationStrategy {@Overridepublic boolean execute(String str) {return str.matches("[a-z]+");}
}

同理，如果我们需要判断是否全为数字，则可以这样写:

/*** 判断传入字符是否全为数字*/
public class IsNumeric implements ValidationStrategy {@Overridepublic boolean execute(String str) {return str.matches("\\d+");}
}

使用时，我们只需按需传入校验规则即可：

public class Main {public static void main(String[] args) {//校验是否全为数字Validator v1 = new Validator(new IsNumeric());System.out.println(v1.validate("1234"));//校验是否全是小写Validator v2 = new Validator(new IsAllLowerCase());System.out.println(v2.validate("dalhl"));}
}

输出结果如下:

true
true

不知道读者是否可以发现问题，规则的校验往往只是一两行代码，为了适配规则校验所用到的策略模式，开发者往往需要对此额外创建一个类，要知道字符校验的规则是成百上千的，并且很多校验规则很可能仅仅是某个业务才会用到的。

所以我们是否有办法做到既能适配策略模式，又避免为了一段简单的校验代码而去创建一个类呢？

查看我们校验策略接口ValidationStrategy的定义，它要求传入一个String返回一个boolean，由此我们想到了java8提供的函数时接口Function，其定义如下所示，可以根据泛型要求要指明泛型T和R，apply方法要求传入一个T，这里可以直接理解为我们的String，然后返回一个R，同理代入我们的boolean:

@FunctionalInterface
public interface Function<T, R> {/*** Applies this function to the given argument.** @param t the function argument* @return the function result*/R apply(T t);.......}

按照java8的lambda语法糖，Function<T, R>只有一个需要实现的方法R apply(T t)，我们完全可以表面类的创建，取而代之的是这样一段表达式:

t->R

查看我们ValidationStrategy的定义，它也是只有一个方法execute，我们完全可以将其视为Function<String, Boolean>，即可得表达式s->boolean：

在这里插入图片描述

由此我们得出下面这段代码，可以看到根据接口的定义匹配java8对应的函数时接口，然后基于lambda表达式即可完成创建，这样做法避免了类的生命，避免了简单逻辑复杂化实现的问题：

public static void main(String[] args) {//校验是否全为数字Validator v1 = new Validator((s) -> s.matches("\\d+"));System.out.println(v1.validate("1234"));//校验是否全是小写Validator v2 = new Validator(s -> s.matches("[a-z]+"));System.out.println(v2.validate("dalhl"));}

模板方法

银行接待VIP顾客的核心流程为:

  1. 查询顾客是否是VIP。
  2. 招待顾客，为顾客办理业务。

所有银行的大体流程都是这样，唯一的区别就是第2步，对此我们可以使用模板方法模式，创建一个抽象类，将第1步抽出来，而第2步按照不同银行进行不同的实现：

public abstract class Banking {public void processCustomer(int id) {//查询会员名String customer = getCustomerWithId(id);//招待会员makeCustomerHappy(customer);}private String getCustomerWithId(int id) {return RandomUtil.randomString(5);}protected abstract void makeCustomerHappy(String customer);
}

对应两个银行的实现代码,先来看看BankingA 的招待逻辑:

public class BankingA extends Banking {@Overrideprotected void makeCustomerHappy(String customer) {System.out.println("请"+customer+"吃饭，并为其办理业务");}
}

BankingB的招待逻辑:

public class BankingB extends Banking {@Overrideprotected void makeCustomerHappy(String customer) {System.out.println("请" + customer + "喝茶，并为其办理业务");}
}

测试代码如下：

public static void main(String[] args) {BankingA bankingA = new BankingA();bankingA.processCustomer(1);BankingB bankingB= new BankingB();bankingB.processCustomer(1);}

对应输出结果:

请6brkb吃饭，并为其办理业务
请autjm喝茶，并为其办理业务

还是一样的问题，找到会员是一段无返回值的简单输出，为了适配模板方法，这一行代码也还是要创建一个类，所以我们还是需要用lambda对其进行简化。

查看抽象方法makeCustomerHappy的定义，它要求传入一个传入而返回一个void，查阅java8对应的函数式接口，我们找到了Consumer：

@FunctionalInterface
public interface Consumer<T> {/*** Performs this operation on the given argument.** @param t the input argument*/void accept(T t);

于是我们得出公式s->Void：

在这里插入图片描述

对此我们将抽象类Banking 加以改造，将抽象方法makeCustomerHappy改为Consumer接口：

public abstract class Banking {public void processCustomer(int id, Consumer<String> makeCustomerHappy) {//查询会员名String customer = getCustomerWithId(id);//招待会员makeCustomerHappy.accept(customer);}private String getCustomerWithId(int id) {return RandomUtil.randomString(5);}}

这样一来，后续的调用即可用一段lambda实现：

public class Main {public static void main(String[] args) {Banking bankingA = new Banking();bankingA.processCustomer(1,customer-> System.out.println("请"+customer+"吃饭，并为其办理业务"));Banking bankingB = new Banking();bankingB.processCustomer(1,customer-> System.out.println("请"+customer+"喝茶，并为其办理业务"));}
}

观察者模式

观察者模式算是最经典也最好理解的设计模式，观察者只需将自己注册到感兴趣的主题上，一旦有主题更新就会及时通知观察者，观察者按照自己的需要进行响应处理。

对此我们首先定义观察者的接口:

/*** 观察者*/
public interface Observer {void inform(String msg);
}

接下来就是主题:

public interface Subject {void registerObserver(Observer observer);void notifyObserver();
}

创建一个观察者1以及观察者2以及实现他们对自己感兴趣主题时会做出的反馈输出方法inform:

public class Observer1 implements Observer {@Overridepublic void inform(String msg) {System.out.println("观察者1收到通知，内容为：" + msg);}
}
public class Observer2 implements Observer {@Overridepublic void inform(String msg) {System.out.println("观察者2收到通知，内容为：" + msg);}
}

最后就是主题类的实现，我们将观察者聚合，如果观察者对SubJect1 感兴趣，则通过registerObserver完成注册，一旦主题要发布新消息就可以通过notifyObserver及时通知每一个订阅者:

public class SubJect1 implements Subject {private String msg;public SubJect1(String msg) {this.msg = msg;}private List<Observer> observerList = new ArrayList<>();@Overridepublic void registerObserver(Observer observer) {observerList.add(observer);}@Overridepublic void notifyObserver() {observerList.forEach(o -> o.inform(msg));}
}

测试代码和对应输出结果如下所示：

public static void main(String[] args) {SubJect1 subJect1 = new SubJect1("请大家学习《基于lambda简化设计模式》");//注册订阅者subJect1.registerObserver(new Observer1());subJect1.registerObserver(new Observer2());//主题发起通知subJect1.notifyObserver();}

输出结果:

观察者1收到通知，内容为：请大家学习《基于lambda简化设计模式》
观察者2收到通知，内容为：请大家学习《基于lambda简化设计模式》

很明显的Observer的inform是典型的Consumer接口，我们直接将其简化：

public static void main(String[] args) {SubJect1 subJect1 = new SubJect1("请大家学习《基于lambda简化设计模式》");//注册订阅者subJect1.registerObserver(s -> System.out.println("观察者1收到消息" + s));subJect1.registerObserver(s -> System.out.println("观察者2收到消息" + s));//主题发起通知subJect1.notifyObserver();}

责任链模式

我们希望字符串被对象1处理完成之后要转交给对象2处理，并且我们后续可能还会交给更多的对象处理，通过对需求的梳理和抽象，这个功能完全可以通过责任链模式来实现。

首先声明公共抽象类，可以看到考虑类的通用性笔者将这个类的入参设置为泛型，并且公共方法handle的步骤为:

  1. 调用自己的handWork处理输入数据，handWork交给实现类自行编写。
  2. 若successor不为空，则将处理结果交给下一个处理器处理，由此构成一条处理链。
public abstract class ProcessingObject<T> {/*** 下一个处理器*/private ProcessingObject<T> successor;public ProcessingObject<T> getSuccessor() {return successor;}public void setSuccessor(ProcessingObject<T> successor) {this.successor = successor;}public T handle(T input) {//先自己处理完，如果有后继责任链，则交给后面的责任链处理，递归下去T t = handWork(input);if (successor != null) {return successor.handWork(t);}return t;}/*** 自己的处理逻辑** @param intput* @return*/abstract T handWork(T intput);
}

对应的我们基于这个抽象类实现两个字符处理器，ProcessingStr1会将收到的中文逗号换位英文逗号：

public class ProcessingStr1 extends ProcessingObject<String> {@OverrideString handWork(String intput) {return intput.replace("，", ",");}
}

而ProcessingStr2 会将中文句号替换为英文句号：

public class ProcessingStr2 extends ProcessingObject<String> {@OverrideString handWork(String intput) {return intput.replace("。", ".");}
}

测试代码和输出结果如下：

public static void main(String[] args) {ProcessingObject<String> p1 = new ProcessingStr1();ProcessingObject<String> p2 = new ProcessingStr2();p1.setSuccessor(p2);System.out.println(p1.handle("hello，world。"));}

可以看到所有的中文符号都被替换成英文符号了:

hello,world.

话不多说，不难看出上文这种传入String返回String的方法，我们完全可以使用UnaryOperator函数式接口实现表达式。

从UnaryOperator源码可知，它继承Function，我们只需传入泛型T即可得到一个Function<T, T>，从而让我们得到一个T->T的Function表达式：

@FunctionalInterface
public interface UnaryOperator<T> extends Function<T, T> {/*** Returns a unary operator that always returns its input argument.** @param <T> the type of the input and output of the operator* @return a unary operator that always returns its input argument*/static <T> UnaryOperator<T> identity() {return t -> t;}
}

而责任连的方式也很简单，因为UnaryOperator是Function的子类，这意味着我们可以使用Function的andThen将所有的UnaryOperator完成衔接：

 UnaryOperator<String> p1 = i -> i.replace("，", ",");UnaryOperator<String> p2 = i -> i.replace("。", ".");p1.andThen(p2);System.out.println(p1.apply("hello，world。"));

小结

为了适配设计模式常会出现为了一段简单的逻辑，而去编写大量实现类的情况，所以我们建议，对于逻辑比较简单且需要适配设计模式的功能，可以尝试找到合适的函数式接口简化功能的实现，避免大量类文件的声明。

参考

Java 8 in Action

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/265548.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

玩转大数据14：分布式计算框架的选择与比较

玩转大数据14：分布式计算框架的选择与比较

1. 引言 随着大数据时代的到来&#xff0c;越来越多的企业和组织需要处理海量数据。分布式计算框架提供了一种有效的方式来解决大数据处理的问题。分布式计算框架将计算任务分解成多个子任务&#xff0c;并在多个节点上并行执行&#xff0c;从而提高计算效率。 2. 分布式计算…
阅读更多...
你的轻量化设计能有效提高模型的推理速度吗？

你的轻量化设计能有效提高模型的推理速度吗？

写在前面&#xff1a;本博客仅作记录学习之用&#xff0c;部分图片来自网络&#xff0c;如需引用请注明出处&#xff0c;同时如有侵犯您的权益&#xff0c;请联系删除&#xff01; 文章目录 前言预备知识模型指标MACs计算卷积MACs全连接MACs激活函数MACsBN MACs 存储访问存储构…
阅读更多...
基于SpringBoot+Vue前后端分离的景点数据分析平台（Java毕业设计）

基于SpringBoot+Vue前后端分离的景点数据分析平台（Java毕业设计）

大家好&#xff0c;我是DeBug&#xff0c;很高兴你能来阅读&#xff01;作为一名热爱编程的程序员&#xff0c;我希望通过这些教学笔记与大家分享我的编程经验和知识。在这里&#xff0c;我将会结合实际项目经验&#xff0c;分享编程技巧、最佳实践以及解决问题的方法。无论你是…
阅读更多...
彻底搞懂Python常用时间库time、datetime与时间格式之间的转换关系

彻底搞懂Python常用时间库time、datetime与时间格式之间的转换关系

Python项目中很多时候会需要将时间在Datetime格式和TimeStamp格式之间转化&#xff0c;本文将对python中多个时间储存方式、时间模块(如time、datetime、timeit)以及他们之间的转换关系进行详细的梳理和总结。整体梳理后表示图如下&#xff1a; 一&#xff0c;python中储存时间…
阅读更多...
Ubuntu下安装SDL

Ubuntu下安装SDL

源码下载地址&#xff08;SDL version 2.0.14&#xff09;&#xff1a;https://www.libsdl.org/release/SDL2-2.0.14.tar.gz 将源码包拷贝到系统里 使用命令解压 tar -zxvf SDL2-2.0.14.tar.gz 解压得到文件夹 SDL2-2.0.14 进入文件夹 执行命令 ./configure 执行命令 make…
阅读更多...
静态SOCKS5：了解基本概念和协议

静态SOCKS5：了解基本概念和协议

SOCKS5是一种网络协议&#xff0c;是SOCKS协议的第五个版本&#xff0c;它提供了一种安全的、加密的网络连接&#xff0c;可以帮助用户在互联网上保护自己的隐私和安全。静态SOCKS5是指使用静态IP地址和端口的SOCKS5代理服务器&#xff0c;这种代理服务器可以提供更稳定、更快速…
阅读更多...
解决vue3 动态引入报错问题

解决vue3 动态引入报错问题

之前这样写的&#xff0c;能使用&#xff0c;但是有警告 警告&#xff0c;查了下&#xff0c;是动态引入的问题&#xff0c;看到说要用glob 然后再我的基础上&#xff0c;稍微 改了下&#xff0c;就可以了&#xff1a; 最后打印了下&#xff0c;modules[../../components/flowc…
阅读更多...
SPI 通信-stm32入门

SPI 通信-stm32入门

本节我们将继续学习下一个通信协议 SPI&#xff0c;SPI 通信和我们刚学完的 I2C 通信差不多。两个协议的设计目的都一样&#xff0c;都是实现主控芯片和各种外挂芯片之间的数据交流&#xff0c;有了数据交流的能力&#xff0c;我们主控芯片就可以挂载并操纵各式各样的外部芯片&…
阅读更多...
如何使用cpolar+Inis在Ubuntu系统快速搭建本地博客网站公网可访问

如何使用cpolar+Inis在Ubuntu系统快速搭建本地博客网站公网可访问

文章目录 前言1. Inis博客网站搭建1.1. Inis博客网站下载和安装1.2 Inis博客网站测试1.3 cpolar的安装和注册 2. 本地网页发布2.1 Cpolar临时数据隧道2.2 Cpolar稳定隧道&#xff08;云端设置&#xff09;2.3.Cpolar稳定隧道&#xff08;本地设置&#xff09; 3. 公网访问测试总…
阅读更多...
【数学建模】《实战数学建模：例题与讲解》第九讲-时间序列分析（含Matlab代码）

【数学建模】《实战数学建模：例题与讲解》第九讲-时间序列分析（含Matlab代码）

【数学建模】《实战数学建模&#xff1a;例题与讲解》第九讲-时间序列分析&#xff08;含Matlab代码&#xff09; 基本概念确定性时间序列分析方法平稳时间序列模型ARIMA模型季节性序列 习题8.11. 题目要求2.解题过程3.程序4.结果 习题8.21. 题目要求2.解题过程3.程序4.结果 习…
阅读更多...
秋招春招，我没有拿到一个offer怎么办？

秋招春招，我没有拿到一个offer怎么办？

无论是秋招&#xff0c;还是春招&#xff0c;对于应届毕业生来说&#xff0c;都是最佳的拿offer的时机&#xff0c;当然错过了也不是绝境&#xff0c;机会无处不在&#xff0c;只是说校招是最好的机会。希望朋友们重视起来&#xff0c;积极的争取到满意的工作岗位。 从竞争的角…
阅读更多...
KUKA机器人坐标点如何赋值？

KUKA机器人坐标点如何赋值？

KUKA机器人坐标点如何赋值？ KUKA机器人系统中如何实现将某个点位整体赋值给另一个点位呢？ 具体的方法可参考以下内容： 如下图所示，选中某个程序，然后点击下方的打开， 如下图所示，进入程序后，这里有P1和P2两个点位，如果要实现让P2的点位和P1的点位完全相同，除了通过示…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023