How Tomcat Works读书笔记

作者: 想54256 | 来源:发表于2019-10-26 17:47 被阅读0次

title: How Tomcat Works（基于Tomcat4）
date: 2019/08/12 15:51

一、一个简单的web服务器

基于Java的Http服务器需要两个重要的类java.net.ServerSocket和java.net.Socket。

1.1 HTTP

Http使用可靠的TCP连接，默认使用TCP/80端口

1.2 Socket类

套接字是网络连接的端点。套接字使程序可以从网络中读取数据，可以向网络中写入数据。不同计算机上的两个应用程序可以通过连接发送或接受字节流。

Socket类表示客户端套接字（想要连接到远程服务器应用程序时需要创建的套接字）、ServerSocket类表示服务器套接字（等待客户端的连接请求的套接字），当服务器套接字收到请求后，他会创建一个Socket实例来处理与客户端的通信。

二、一个简单的Servlet容器

2.1 Servlet接口

2.2 应用程序1

一个功能健全的servlet容器对Http请求需要做以下几件事：

第一次调用某个servlet时，要载入该servlet类，之后调用它的init()方法。

// 连接器调用pipline，pipline调用基础阀，基础阀执行wrapper.allocate();
Servlet servlet = this.loadServlet();
servlet.init();

针对每个request请求，创建一个javax.servlet.ServletRequest和javax.servlet.ServletResponse对象。（连接器干的）
调用servlet的service方法（基础阀干的，通过过滤器链传递到servlet）
调用destory方法并卸载此类

连接器最终生成的是HttpRequestImpl的对象，由于HttpRequestImpl类中有部分公有方法不想让servlet程序员使用，有两种办法能够解决：

使用访问修饰符
使用Faced类

三、连接器

连接器主要负责创建HttpServletRequest和HttpServletResponse对象，并将他们作为参数传给servlet的service方法。

3.1 StringManager类

该类用来处理Catalina中错误消息的国际化操作。

Tomcat将错误消息存储到properties文件中，如果所有错误信息储存再一个文件中，会很难维护，所以Tomcat将properties文件划分到不同的包中，每个properties文件使用一个StringManager对象来处理。

private static Hashtable managers = new Hashtable();

public synchronized static StringManager getManager(String packageName) {
    StringManager mgr = (StringManager)managers.get(packageName);
    if (mgr == null) {
        mgr = new StringManager(packageName);
        managers.put(packageName, mgr);
    }
    return mgr;
}

properties文件格式

StringManager会根据该应用程序的服务器的语言环境选择使用哪个文件。

3.2 应用程序

连接器需要在请求来的时候从socket中一些值设置给Request对象，这些值包括：URI、查询字符串、参数（body中）、cookie、请求头等信息；由于查询字符串和参数可能巨大，所以一般再连接器中不解析它们，而是在servlet真正用到的时候进行解析的。

连接器解析Http请求主要分为以下5块：

3.2.1 启动程序

public final class Bootstrap {
    public static void main(String[] args) {
        // HttpConnector负责接受连接，并调用HttpProcessor.process(Socket socket)方法
        HttpConnector connector = new HttpConnector();
        connector.start();
    }
}

3.2.2 HttpConnector类

public class HttpConnector implements Runnable {

    boolean stopped;
    private String scheme = "http";

    public String getScheme() {
        return scheme;
    }

    public void run() {
        ServerSocket serverSocket = null;
        int port = 8080;
        serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
        while (!stopped) {
            // 等待http请求
            Socket socket = serverSocket.accept();
            // 调用连接器的process方法，对请求进行解析
            HttpProcessor processor = new HttpProcessor(this);
            processor.process(socket);
        }
    }

    public void start() {
        Thread thread = new Thread(this);
        thread.start();
    }
}

3.2.3 HttpProcessor类

public void process(Socket socket) {
    SocketInputStream input = null;
    OutputStream output = null;
    try {
        // 获取socket中的输入流、输出流
        input = new SocketInputStream(socket.getInputStream(), 2048);
        output = socket.getOutputStream();

        // 创建Request和Response对象
        request = new HttpRequest(input);
        
        response = new HttpResponse(output);
        response.setRequest(request);
        response.setHeader("Server", "Pyrmont Servlet Container");

        // 解析请求
        parseRequest(input, output);
        parseHeaders(input);

        // 检查这是对servlet还是静态资源的请求，调用不同的处理程序
        // 对servlet的请求以/servlet/开头
        if (request.getRequestURI().startsWith("/servlet/")) {
            ServletProcessor processor = new ServletProcessor();
            processor.process(request, response);
        } else {
            StaticResourceProcessor processor = new StaticResourceProcessor();
            processor.process(request, response);
        }

        // Close the socket
        socket.close();
        // no shutdown for this application
    } catch (Exception e) {
        e.printStackTrace();
    }
}

3.2.3.1 创建HttpRequest对象

主要包含五部分：

读取套接字的输入流
解析请求行

第一行就是请求行
解析请求头
解析cookie
读取参数

前面说过读取参数会延迟到servlet第一次获取参数时进行解析，所以在request对象中有一个parseParameters()方法，会在第一次获取参数时进行解析。

3.2.3.2 创建HttpResponse对象

获取输出流，转换成PrintWirter对象

四、Tomcat的默认连接器

功能：负责创建Request、Response对象，然后调用Container接口的invoke方法。

由于HttpProcessor将Request对象作为全局变量，所以多线程访问的时候有线程安全问题，所以HttpConnector内部维护一个对象池。

4.2 Connector接口

Tomcat的连接器必须实现该接口。

public interface Connector {

    // 返回与之关联的容器
    public Container getContainer();

    // 将连接器与某个servlet相关联；当request、response对象创建好了之后调用它的invoke方法
    public void setContainer(Container container);

    // 为引入的Http请求创建request对象
    public Request createRequest();

    // 创建response对象
    public Response createResponse();
    
    // 初始化连接器
    public void initialize() throws LifecycleException;

    ...
}

注：Tomcat8中没有Connector接口，改为org.apache.catalina.connector.Connector类，使用的是Coyote连接器。

4.3 HttpConnector类（连接器）

