行为型模式-责任链模式

Posted 2022-08-09 vbirdbest

一：定义

又名职责链模式，为了避免请求发送者与多个请求处理者耦合在一起，将所有的请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

案例

请假流程：请假1天只需要小组长同意即可，请假1-3天还需要部门经理审批，请假3-7天还需要总经理审批才行。

/**
 * 请假条
 */
@Data
@AllArgsConstructor
public class LeaveRequest 
    /** 姓名 */
    private String name;
    /** 请假天数 */
    private int num;
    /** 请假内容 */
    private String content;

/**
 * 抽象处理者
 */
@Data
public abstract class Handler 
    public final static int NUM_ONE = 1;
    public final static int NUM_THREE = 3;
    public final static int NUM_SEVEN = 7;


    // 请假天数区间
    private int numStart;
    private int numEnd;

    // 后继者（上级领导）
    private Handler nextHandler;


    public Handler(int numStart) 
        this.numStart = numStart;
    

    public Handler(int numStart, int numEnd) 
        this.numStart = numStart;
        this.numEnd = numEnd;
    

    // 各领导处理请求条的方法
    protected abstract void handleLeave(LeaveRequest request);

    // 提交请求条
    public final void submit(LeaveRequest request) 
        // 当前领导进行审批
        this.handleLeave(request);

        // 超过当前领导所允许请假的最大天数
        if (nextHandler != null && request.getNum() > this.getNumEnd()) 
            nextHandler.submit(request);
         else 
            System.out.println("流程审批结束！");
        
    

---

/**
 * 小组长（具体的处理者）
 */
public class GroupLeader extends Handler
    public GroupLeader() 
        super(0, Handler.NUM_ONE);
    

    @Override
    protected void handleLeave(LeaveRequest request) 
        System.out.println(request.getName() + "请假" + request.getNum() + "天，" + request.getContent());
        System.out.println("小组长审批：同意");
    

/*
 * 部门经理（具体的处理者）
 */
public class Manager extends Handler
    public Manager() 
        super(Handler.NUM_ONE, Handler.NUM_THREE);
    

    @Override
    protected void handleLeave(LeaveRequest request) 
        System.out.println(request.getName() + "请假" + request.getNum() + "天，" + request.getContent());
        System.out.println("部门经理审批：同意");
    

/**
 * 总经理（具体的处理者）
 */
public class GeneralManager extends Handler
    public GeneralManager() 
        super(Handler.NUM_THREE, Handler.NUM_SEVEN);
    

    @Override
    protected void handleLeave(LeaveRequest request) 
        System.out.println(request.getName() + "请假" + request.getNum() + "天，" + request.getContent());
        System.out.println("总经理审批：同意");
    

public class Client 
    public static void main(String[] args) 
        LeaveRequest request = new LeaveRequest("小明", 1, "结婚");

        // 领导们
        GroupLeader groupLeader = new GroupLeader();
        Manager manager = new Manager();
        GeneralManager generalManager = new GeneralManager();

        groupLeader.setNextHandler(manager);
        manager.setNextHandler(generalManager);

        // 将请求提交给小组长
        groupLeader.submit(request);
    

优缺点

优点：

• 降低了对象之间的耦合度：该模式降低了请求发送者和接收者的耦合度。
• 增强了系统的可扩展性：可以根据需要增加新的请求处理类，满足开闭原则。
• 增强了给对象指派职责链的灵活性：当工作流程发生变化，可以动态的改变链内的成员或者修改它们的次序，也可以动态的新增或者删除责任。
• 责任链简化了对象之间的连接：一个对象只需要保持一个执行其后继者的引用，不需要保持其它所有处理者的引用，这避免了使用众多的if 或者 if else 语句。
• 责任分摊：每个类只需处理自己该处理的工作，不能处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

缺点：

• 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都没得到处理。
• 对比较长的责任链，请求的处理可能设计多个处理对象，系统性能将收到一定影响。
• 责任链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能造成循环调用。

JavaWeb示例

public interface Request 


public interface Response 

public class FilterChain 
    private List<Filter> filters = new ArrayList<>();
    private int index = 0;

    public FilterChain addFilter(Filter filter) 
        this.filters.add(filter);
        return this;
    

    public void doFilter(Request request, Response response) 
        if (index == filters.size()) 
            return;
        

        Filter filter = filters.get(index);
        index++;
        filter.doFilter(request, response, this);
    

public class FirstFilter implements Filter 
    @Override
    public void doFilter(Request request, Response response, FilterChain filterChain) 
        System.out.println("FirstFilter begin");
        filterChain.doFilter(request, response);
        System.out.println("FirstFilter end");
    



public class SecondFilter implements Filter 
    @Override
    public void doFilter(Request request, Response response, FilterChain filterChain) 
        System.out.println("SecondFilter begin");
        filterChain.doFilter(request, response);
        System.out.println("SecondFilter end");
    

public class Client 
    public static void main(String[] args) 
        Request request = null;
        Response response = null;

        FilterChain filterChain = new FilterChain();
        filterChain.addFilter(new FirstFilter())
                .addFilter(new SecondFilter());
        filterChain.doFilter(request, response);