你沒見過的責任鏈設計模式！【設計模式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上下文。

哎，感覺數學還是要學好，雖然你可以不懂，但是底層都有數學基礎做支撐的。另外設計模式看類圖已經沒那么實用了，因為方法成為第一等公民后，函數編程已經來臨，大部分設計模式可能都會有新的表述。