public final class HttpConnector
        implements Connector, Lifecycle, Runnable {

4.3.1 创建服务器套接字

HttpConnector的initialize()方法会调用open()方法（私有方法）从服务器套接字工厂得到一个服务器套接字实例。

4.3.2 维护HttpProcessor实例（具体干活的人）

上面说了，由于一个HttpProcessor实例只能串行的干活，才能保证线程安全，所以默认连接器维护了一个处理器栈：

private Stack<HttpProcessor> processors = new Stack<>();

内部的数量由两个变量决定：

private int maxProcessors = 20;

protected int minProcessors = 5;

在HttpConnector启动（Lifecycle的start方法）的时候会对内部对象进行填充：

public void start() throws LifecycleException {

    // Validate and update our current state
    if (started)
        throw new LifecycleException
                (sm.getString("httpConnector.alreadyStarted"));
    threadName = "HttpConnector[" + port + "]";
    lifecycle.fireLifecycleEvent(START_EVENT, null);
    started = true;

    // Start our background thread
    threadStart();

    // 创建指定的**最小**处理器数
    while (curProcessors < minProcessors) {
        if ((maxProcessors > 0) && (curProcessors >= maxProcessors))
            break;
        
        // 创建对象
        HttpProcessor processor = newProcessor();
        // 压入栈
        recycle(processor);
    }

}

4.3.3 提供Http请求服务

HttpConnector实现了Runable接口，上面的threadStart()方法将其启动：

public void run() {
    // Loop until we receive a shutdown command
    while (!stopped) {
        Socket socket = null;
        try {
            // 等待http请求
            socket = serverSocket.accept();
            if (connectionTimeout > 0)
                socket.setSoTimeout(connectionTimeout);
            socket.setTcpNoDelay(tcpNoDelay);
        } catch (IOException e) {
            try {
                // If reopening fails, exit
                synchronized (threadSync) {
                    if (started && !stopped)
                        log("accept error: ", e);
                    if (!stopped) {
                        serverSocket.close();
                        serverSocket = open();
                    }
            } ...
            continue;
        }

        // 获取一个HttpProcessor对象（可能是从栈中取出，可能是创建的，如果max <= current返回null）
        HttpProcessor processor = createProcessor();
        if (processor == null) {
            try {
                log(sm.getString("httpConnector.noProcessor"));
                socket.close();
            } catch (IOException e) {
                ;
            }
            continue;
        }
        // 传入socket对象，唤醒processor的run方法
        processor.assign(socket);
    }

    synchronized (threadSync) {
        threadSync.notifyAll();
    }

}

4.3.4 HttpProcessor类

public void run() {
    // Process requests until we receive a shutdown signal
    while (!stopped) {

        // 获取套接字对象，processor.assign(socket)传入的
        Socket socket = await();
        if (socket == null)
            continue;

        // 处理
        try {
            process(socket);
        } catch (Throwable t) {
            log("process.invoke", t);
        }

        // 将当前实例压会栈中
        connector.recycle(this);

    }

    // 告诉 threadstop()我们已经成功关闭了自己
    synchronized (threadSync) {
        threadSync.notifyAll();
    }
}

private void process(Socket socket) {
    // 表示处理过程是否出错
    boolean ok = true;
    boolean finishResponse = true;
    SocketInputStream input = null;
    OutputStream output = null;

    // Construct and initialize the objects we will need
    try {
        input = new SocketInputStream(socket.getInputStream(),
                                        connector.getBufferSize());
    } catch (Exception e) {
        log("process.create", e);
        ok = false;
    }

    keepAlive = true;

    // 不断的读取输入流，知道HttpProcessor实例终止
    while (!stopped && ok && keepAlive) {

        finishResponse = true;

        try {
            // request、response对象的初始化工作
            request.setStream(input);
            request.setResponse(response);
            output = socket.getOutputStream();
            response.setStream(output);
            response.setRequest(request);
            ((HttpServletResponse) response.getResponse()).setHeader
                ("Server", SERVER_INFO);
        } catch (Exception e) {
            log("process.create", e);
            ok = false;
        }


        // Parse the incoming request
        try {
            if (ok) {

                // 解析连接，取出internet地址赋值给Request对象
                parseConnection(socket);
                // 解析各种东西，参见第三章
                parseRequest(input, output);
                if (!request.getRequest().getProtocol()
                    .startsWith("HTTP/0"))
                    // 解析请求头
                    parseHeaders(input);
                if (http11) {
                    // Sending a request acknowledge back to the client if
                    // requested.
                    ackRequest(output);
                    // If the protocol is HTTP/1.1, chunking is allowed.
                    if (connector.isChunkingAllowed())
                        response.setAllowChunking(true);
                }

            }
        } catch (EOFException e) {
            // It's very likely to be a socket disconnect on either the
            // client or the server
            ok = false;
            finishResponse = false;
        } catch (ServletException e) {
            ok = false;
            try {
                ((HttpServletResponse) response.getResponse())
                    .sendError(HttpServletResponse.SC_BAD_REQUEST);
            } catch (Exception f) {
                ;
            }
        } catch (InterruptedIOException e) {
            if (debug > 1) {
                try {
                    log("process.parse", e);
                    ((HttpServletResponse) response.getResponse())
                        .sendError(HttpServletResponse.SC_BAD_REQUEST);
                } catch (Exception f) {
                    ;
                }
            }
            ok = false;
        } catch (Exception e) {
            try {
                log("process.parse", e);
                ((HttpServletResponse) response.getResponse()).sendError
                    (HttpServletResponse.SC_BAD_REQUEST);
            } catch (Exception f) {
                ;
            }
            ok = false;
        }

        // Ask our Container to process this request
        try {
            ((HttpServletResponse) response).setHeader
                ("Date", FastHttpDateFormat.getCurrentDate());
            if (ok) {
                // *** 获取容器执行invoke方法，最终到达servlet.service() ***
                connector.getContainer().invoke(request, response);
            }
        } catch (ServletException e) {
            log("process.invoke", e);
            try {
                ((HttpServletResponse) response.getResponse()).sendError
                    (HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
            } catch (Exception f) {
                ;
            }
            ok = false;
        } catch (InterruptedIOException e) {
            ok = false;
        } catch (Throwable e) {
            log("process.invoke", e);
            try {
                ((HttpServletResponse) response.getResponse()).sendError
                    (HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
            } catch (Exception f) {
                ;
            }
            ok = false;
        }

        // 直到finishResponse为true表示处理结束（包括循环读取请求头，调用service方法等），将结果发送给客户端。
        if (finishResponse) {
            try {
                response.finishResponse();
            } catch (IOException e) {
                ok = false;
            } catch (Throwable e) {
                log("process.invoke", e);
                ok = false;
            }
            try {
                request.finishRequest();
            } catch (IOException e) {
                ok = false;
            } catch (Throwable e) {
                log("process.invoke", e);
                ok = false;
            }
            try {
                if (output != null)
                    output.flush();
            } catch (IOException e) {
                ok = false;
            }
        }

        // We have to check if the connection closure has been requested
        // by the application or the response stream (in case of HTTP/1.0
        // and keep-alive).
        if ( "close".equals(response.getHeader("Connection")) ) {
            keepAlive = false;
        }

        // End of request processing
        status = Constants.PROCESSOR_IDLE;

        // Recycling the request and the response objects
        request.recycle();
        response.recycle();

    }

    try {
        shutdownInput(input);
        socket.close();
    } catch (IOException e) {
        ;
    } catch (Throwable e) {
        log("process.invoke", e);
    }
    socket = null;

}

五、Servlet容器

servlet容器是用来处理请求servlet资源，并为客户端填充response对象的模块。

Tomcat中有下面4中容器：

Engine：解析请求，分配到适当的虚拟主机
Host：虚拟主机；运行多个Web应用（一个Context代表一个Web应用），并负责安装、展开、启动和结束每个Web应用。
Context：代表在特定虚拟主机上运行的一个Web应用
Wrapper：表示一个独立的servlet

它们所有的实现类都继承ContainerBase抽象类。

https://www.cnblogs.com/kismetv/p/7228274.html#title3-1

5.1 Container接口

public interface Container {

    // 添加子容器；Host容器下只能添加Context容器。。。
    void addChild(Container child);

    // 移除子容器
    void removeChild(Container child);

    // 根据名称查找子容器
    public Container findChild(String name);

    // 查找子容器集合
    public Container[] findChildren();

    // 其它组件的get/set方法，包括：载入器（Loader）、记录器（Logger）、Session管理器（Manager）、领域（Realm）、资源（Resource）

    容器是Tomcat的核心，所以才将所有组件都与容器连接起来，而且通过Lifecyle接口，使我们可以只启动容器组件就可以了（他帮我们启动其它组件）
}

注：这是组合模式的一种使用

5.2 管道任务

当连接器调用容器的invoke()方法后，容器会调用pipline的invoke()方法（pipline是管理阀的容器，类似FilterChain；阀表示具体的执行任务），pipline会调用ValveContext的invokeNext方法，当所有阀全都调用完成之后就会调用基础阀的invoke方法。

看下StandardWrapperValve的invoke方法的部分代码：

StandardWrapper wrapper = (StandardWrapper) getContainer();

ServletRequest sreq = request.getRequest();
ServletResponse sres = response.getResponse();

// 如果是第一次的话，这个方法里面调用了servlet的init方法
Servlet servlet = wrapper.allocate();;

// 构造Filter责任链
ApplicationFilterChain filterChain = createFilterChain(request, servlet);

// 执行责任链和servlet的service方法
filterChain.doFilter(sreq, sres);

5.3 Wrapper接口

Wrapper的实现类主要负责管理其基础的servlet类的生命周期

// 载入并加载servlet，在它的子类StandardWrapper中直接调用的loadServlet方法
void load() throws ServletException;

// 该方法会返回已加载的servlet类，还要考虑它是否实现了SingleThreadModel
Servlet allocate() throws ServletException;

六、生命周期

Catalina包含很多组件，当Catalina启动时，这些组件也会一起启动，关闭时也会一起关闭。

通过实现Lifecyle接口就可以达到统一启动/关闭这些组件的效果。

Lifecycle可以触发下面6个事件，实现LifecycleListener的类可以通过addLifecycleListener()注册到相应的生命周期对象上。

public interface Lifecycle {

    // 添加事件监听器
    void addLifecycleListener(LifecycleListener listener);

    /**
     * The LifecycleEvent type for the "component start" event.
     */
    public static final String START_EVENT = "start";


    /**
     * The LifecycleEvent type for the "component before start" event.
     */
    public static final String BEFORE_START_EVENT = "before_start";


    /**
     * The LifecycleEvent type for the "component after start" event.
     */
    public static final String AFTER_START_EVENT = "after_start";


    /**
     * The LifecycleEvent type for the "component stop" event.
     */
    public static final String STOP_EVENT = "stop";


    /**
     * The LifecycleEvent type for the "component before stop" event.
     */
    public static final String BEFORE_STOP_EVENT = "before_stop";


    /**
     * The LifecycleEvent type for the "component after stop" event.
     */
    public static final String AFTER_STOP_EVENT = "after_stop";

6.1 Lifecycle接口

void addLifecycleListener(LifecycleListener listener);

public LifecycleListener[] findLifecycleListeners();

public void removeLifecycleListener(LifecycleListener listener);

// 启动操作
public void start() throws LifecycleException;

// 关闭操作
public void stop() throws LifecycleException;

其实也是组合模式的使用

6.2 LifecycleEvent

当事件触发的时候传给listener的对象

6.3 LifecycleListener

事件触发是的处理程序要放在lifecycleEvent方法中。

public interface LifecycleListener {

    public void lifecycleEvent(LifecycleEvent event);
}

6.4 LifecycleSupport（工具类）

public final class LifecycleSupport {

    // 构造需要一个生命周期对象
    public LifecycleSupport(Lifecycle lifecycle) {

        super();
        this.lifecycle = lifecycle;

    }

    private Lifecycle lifecycle = null;

    // 监听器集合
    private LifecycleListener listeners[] = new LifecycleListener[0];

    // 当调用生命周期的addLifecycleListener方法时，大多数代码的实现直接调用的LifecycleSupport的这个方法
    public void addLifecycleListener(LifecycleListener listener) {

      synchronized (listeners) {
          LifecycleListener results[] =
            new LifecycleListener[listeners.length + 1];
          for (int i = 0; i < listeners.length; i++)
              results[i] = listeners[i];
          results[listeners.length] = listener;
          listeners = results;
      }

    }


    public LifecycleListener[] findLifecycleListeners() {

        return listeners;

    }

    // 触发事件，type是上面Lifecyle中定义的那6个常量，data是要传给listener的数据
    public void fireLifecycleEvent(String type, Object data) {

        LifecycleEvent event = new LifecycleEvent(lifecycle, type, data);
        LifecycleListener interested[] = null;
        synchronized (listeners) {
            interested = (LifecycleListener[]) listeners.clone();
        }
        for (int i = 0; i < interested.length; i++)
            interested[i].lifecycleEvent(event);

    }

    public void removeLifecycleListener(LifecycleListener listener) {

        synchronized (listeners) {
            int n = -1;
            for (int i = 0; i < listeners.length; i++) {
                if (listeners[i] == listener) {
                    n = i;
                    break;
                }
            }
            if (n < 0)
                return;
            LifecycleListener results[] =
              new LifecycleListener[listeners.length - 1];
            int j = 0;
            for (int i = 0; i < listeners.length; i++) {
                if (i != n)
                    results[j++] = listeners[i];
            }
            listeners = results;
        }

    }
}

6.5 应用程序

能体现Lifecyle的就是启动类中的代码了：

public final class Bootstrap {
    public static void main(String[] args) {
        Connector connector = new HttpConnector();
        Wrapper wrapper1 = new SimpleWrapper();
        wrapper1.setName("Primitive");
        wrapper1.setServletClass("PrimitiveServlet");
        Wrapper wrapper2 = new SimpleWrapper();
        wrapper2.setName("Modern");
        wrapper2.setServletClass("ModernServlet");

        Context context = new SimpleContext();
        context.addChild(wrapper1);
        context.addChild(wrapper2);

        Mapper mapper = new SimpleContextMapper();
        mapper.setProtocol("http");
        // 将监听器绑定到context容器中
        LifecycleListener listener = new SimpleContextLifecycleListener();
        ((Lifecycle) context).addLifecycleListener(listener);
        context.addMapper(mapper);
        Loader loader = new SimpleLoader();
        context.setLoader(loader);
        // context.addServletMapping(pattern, name);
        context.addServletMapping("/Primitive", "Primitive");
        context.addServletMapping("/Modern", "Modern");
        connector.setContainer(context);
        try {
            // 初始化连接器（创建ServerSocket）
            connector.initialize();
            // 启动连接器（创建HttpProcesser集合）
            ((Lifecycle) connector).start();
            // 启动容器（它又会调用子容器的start()方法）
            ((Lifecycle) context).start();

            // make the application wait until we press a key.
            System.in.read();
            ((Lifecycle) context).stop();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6.6 总结

通过生命周期就可以采用伪递归的方式让组件做一些开始、收尾工作。

LifecyleListener就是在启动/关闭过程中埋下的钩子。

七、日志记录器

日志记录器是用来记录消息的组件。

https://wiki.jikexueyuan.com/project/tomcat/logging.html

7.1 Logger接口

日志记录器都必须实现这个接口。

public interface Logger {

    // 定义的日志的等级
    public static final int FATAL = Integer.MIN_VALUE;

    public static final int ERROR = 1;

    public static final int WARNING = 2;

    public static final int INFORMATION = 3;

    public static final int DEBUG = 4;

7.2 Tomcat的日志记录器

Tomcat提供了3种日志记录器：FileLogger、SystemOutLogger、SystemErrLogger，它们3个都继承了LoggerBase抽象类。

7.2.1 LoggerBase类

实现了所有Logger接口的方法，除了下面这个：

public abstract void log(String msg);

LoggerBase中有几个重载的log方法，最终都会调用这个方法。

日志等级是由protected int verbosity = ERROR;变量定义的，默认为Error。

7.2.2 SystemOutLogger类

public class SystemOutLogger extends LoggerBase {
    public void log(String msg) {
        System.out.println(msg);
    }
}

7.2.3 SystemErrLogger类

public class SystemErrLogger extends LoggerBase {
    public void log(String msg) {
        System.err.println(msg);
    }
}

7.2.4 FileLogger

当我知道Tomcat8中没有Logger接口，就不想写了

八、载入器

由于整个Tomcat共用一个JVM，如果采用系统类加载器的话所有web应用程序（Context）之间可以互相使用对方的类，违背了下面的规范：

为部署在单个Tomcat实例中的每个Web应用程序创建一个类加载器。/WEB-INF/classesWeb应用程序目录中的所有解压缩的类和资源，以及Web应用程序/WEB-INF/lib目录下的JAR文件中的类和资源，都对此Web应用程序可见，但对其他应用程序不可见。 —— Tomcat7官方文档

还有另外一个原因是为了提供自动重载功能，当WEB-INF/classes和WEB-INF/lib目录发生变化时，Web应用要重新载入这些类。

Tomcat要自定义类加载器原因主要是以下3条：

在载入类中指定某些规则
缓存已经载入的类
实现类的预载入

8.1 类加载器

JVM使用了3种类加载器来载入需要的类，分别是引导类加载器（Bootstrap ClassLoader）、扩展类加载器（Extension ClassLoader）、系统类加载器（System ClassLoader）。

3种类加载器是父子继承关系，引导类加载器在最上层，系统类加载器在最下层。

引导类加载器（本地代码编写）：引导启动Java虚拟机。用于加载JVM需要的类，以及所有Java核心类（例如java.lang，java.io包下的类）；它会在rt.jar、i18n.jar中搜索要载入的类。

扩展类加载器：负责载入标准扩展目录中的类。标准扩展目录是/jdk/jre/lib/ext

系统类加载器：它会搜索在环境变量CLASSPATH中指明的路径和文件。

类载入过程（双亲委托机制）：要载入一个类的时候，会先交给系统类加载器，系统类加载器交给扩展类加载器，扩展类加载器又会交给引导类加载器，如果引导类加载器无法加载就交给扩展类加载器，扩展类加载器无法加载就交给系统类加载器，系统类加载器无法加载就抛出ClassNotFoundException异常。

为啥要执行这样的循环过程呢？

如果我们自定义一个java.lang.Object类，假设他能被载入，由于JVM是信任java.lang.Object类的，安全管理器就不会监视这个类的活动，这是非常危险的。

采用双亲委托机制，就会将java.lang.Object类的加载交给引导类加载器，而引导类加载器会在rt.jar、i18n.jar中去寻找这个类进行加载，我们自定义的类并不会被加载。

package java.lang;

public class Object {
    public static void main(String[] args) {
        System.out.println(123);
    }
}

// 证明自定义Object类并没有加载进去
错误: 在类 java.lang.Object 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

8.2 Loader接口

仓库：表示类载入器会在哪里搜索要载入的类

资源：一个类载入器中的DirContext对象（代表着一个web应用的目录吗？？走流程的时候看一下）

public interface Loader {
    
    // 返回类加载器
    ClassLoader getClassLoader();

    Context getContext();

    // 这个方法会在容器启动（start方法）的时候调用，setContext(this)
    void setContext(Context var1);

    boolean getDelegate();

    // 是否委托给父类载入器
    void setDelegate(boolean var1);

    boolean getReloadable();

    void setReloadable(boolean var1);

    void addPropertyChangeListener(PropertyChangeListener var1);

    boolean modified();

    void removePropertyChangeListener(PropertyChangeListener var1);
}

Loader的实现类

public class WebappLoader
    implements Lifecycle, Loader, PropertyChangeListener, Runnable {

    // ClassLoader的子类
    private WebappClassLoader classLoader = null;

8.3 Reloader接口

public interface Reloader {


    /**
     * 设置仓库路径（在哪里搜索要载入的类）
     */
    public void addRepository(String repository);


    /**
     * Return a String array of the current repositories for this class
     * loader.  If there are no repositories, a zero-length array is
     * returned.
     */
    public String[] findRepositories();


    /**
     * 是否修改了一个或多个类或资源
     */
    public boolean modified();
}

8.4 WebappLoader

public class WebappLoader
    implements Lifecycle, Loader, PropertyChangeListener, Runnable {

    // ClassLoader的子类
    private WebappClassLoader classLoader = null;

它负责载入Web应用程序中所使用到的类，支持自动重载功能（通过Runable的run方法不断轮询其类加载器的modified()实现）

当调用该类的start()方法时会做以下几项工作：

8.4.1 创建类载入器

private WebappClassLoader createClassLoader()
        throws Exception {
        
        // loaderClass可以通过setLoaderClass方法改变
        Class clazz = Class.forName(loaderClass);

8.4.2 设置仓库

// 伪代码
private void setRepositories() {

    String classesPath = "/WEB-INF/classes";
    // addRepository的重载方法，第二个参数传入的是 new File(应用/WEB-INF/classes)对象
    classLoader.addRepository(classesPath + "/", classRepository);

    String libPath = "/WEB-INF/lib";
    classLoader.setJarPath(libPath);

8.4.3 设置类路径

为jasper JSP编译器设置一个字符串形式的属性来表明类路径信息。

8.4.4 设置访问权限

如果运行时使用了安全管理器，setPermissions()方法会为泪在如期设置访问目录的权限，例如：设置只能访问WEB-INF/classes和WEB-INF/lib目录。

8.4.5 开启新线程执行类的重新载入

public void run() {

    // Loop until the termination semaphore is set
    while (!threadDone) {

        // Wait for our check interval
        threadSleep();

        if (!started)
            break;

        try {
            // Perform our modification check
            if (!classLoader.modified())
                continue;
        } catch (Exception e) {
            log(sm.getString("webappLoader.failModifiedCheck"), e);
            continue;
        }

        // 重新加载；最终调用的是context.reload()方法
        notifyContext();
        // 为啥这里要退出呢？？会不会在上面reload的过程中重新启动了一个WebappLoader呢？
        break;

    }
}

Tomcat5看书 P119

8.5 WebappClassLoader类

public class WebappClassLoader
    extends URLClassLoader
    implements Reloader, Lifecycle {

继承自URLClassLoader，实现了Reloader接口，支持重载。

它会缓存之前已经加载过的类来提高性能，它还会缓存加载失败的类的名字，当再次请求的时候就会直接抛出ClassNotFoundException异常，而不会在指定的仓库或jar包中搜索需要载入的类。

为了安全性，不让这个加载器加载某些类，类的名称存储在一个字符串数组变量triggerd中：

private static final String[] triggers = {
    "javax.servlet.Servlet"                     // Servlet API
};

此外，某些特殊包下的类也是不允许载入的：

private static final String[] packageTriggers = {
    "javax",                                     // Java extensions
    "org.xml.sax",                               // SAX 1 & 2
    "org.w3c.dom",                               // DOM 1 & 2
    "org.apache.xerces",                         // Xerces 1 & 2
    "org.apache.xalan"                           // Xalan
};

8.5.1 类缓存

java.lang.ClassLoader类会维护一个Vector<Class<?>>对象，保存已经载入的类，防止这些类在不使用的时候被垃圾回收了。

每个由WebappClassLoader载入的类（从/WEB-INF/classes，/WEB-INF/lib等目录下载入的类），都视为“资源”，“资源”使用ResourceEntry进行表示：

public class ResourceEntry {

    /**
     * The "last modified" time of the origin file at the time this class
     * was loaded, in milliseconds since the epoch.
     */
    public long lastModified = -1;


    /**
     * Binary content of the resource.
     */
    public byte[] binaryContent = null;


    /**
     * Loaded class.
     */
    public Class loadedClass = null;


    /**
     * URL source from where the object was loaded.
     */
    public URL source = null;


    /**
     * URL of the codebase from where the object was loaded.
     */
    public URL codeBase = null;


    /**
     * Manifest (if the resource was loaded from a JAR).
     */
    public Manifest manifest = null;


    /**
     * Certificates (if the resource was loaded from a JAR).
     */
    public Certificate[] certificates = null;

}

所有已经缓存的类会存储在一个HashMap中：

protected HashMap<String, ResourceEntry> resourceEntries = new HashMap<>();

8.5.2 载入类

先检查本地缓存
本地缓存没有，则检查上一层缓存（调用ClassLoader.findLoadedClass()）
如果两个缓存中没有，则使用系统类加载器加载，防止Web应用程序的类覆盖J2EE的类（原因前面讲了）
如果使用了安全管理器（与8.4.4对应），则检查是否允许载入该类，如果不允许则抛出ClassNotFoundException
如果设置了Delegate属性或待载入的类属于包触发器（packageTriggers）的包名，则调用父类加载器来载入相关类，如果父类加载器为null，则使用系统类加载器。
从当前仓库载入相关类
如果当前仓库没有需要的类，且标志位delegate关闭，则使用父类加载器；如果父类加载器为null，则使用系统类加载器
如果还是没找到需要的类，则抛出ClassNotFoundException异常。

九、Session管理

Catalina通过一个称为Session管理器的组件来管理建立的Session对象，该组件必须实现Manager接口。Session管理器必须与一个Context容器相关联。

我们可以通过request.getSession()来获取Session：

// HttpRequestBase.java
public HttpSession getSession() {
    return (getSession(true));
}

public HttpSession getSession(boolean create) {
    if( System.getSecurityManager() != null ) {
        PrivilegedGetSession dp = new PrivilegedGetSession(create);
        return (HttpSession)AccessController.doPrivileged(dp);
    }
    return doGetSession(create);
}

private HttpSession doGetSession(boolean create) {
    // There cannot be a session if no context has been assigned yet
    if (context == null)
        return (null);

    // Return the current session if it exists and is valid
    if ((session != null) && !session.isValid())
        session = null;
    if (session != null)
        return (session.getSession());


    // Return the requested session if it exists and is valid
    Manager manager = null;
    if (context != null)
        // 从context中获取session管理器
        manager = context.getManager();

    if (manager == null)
        return (null);      // Sessions are not supported

    if (requestedSessionId != null) {
        try {
            // 如果sessionId不为空，那么从管理器中寻找他
            session = manager.findSession(requestedSessionId);
        } catch (IOException e) {
            session = null;
        }
        if ((session != null) && !session.isValid())
            session = null;
        if (session != null) {
            return (session.getSession());
        }
    }

    // Create a new session if requested and the response is not committed
    if (!create)
        return (null);
    if ((context != null) && (response != null) &&
        context.getCookies() &&
        response.getResponse().isCommitted()) {
        throw new IllegalStateException
            (sm.getString("httpRequestBase.createCommitted"));
        }

        // 通过管理器创建一个session
        session = manager.createSession();
        if (session != null)
            return (session.getSession());
        else
            return (null);

    }

9.1 Session对象

9.1.1 Session接口

public interface Session {

    // 获取该session的标识符
    public String getId();

    public void setId(String id);

    // 获取session管理器
    public Manager getManager();


    // 设置session管理器
    public void setManager(Manager manager);

    // 返回客户端上次发送与此会话关联的请求的时间（可以通过该返回值判断session对象的有效性）
    public long getLastAccessedTime();

    // 设置session的有效性
    public void setValid(boolean isValid);

    // 当访问一个session实例的时候，session管理器会调用该方法修改session对象的最终访问时间
    public void access();

    // 将session设置为过期
    public void expire();

    // 获取一个被外观类包装的HttpSession类
    public HttpSession getSession();

}

9.1.2 StandardSession类

class StandardSession
        implements HttpSession, Session, Serializable {

    // 构造函数接收的是session管理器对象
    public StandardSession(Manager manager) {
        super();
        this.manager = manager;
        if (manager instanceof ManagerBase)
            this.debug = ((ManagerBase) manager).getDebug();
    }

    public HttpSession getSession() {
        if (facade == null)
            facade = new StandardSessionFacade(this);
        return facade;
    }

    // 设置session过期
    public void expire() {
        expire(true);
    }

    public void expire(boolean notify) {

        // Mark this session as "being expired" if needed
        if (expiring)
            return;
        // 将过期标识设置为true，有效标识设置为false
        expiring = true;
        setValid(false);

        // 从session管理器移除当前session对象
        if (manager != null)
            manager.remove(this);

        // 解绑与当前session相关联的任何对象
        String keys[] = keys(); // 获取session域的所有key值
        for (int i = 0; i < keys.length; i++)
            removeAttribute(keys[i], notify);

        // 触发session过期事件
        if (notify) {
            fireSessionEvent(Session.SESSION_DESTROYED_EVENT, null);
        }

        // Notify interested application event listeners
        // FIXME - Assumes we call listeners in reverse order
        Context context = (Context) manager.getContainer();
        Object listeners[] = context.getApplicationListeners();
        if (notify && (listeners != null)) {
            HttpSessionEvent event =
                    new HttpSessionEvent(getSession());
            for (int i = 0; i < listeners.length; i++) {
                int j = (listeners.length - 1) - i;
                if (!(listeners[j] instanceof HttpSessionListener))
                    continue;
                HttpSessionListener listener =
                        (HttpSessionListener) listeners[j];
                try {
                    // 触发容器事件
                    fireContainerEvent(context,
                            "beforeSessionDestroyed",
                            listener);
                    listener.sessionDestroyed(event);
                    fireContainerEvent(context,
                            "afterSessionDestroyed",
                            listener);
                } catch (Throwable t) {
                    try {
                        fireContainerEvent(context,
                                "afterSessionDestroyed",
                                listener);
                    } catch (Exception e) {
                        ;
                    }
                    // FIXME - should we do anything besides log these?
                    log(sm.getString("standardSession.sessionEvent"), t);
                }
            }
        }

        // We have completed expire of this session
        expiring = false;
        if ((manager != null) && (manager instanceof ManagerBase)) {
            recycle();
        }

    }

9.2 Manager

Session管理器负责管理Session对象（Session对象的创建、摧毁）。

ManagerBase抽象类对Manager接口进行了部分实现，它有2个直接子类：

StandardManager：将session对象储存在内存中，当Catalina关闭时，他会将Session对象存储到一个文件中（Lifecycle的stop方法中），重启后，又会将这些Session对象重新载入内存中。
PersistentManagerBase：它也是一个抽象类，用于将session对象存储到辅助存储器中。

public interface Manager {
    
    // 将Manager与容器相关联
    public void setContainer(Container container);

    // 创建一个session实例
    public Session createSession();

    // 将session实例添加到Session池中
    public void add(Session session);

    // 将session实例从Session池中移除
    public void remove(Session session);

    // 设置此管理器创建的session对象的默认最长存活时间
    public void setMaxInactiveInterval(int interval);

    // 持久化到储存器中
    public void unload() throws IOException;
    
    // 从储存器中拿出来
    public void load() throws ClassNotFoundException, IOException;

9.2.2 ManagerBase类

Context容器中所有活动的Session对象都存储在一个名为sessions的HashMap变量中：

protected HashMap sessions = new HashMap();

public void add(Session session) {
    synchronized (sessions) {
        sessions.put(session.getId(), session);
    }
}

9.2.3 StandardManager类

实现了Lifecyle接口，通过它对Session对象进行load和unload；会生成一个SESSION.ser的文件中。

session管理器还要负责销毁那些失效的Session对象：

public void run() {
    while (!threadDone) {
        threadSleep();
        processExpires();
    }
}

9.2.4 PersistentManagerBase类

// 使用stroe代表辅助储存器
private Store store = null;

本章剩下的看书把。

十一、StandardWrapper

11.1 方法调用序列

image

1、连接器创建request和response对象

2、连接器调用StandardContext实例的invoke()方法

3、StandardContext实例的invoke()方法会调用其管道对象（Pipline）的invoke()方法。最终会调用管道对象中的基础阀StandardContextValve实例的invoke()方法。

4、StandardContextValve实例的invoke()方法会获取相应的Wrapper实例处理Http请求，调用Wrapper实例的invoke方法。

5、同上，StandardWrapper实例的invoke()方法调用其管道对象的invoke()方法。

6、同上，调用基础阀StandardWrapperValve实例的invoke()方法，invoke方法会调用Wrapper实例的allocate()方法获取servlet实例。

7、allocate()调用load()方法载入相应的servlet类，如果已经载入，无需重新载入。

8、load()方法会调用servlet实例的init()方法

9、StandardWrapper实例调用servlet实例的service()方法。

11.3 StandardWrapper

StandardWrapper对象的主要任务是载入（loader.load()）它所代表的servlet类，并进行实例化（clazz.newInstance()）。

11.3.1 分配servlet实例（Wrapper的allocate()方法）

public Servlet allocate() throws ServletException {

    // SingleThreadedModel现在已经废弃，就不介绍了
    if (!singleThreadModel) {

        // 双重检查锁，检查servlet之前是否加载过
        if (instance == null) {
            synchronized (this) {
                if (instance == null) {
                    try {
                        instance = loadServlet();
                    } catch (ServletException e) {
                        throw e;
                    } catch (Throwable e) {
                        throw new ServletException
                                (sm.getString("standardWrapper.allocate"), e);
                    }
                }
            }
        }

        if (!singleThreadModel) {
            if (debug >= 2)
                log("  Returning non-STM instance");
            // 将已分配的计数+1
            countAllocated++;
            return (instance);
        }

    }
}

11.3.2 载入Servlet类（Wrapper的load()方法）

public synchronized void load() throws ServletException {
    instance = loadServlet();
}

// allocate()和load()方法都调用了该方法
public synchronized Servlet loadServlet() throws ServletException {

    // 如果之前已经加载过了，直接返回
    if (instance != null)
        return instance;

    PrintStream out = System.out;
    SystemLogHandler.startCapture();

    Servlet servlet = null;
    try {
        // 将servlet类的类名赋值给actualClass
        String actualClass = servletClass;
        // 检查请求的servlet是不是一个jsp页面，如果是的话重新赋值actualClass
        if ((actualClass == null) && (jspFile != null)) {
            Wrapper jspWrapper = (Wrapper)
                    ((Context) getParent()).findChild(Constants.JSP_SERVLET_NAME);
            if (jspWrapper != null)
                actualClass = jspWrapper.getServletClass();
        }

        // 如果它是servlet，但是没有setServletClass()就会报错
        if (actualClass == null) {
            unavailable(null);
            throw new ServletException
                    (sm.getString("standardWrapper.notClass", getName()));
        }

        // 获取载入器（如果当前容器没有载入器，就获取它父容器的载入器）
        Loader loader = getLoader();
        if (loader == null) {
            unavailable(null);
            throw new ServletException
                    (sm.getString("standardWrapper.missingLoader", getName()));
        }

        // 获取载入器中的类加载器
        ClassLoader classLoader = loader.getClassLoader();

        // Catalina提供了一些用于访问servlet容器内部数据专用的servlet类，如果要加载的类是这种专用的servlet（参见19章），则将ClassLoader辅值为当前类的加载器
        if (isContainerProvidedServlet(actualClass)) {
            classLoader = this.getClass().getClassLoader();
            log(sm.getString
                    ("standardWrapper.containerServlet", getName()));
        }

        // Load the specified servlet class from the appropriate class loader
        Class classClass = null;
        try {
            if (classLoader != null) {
                System.out.println("Using classLoader.loadClass");
                // 使用类加载器加载该类
                classClass = classLoader.loadClass(actualClass);
            } else {
                System.out.println("Using forName");
                classClass = Class.forName(actualClass);
            }
        } catch (ClassNotFoundException e) {
            unavailable(null);
            throw new ServletException
                    (sm.getString("standardWrapper.missingClass", actualClass),
                            e);
        }
        if (classClass == null) {
            unavailable(null);
            throw new ServletException
                    (sm.getString("standardWrapper.missingClass", actualClass));
        }

        // Instantiate and initialize an instance of the servlet class itself
        try {
            // 实例化
            servlet = (Servlet) classClass.newInstance();
        } catch (ClassCastException e) {
            unavailable(null);
            // Restore the context ClassLoader
            throw new ServletException
                    (sm.getString("standardWrapper.notServlet", actualClass), e);
        } catch (Throwable e) {
            unavailable(null);
            // Restore the context ClassLoader
            throw new ServletException
                    (sm.getString("standardWrapper.instantiate", actualClass), e);
        }

        // 检查该类是否允许载入
        if (!isServletAllowed(servlet)) {
            throw new SecurityException
                    (sm.getString("standardWrapper.privilegedServlet",
                            actualClass));
        }

        // 检查该servlet是否实现了ContainerServlet接口（参见19章），如果实现了，将当前Wrapper对象设置进去
        if ((servlet instanceof ContainerServlet) &&
                isContainerProvidedServlet(actualClass)) {
            System.out.println("calling setWrapper");
            ((ContainerServlet) servlet).setWrapper(this);
            System.out.println("after calling setWrapper");
        }

        try {
            // 触发BEFORE_INIT_EVENT事件
            instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT, servlet);

            // 初始化servlet
            servlet.init(facade);

            // loadOnStartup：此servlet的启动时加载顺序值，负值表示首次调用时加载
            // 如果是jsp页面，调用该servlet的service方法
            if ((loadOnStartup > 0) && (jspFile != null)) {
                // Invoking jspInit
                HttpRequestBase req = new HttpRequestBase();
                HttpResponseBase res = new HttpResponseBase();
                req.setServletPath(jspFile);
                req.setQueryString("jsp_precompile=true");
                servlet.service(req, res);
            }
            // 触发AFTER_INIT_EVENT事件
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT, servlet);
        } catch (UnavailableException f) {
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
                    servlet, f);
            unavailable(f);
            throw f;
        } catch (ServletException f) {
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
                    servlet, f);
            // If the servlet wanted to be unavailable it would have
            // said so, so do not call unavailable(null).
            throw f;
        } catch (Throwable f) {
            instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
                    servlet, f);
            // If the servlet wanted to be unavailable it would have
            // said so, so do not call unavailable(null).
            throw new ServletException
                    (sm.getString("standardWrapper.initException", getName()), f);
        }

    } finally {
        String log = SystemLogHandler.stopCapture();
        if (log != null && log.length() > 0) {
            if (getServletContext() != null) {
                getServletContext().log(log);
            } else {
                out.println(log);
            }
        }
    }
    return servlet;

}

11.3.3 ServletConfig对象

StandardWrapper本身就是ServletConfig对象。

上面loadServlet()方法中加载完servlet之后对其进行初始化，init()方法需要传入一个ServletConfig对象：

// 初始化servlet；因为不信任servlet程序员所以使用一个门面进行包装一下
servlet.init(facade);

public interface ServletConfig {
    String getServletName();

    ServletContext getServletContext();

    String getInitParameter(String var1);

    Enumeration getInitParameterNames();
}

public final class StandardWrapper
        extends ContainerBase
        implements ServletConfig, Wrapper {

    public String getServletName() {
        return name;
    }

    public ServletContext getServletContext() {
        if (parent == null)
            return (null);
        else if (!(parent instanceof Context))
            return (null);
        else
            return (((Context) parent).getServletContext());
    }

    private HashMap parameters = new HashMap();

    public String getInitParameter(String name) {
        return (findInitParameter(name));
    }

    public String findInitParameter(String name) {
        synchronized (parameters) {
            return ((String) parameters.get(name));
        }
    }

    public Enumeration getInitParameterNames() {
        synchronized (parameters) {
            return (new Enumerator(parameters.keySet()));
        }
    }

11.3.4 Servlet容器的父子关系

Wrapper实例代表一个servlet实例，不能再有子容器，所以调用它的addChildren()方法会报错。

11.5 StandardWrapperValve（基础阀）

它主要要干以下两个操作：

执行与该servlet实例关联的全部过滤器（Filter）
调用servlet实例的service()方法

它的invoke方法：

public void invoke(Request request, Response response,
                       ValveContext valveContext)
            throws IOException, ServletException {
        ...

        // Allocate a servlet instance to process this request
        try {
            if (!unavailable) {
                // 获取servlet实例
                servlet = wrapper.allocate();
            }
        } catch (ServletException e) {
            log(sm.getString("standardWrapper.allocateException",
                    wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
            servlet = null;
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.allocateException",
                    wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
            servlet = null;
        }

        // Acknowlege the request
        try {
            response.sendAcknowledgement();
        } catch (IOException e) {
            sreq.removeAttribute(Globals.JSP_FILE_ATTR);
            log(sm.getString("standardWrapper.acknowledgeException",
                    wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.acknowledgeException",
                    wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
            servlet = null;
        }

        // 创建过滤器链
        ApplicationFilterChain filterChain = createFilterChain(request, servlet);

        // Call the filter chain for this request
        // NOTE: This also calls the servlet's service() method
        try {
            String jspFile = wrapper.getJspFile();
            if (jspFile != null)
                sreq.setAttribute(Globals.JSP_FILE_ATTR, jspFile);
            else
                sreq.removeAttribute(Globals.JSP_FILE_ATTR);
            if ((servlet != null) && (filterChain != null)) {

                // 调用过滤器链
                filterChain.doFilter(sreq, sres);
            }
            sreq.removeAttribute(Globals.JSP_FILE_ATTR);
        } catch (IOException e) {
            sreq.removeAttribute(Globals.JSP_FILE_ATTR);
            log(sm.getString("standardWrapper.serviceException",
                    wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
        } catch (UnavailableException e) {
            sreq.removeAttribute(Globals.JSP_FILE_ATTR);
            log(sm.getString("standardWrapper.serviceException",
                    wrapper.getName()), e);
            //            throwable = e;
            //            exception(request, response, e);
            wrapper.unavailable(e);
            long available = wrapper.getAvailable();
            if ((available > 0L) && (available < Long.MAX_VALUE))
                hres.setDateHeader("Retry-After", available);
            hres.sendError(HttpServletResponse.SC_SERVICE_UNAVAILABLE,
                    sm.getString("standardWrapper.isUnavailable",
                            wrapper.getName()));
            // Do not save exception in 'throwable', because we
            // do not want to do exception(request, response, e) processing
        } catch (ServletException e) {
            sreq.removeAttribute(Globals.JSP_FILE_ATTR);
            log(sm.getString("standardWrapper.serviceException",
                    wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
        } catch (Throwable e) {
            sreq.removeAttribute(Globals.JSP_FILE_ATTR);
            log(sm.getString("standardWrapper.serviceException",
                    wrapper.getName()), e);
            throwable = e;
            exception(request, response, e);
        }

        // Release the filter chain (if any) for this request
        try {
            if (filterChain != null)
                // 释放过滤器链
                filterChain.release();
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.releaseFilters",
                    wrapper.getName()), e);
            if (throwable == null) {
                throwable = e;
                exception(request, response, e);
            }
        }

        // Deallocate the allocated servlet instance
        try {
            if (servlet != null) {
                // 释放对该servlet的“引用计数”
                wrapper.deallocate(servlet);
            }
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.deallocateException",
                    wrapper.getName()), e);
            if (throwable == null) {
                throwable = e;
                exception(request, response, e);
            }
        }

        // If this servlet has been marked permanently unavailable,
        // unload it and release this instance
        try {
            if ((servlet != null) &&
                    (wrapper.getAvailable() == Long.MAX_VALUE)) {
                // 如果该servlet类被标记为永久不可用，则调用Wrapper.unload()方法
                wrapper.unload();
            }
        } catch (Throwable e) {
            log(sm.getString("standardWrapper.unloadException",
                    wrapper.getName()), e);
            if (throwable == null) {
                throwable = e;
                exception(request, response, e);
            }
        }

    }

11.6 FilterDef

// FilterDef类中的每个属性表示在定义filter元素时声明的子元素（web.xml）。parameters中保存的是初始化过滤器时所需要的参数。
public final class FilterDef {

    /**
     * The description of this filter.
     */
    private String description = null;

    /**
     * The display name of this filter.
     */
    private String displayName = null;

    /**
     * The fully qualified name of the Java class that implements this filter.
     */
    private String filterClass = null;

    /**
     * The name of this filter, which must be unique among the filters
     * defined for a particular web application.
     */
    private String filterName = null;

    /**
     * The large icon associated with this filter.
     */
    private String largeIcon = null;

    /**
     * The set of initialization parameters for this filter, keyed by
     * parameter name.
     */
    private Map parameters = new HashMap();


    /**
     * The small icon associated with this filter.
     */
    private String smallIcon = null;


    // --------------------------------------------------------- Public Methods


    /**
     * Add an initialization parameter to the set of parameters associated
     * with this filter.
     *
     * @param name The initialization parameter name
     * @param value The initialization parameter value
     */
    public void addInitParameter(String name, String value) {

        parameters.put(name, value);

    }

11.7 ApplicationFilterConfig类

final class ApplicationFilterConfig implements FilterConfig {

    // context对象表示一个web应用程序
    // filterDef表示一个过滤器的定义
    public ApplicationFilterConfig(Context context, FilterDef filterDef)
        throws ClassCastException, ClassNotFoundException,
               IllegalAccessException, InstantiationException,
               ServletException {

        super();
        this.context = context;
        setFilterDef(filterDef);

        // 尝试从filterDef中获取Filter对象，如果为空则通过反射的形式创建filter对象
        if (filterDef.getFilter() == null) {
            getFilter();
        } else {
            this.filter = filterDef.getFilter();
            getInstanceManager().newInstance(filter);
            initFilter();
        }
    }

    // 负责载入并实例化一个过滤器类
    Filter getFilter() throws ClassCastException, ClassNotFoundException,
        IllegalAccessException, InstantiationException, ServletException {

        // Return the existing filter instance, if any
        if (this.filter != null)
            return (this.filter);

        // 获取过滤器的全类路径
        String filterClass = filterDef.getFilterClass();
        ClassLoader classLoader = null;
        if (filterClass.startsWith("org.apache.catalina."))
            classLoader = this.getClass().getClassLoader();
        else
            classLoader = context.getLoader().getClassLoader();

        ClassLoader oldCtxClassLoader =
            Thread.currentThread().getContextClassLoader();

        // 使用类加载器加载该类
        Class clazz = classLoader.loadClass(filterClass);
        // 构造+初始化
        this.filter = (Filter) clazz.newInstance();
        filter.init(this);
        return (this.filter);

    }

11.9 ApplicationFilterChain类

Filter的doFilter()方法会接受一个ApplicationFilterChain对象，可以直接调用chain.doFilter()调用下一个过滤器。

十二、StandardContext类

Context容器需要其它组件支持，例如Session管理器，载入器等。

12.1 StandardContext的配置

StandardContext实例创建后会调用它的start()方法，但是可能会启动失败，这时它的available属性会被设置为false，该属性表明StandardContext对象是否可用。

StandardContext类的configured属性是一个布尔变量，表明StandardContext实例是否正确设置。当start()方法被调用时，他会触发一个生命周期事件，事件触发监听器（ContextConfig），对StandardContext实例进行配置。

12.1.2 启动流程

1、触发BEFORE_START事件

2、将available属性设置为false

3、将configured属性设置为false

4、配置资源（设置web应用的目录）

5、设置载入器（setLoder(new WebappLoader())）

6、设置session管理器（setManger(new Manger())）

7、初始化字符集映射器

8、启动与该Context容器相关联的组件

9、启动子容器

10、启动管道对象

11、启动session管理器

12、触发START事件，此时ContextConfig监听器会对Context进行一些配置操作，如果设置成功就会将configured属性设置为true

13、检查configured属性的值，如果为true则调用postWelcomePages()方法，载入哪些在启动时就载入的子容器（Wrapper实例），将available属性设置为true。若configured属性为false

12.1.3 invoke()方法

该方法由与Context相关的连接器或者父容器（Host）的invoke()方法调用。

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

    // 如果正在重载（paused属性为true），则等待
    while (getPaused()) {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            ;
        }
    }

    // Normal request processing
    if (swallowOutput) {
        try {
            SystemLogHandler.startCapture();
            // 调用父类ContainerBase的invoke()方法
            super.invoke(request, response);
        } finally {
            String log = SystemLogHandler.stopCapture();
            if (log != null && log.length() > 0) {
                log(log);
            }
        }
    } else {
        super.invoke(request, response);
    }

}

public void invoke(Request request, Response response)
        throws IOException, ServletException {
    pipeline.invoke(request, response);
}

12.2 映射器

Tomcat5中映射器已经移除，通过request对象获取Wrapper实例：

// 是不是解析URI的工作交给了连接器？？
Wrapper wrapper = request.getWrapper();

12.3 对重载的支持

StandardContext通过reloadable属性来表明应用程序是否启用了重载功能，当启用了重载功能后，web.xml文件发生变化或WEB-INF/classes目录下的其中一个文件被重新编译后，应用程序就会重载。

StandardContext时通过其载入器实现应用程序的重载的（见8.4）。WebappLoader实现了Runable接口使用另一个线程来不断检查WEB-INF目录中的所有类和JAR文件的时间戳。只需要调用WebappLoader的setContainer()方法将容器和载入器相关联就可以启动该检查线程。

// WebappLoader.java

public void setContainer(Container container) {

    // Deregister from the old Container (if any)
    if ((this.container != null) && (this.container instanceof Context))
        ((Context) this.container).removePropertyChangeListener(this);

    // Process this property change
    Container oldContainer = this.container;
    this.container = container;
    support.firePropertyChange("container", oldContainer, this.container);

    // Register with the new Container (if any)
    if ((this.container != null) && (this.container instanceof Context)) {
        // 启动检查线程
        setReloadable( ((Context) this.container).getReloadable() );
        ((Context) this.container).addPropertyChangeListener(this);
    }

}

public void setReloadable(boolean reloadable) {

    // Process this property change
    boolean oldReloadable = this.reloadable;
    this.reloadable = reloadable;
    support.firePropertyChange("reloadable",
                                new Boolean(oldReloadable),
                                new Boolean(this.reloadable));

    // Start or stop our background thread if required
    if (!started)
        return;
    // 之前没启动，现在启动了，则启动重载功能
    if (!oldReloadable && this.reloadable)
        // run()方法参见8.4.5
        threadStart();
    // 之前启动了，现在没启动，则关闭
    else if (oldReloadable && !this.reloadable)
        threadStop();

}

12.4 backgroundProcess()方法

Context容器的运行需要其它组件的支持，例如：载入器、Session管理器。而它们大多都需要执行一个后台任务，Tomcat4中它们都实现了Runable接口，拥有自己的线程。

在Tomcat5中为了节省资源，所有后台处理共享一个线程。这个共享线程有ContainerBase的start()方法调用threadStart()创建。

protected void threadStart() {

    if (thread != null)
        return;
    if (backgroundProcessorDelay <= 0)
        return;

    threadDone = false;
    String threadName = "ContainerBackgroundProcessor[" + toString() + "]";
    thread = new Thread(new ContainerBackgroundProcessor(), threadName);
    thread.setDaemon(true);
    thread.start();

}


protected class ContainerBackgroundProcessor implements Runnable {

    @Override
    public void run() {
        Throwable t = null;
        String unexpectedDeathMessage = sm.getString(
                "containerBase.backgroundProcess.unexpectedThreadDeath",
                Thread.currentThread().getName());
        try {
            while (!threadDone) {
                try {
                    Thread.sleep(backgroundProcessorDelay * 1000L);
                } catch (InterruptedException e) {
                    // Ignore
                }
                if (!threadDone) {
                    processChildren(ContainerBase.this);
                }
            }
        } catch (RuntimeException|Error e) {
            t = e;
            throw e;
        } finally {
            if (!threadDone) {
                log.error(unexpectedDeathMessage, t);
            }
        }
    }

    protected void processChildren(Container container) {
        ClassLoader originalClassLoader = null;

        try {
            if (container instanceof Context) {
                Loader loader = ((Context) container).getLoader();
                // Loader will be null for FailedContext instances
                if (loader == null) {
                    return;
                }

                // Ensure background processing for Contexts and Wrappers
                // is performed under the web app's class loader
                originalClassLoader = ((Context) container).bind(false, null);
            }
            // 调用容器的后台进程
            container.backgroundProcess();
            Container[] children = container.findChildren();
            for (int i = 0; i < children.length; i++) {
                if (children[i].getBackgroundProcessorDelay() <= 0) {
                    processChildren(children[i]);
                }
            }
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            log.error("Exception invoking periodic operation: ", t);
        } finally {
            if (container instanceof Context) {
                ((Context) container).unbind(false, originalClassLoader);
            }
        }
    }
}

// StandardContext的backgroundProcess()方法
@Override
public void backgroundProcess() {

    if (!getState().isAvailable())
        return;

    Loader loader = getLoader();
    if (loader != null) {
        try {
            loader.backgroundProcess();
        } catch (Exception e) {
            log.warn(sm.getString(
                    "standardContext.backgroundProcess.loader", loader), e);
        }
    }
    Manager manager = getManager();
    if (manager != null) {
        try {
            manager.backgroundProcess();
        } catch (Exception e) {
            log.warn(sm.getString(
                    "standardContext.backgroundProcess.manager", manager),
                    e);
        }
    }
    WebResourceRoot resources = getResources();
    if (resources != null) {
        try {
            resources.backgroundProcess();
        } catch (Exception e) {
            log.warn(sm.getString(
                    "standardContext.backgroundProcess.resources",
                    resources), e);
        }
    }
    InstanceManager instanceManager = getInstanceManager();
    if (instanceManager instanceof DefaultInstanceManager) {
        try {
            ((DefaultInstanceManager)instanceManager).backgroundProcess();
        } catch (Exception e) {
            log.warn(sm.getString(
                    "standardContext.backgroundProcess.instanceManager",
                    resources), e);
        }
    }
    super.backgroundProcess();
}

十三、Host和Engine

如果想要在同一个Tomcat部署多个Context容器的话，就需要使用Host容器。

13.1 Host接口

// 用于返回用于处理引入的Http请求的Context容器实例（Tomcat5后已经移除，从request对象中获取）
Context map(String uri);

13.2 StandardHost

public class StandardHost
    extends ContainerBase
    implements Deployer, Host {

    public StandardHost() {
        super();
        pipeline.setBasic(new StandardHostValve());
    }

    public synchronized void start() throws LifecycleException {
        // Set error report valve
        if ((errorReportValveClass != null)
            && (!errorReportValveClass.equals(""))) {
            try {
                Valve valve = (Valve) Class.forName(errorReportValveClass)
                    .newInstance();
                // 添加一个ErrorReportValve阀
                addValve(valve);
            } catch (Throwable t) {
                log(sm.getString
                    ("standardHost.invalidErrorReportValveClass",
                     errorReportValveClass));
            }
        }

        // 添加一个ErrorDispatcherValve阀
        addValve(new ErrorDispatcherValve());

        super.start();
    }

后面的放弃了，感觉没啥用...

十四、服务器组件（Service）和服务组件（Server）

Server代表着整个tomcat

Service作用将容器（engine）和连接器组装起来，为外界提供服务

<Server port="8005" shutdown="SHUTDOWN">
    <Service name="Catalina">
        <Connector port="8080" protocol="HTTP/1.1"
                    connectionTimeout="20000"
                    redirectPort="8443" />
        <!-- Define an AJP 1.3 Connector on port 8009 -->
        <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
        
        <Engine name="Catalina" defaultHost="localhost">
            <Host name="localhost"  appBase="webapps/1"
                unpackWARs="true" autoDeploy="true">
            </Host>
            <Host name="www.baidu.com"  appBase="webapps/3"
                unpackWARs="true" autoDeploy="true">
            </Host>
        </Engine>
    </Service>
</Server>

14.1 服务器组件

它提供了一种优雅的方法来启动/关闭整个系统，不需要再对连接器和容器分别启动/关闭。

public interface Server {
    
    // 关闭命令
    String getShutdown();

    // 监听的端口号
    int getPort();

    // 添加服务组件
    void addService(Service service);

    // 删除服务组件
    void removeService(Service service);

14.2 StandardServer类

StandardServer类有4个与生命周期相关的方法，分别是initialize()方法、start()方法、stop()方法、await()方法。

调用await()方法后会一直阻塞住，直到8085端口上接收到关闭命令。当await()方法返回后，会运行stop()方法来关闭其下的所有子组件（Catalina的start()方法调用的）。

public final class StandardServer
    implements Lifecycle, Server {

14.2.1 initialize()方法

初始化服务器组件

public void initialize() throws LifecycleException {
    // 使用这个变量防止服务器组件初始化两次
    if (initialized)
        throw new LifecycleException (sm.getString("standardServer.initialize.initialized"));
    initialized = true;

    // Initialize our defined Services
    for (int i = 0; i < services.length; i++) {
        // 初始化它下面的服务组件
        services[i].initialize();
    }
}

14.2.2 start()方法

启动服务器组件

public void start() throws LifecycleException {

    // Validate and update our current component state
    if (started)
        throw new LifecycleException
            (sm.getString("standardServer.start.started"));
    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_START_EVENT, null);

    lifecycle.fireLifecycleEvent(START_EVENT, null);
    started = true;

    // Start our defined Services
    synchronized (services) {
        for (int i = 0; i < services.length; i++) {
            // 启动它下面的服务组件，服务组件启动时会启动连接器组件和servlet容器
            if (services[i] instanceof Lifecycle)
                ((Lifecycle) services[i]).start();
        }
    }

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_START_EVENT, null);

}

14.2.3 stop()方法

关闭服务器组件

public void stop() throws LifecycleException {

    // Validate and update our current component state
    if (!started)
        throw new LifecycleException
            (sm.getString("standardServer.stop.notStarted"));

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(BEFORE_STOP_EVENT, null);

    lifecycle.fireLifecycleEvent(STOP_EVENT, null);
    started = false;

    // 调用下面的服务组件的stop方法
    for (int i = 0; i < services.length; i++) {
        if (services[i] instanceof Lifecycle)
            ((Lifecycle) services[i]).stop();
    }

    // Notify our interested LifecycleListeners
    lifecycle.fireLifecycleEvent(AFTER_STOP_EVENT, null);

}

14.2.4 await()方法

负责等待关闭整个Tomcat部署的命令

14.3 Service接口

一个服务组件可以有一个servlet容器和多个连接器实例。

14.1 StandardService类

它的initialize()方法用于初始化添加到其中的所有连接器。

start()方法负责启动被添加到该服务组件的连接器和servlet容器。

十五、Digester库

Digester可以将xml转换成对象。

15.2 ContextConfig（见12.1）

与其它容器不同，Context容器必须设置一个监听器来对Context进行配置，设置成功后将configured属性为true。

工作内容：

他会为Context的pipline添加一个许可阀和验证器阀；
读取和解析默认的web.xml和应用自定义的web.xml文件，将xml转换成java对象；
为每个servlet创建一个StandardWrapper对象。

public void lifecycleEvent(LifecycleEvent event) {

    // Identify the context we are associated with
    try {
        context = (Context) event.getLifecycle();
        if (context instanceof StandardContext) {
            int contextDebug = ((StandardContext) context).getDebug();
            if (contextDebug > this.debug)
                this.debug = contextDebug;
        }
    } catch (ClassCastException e) {
        log(sm.getString("contextConfig.cce", event.getLifecycle()), e);
        return;
    }

    // 处理开始和结束事件
    if (event.getType().equals(Lifecycle.START_EVENT))
        start();
    else if (event.getType().equals(Lifecycle.STOP_EVENT))
        stop();

}

private synchronized void start() {

    if (debug > 0)
        log(sm.getString("contextConfig.start"));
    context.setConfigured(false);
    ok = true;

    // Set properties based on DefaultContext
    Container container = context.getParent();
    if( !context.getOverride() ) {
        if( container instanceof Host ) {
            // 和DefaultContext有关（它加载了好多的东西，包括listener）
            ((Host)container).importDefaultContext(context);
            container = container.getParent();
        }
        if( container instanceof Engine ) {
            // 和DefaultContext有关（它加载了好多的东西，包括listener）
            ((Engine)container).importDefaultContext(context);
        }
    }

    // 读取默认的web.xml
    defaultConfig();
    // 读取应用的web.xml
    applicationConfig();
    if (ok) {
        validateSecurityRoles();
    }

    // Scan tag library descriptor files for additional listener classes
    if (ok) {
        try {
            tldScan();
        } catch (Exception e) {
            log(e.getMessage(), e);
            ok = false;
        }
    }

    // Configure a certificates exposer valve, if required
    if (ok)
        certificatesConfig();

    // Configure an authenticator if we need one
    if (ok)
        authenticatorConfig();

    // Dump the contents of this pipeline if requested
    if ((debug >= 1) && (context instanceof ContainerBase)) {
        log("Pipline Configuration:");
        Pipeline pipeline = ((ContainerBase) context).getPipeline();
        Valve valves[] = null;
        if (pipeline != null)
            valves = pipeline.getValves();
        if (valves != null) {
            for (int i = 0; i < valves.length; i++) {
                log("  " + valves[i].getInfo());
            }
        }
        log("======================");
    }

    // Make our application available if no problems were encountered
    if (ok)
        context.setConfigured(true);
    else {
        log(sm.getString("contextConfig.unavailable"));
        context.setConfigured(false);
    }

}

十六、关闭钩子

Java虚拟机关闭之前会先启动所有的关闭钩子。

Tomcat利用关闭钩子进行清理工作（调用组件们的stop()方法）

protected class CatalinaShutdownHook extends Thread {

    public void run() {

        if (server != null) {
            try {
                ((Lifecycle) server).stop();
            } catch (LifecycleException e) {
                System.out.println("Catalina.stop: " + e);
                e.printStackTrace(System.out);
                if (e.getThrowable() != null) {
                    System.out.println("----- Root Cause -----");
                    e.getThrowable().printStackTrace(System.out);
                }
            }
        }

    }
}

十七、启动Tomcat

Tomcat启动时会用到两个类，分别时Catalina类和Bootstrap类。

Catalina类用于启动和关闭Server对象，并负责解析Tomcat配置文件server.xml。

Bootstrap类是一个入口点，负责创建Catalina实例，并调用其process方法。

17.1 Catalina类

其中包含一个Digester对象，用于解析server.xml。

process()方法：

public void process(String args[]) {
    // 设置连个系统属性，分别时catalina.home和catalina.base.catalina.home
    setCatalinaHome();
    setCatalinaBase();
    try {
        // argument()处理命令行参数
        if (arguments(args))
            // 
            execute();
    } catch (Exception e) {
        e.printStackTrace(System.out);
    }
}

protected void execute() throws Exception {
    if (starting)
        start();
    else if (stopping)
        stop();
}

17.1.1 start()方法

start()方法部分代码：

// 使用Digester对象解析server.xml
...

if (server instanceof Lifecycle) {
    try {
        // 初始化服务器组件
        server.initialize();
        // 启动服务器组件
        ((Lifecycle) server).start();
        try {
            // 注册关闭时的钩子
            Runtime.getRuntime().addShutdownHook(shutdownHook);
        } catch (Throwable t) {
            // This will fail on JDK 1.2. Ignoring, as Tomcat can run
            // fine without the shutdown hook.
        }
        // Wait for the server to be told to shut down
        server.await();
    } catch (LifecycleException e) {
        System.out.println("Catalina.start: " + e);
        e.printStackTrace(System.out);
        if (e.getThrowable() != null) {
            System.out.println("----- Root Cause -----");
            e.getThrowable().printStackTrace(System.out);
        }
    }
}

17.1.2 stop()方法

protected void stop() {

    // Create and execute our Digester
    Digester digester = createStopDigester();
    File file = configFile();
    try {
        InputSource is =
            new InputSource("file://" + file.getAbsolutePath());
        FileInputStream fis = new FileInputStream(file);
        is.setByteStream(fis);
        digester.push(this);
        digester.parse(is);
        fis.close();
    } catch (Exception e) {
        System.out.println("Catalina.stop: " + e);
        e.printStackTrace(System.out);
        System.exit(1);
    }

    // Stop the existing server
    try {
        // 向server组件监听的端口发送SHUTDOWN命令
        Socket socket = new Socket("127.0.0.1", server.getPort());
        OutputStream stream = socket.getOutputStream();
        String shutdown = server.getShutdown();
        for (int i = 0; i < shutdown.length(); i++)
            stream.write(shutdown.charAt(i));
        stream.flush();
        stream.close();
        socket.close();
    } catch (IOException e) {
        System.out.println("Catalina.stop: " + e);
        e.printStackTrace(System.out);
        System.exit(1);
    }

}

Bootstrap主要是创建了3个类加载器，将sharedClassLoader设置给了Catalina的parentClassLoader属性。

十八、部署器

要使用一个web应用程序，必须要将该应用程序的Context实例部署到一个Host实例中。在Tomcat中，Context实例可以用war文件的形式来部署。

部署器是Deployer接口的实例。部署器与Host实例相关联，用来安装Context实例（既创建一个StandardContext实例，并添加到Host实例中）

Tomcat8中已经找不到它的身影。