微信号:kant_prog

介绍:关注Java和Python和云计算技术分享,主要分享一些进阶类的内容希望更多“成长中的程序员”可以从这些内容中学会“思考”.

从函数式的角度重看GOF设计模式(一)

2016-07-08 08:02 fireflyc

这是本系列文章中的第一篇,我们会回顾一些GOF模式,然后尝试用更简洁、更灵活的方式重新实现它们。

在开始分析各种设计模式之前,先讨论一个问题:简单的英语语法练习。看这样的句子:“smoking is unhealthy”和“running is tiring”。注意句子中的“smoking”和“running”,在英语中,ing后缀可以把一个名词转换动词。GOF设计模式尤其是“行为模式”,也是采用相似的做法。和ing后缀实现名词动词转换一样,某些设计模式也是一种转换,只不过涉及到的是函数、对象而已

比较扯淡的是,这种转换往往不是有必要的,仅仅是把一些函数式编程的概念强行转换成面向对象风格。所以这就带来更多的代码,更低的可读性而且维护起来更困难。实际上,这不仅仅是用对象把函数包装起来那么简单,你还必须得把这些松散的对象“粘起来”。相同的结果,如果用函数式编程实现更加简单。

让我们开始看最常见的一个设计模式

Command模式

Command模式是一个从函数式强行变成面向对象的典范(代码量剧增)。我们看一下面向对象怎么实现。首先得有一个“接口”:

interface Command {
  void run(); }

现在,可以提供这个Command接口的不同实现了。比如想输出一条消息——可以这样写:

public class Logger implements Command {
   public final String message;
   public Logger( String message ) {
       this.message = message;    }
   @Override    public void run() {        System.out.println("Logging: " + message);    } }

现在把消息放到文件中

public class FileSaver implements Command {
   public final String message;
   public FileSaver( String message ) {
       this.message = message;    }
   @Override    public void run() {        System.out.println("Saving: " + message);    } }

把消息通过邮件发送出去

public class Mailer implements Command {    
  public final String message;    
  public Mailer( String message ) {      
      this.message = message;   }
  @Override   public void run() {       System.out.println("Sending: " + message);   } }

现在需要创建一些指令对象来执行

public class Executor {    
   public void execute(List<Command> tasks) {
       for (Command task : tasks) {            task.run();        }    } }

最后让我new一些对象,塞到List里面调用Executor,开跑~~~

就像这段“裹脚布”代码一样的,GOF的设计模式就是把函数包装(要执行的动作)成对象(把动作变成一个一个的“指令”)。但是这种扯淡的方式除了为了“Java的面向对象”之外没有任何好处。随着lambda在Java8中被引入,现在终于可以混合使用函数式和面向对象了,我们来尝试把这个例子变的更简洁。

首先需要注意,我们不需要定义Command接口了,有一个Runnable类它的抽象方法和Command要实现的接口签名一样(注:方法签名相同是指方法的返回值类型相同,参数相同)。所以我们只需要实现三个静态函数就可以了。

public static void log(String message) {
    System.out.println("Logging: " + message);
}
public static void save(String message) {    System.out.println("Saving: " + message); }
public static void send(String message) {    System.out.println("Sending: " + message); }

回头看看函数式的实现更加突出代码的业务逻辑而不是做各种“裹脚布”一样的转换。Executor类可以直接用一句代码实现

public static void execute(List<Runnable> tasks ) {
    tasks.forEach( Runnable::run );
}

我们可以在执行之前定义一些要执行的函数

List<Runnable> tasks = new ArrayList<>();
tasks.add(() -> log("Hi"));
tasks.add(() -> save("Cheers"));
tasks.add(() -> send("Bye"));

execute( tasks );

这里没有写参数Java编译器会自动翻译成lambda匿名函数,实际上它就是把“调用静态方法执行某个动作”包装在一个实现了Runnable接口匿名函数(注:其实是方法签名和Runnable的run相同)让后扔个一个List去执行。

Strategy模式

策略模式是一个数据加工过程,我们可以而多个算法,把他们放到一起封装起来,使之可以相互替换。下面的例子中,我需要定义一个处理文本的过程:输入,筛选,最后把结果转换格式化输出。话句话说我需要两个行为:过滤文本,转换格式。第一步定义一个接口:

