tomcat(5)servlet容器

// invoke each valve added to the pipeline，先是非基础阀调用 invoke方法
for(;;){
valve[i].invoke();
}
// then, invoke the basic valve， 后是基础阀调用 invoke方法（基础阀最后一个调用invoke方法）
basicValve.invoke(...);
public void invoke(Request request, Response response) // SimplePipeline.invoke()
throws IOException, ServletException {
// Invoke the first Valve in this pipeline for this request
(new SimplePipelineValveContext()).invokeNext(request, response);
}
public void invokeNext(Request request, Response response) // SimplePipeline.invokeNext()
throws IOException, ServletException {
int subscript = stage;
stage = stage + 1;
// Invoke the requested Valve for the current request thread
if (subscript < valves.length) {
valves[subscript].invoke(request, response, this);
}
else if ((subscript == valves.length) && (basic != null)) {
basic.invoke(request, response, this);
}
else {
throw new ServletException("No valve");
}
}
} // end of inner class

public interface Pipeline {
public Valve getBasic();
public void setBasic(Valve valve);
public void addValve(Valve valve);
public Valve[] getValves();
public void invoke(Request request, Response response)
throws IOException, ServletException;
public void removeValve(Valve valve);
}

public interface Valve {
public String getInfo();
　　 public void invoke(Request request, Response response,ValveContext context) throws IOException, ServletException;

public interface Contained {
public Container getContainer();
public void setContainer(Container container);
}

public interface Wrapper extends Container {
public long getAvailable();
public void setAvailable(long available);
public String getJspFile();
public void setJspFile(String jspFile);
public int getLoadOnStartup();
public void setLoadOnStartup(int value);
public String getRunAs();
public void setRunAs(String runAs);
public String getServletClass();
public void setServletClass(String servletClass);
public boolean isUnavailable();
public void addInitParameter(String name, String value);
public void addInstanceListener(InstanceListener listener);
public void addSecurityReference(String name, String link);
public Servlet allocate() throws ServletException;
public void deallocate(Servlet servlet) throws ServletException;
public String findInitParameter(String name);
public String[] findInitParameters();
public String findSecurityReference(String name);
public String[] findSecurityReferences();
public void load() throws ServletException;
public void removeInitParameter(String name);
public void removeInstanceListener(InstanceListener listener);
public void removeSecurityReference(String name);
public void unavailable(UnavailableException unavailable);
public void unload() throws ServletException;
}

public class SimpleLoader implements Loader {

public static final String WEB_ROOT =
System.getProperty("user.dir") + File.separator  + "webroot";

ClassLoader classLoader = null;
Container container = null;

public SimpleLoader() {
try {
URL[] urls = new URL[1];
URLStreamHandler streamHandler = null;
File classPath = new File(WEB_ROOT);
String repository = (new URL("file", null, classPath.getCanonicalPath() + File.separator)).toString() ;
urls[0] = new URL(null, repository, streamHandler);
classLoader = new URLClassLoader(urls);
}
catch (IOException e) {
System.out.println(e.toString() );
}
}

public class SimplePipeline implements Pipeline {

public SimplePipeline(Container container) {
setContainer(container);
}

// The basic Valve (if any) associated with this Pipeline.
protected Valve basic = null;
// The Container with which this Pipeline is associated.
protected Container container = null;
// the array of Valves
protected Valve valves[] = new Valve[0];

public void setContainer(Container container) {
this.container = container;
}

public Valve getBasic() {
return basic;
}

public void setBasic(Valve valve) {
this.basic = valve;
((Contained) valve).setContainer(container);
}

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

synchronized (valves) {
Valve results[] = new Valve[valves.length +1];
System.arraycopy(valves, 0, results, 0, valves.length);
results[valves.length] = valve;
valves = results;
}
}

public Valve[] getValves() {
return valves;
}

public void invoke(Request request, Response response)
throws IOException, ServletException {
// Invoke the first Valve in this pipeline for this request
(new SimplePipelineValveContext()).invokeNext(request, response);
}

public void removeValve(Valve valve) {
}

// this class is copied from org.apache.catalina.core.StandardPipeline class's
// StandardPipelineValveContext inner class.
protected class SimplePipelineValveContext implements ValveContext {

protected int stage = 0;

public String getInfo() {
return null;
}

public void invokeNext(Request request, Response response)
throws IOException, ServletException {
int subscript = stage;
stage = stage + 1;
// Invoke the requested Valve for the current request thread
if (subscript < valves.length) {
valves[subscript].invoke(request, response, this);
}
else if ((subscript == valves.length) && (basic != null)) {
basic.invoke(request, response, this);
}
else {
throw new ServletException("No valve");
}
}
} // end of inner class
}

public class SimpleWrapper implements Wrapper, Pipeline {

// the servlet instance
private Servlet instance = null;
private String servletClass;
private Loader loader;
private String name;
private SimplePipeline pipeline = new SimplePipeline(this);
protected Container parent = null;

public SimpleWrapper() {
pipeline.setBasic(new SimpleWrapperValve());
}

public synchronized void addValve(Valve valve) {
pipeline.addValve(valve);
}

public Servlet allocate() throws ServletException {
// Load and initialize our instance if necessary
if (instance==null) {
try {
instance = loadServlet();
}
catch (ServletException e) {
throw e;
}
catch (Throwable e) {
throw new ServletException("Cannot allocate a servlet instance", e);
}
}
return instance;
}

private Servlet loadServlet() throws ServletException {
if (instance!=null)
return instance;

Servlet servlet = null;
String actualClass = servletClass;
if (actualClass == null) {
throw new ServletException("servlet class has not been specified");
}

Loader loader = getLoader();
// Acquire an instance of the class loader to be used
if (loader==null) {
throw new ServletException("No loader.");
}
ClassLoader classLoader = loader.getClassLoader();

// Load the specified servlet class from the appropriate class loader
Class classClass = null;
try {
if (classLoader!=null) {
classClass = classLoader.loadClass(actualClass);
}
}
catch (ClassNotFoundException e) {
throw new ServletException("Servlet class not found");
}
// Instantiate and initialize an instance of the servlet class itself
try {
servlet = (Servlet) classClass.newInstance();
}
catch (Throwable e) {
throw new ServletException("Failed to instantiate servlet");
}

// Call the initialization method of this servlet
try {
servlet.init(null);
}
catch (Throwable f) {
throw new ServletException("Failed initialize servlet.");
}
return servlet;
}

public String getInfo() {
return null;
}

public Loader getLoader() {
if (loader != null)
return (loader);
if (parent != null)
return (parent.getLoader());
return (null);
}

public class SimpleWrapperValve implements Valve, Contained {

protected Container container;

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

SimpleWrapper wrapper = (SimpleWrapper) getContainer();
ServletRequest sreq = request.getRequest();
ServletResponse sres = response.getResponse();
Servlet servlet = null;
HttpServletRequest hreq = null;
if (sreq instanceof HttpServletRequest)
hreq = (HttpServletRequest) sreq;
HttpServletResponse hres = null;
if (sres instanceof HttpServletResponse)
hres = (HttpServletResponse) sres;

// Allocate a servlet instance to process this request
try {
servlet = wrapper.allocate();
if (hres!=null && hreq!=null) {
servlet.service(hreq, hres);
}
else {
servlet.service(sreq, sres);
}
}
catch (ServletException e) {
}
}

public String getInfo() {
return null;
}

public Container getContainer() {
return container;
}

public void setContainer(Container container) {
this.container = container;
}
}

public class ClientIPLoggerValve implements Valve, Contained {

protected Container container;

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

// Pass this request on to the next valve in our pipeline
valveContext.invokeNext(request, response);
System.out.println("Client IP Logger Valve");
ServletRequest sreq = request.getRequest();
System.out.println(sreq.getRemoteAddr());
System.out.println("------------------------------------");
}

public String getInfo() {
return null;
}

public Container getContainer() {
return container;
}

public void setContainer(Container container) {
this.container = container;
}
}

