首页 / 设计模式 / java-设计模式-责任链

java-设计模式-责任链

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java-设计模式-责任链，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含8980字，纯文字阅读大概需要13分钟。

内容图文

纯的与不纯的责任链模式

　　一个纯的责任链模式要求一个具体的处理者对象只能在两个行为中选择一个：一是承担责任，而是把责任推给下家。不允许出现某一个具体处理者对象在承担了一部分责任后又 把责任向下传的情况。

　　在一个纯的责任链模式里面，一个请求必须被某一个处理者对象所接收；在一个不纯的责任链模式里面，一个请求可以最终不被任何接收端对象所接收。

　　纯的责任链模式的实际例子很难找到，一般看到的例子均是不纯的责任链模式的实现。有些人认为不纯的责任链根本不是责任链模式，这也许是有道理的。但是在实际的系统里，纯的责任链很难找到。如果坚持责任链不纯便不是责任链模式，那么责任链模式便不会有太大意义了。

责任链模式在Tomcat中的应用

　　众所周知Tomcat中的Filter就是使用了责任链模式，创建一个Filter除了要在web.xml文件中做相应配置外，还需要实现javax.servlet.Filter接口。

            public
            class TestFilter implements Filter{

    publicvoid doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
        
        chain.doFilter(request, response);
    }

    publicvoid destroy() {
    }

    publicvoid init(FilterConfig filterConfig) throws ServletException {
    }

}

　　使用DEBUG模式所看到的结果如下

技术分享

　　其实在真正执行到TestFilter类之前，会经过很多Tomcat内部的类。顺带提一下其实Tomcat的容器设置也是责任链模式，注意被红色方框所圈中的类，从Engine到Host再到Context一直到Wrapper都是通过一个链传递请求。被绿色方框所圈中的地方有一个名为ApplicationFilterChain的类，ApplicationFilterChain类所扮演的就是抽象处理者角色，而具体处理者角色由各个Filter扮演。

第一个疑问是ApplicationFilterChain将所有的Filter存放在哪里？

　　答案是保存在ApplicationFilterChain类中的一个ApplicationFilterConfig对象的数组中。

            /**
            
     * Filters.
     
            */
            private ApplicationFilterConfig[] filters = 
        new ApplicationFilterConfig[0];

那ApplicationFilterConfig对象又是什么呢？

　   ApplicationFilterConfig是一个Filter容器。以下是ApplicationFilterConfig类的声明：

            /**
            
 * Implementation of a <code>javax.servlet.FilterConfig</code> useful in
 * managing the filter instances instantiated when a web application
 * is first started.
 *
 * 
            @author
             Craig R. McClanahan
 * 
            @version
             $Id: ApplicationFilterConfig.java 1201569 2011-11-14 01:36:07Z kkolinko $
 
            */

　　当一个web应用首次启动时ApplicationFilterConfig会自动实例化，它会从该web应用的web.xml文件中读取配置的Filter的信息，然后装进该容器。

刚刚看到在ApplicationFilterChain类中所创建的ApplicationFilterConfig数组长度为零，那它是在什么时候被重新赋值的呢？ 

            private ApplicationFilterConfig[] filters = 
        new ApplicationFilterConfig[0];

　　是在调用ApplicationFilterChain类的addFilter()方法时。

            /**
            
     * The int which gives the current number of filters in the chain.
     
            */
            private
            int n = 0;
                public
            static
            final
            int INCREMENT = 10;
            void
             addFilter(ApplicationFilterConfig filterConfig) {

        
            //
             Prevent the same filter being added multiple times
            for
            (ApplicationFilterConfig filter:filters)
            
            if(filter==filterConfig)
                return;

        if (n == filters.length) {
            ApplicationFilterConfig[] newFilters =
                new ApplicationFilterConfig[n + INCREMENT];
            System.arraycopy(filters, 0, newFilters, 0, n);
            filters= newFilters;
        }
        filters[n++] = filterConfig;

    }

　　变量n用来记录当前过滤器链里面拥有的过滤器数目，默认情况下n等于0，ApplicationFilterConfig对象数组的长度也等于0，所以当第一次调用addFilter()方法时，if (n == filters.length)的条件成立，ApplicationFilterConfig数组长度被改变。之后filters[n++] = filterConfig;将变量filterConfig放入ApplicationFilterConfig数组中并将当前过滤器链里面拥有的过滤器数目+1。