interface TextFormatter {
  boolean filter(String text);
  String format(String text); }

然后我们实现TextFormatter接口,这个类封装了用户怎么样过滤和格式化文本的业务逻辑

public class TextEditor {
   private final TextFormatter textFormatter;
   public TextEditor(TextFormatter textFormatter) {
       this.textFormatter = textFormatter;    }
   public void publishText(String text) {
       if (textFormatter.filter( text )) {           System.out.println( textFormatter.format( text ) );        }    } }

你可以再来一个实现,接收任何文本,然后原样输出

public class PlainTextFormatter implements TextFormatter {
   @Override    public boolean filter( String text ) {
      return true;    }    
   @Override    public String format( String text ) {        
      return text;    } }

再来一个实现,用来处理日志中的“ERROR”,如果发现”ERROR”就把文本转换成大写。

public class ErrorTextFormatter implements TextFormatter {    @Override
    public boolean filter( String text ) {        
      return text.startsWith( "ERROR" );    }
   @Override    public String format( String text ) {        
      return text.toUpperCase();    } }

最后我们再来一个,它把小于20个字符的文本变成小写。

public class ShortTextFormatter implements TextFormatter { 
    @Override    public boolean filter( String text ) {      
      return text.length() < 20;    }    
   @Override    public String format( String text ) {      
      return text.toLowerCase();    } }

至此,我们可以创建一个TextEditor,然后把TextFormatter塞给它,让它来输出数据了。

TextEditor textEditor = new TextEditor( new ErrorTextFormatter() );
textEditor.publishText( "ERROR - something bad happened" );
textEditor.publishText( "DEBUG - I'm here" );

看起来很不错。“然并卵”,这段代码更加冗长了。真正有意义的代码只有TextEditor的publishText方法。其他两个“行为”都可以通过参数传递给publishText方法。第一个参数一个用于过滤的谓语(注:一个函数,返回true或者false),一个UnaryOperator(一个函数类型,它接收的参数类型和返回值类型相同)用于在往标准输出里面扔之前格式化文本。

public static void publishText( String text, Predicate<String> filter,
                     UnaryOperator<String> format)
{  
   if (filter.test( text )) {        System.out.println( format.apply( text ) );    } }

我们可以实现一个等价于PlainTextFormatter的代码

publishText( "DEBUG - I'm here", s -> true, s -> s );

重新实现ErrorTextFormatter,传一个谓语(注:一个函数,返回true或者false)用于判断文本是否以ERROR开头,在扔一个String的大写转换函数。

publishText( "ERROR - something bad happened", 
                     s -> s.startsWith( "ERROR" ),
                     String::toUpperCase );

可能你说这种更加“紧凑”的的方法没有通过类实现的更具有复用性,每次都要写一个这么长的调用。函数式其实允许我们把这些放到一个类里面,形成一个工具类

public class TextUtil {    
   public boolean acceptAll(String text) {        
       return true;    }    
   public String noFormatting(String text) {        
       return text;    }
   public boolean acceptErrors(String text) {        
       return text.startsWith( "ERROR" );    }  
   public String formatError(String text) {        
       return text.toUpperCase();    } }

通过这种方式来代替而不是lambda匿名函数,我们就可以重用这些函数的定义了

publishText( "DEBUG - I'm here", TextUtil::acceptAll, 
                               TextUtil::noFormatting );

值得注意的是,这些比类的实现方式更加短小的函数(它们可以自由组合而不必考虑“类”),而且更具有复用性。在本系列的下一部分,我们将回顾2个其他GOF中常用的模式——Template和Observer。


欢迎关注公众账号了解更多信息

 
写程序的康德 更多文章 Java并发原理无废话指南(3) 从函数式的角度重看GOF设计模式(二) 从函数式的角度重看GOF设计模式(三) 从函数式的角度重看GOF设计模式(四) 什么才是真正的Actor模型
猜您喜欢 Cocos Creator直播群爆满 老司机紧急开启绿色通道 PHP哈希表碰撞攻击原理 工程师无所不能! WWDC2016汇总:苹果更新了四大OS系统 云端life:一张图读懂2016红包大战到底有多火