public class HeaderLoggerValve implements Valve, Contained {

protected Container container;

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

// Pass this request on to the next valve in our pipeline
valveContext.invokeNext(request, response);

System.out.println("Header Logger Valve");
ServletRequest sreq = request.getRequest();
if (sreq instanceof HttpServletRequest) {
HttpServletRequest hreq = (HttpServletRequest) sreq;
Enumeration headerNames = hreq.getHeaderNames();
while (headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement().toString();
String headerValue = hreq.getHeader(headerName);
System.out.println(headerName + ":" + headerValue);
}

}
else
System.out.println("Not an HTTP Request");

System.out.println("------------------------------------");
}

public String getInfo() {
return null;
}

public Container getContainer() {
return container;
}

public void setContainer(Container container) {
this.container = container;
}
}

package com.tomcat.chapter5.startup;

import org.apache.catalina.Loader;
import org.apache.catalina.Pipeline;
import org.apache.catalina.Valve;
import org.apache.catalina.Wrapper;
import org.apache.catalina.connector.http.HttpConnector;

import com.tomcat.chapter5.core.SimpleLoader;
import com.tomcat.chapter5.core.SimpleWrapper;
import com.tomcat.chapter5.valves.ClientIPLoggerValve;
import com.tomcat.chapter5.valves.HeaderLoggerValve;

