责任链模式

责任链模式解析

最新推荐文章于 2025-09-07 20:32:33 发布

转载最新推荐文章于 2025-09-07 20:32:33 发布 · 61 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/u/3701483/blog/1588022

文章标签：

#java #python

2019独角兽企业重金招聘Python工程师标准>>>

1.定义

在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

2.问题和解决方案

击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客依次坐定位置，由一人击鼓，击鼓的地方与传花的地方是分开的，以示公正。开始击鼓时，花束就开始依次传递，鼓声一落，如果花束在某人手中，则该人就得饮酒。

　　比如说，贾母、贾赦、贾政、贾宝玉和贾环是五个参加击鼓传花游戏的传花者，他们组成一个环链。击鼓者将花传给贾母，开始传花游戏。花由贾母传给贾赦，由贾赦传给贾政，由贾政传给贾宝玉，又贾宝玉传给贾环，由贾环传回给贾母，如此往复，如下图所示。当鼓声停止时，手中有花的人就得执行酒令。

　击鼓传花便是责任链模式的应用。责任链可能是一条直线、一个环链或者一个树结构的一部分。

3.结构

577

一个典型的对象结构可能如下图所示

、

抽象处理者角色(Handler:Approver):定义一个处理请求的接口，和一个后继连接(可选)。如果需要，接口可以定义出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。

具体处理者角色(ConcreteHandler:President):处理它所负责的请求，可以访问后继者，如果可以处理请求则处理，否则将该请求转给他的后继者。

客户类(Client):向一个链上的具体处理者ConcreteHandler对象提交请求

抽象处理者角色

public abstract class Handler {  
  
    /** 
     * 下一级责任链 
     */  
    protected Handler successor;  
  
    /** 
     * 示意处理请求的方法，虽然这个示意方法是没有传入参数的 但实际是可以传入参数的，根据具体需要来选择是否传递参数 
     */  
    public abstract void handleRequest();  
  
    /** 
     * 取值方法 
     */  
    public Handler getSuccessor() {  
        return successor;  
    }  
  
    /** 
     * 赋值方法，设置下一级责任链
     */  
    public void setSuccessor(Handler successor) {  
        this.successor = successor;  
    }  
  
}

具体处理者角色

public class ConcreteHandler extends Handler {  
    /** 
     * 处理方法，调用此方法处理请求 
     */  
    @Override  
    public void handleRequest() {  
        /** 
         * 判断是否有后继的责任对象 如果有，就转发请求给后继的责任对象 如果没有，则处理请求 
         */  
        if (getSuccessor() != null) {  
            System.out.println("放过请求");  
            getSuccessor().handleRequest();  
        } else {  
            System.out.println("处理请求");  
        }  
    }  
  
}

客户端类

public class Client {  
  
    public static void main(String[] args) {  
        // 组装责任链  
        Handler handler1 = new ConcreteHandler();  
        Handler handler2 = new ConcreteHandler();  
        handler1.setSuccessor(handler2);  
        // 提交请求  
        handler1.handleRequest();  
    } 
}

可以看出，客户端创建了两个处理者对象，并指定第一个处理者对象的下家是第二个处理者对象，而第二个处理者对象没有下家。然后客户端将请求传递给第一个处理者对象。

　　由于本示例的传递逻辑非常简单：只要有下家，就传给下家处理；如果没有下家，就自行处理。因此，第一个处理者对象接到请求后，会将请求传递给第二个处理者对象。由于第二个处理者对象没有下家，于是自行处理请求。

4.应用场景

过滤器接口

public abstract class Filter {
    //request 和response在真正的servlet中是对象，此处简化处理为string
    public abstract void doFilter(String request,String response,FilterChain filterChain);
}

过滤器-处理字符集

public class EncodeFilter extends Filter {

    @Override
    public void doFilter(String request, String response, FilterChain filterChain) {
        System.out.println("对request做utf-8编码");
        filterChain.doFilter(request, response);
        System.out.println("对response做utf-8编码");
    }

}

过滤器-处理xss攻击

public class XssFilter extends Filter {

    @Override
    public void doFilter(String request, String response, FilterChain filterChain) {
        System.out.println("过滤request的xss内容");
        filterChain.doFilter(request, response);
        System.out.println("过滤response的xss内容");
    }

}

servlet接口，仅实现service接口

public interface Servlet {
    public void service(String request,String response);
}

定义一个servlet实现

public class MainServlet implements Servlet {

    @Override
    public void service(String request, String response) {
        System.out.println(request);
                //为response赋值
        response="返回结果";
        System.out.println(response);
    }
}

定义内部处理的filter链，链中保存真正filter的执行顺序，和servlet

public class FilterChain {
    private int cursor;
    public List<Filter> filters=new ArrayList<Filter>();
    public Servlet servlet;
    public void setServlet(Servlet servlet){
        this.servlet=servlet;
    }
    public void addFilter(Filter filter){
        this.filters.add(filter);
    }
    
    
    public void doFilter(String request,String response){
        if(cursor<filters.size()){
            filters.get(cursor++).doFilter(request, response,this);
        }else {
            servlet.service(request, response);
        }
    }
}

客户端代码

public class Client {
    public static void main(String[] args) {
        //定义filter
        Filter encodeFilter=new EncodeFilter();
        Filter xssFilter=new XssFilter();
        FilterChain chain=new FilterChain();
        chain.addFilter(encodeFilter);
        chain.addFilter(xssFilter);
        
        //定义servlet
        Servlet servlet=new MainServlet();
        chain.setServlet(servlet);
        chain.doFilter("发送请求", "");
    }
}

处理结果

对request做utf-8编码
过滤request的xss内容
发送请求
返回结果
过滤response的xss内容
对response做utf-8编码

5.优缺点

优点

降低耦合度：该模式使得一个对象无需知道是其他哪一个对象处理其请求。对象仅需知道该请求会被“正确”地处理。接收者和发送者都没有对方的明确的信息，且链中的对象不需知道链的结构。

职责链可简化对象的相互连接 : 结果是，职责链可简化对象的相互连接。它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接受者的引用。

增强了给对象指派职责( R e s p o n s i b i l i t y )的灵活性：当在对象中分派职责时，职责链给你更多的灵活性。你可以通过在运行时刻对该链进行动态的增加或修改来增加或改变处理一个请求的那些职责。你可以将这种机制与静态的特例化处理对象的继承机制结合起来使用。

增加新的请求处理类很方便

缺点

不能保证请求一定被接收。既然一个请求没有明确的接收者，那么就不能保证它一定会被处理 —该请求可能一直到链的末端都得不到处理。一个请求也可能因该链没有被正确配置而得不到处理。

系统性能将受到一定影响，而且在进行代码调试时不太方便；可能会造成循环调用。

6.总结

在职责链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织链和分配责任。

职责链模式的主要优点在于可以降低系统的耦合度，简化对象的相互连接，同时增强给对象指派职责的灵活性，增加新的请求处理类也很方便；其主要缺点在于不能保证请求一定被接收，且对于比较长的职责链，请求的处理可能涉及到多个处理对象，系统性能将受到一定影响，而且在进行代码调试时不太方便。

参考：

http://blog.youkuaiyun.com/m13666368773/article/details/7702368

http://blog.youkuaiyun.com/hguisu/article/details/7547231

转载于:https://my.oschina.net/u/3701483/blog/1588022