开发者社区> 晴天哥> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Tomcat中设计模式-职责链

简介:
+关注继续查看

开篇

 责任链模式:责任链模式可以用在这样的场景,当一个request过来的时候,需要对这个request做一系列的加工,使用责任链模式可以使每个加工组件化,减少耦合。也可以使用在当一个request过来的时候,需要找到合适的加工方式。当一个加工方式不适合这个request的时候,传递到下一个加工方法,该加工方式再尝试对request加工。

 在tomcat中容器之间的调用使用的就是责任链的设计模式,当一个请求过来的时候首先是engine容器接受请求,然后engine容器会把请求传到host容器,host容器又会传到context容器,context容器传到wrapper容器,最后wrapper容器使用适配请求的servlet处理请求。


职责链组成

Valve

Valve作为职责链上的每个节点,主要用于处理流到该节点的request对象。

说明:

    1. Valve的具体实现的类的一部分如上图所示。
    1. Valve的抽象类ValveBase包含Valve next元素,也就是每个Value包含指向下一个Valve的对象,类似递归。
public interface Valve {
    public Valve getNext();
    public void setNext(Valve valve);
    public void backgroundProcess();
    public void invoke(Request request, Response response) throws IOException, ServletException;
    public boolean isAsyncSupported();
}

public abstract class ValveBase extends LifecycleMBeanBase implements Contained, Valve {
    // 指向下一个Valve对象
    protected Valve next = null;

    public Valve getNext() {
        return next;
    }

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

    public void backgroundProcess() {
    }
}
final class StandardEngineValve extends ValveBase {

    public final void invoke(Request request, Response response)
        throws IOException, ServletException {

        Host host = request.getHost();
        if (host == null) {
            response.sendError
                (HttpServletResponse.SC_BAD_REQUEST,
                 sm.getString("standardEngine.noHost",
                              request.getServerName()));
            return;
        }
        if (request.isAsyncSupported()) {
            request.setAsyncSupported(host.getPipeline().isAsyncSupported());
        }

        host.getPipeline().getFirst().invoke(request, response);
    }
}


Pipeline

Pipeline作为职责链对象,主要维护Valve职责链节点对象。
StandardPipeline.png

说明:

    1. Pipeline作为职责链对象,维护Valve职责链对象。
    1. Pipeline包含职责链对象的头节点Valve first和尾节点Valve basic。
public interface Pipeline {

    public Valve getBasic();

    public void setBasic(Valve valve);

    public void addValve(Valve valve);

    public Valve[] getValves();

    public void removeValve(Valve valve);

    public Valve getFirst();

    public boolean isAsyncSupported();

    public Container getContainer();

    public void setContainer(Container container);

    public void findNonAsyncValves(Set<String> result);
}
public class StandardPipeline extends LifecycleBase
        implements Pipeline, Contained {

    public StandardPipeline() {
        this(null);
    }

    public StandardPipeline(Container container) {
        super();
        setContainer(container);
    }

    protected Valve basic = null;
    protected Container container = null;
    protected Valve first = null;

    public Valve getBasic() {
        return (this.basic);
    }

    public void setBasic(Valve valve) {
        Valve oldBasic = this.basic;
        if (oldBasic == valve)
            return;

        if (oldBasic != null) {
            if (getState().isAvailable() && (oldBasic instanceof Lifecycle)) {
                try {
                    ((Lifecycle) oldBasic).stop();
                } catch (LifecycleException e) {
                }
            }
            if (oldBasic instanceof Contained) {
                try {
                    ((Contained) oldBasic).setContainer(null);
                } catch (Throwable t) {
                }
            }
        }

        if (valve == null)
            return;
        if (valve instanceof Contained) {
            ((Contained) valve).setContainer(this.container);
        }
        if (getState().isAvailable() && valve instanceof Lifecycle) {
            try {
                ((Lifecycle) valve).start();
            } catch (LifecycleException e) {
                return;
            }
        }

        Valve current = first;
        while (current != null) {
            if (current.getNext() == oldBasic) {
                current.setNext(valve);
                break;
            }
            current = current.getNext();
        }
        this.basic = valve;
    }

    public void addValve(Valve valve) {
        if (valve instanceof Contained)
            ((Contained) valve).setContainer(this.container);

        if (getState().isAvailable()) {
            if (valve instanceof Lifecycle) {
                try {
                    ((Lifecycle) valve).start();
                } catch (LifecycleException e) {
                }
            }
        }

        if (first == null) {
            first = valve;
            valve.setNext(basic);
        } else {
            Valve current = first;
            while (current != null) {
                if (current.getNext() == basic) {
                    current.setNext(valve);
                    valve.setNext(basic);
                    break;
                }
                current = current.getNext();
            }
        }
        container.fireContainerEvent(Container.ADD_VALVE_EVENT, valve);
    }


    public Valve getFirst() {
        if (first != null) {
            return first;
        }
        return basic;
    }
}


职责链元素组合关系

职责链
说明:

    1. 容器StandardEngine包含职责链对象StandardPipeline。
    1. StandardPipeline作为职责链对象包含职责接地啊Valve对象。
    1. Valve对象有一些具体的实现类如StandardEngineValve对象。


职责链调用栈

调用栈
说明:

    1. 每个容器包含职责链对象Pipeline。
    1. 每个职责对象Valve的具体实现当中会包含下一个容器对象,相当于Valve对象内部会访问下一个容器,进而实现职责链传递。


招聘信息

【招贤纳士】

欢迎热爱技术、热爱生活的你和我成为同事,和贝贝共同成长。

贝贝集团诚招算法、大数据、BI、Java、PHP、android、iOS、测试、运维、DBA等人才,有意可投递zhi.wang@beibei.com

贝贝集团创建于2011年,旗下拥有贝贝网、贝店、贝贷等平台,致力于成为全球领先的家庭消费平台。

贝贝创始团队来自阿里巴巴,先后获得IDG资本、高榕资本、今日资本、新天域资本、北极光等数亿美金的风险投资。

公司地址:杭州市江干区普盛巷9号东谷创业园(上下班有多趟班车)

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
【Tomcat技术专题】一切从零开始,让我们进入Tomcat的构设计模式
【Tomcat技术专题】一切从零开始,让我们进入Tomcat的构设计模式
0 0
走进JavaWeb技术世界7:Tomcat中的设计模式
本文首发于我的个人公众号:程序员江湖     欢迎大家关注我的微信公众号:程序员江湖 努力成为最有影响力的程序员自媒体,专注于面试,职场,个人提升三大主题。
1530 0
Tomcat源码分析----Tomcat中重要的设计模式
本章主要介绍tomcat中的设计模式
5904 0
Tomcat 系统架构与设计模式--工作原理
本文以 Tomcat 5 为基础,也兼顾最新的 Tomcat 6 和 Tomcat 4。Tomcat 的基本设计思路和架构是具有一定连续性的。 Tomcat 总体结构 Tomcat 的结构很复杂,但是 Tomcat 也非常的模块化,找到了 Tomcat 最核心的模块,您就抓住了 Tomcat 的“七寸”。下面是 Tomcat 的总体结构图: 图 1.Tomcat 的总体结构从上图中可
1218 0
CentOS 7 在tomcat下配置geoserver跨域
CentOS 7 在tomcat下配置geoserver跨域
0 0
IDEA配置Tomcat以及环境
IDEA配置Tomcat以及环境
0 0
IDEA配置Tomcat Server
IDEA配置Tomcat Server
0 0
+关注
晴天哥
专注java技术,热爱长跑和阅读开源代码 邮箱 lebron374@163.com
文章
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载