责任链模式

用处：一个请求可以被多个对象接受，并按照接受的顺序被处理。

这里被处理一般有两种实现方式：

1、被某个处理器处理了，直接返回，之后的处理器不再处理

2、每个处理器都会处理

具体实现：（以一个例子为例）

问题：给定一个请求，如果该请求的价值大于1000，则Manager处理不了；如果大于10000，则Director处理不了；否则CEO处理。

package chainofresponsibilty.example;

public class Request {
    private String name;
    private double amount;

    public Request(String name, double amount) {
        this.name = name;
        this.amount = amount;
    }

    public String getName() {
        return name;
    }

    public double getAmount() {
        return amount;
    }
}

/**
 * v1：用链表实现的（抽象类）
 * v2：用列表实现的（接口）
 */

1、用链表实现接收对象之间的关系

因为用的是链表，所以抽象的处理器是个抽象类，抽象类中要有下一个元素。

代码：

public abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public final void handle(Request request) {
        boolean isHandled = doHandle(request);
        if (!isHandled && successor != null) {
            successor.handle(request);
        }
    }

    public abstract boolean doHandle(Request request);
}

package chainofresponsibilty.example.v1;

import chainofresponsibilty.example.Request;

public class ManagerHandler extends Handler {
    @Override
    public boolean doHandle(Request request) {
        if (request.getAmount() > 1000) {
            System.out.println("Manager权限不够");
            return false;
        }
        return true;
    }
}

package chainofresponsibilty.example.v1;

import chainofresponsibilty.example.Request;

public class DirectorHandler extends Handler {
    @Override
    public boolean doHandle(Request request) {
        if (request.getAmount() > 10000) {
            System.out.println("Director权限不够");
            return false;
        }
        return true;
    }
}

package chainofresponsibilty.example.v1;

import chainofresponsibilty.example.Request;

public class CEOHandler extends Handler {
    @Override
    public boolean doHandle(Request request) {
        System.out.println("最终被CEO执行");
        return true;
    }
}

package chainofresponsibilty.example.v1;

import chainofresponsibilty.example.Request;

public class HandlerChain {
    private Handler head;
    private Handler tail;

    public void addHandler(Handler handler) {
        handler.setSuccessor(null);

        if (head == null) {
            head = handler;
            tail = handler;
            return;
        }

        tail.setSuccessor(handler);
        tail = handler;
    }

    public void handle(Request request) {
        head.handle(request);
    }
}

package chainofresponsibilty.example.v1;

import chainofresponsibilty.example.Request;

public class Application {
    public static void main(String[] args) {
        Request request = new Request("cao", 15000);
        HandlerChain chain = new HandlerChain();
        chain.addHandler(new ManagerHandler());
        chain.addHandler(new DirectorHandler());
        chain.addHandler(new CEOHandler());
        chain.handle(request);
    }
}

2、用列表实现接收对象之间的关系

因为用的是链表，所以抽象的处理器是个接口，每个实现类只要实现该功能即可。

代码：

package chainofresponsibilty.example.v2;

import chainofresponsibilty.example.Request;

public interface Handler {
    boolean isHandler(Request request);
}

package chainofresponsibilty.example.v2;

import chainofresponsibilty.example.Request;

public class ManagerHandler implements Handler {
    @Override
    public boolean isHandler(Request request) {
        if (request.getAmount() > 1000) {
            System.out.println("Manager处理不了");
            return false;
        }
        return true;
    }
}

package chainofresponsibilty.example.v2;

import chainofresponsibilty.example.Request;

public class DirectorHandler implements Handler {
    @Override
    public boolean isHandler(Request request) {
        if (request.getAmount() > 10000) {
            System.out.println("Director处理不了");
            return false;
        }
        return true;
    }
}

package chainofresponsibilty.example.v2;

import chainofresponsibilty.example.Request;

public class CEOHandler implements Handler {
    @Override
    public boolean isHandler(Request request) {
        System.out.println("CEO处理了");
        return true;
    }
}

package chainofresponsibilty.example.v2;

import chainofresponsibilty.example.Request;

import java.util.ArrayList;
import java.util.List;

public class HandlerChain {
    private List<Handler> list;

    public HandlerChain() {
        this.list = new ArrayList<>();
    }

    public void addHandler(Handler handler) {
        list.add(handler);
    }

    public void handle(Request request) {
        for (Handler handler : list) {
            boolean isHandle = handler.isHandler(request);
            if (isHandle) {
                break;
            }
        }
    }
}

package chainofresponsibilty.example.v2;

import chainofresponsibilty.example.Request;

public class Application {
    public static void main(String[] args) {
        Request request = new Request("cao", 16000);
        HandlerChain chain = new HandlerChain();
        chain.addHandler(new ManagerHandler());
        chain.addHandler(new DirectorHandler());
        chain.addHandler(new CEOHandler());
        chain.handle(request);
    }
}