Pipeline设计模式案例

1、创建管道模型的三部分

pipeline管道（流水线过程）、valve 阀门（也称为handler，是流水线单个模块的具体处理方法）、Context产品

 Context产品

public class MyContext {//要在生产线上进行处理的产品
    String name;

    public MyContext() {
    }

    public MyContext(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Handler接口

public interface Handler {//流水线上处理产品的功能部件，因为有很多种功能部件，定义一个接口统一规范

    //功能部件实际完成功能的函数
    // 形参是他要操作的产品
    // 布尔型返回值表示该部件是否正常完成功能
    Boolean handle(MyContext context);
}

pipeline管道 

流水线的功能部件是顺序执行的，①号模块处理完产品后交给②号模块加工，所以用一条链表表示每个模块的处理顺序（参照408指令流水线），（？我自己理解的）管道可以控制模块在流水线的哪部分处理产品

public interface Pipeline {//

    /**
     * 启动管道，让流水线上的所有功能部件开始工作
     */
    void start();

    /**
     * 得到最后生产好的context
     */
    MyContext getContext();

    /**
     * 添加hander到队首
     */
    void addHead(Handler... handlers);//用可变参数可以一次性添加多个Handler到链表开头

    /**
     * 添加hander到队尾
     */
    void addTail(Handler... handlers);

}

2、创建handler链表并控制它们的执行顺序

public class HandlerNode {
    private Handler handler;//结点内容
    private HandlerNode next;//结点的next指针

    public void exec(MyContext context){//每个结点要做的工作，执行当前handler方法加工产品，并启动下一个功能部件
        Boolean ret = handler.handle(context);
        if (ret) {//该结点的handler已经成功加工完成context产品
            if (next != null) {//该节点后面还有其它功能部件
                next.exec(context);//把产品交给下一个功能部件
            }
        }
    }

    public Handler getHandler() {
        return handler;
    }

    public void setHandler(Handler handler) {
        this.handler = handler;
    }

    public HandlerNode getNext() {
        return next;
    }

    public void setNext(HandlerNode next) {
        this.next = next;
    }
}

3、实现Pipeline接口

public class OrderPipeline implements Pipeline {

    private HandlerNode head = new HandlerNode();//链表的头结点

    private HandlerNode tail = head;//链表的尾结点，一定要赋值，不让空指针异常，tail=null

    private MyContext context;

    public void start() {//启动所有功能部件（handler）
        // 启动第一个执行的功能部件，里面就会自动执行完整的流水线过程
        head.getNext().exec(context);
    }

    public MyContext getContext() {
        return context;
    }

    public OrderPipeline(MyContext context) {
        this.context = context;
    }

    /**
     * 添加多个新的结点（hander）到链首（带头结点的链表）
     * @param handlers
     */
    public void addHead(Handler... handlers) {
        //后加的新结点靠近头部，是流水线里先执行的部分
        // (handler1, handler2,handler3)
        HandlerNode next = head.getNext();

        for (Handler handler : handlers) {

            HandlerNode handlerNode = new HandlerNode();
            handlerNode.setHandler(handler);


            handlerNode.setNext(next);
            next = handlerNode;

        }
        head.setNext(next);


    }

    /**
     * 添加handler到尾部
     * @param handlers
     */
    public void addTail(Handler... handlers) {

        HandlerNode node = tail;

        for (Handler handler : handlers) {

            HandlerNode handlerNode = new HandlerNode();
            handlerNode.setHandler(handler);

            node.setNext(handlerNode);
            node = handlerNode;
        }

        tail = node;

    }
}

核心是链表结点新增的两个方法、在结点内exec/执行handle()

4、测试效果

先创建三个在流水线上实现不同功能实现类（功能部件）

public class Handler1 implements Handler {

    public Boolean handle(MyContext context) {
        System.out.println("handler1.....handle");
        return true;
    }
}

public class Handler2 implements Handler {

    public Boolean handle(MyContext context) {
        System.out.println("handler2.....handle");
        return true;
    }
}

public class Handler3 implements Handler {

    public Boolean handle(MyContext context) {
        System.out.println("handler3.....handle");
        return true;
    }
}

在main函数启动管道

public class PipelineMain {

    public static void main(String[] args) {
        Handler handler1 = new Handler1();
        Handler handler2 = new Handler2();
        Handler handler3 = new Handler3();

        Pipeline orderPipeline = new OrderPipeline(new MyContext("产品"));

        orderPipeline.addHead(handler1,handler2,handler3);//handler3是流水线第一个执行的功能
        orderPipeline.start();
    }
}

每个handler可以用一个子线程实现