你没见过的责任链设计模式！【设计模式2】

【New责任链&装饰者】

感慨一下，本以为上下篇能一起发呢，结果要隔一定时间，传统的责任链与装饰者模式：https://www.cnblogs.com/SharePointApp/p/10340578.html

基本代码

现在要做的就是责任链如果使用外置模式，能不能像装饰者一样几个处理类联合处理？答案是可以的，不过就用到java8的特性，具体代码如下

//简化的上下文
public class Context {
    String handlerResult;
}

//处理接口
public interface IHandler {
    void handler(Context context);
}

//默认Null接口实现
public class NullHandler implements IHandler {
    @Override
    public void handler(Context context) {

    }
}

//接口的链式结构
public interface IMiddleware {
    IHandler handle(IHandler handler);
}

//构建链式结构
public class MiddlewareCenter {
    private ArrayList<IMiddleware> middlewares = new ArrayList<>();

    public void userMiddleware(IMiddleware middleware) {
        middlewares.add(middleware);
    }

    public void use(IHandler handler) {
        this.userMiddleware(currenthandler -> {
            return context -> {
                handler.handler(context);
                currenthandler.handler(context);
            };
        });
    }

    public void run(IHandler handler) {
        this.userMiddleware(currenthandler -> {
            return context -> {
                handler.handler(context);
            };
        });
    }

    public IHandler build() {
        IHandler handler = new NullHandler();
        Collections.reverse(middlewares);
        for (IMiddleware middlerware : middlewares) {
            handler=middlerware.handle(handler);
        }
        return handler;
    }
}

下面贴的是测试代码，略显冗长

public class Executor {
    public static void main(String[] args){
        Context context=new Context();
        context.handlerResult="";
        MiddlewareCenter center=new MiddlewareCenter();
        center.use(Executor::addString);
        center.use(Executor::addString2);
        center.use(Executor::modifyString);
        center.build().handler(context);
        System.out.println(context.handlerResult);

        Context context1=new Context();
        context1.handlerResult="";
        MiddlewareCenter center1=new MiddlewareCenter();
        center1.use(Executor::addString);
        center1.use(Executor::modifyString);
        center1.use(Executor::addString2);
        center1.build().handler(context1);
        System.out.println(context1.handlerResult);

        Context context2=new Context();
        context2.handlerResult="";
        MiddlewareCenter center2=new MiddlewareCenter();
        center2.use(Executor::addString);
        center2.run(Executor::modifyString);
        center2.use(Executor::addString2);
        center2.build().handler(context2);
        System.out.println(context2.handlerResult);
    }

    private static void addString(Context context){
        context.handlerResult=context.handlerResult+"addString;";
    }

    private static void addString2(Context context){
        context.handlerResult=context.handlerResult+"addString2;";
    }

    private static void modifyString(Context context){
        context.handlerResult=context.handlerResult.replace("addString","addString->modifyString");
    }
}

执行结果如下：

代码解析

先说说好处：

• 在Java8中，lamada表达式以及方法已经是一类公民，可以减少很多不必要的子类扩展。所以在组装的时候IHandler对象的时候，没有必要构建很多IHandler对象（传统的责任链、装饰者模式也可以，利用lamada表达式）。
• 在MiddleWareCenter中，可以直接将IHandler对象组装在一起，和责任链模式外置类似，但是也可以用IMiddleWare对象，使用内置的方式将IHandler组装起来。使代码有很大的灵活性。
• 总的说来就是使用的时候既简单，又强大，还有代码看起来更时髦。

缺点呢？

• 相比于责任链内置、责任链外置、装饰者模式，没有什么缺点，不过代码略有一点难以理解

 核心代码解析

public IHandler build() {
        IHandler handler = new NullHandler();
        Collections.reverse(middlewares);
        for (IMiddleware middlerware : middlewares) {
            handler=middlerware.handle(handler);
        }
        return handler;
    }

这句代码可能是最难以理解的，我们知道middlewares的类型是IArrayList<IMiddleWare>,所以这段代码就是翻转集合，之后遍历组装。怎么遍历组装的，就得用数学知识进行简单的讲解了

我们知道IMiddleWare的handler方法是一个IHandler到IHandler的函数（略思考，这没难度），我们将IHandler用自变量X代替，所以IArrayList<IMiddleWare>就是函数F（X）的集合（假设里面的函数是A(X)、B(X)、C(X)）。

翻转集合之后，遍历组装的结果是C(B(A(X)))，这是一个复合函数，但是本质上还是一个F(X)，即IHandler到IHandler的函数。而IHandler到IHandler的函数，我们给X的值就是NullHandler，所以带入复合函数C(B(A(X)))后得到C(B(A(NullHandler)))。这个结果是一个IHandler对象，他可以用于处理Context上下文。

哎，感觉数学还是要学好，虽然你可以不懂，但是底层都有数学基础做支撑的。另外设计模式看类图已经没那么实用了，因为方法成为第一等公民后，函数编程已经来临，大部分设计模式可能都会有新的表述。