那ApplicationFilterChain的addFilter()方法又是在什么地方被调用的呢？

　　是在ApplicationFilterFactory类的createFilterChain()方法中。

              1
            public
             ApplicationFilterChain createFilterChain

              2
                    (ServletRequest request, Wrapper wrapper, Servlet servlet) {

              3
              4
            //
             get the dispatcher type
              5         DispatcherType dispatcher = null; 
  6if (request.getAttribute(DISPATCHER_TYPE_ATTR) != null) {
  7             dispatcher = (DispatcherType) request.getAttribute(DISPATCHER_TYPE_ATTR);
  8        }
  9         String requestPath = null;
 10         Object attribute = request.getAttribute(DISPATCHER_REQUEST_PATH_ATTR);
 11 12if (attribute != null){
 13             requestPath = attribute.toString();
 14        }
 15 16// If there is no servlet to execute, return null 17if (servlet == null)
 18return (null);
 19 20boolean comet = false;
 21 22// Create and initialize a filter chain object 23         ApplicationFilterChain filterChain = null;
 24if (request instanceof Request) {
 25             Request req = (Request) request;
 26             comet = req.isComet();
 27if (Globals.IS_SECURITY_ENABLED) {
 28// Security: Do not recycle 29                 filterChain = new ApplicationFilterChain();
 30if (comet) {
 31                    req.setFilterChain(filterChain);
 32                }
 33             } else {
 34                 filterChain = (ApplicationFilterChain) req.getFilterChain();
 35if (filterChain == null) {
 36                     filterChain = new ApplicationFilterChain();
 37                    req.setFilterChain(filterChain);
 38                }
 39            }
 40         } else {
 41// Request dispatcher in use 42             filterChain = new ApplicationFilterChain();
 43        }
 44 45        filterChain.setServlet(servlet);
 46 47        filterChain.setSupport
 48            (((StandardWrapper)wrapper).getInstanceSupport());
 49 50// Acquire the filter mappings for this Context 51         StandardContext context = (StandardContext) wrapper.getParent();
 52         FilterMap filterMaps[] = context.findFilterMaps();
 53 54// If there are no filter mappings, we are done 55if ((filterMaps == null) || (filterMaps.length == 0))
 56return (filterChain);
 57 58// Acquire the information we will need to match filter mappings 59         String servletName = wrapper.getName();
 60 61// Add the relevant path-mapped filters to this filter chain 62for (int i = 0; i < filterMaps.length; i++) {
 63if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
 64continue;
 65            }
 66if (!matchFiltersURL(filterMaps[i], requestPath))
 67continue;
 68             ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
 69                context.findFilterConfig(filterMaps[i].getFilterName());
 70if (filterConfig == null) {
 71// FIXME - log configuration problem 72continue;
 73            }
 74boolean isCometFilter = false;
 75if (comet) {
 76try {
 77                     isCometFilter = filterConfig.getFilter() instanceof CometFilter;
 78                 } catch (Exception e) {
 79// Note: The try catch is there because getFilter has a lot of 
 80// declared exceptions. However, the filter is allocated much
 81// earlier 82                     Throwable t = ExceptionUtils.unwrapInvocationTargetException(e);
 83                    ExceptionUtils.handleThrowable(t);
 84                }
 85if (isCometFilter) {
 86                    filterChain.addFilter(filterConfig);
 87                }
 88             } else {
 89                filterChain.addFilter(filterConfig);
 90            }
 91        }
 92 93// Add filters that match on servlet name second 94for (int i = 0; i < filterMaps.length; i++) {
 95if (!matchDispatcher(filterMaps[i] ,dispatcher)) {
 96continue;
 97            }
 98if (!matchFiltersServlet(filterMaps[i], servletName))
 99continue;