public final class Bootstrap1 {
public static void main(String[] args) {

/* call by using http://localhost:8080/ModernServlet, but could be invoked by any name */

HttpConnector connector = new HttpConnector();
Wrapper wrapper = new SimpleWrapper();
wrapper.setServletClass("servlet.ModernServlet"); // 设置servlet的相对路径

Loader loader = new SimpleLoader(); // 类加载器
Valve valve1 = new HeaderLoggerValve(); // 把请求头信息output到 console
Valve valve2 = new ClientIPLoggerValve();// 用来将client的IP 地址输出到控制台上

wrapper.setLoader(loader);
((Pipeline) wrapper).addValve(valve1);
((Pipeline) wrapper).addValve(valve2);

connector.setContainer(wrapper);

try {
connector.initialize(); // 创建服务器套接字
connector.start(); //

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

E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\src>java -cp .;lib/servlet.jar;lib/catalina_4_1_24.jar;E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\webroot com.tomcat.chapter5.startup/Bootstrap1
HttpConnector Opening server socket on all host IP addresses
HttpConnector[8080] Starting background thread
ModernServlet -- init
Client IP Logger Valve
127.0.0.1
------------------------------------
Header Logger Valve
host:localhost:8080
connection:keep-alive
accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
user-agent:Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36
accept-encoding:gzip, deflate, sdch
accept-language:zh-CN,zh;q=0.8,en;q=0.6
------------------------------------
Client IP Logger Valve
127.0.0.1
------------------------------------
Header Logger Valve
host:localhost:8080
connection:keep-alive
accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
user-agent:Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36
accept-encoding:gzip, deflate, sdch
accept-language:zh-CN,zh;q=0.8,en;q=0.6
------------------------------------

public interface Mapper {
public Container getContainer(); // 返回与该映射器相关联的servlet容器的实例；
public void setContainer(Container container); // 设置与该映射器相关联的servlet容器；
public String getProtocol(); // 返回该映射器负责处理的协议
public void setProtocol(String protocol);    //指定该映射器负责处理哪种协议
public Container map(Request request, boolean update); // 返回要处理某个特定请求的子容器的实例；
}

step1）SimpleContext类的invoke方法调用管道的invoke方法：









step2）管道SimplePipeline的invoke如下：

public void invoke(Request request, Response response)
throws IOException, ServletException {
// Invoke the first Valve in this pipeline for this request
(new SimplePipelineValveContext()).invokeNext(request, response); // 会调用所有添加到Context 实例中的阀，然后再调用基础阀的invoke方法；
}

public class SimpleContext implements Context, Pipeline {

public SimpleContext() {
pipeline.setBasic(new SimpleContextValve());
}
public void invoke(Request request, Response response, ValveContext valveContext)  // SimpleContextValve.invoke()
throws IOException, ServletException {
// Validate the request and response object types
if (!(request.getRequest() instanceof HttpServletRequest) ||
!(response.getResponse() instanceof HttpServletResponse)) {
return;     // NOTE - Not much else we can do generically
}

// Disallow any direct access to resources under WEB-INF or META-INF
HttpServletRequest hreq = (HttpServletRequest) request.getRequest();
String contextPath = hreq.getContextPath();
String requestURI = ((HttpRequest) request).getDecodedRequestURI();
String relativeURI =
requestURI.substring(contextPath.length()).toUpperCase();

Context context = (Context) getContainer();
// Select the Wrapper to be used for this Request
Wrapper wrapper = null;
try {
wrapper = (Wrapper) context.map(request, true); // attention for this line.
}
catch (IllegalArgumentException e) {
badRequest(requestURI, (HttpServletResponse) response.getResponse());
return;
}
if (wrapper == null) {
notFound(requestURI, (HttpServletResponse) response.getResponse());
return;
}
// Ask this Wrapper to process this Request
response.setContext(context);
wrapper.invoke(request, response);
}

public class SimpleContextMapper implements Mapper {

/**
* The Container with which this Mapper is associated.
*/
private SimpleContext context = null;

public Container getContainer() {
return (context);
}

public void setContainer(Container container) {
if (!(container instanceof SimpleContext))
throw new IllegalArgumentException
("Illegal type of container");
context = (SimpleContext) container;
}

public String getProtocol() {
return null;
}

public void setProtocol(String protocol) {
}

/**
* Return the child Container that should be used to process this Request,
* based upon its characteristics.  If no such child Container can be
* identified, return <code>null</code> instead.
*
* @param request Request being processed
* @param update Update the Request to reflect the mapping selection?
*
* @exception IllegalArgumentException if the relative portion of the
*  path cannot be URL decoded
*/
public Container map(Request request, boolean update) {
// Identify the context-relative URI to be mapped
String contextPath =
((HttpServletRequest) request.getRequest()).getContextPath();
String requestURI = ((HttpRequest) request).getDecodedRequestURI();
String relativeURI = requestURI.substring(contextPath.length());
// Apply the standard request URI mapping rules from the specification
Wrapper wrapper = null;
String servletPath = relativeURI;
String pathInfo = null;
String name = context.findServletMapping(relativeURI);
if (name != null)
wrapper = (Wrapper) context.findChild(name);
return (wrapper);
}
}

HttpConnector connector = new HttpConnector();

Wrapper wrapper1 = new SimpleWrapper();
wrapper1.setName("Primitive");
wrapper1.setServletClass("servlet.PrimitiveServlet");

Wrapper wrapper2 = new SimpleWrapper();
wrapper2.setName("Modern");
wrapper2.setServletClass("servlet.ModernServlet");

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

Valve valve1 = new HeaderLoggerValve();
Valve valve2 = new ClientIPLoggerValve();

((Pipeline) context).addValve(valve1);
((Pipeline) context).addValve(valve2);

Mapper mapper = new SimpleContextMapper();
mapper.setProtocol("http");
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 {
connector.initialize();
connector.start();

// make the application wait until we press a key.
System.in.read();
}

E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\src>java -cp .;lib/servlet.jar;lib/catalina_4_1_24.jar;E:\bench-cluster\cloud-data-preprocess\HowTomcatWorks\webroot  com.tomcat.chapter5.startup.
Bootstrap2
HttpConnector Opening server socket on all host IP addresses
HttpConnector[8080] Starting background thread
Client IP Logger Valve
127.0.0.1
------------------------------------
Header Logger Valve
host:localhost:8080
connection:keep-alive
accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
user-agent:Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.71 Safari/537.36
accept-encoding:gzip, deflate, sdch
accept-language:zh-CN,zh;q=0.8,en;q=0.6
------------------------------------
init
from service
Client IP Logger Valve
127.0.0.1
------------------------------------