Lambda 重构面向对象的设计模式

Lambda 重构面向对象的设计模式

策略模式

策略模式包含三部分内容
一个代表某个算法的接口（它是策略模式的接口）。
一个或多个该接口的具体实现，它们代表了算法的多种实现（比如，实体类ConcreteStrategyA或者ConcreteStrategyB）。
一个或多个使用策略对象的客户

public interface ValidationStrategy { boolean execute(String s); 
}public class IsAllLowerCase implements ValidationStrategy { public boolean execute(String s){ return s.matches("[a-z]+"); } 
} 
public class IsNumeric implements ValidationStrategy { public boolean execute(String s){ return s.matches("\\d+"); } 
}public class Validator{ private final ValidationStrategy strategy; public Validator(ValidationStrategy v){ this.strategy = v;  } public boolean validate(String s){ return strategy.execute(s); } 
} 
Validator numericValidator = new Validator(new IsNumeric()); 
boolean b1 = numericValidator.validate("aaaa"); 
Validator lowerCaseValidator = new Validator(new IsAllLowerCase ()); 
boolean b2 = lowerCaseValidator.validate("bbbb"); 

Validator numericValidator =  new Validator((String s) -> s.matches("[a-z]+")); 
boolean b1 = numericValidator.validate("aaaa"); 
Validator lowerCaseValidator = new Validator((String s) -> s.matches("\\d+")); 
boolean b2 = lowerCaseValidator.validate("bbbb");

Lambda表达式避免了采用策略设计模式时僵化的模板代码。如果你仔细分 析一下个中缘由，可能会发现，Lambda表达式实际已经对部分代码（或策略）进行了封装，而 这就是创建策略设计模式的初衷。因此，我们强烈建议对类似的问题，你应该尽量使用Lambda 表达式来解决

模板方法

让我们从一个例子着手，看看这个模式是如何工作的。假设你需要编写一个简单的在线银行 应用。通常，用户需要输入一个用户账户，之后应用才能从银行的数据库中得到用户的详细信息， 最终完成一些让用户满意的操作。不同分行的在线银行应用让客户满意的方式可能还略有不同， 比如给客户的账户发放红利，或者仅仅是少发送一些推广文件。你可能通过下面的抽象类方式来 实现在线银行应用

abstract class OnlineBanking { public void processCustomer(int id){ Customer c = Database.getCustomerWithId(id); makeCustomerHappy(c); }abstract void makeCustomerHappy(Customer c); 
} 

使用Lambda表达式

public void processCustomer(int id, Consumer<Customer> makeCustomerHappy){ Customer c = Database.getCustomerWithId(id); makeCustomerHappy.accept(c); 
} new OnlineBankingLambda().processCustomer(1337, (Customer c) -> System.out.println("Hello " + c.getName()); 

观察者模式

interface Observer { void notify(String tweet); 
}class NYTimes implements Observer{ public void notify(String tweet) { if(tweet != null && tweet.contains("money")){ System.out.println("Breaking news in NY! " + tweet); } } 
} 
class Guardian implements Observer{ public void notify(String tweet) { if(tweet != null && tweet.contains("queen")){ System.out.println("Yet another news in London... " + tweet); } } 
} 
class LeMonde implements Observer{ public void notify(String tweet) { if(tweet != null && tweet.contains("wine")){ System.out.println("Today cheese, wine and news! " + tweet); } } 
} interface Subject{ void registerObserver(Observer o); void notifyObservers(String tweet); 
} class Feed implements Subject{ private final List<Observer> observers = new ArrayList<>(); public void registerObserver(Observer o) { this.observers.add(o); } public void notifyObservers(String tweet) { observers.forEach(o -> o.notify(tweet)); } 
}Feed f = new Feed(); 
f.registerObserver(new NYTimes()); 
f.registerObserver(new Guardian()); 
f.registerObserver(new LeMonde()); 
f.notifyObservers("The queen said her favourite book is Java 8 in Action!"); 

使用Lambda表达式

f.registerObserver((String tweet) -> { if(tweet != null && tweet.contains("money")){ System.out.println("Breaking news in NY! " + tweet); } 
}); 
f.registerObserver((String tweet) -> { if(tweet != null && tweet.contains("queen")){ System.out.println("Yet another news in London... " + tweet); } 
}); 

那么，是否我们随时随地都可以使用Lambda表达式呢？答案是否定的！我们前文介绍的例 子中，Lambda适配得很好，那是因为需要执行的动作都很简单，因此才能很方便地消除僵化代 码。但是，观察者的逻辑有可能十分复杂，它们可能还持有状态，抑或定义了多个方法，诸如此 类。在这些情形下，你还是应该继续使用类的方式

责任链模式

通常，这种模式是通过定义一个代表处理对象的抽象类来实现的，在抽象类中会定义一个字 段来记录后续对象。一旦对象完成它的工作，处理对象就会将它的工作转交给它的后继。代码中， 这段逻辑看起来是下面这样

public abstract class ProcessingObject<T> { protected ProcessingObject<T> successor; public void setSuccessor(ProcessingObject<T> successor){ this.successor = successor;} public T handle(T input){ T r = handleWork(input); if(successor != null){ return successor.handle(r); } return r; } abstract protected T handleWork(T input); 
} public class HeaderTextProcessing extends ProcessingObject<String> { public String handleWork(String text){ return "From Raoul, Mario and Alan: " + text; } 
} 
public class SpellCheckerProcessing extends ProcessingObject<String> { public String handleWork(String text){ return text.replaceAll("labda", "lambda"); } 
} ProcessingObject<String> p1 = new HeaderTextProcessing(); 
ProcessingObject<String> p2 = new SpellCheckerProcessing(); 
p1.setSuccessor(p2);
String result = p1.handle("Aren't labdas really sexy?!!"); 
System.out.println(result); 

使用Lambda表达式

UnaryOperator<String> headerProcessing =  (String text) -> "From Raoul, Mario and Alan: " + text;
UnaryOperator<String> spellCheckerProcessing =  (String text) -> text.replaceAll("labda", "lambda"); 
Function<String, String> pipeline =  headerProcessing.andThen(spellCheckerProcessing); 
String result = pipeline.apply("Aren't labdas really sexy?!!")

工厂模式

public class ProductFactory { public static Product createProduct(String name){ switch(name){ case "loan": return new Loan(); case "stock": return new Stock(); case "bond": return new Bond(); default: throw new RuntimeException("No such product " + name); } } 
} 
Product p = ProductFactory.createProduct("loan"); 

使用Lambda表达式

final static Map<String, Supplier<Product>> map = new HashMap<>(); 
static { map.put("loan", Loan::new); map.put("stock", Stock::new); map.put("bond", Bond::new); 
} public static Product createProduct(String name){ Supplier<Product> p = map.get(name); if(p != null) return p.get(); throw new IllegalArgumentException("No such product " + name); 
}