100             ApplicationFilterConfig filterConfig = (ApplicationFilterConfig)
101                context.findFilterConfig(filterMaps[i].getFilterName());
102if (filterConfig == null) {
103// FIXME - log configuration problem104continue;
105            }
106boolean isCometFilter = false;
107if (comet) {
108try {
109                     isCometFilter = filterConfig.getFilter() instanceof CometFilter;
110                 } catch (Exception e) {
111// Note: The try catch is there because getFilter has a lot of 
112// declared exceptions. However, the filter is allocated much
113// earlier114                }
115if (isCometFilter) {
116                    filterChain.addFilter(filterConfig);
117                }
118             } else {
119                filterChain.addFilter(filterConfig);
120            }
121        }
122123// Return the completed filter chain124return (filterChain);
125126     }

　　可以将如上代码分为两段，51行之前为第一段，51行之后为第二段。

　　第一段的主要目的是创建ApplicationFilterChain对象以及一些参数设置。

　　第二段的主要目的是从上下文中获取所有Filter信息，之后使用for循环遍历并调用filterChain.addFilter(filterConfig);将filterConfig放入ApplicationFilterChain对象的ApplicationFilterConfig数组中。

那ApplicationFilterFactory类的createFilterChain()方法又是在什么地方被调用的呢？

　　是在StandardWrapperValue类的invoke()方法中被调用的。

技术分享

　　由于invoke()方法较长，所以将很多地方省略。

            public
            final
            void
             invoke(Request request, Response response)
        
            throws
             IOException, ServletException {
   ...省略中间代码

            　　　　 //
             Create the filter chain for this request
        ApplicationFilterFactory factory =
            ApplicationFilterFactory.getInstance();
        ApplicationFilterChain filterChain =
            factory.createFilterChain(request, wrapper, servlet);
　　...省略中间代码
         filterChain.doFilter(request.getRequest(), response.getResponse());...省略中间代码
    }

　　那正常的流程应该是这样的：

　　在StandardWrapperValue类的invoke()方法中调用ApplicationFilterChai类的createFilterChain()方法———>在ApplicationFilterChai类的createFilterChain()方法中调用ApplicationFilterChain类的addFilter()方法———>在ApplicationFilterChain类的addFilter()方法中给ApplicationFilterConfig数组赋值。

技术分享

　　根据上面的代码可以看出StandardWrapperValue类的invoke()方法在执行完createFilterChain()方法后，会继续执行ApplicationFilterChain类的doFilter()方法，然后在doFilter()方法中会调用internalDoFilter()方法。

　　以下是internalDoFilter()方法的部分代码

            //
             Call the next filter if there is one
            if (pos < n) {
//拿到下一个Filter，将指针向下移动一位
//pos它来标识当前ApplicationFilterChain（当前过滤器链）执行到哪个过滤器
            ApplicationFilterConfig filterConfig = filters[pos++];
            Filter filter = null;
            try {
//获取当前指向的Filter的实例
                filter = filterConfig.getFilter();
                support.fireInstanceEvent(InstanceEvent.BEFORE_FILTER_EVENT,
                                          filter, request, response);
                
                if (request.isAsyncSupported() && "false".equalsIgnoreCase(
                        filterConfig.getFilterDef().getAsyncSupported())) {
                    request.setAttribute(Globals.ASYNC_SUPPORTED_ATTR,
                            Boolean.FALSE);
                }
                if( Globals.IS_SECURITY_ENABLED ) {
                    final ServletRequest req = request;
                    final ServletResponse res = response;
                    Principal principal = 
                        ((HttpServletRequest) req).getUserPrincipal();

                    Object[] args = new Object[]{req, res, this};
                    SecurityUtil.doAsPrivilege
                        ("doFilter", filter, classType, args, principal);
                    
                } else {
//调用Filter的doFilter()方法  
                    filter.doFilter(request, response, this);
                }

　　这里的filter.doFilter(request, response, this);就是调用我们前面创建的TestFilter中的doFilter()方法。而TestFilter中的doFilter()方法会继续调用chain.doFilter(request, response);方法，而这个chain其实就是ApplicationFilterChain,所以调用过程又回到了上面调用dofilter和调用internalDoFilter方法，这样执行直到里面的过滤器全部执行。

　　如果定义两个过滤器，则Debug结果如下：

技术分享

 

 

 

原文：http://blog.csdn.net/jianghuxiaojin/article/details/51772311

内容总结

以上是互联网集市为您收集整理的java-设计模式-责任链全部内容，希望文章能够帮你解决java-设计模式-责任链所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1057964.html

来源：【匿名】