Java 责任链-lambda功能实施

您将如何在Java8中使用Lambda实现责任链模式

---

我只在以下内容中找到了一段：

责任链

可以或不可以委托给另一个lambda的lambda，该lambda可以或不可以无限委托给另一个lambda。 （如何将“下一个”引用引入lambda留给读者作为练习。）

我改编了：

在本例中，我们有不同的角色，每个角色都有一个固定的购买限额和一个继任者。每当角色中的用户收到超过其限制的购买请求时，该请求将传递给其继任者

生成器允许构建处理程序链：

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;
        }
    }
}

链

是一个基本的消费者界面：

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

公共接口链{
空柄（T）；
}

生成器实现：

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;
        }
    }
}

package com.intactile.vega.api；
公共类链生成器{
公共静态链生成器链生成器（）{
返回新的ChainBuilder（）；
}
私人HandlerImpl优先；
私有链生成器（）{
}
公共成功构建者优先（处理者）{
第一个=新的HandlerImpl（处理程序）；
返回新的SuccessorBuilder（第一个）；
}
公共类SuccessorBuilder{
私有handleImpl电流；
私有SuccessorBuilder（HandlerImpl当前版本）{
这个电流=电流；
}
公共成功构建者继任者（处理者继任者）{
HandlerImpl successorWrapper=新的HandlerImpl（继任者）；
当前.setSuccessor（successorWrapper）；
当前=成功包装器；
归还这个；
}
公共链构建（）{
返回新的ChainImpl（第一个）；
}
}
私有静态类ChainImpl实现了Chain{
私人最终处理者优先；
public ChainImpl（处理程序优先）{
this.first=first；
}
@凌驾
公共无效句柄（T）{
第一，处理（t）；
}
}
私有静态类HandlerImpl实现处理程序{
私人最终处理人代表；
私人经办人继承人；
公共HandlerImpl（处理程序委托）{
this.delegate=委托；
}
私有无效设置接班人（HandlerImpl接班人）{
这个后继者=后继者；
}
@凌驾
公共布尔句柄（T）{
if（委托句柄（t））{
返回true；
}
else if（继任者！=null）{
返回后继句柄（t）；
}
返回false；
}
}
}

问题在于，在将问题发布到此处之前，您似乎没有做过任何研究或努力。您不能要求他人为您编写或共享代码。请参阅模式的当前Java实现，了解Lambda表达式。尝试使用Lamda实现您自己的代码，然后您可以询问人们为什么您的代码不起作用，或者是否可以改进。祝你好运我花了至少30分钟在谷歌上搜索责任链兰博达。我最好的办法就是我真的不明白。这是GOF模式之一。网上有很多关于指挥和Lamda、战略和Lamda、装饰和Lamda的资源。我还没有看到任何关于科夫和拉姆达的事情。我还是不明白这个问题出了什么问题。但是好的，很好。错误的问题。您可能会查看

消费者。然后（）

以了解如何接近它

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;
        }
    }
}