責任の鎖lambda

Question

私は、Java 8でLambdaを使って連鎖責任パターンを実装することが可能であると思っていましたか？どのように見えるでしょうか？ 、責任

かまたは別のラムダに委任しない場合があり、別のラムダに委任しない場合がありラムダの

チェーン：

---

は私だけthis articleで段落を見つけました広告無限。 （ラムダに「次へ」参照は読者の演習として残して取得する方法。）

Answer 1

私はjava example from the wikipedia articleを適応している：

この例では、我々は異なる役割を持って、各固定購買限度と後継者を持つ。役割のユーザーが制限を超える購入要求を受け取るたびに、その要求はその後継者に渡されます。

ビルダーは、ハンドラのチェーンを構築することができます：

public class Main { 
    public static void main(String[] args) { 
     final double base = 500; 
     ChainBuilder<PurchaseRequest> chainBuilder = ChainBuilder.chainBuilder(); 
     Chain<PurchaseRequest> chain = chainBuilder 
       .first(request -> { 
        if (request.getAmount() < base * 10) { 
         System.out.println("Manager will approve $" + request.getAmount()); 
         return true; 
        } 
        return false; 
       }) 
       .successor(request -> { 
        if (request.getAmount() < base * 20) { 
         System.out.println("Director will approve $" + request.getAmount()); 
         return true; 
        } 
        return false; 
       }) 
       .successor(request -> { 
        if (request.getAmount() < base * 50) { 
         System.out.println("President will approve $" + request.getAmount()); 
        } else { 
         System.out.println("Your request for $" + request.getAmount() + " needs a board meeting!"); 
        } 
        return true; 
       }).build(); 

     chain.handle(new PurchaseRequest(1000)); // manager 
     chain.handle(new PurchaseRequest(9000)); // director 
     chain.handle(new PurchaseRequest(23000)); // president 
     chain.handle(new PurchaseRequest(100000)); // board 
    } 

    private static class PurchaseRequest { 
     private final double amount; 

     private PurchaseRequest(double amount) { 
      this.amount = amount; 
     } 

     public double getAmount() { 
      return amount; 
     } 
    } 
} 

---

ラムダは、機能的なインターフェイスHandlerを実装しています。 trueは、要求が処理された場合、要求は、後継者によって処理されるべきかfalse、戻りある：

public interface Chain<T> { 
    void handle(T t); 
} 

ビルダー実装：

public interface Handler<T> { 
    boolean handle(T t); 
} 

Chainは、基本的な消費者のようなインターフェイスである

package com.intactile.vega.api; 

public class ChainBuilder<T> { 
    public static <T> ChainBuilder<T> chainBuilder() { 
     return new ChainBuilder<>(); 
    } 

    private HandlerImpl<T> first; 

    private ChainBuilder() { 
    } 

    public SuccessorBuilder first(Handler<T> handler) { 
     first = new HandlerImpl<>(handler); 
     return new SuccessorBuilder(first); 
    } 

    public class SuccessorBuilder { 
     private HandlerImpl<T> current; 

     private SuccessorBuilder(HandlerImpl<T> current) { 
      this.current = current; 
     } 

     public SuccessorBuilder successor(Handler<T> successor) { 
      HandlerImpl<T> successorWrapper = new HandlerImpl<>(successor); 
      current.setSuccessor(successorWrapper); 
      current = successorWrapper; 
      return this; 
     } 

     public Chain<T> build() { 
      return new ChainImpl<T>(first); 
     } 
    } 

    private static class ChainImpl<T> implements Chain<T> { 
     private final Handler<T> first; 

     public ChainImpl(Handler<T> first) { 
      this.first = first; 
     } 

     @Override 
     public void handle(T t) { 
      first.handle(t); 
     } 
    } 

    private static class HandlerImpl<T> implements Handler<T> { 
     private final Handler<T> delegate; 
     private Handler<T> successor; 

     public HandlerImpl(Handler<T> delegate) { 
      this.delegate = delegate; 
     } 

     private void setSuccessor(HandlerImpl<T> successor) { 
      this.successor = successor; 
     } 

     @Override 
     public boolean handle(T t) { 
      if (delegate.handle(t)) { 
       return true; 
      } 
      else if (successor != null) { 
       return successor.handle(t); 
      } 
      return false; 
     } 
    } 
}