Servlet容器 - Tomcat请求处理原理

一． TCP/IP vs.  Socket

socket的历史

套接口(Socket), 有时称为“Berkeley 套接口”。因为它源自Berkeley Unix。在80 年代早期，远景研究规划局（Advanced Research Projects Agency, ARPA）资助了佳利福尼亚大学伯克利分校的一个研究组，让他们将TCP/IP软件移植到UNIX操作系统中，并将结果提供给其他网点。作为项目的一部分，设计者们创建了一个接口，应用进程使用这个接口可以方便的进行通信。他们决定，只要有可能就使用以有的系统调用，对那些不能方便的容入已有的函数集的情况，就再增加新的系统调用以支持TCP/IP 功能。这样做的结果就出现了插口接口（Berkeley Socket），这个系统被称为Berkeley UNIX或BSD UNIX。(TCP/IP 首次出现在BSD 4.1 版本release 4.1 of Berkeley Software Distribution)。由许多计算机厂商，都采用了Berkeley UNIX，于是许多机器上都可以使用Socket 了。这样，Socket 接口就被广泛使用，到现在已经成为事实上的标准。

Socket用于实现进程之间的 端到端连接，也就是说网络上两个或两个以上双工方式通信的进程之间总有一个连接，这个连接的端点称为套接字，套接字是在比较低的层次上通信的， 不同的操作系统对Socket有不同的支持方式， 不同的语言，对Socket的实现也均不相同，而且Socket在TCP与UDP两大 协议族中也有各自的工作方式。

二． 迭代服务器 vs 并发服务器

1. 迭代服务器模型：只有一个进程/线程处理请求，简单，性能不高

listenfd = socket( ... );    // 创建socket
bind(listen, ... );		// 绑定socket地址
listen(listenfd,LISTENQ);		// 监听
for(;;)
{
    connfd = accept(listenfd, ... ); 		// 接受请求
    doit(connfd);		// 处理请求
    close(connfd);		// 关闭连接
}

2. 并发服务器模型：多个进程/线程并发处理请求，性能较高，结构复杂

listenfd = socket( ... );
bind(listen, ... );
listen(listenfd,LISTENQ);
for(;;)
{
    connfd = accept(listenfd, ... );
    if((pid = fork()) == 0) {    // 创建子进程
        close(listenfd);
        doit(connfd);
        close(connfd);
        exit(0);
    }
    close(connfd);
}

三． Servlet容器与Tomcat

1.    Connector

public class HttpConnector implements Runnable {
	private int port 8080;
	private ServerSocket serverSocket;

	public void run() {
		while(1) {
			Socket socket = serverSocket.accept();  // 监听客户连接
			passToContainer(socket);	// 交由Container处理
}
	}
}

2.     Container

public class StandardHost {
	private Pipeline pipeline = new StandardPipeline(this);

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

public void invoke(Request request, Response response) {
	this.pipeline.invoke(request, response);
}
}

Public class StandardHostValve {
	public void invoke(Request request, Response response) {
		Context context = host.map(request);
		Context.invoke(request, response);
}
}

public class StandardContext implements Context
{
	private String docBase;
	private Pipeline pipeline = new StandardPipeline(this);
	private Mapper mapper;

public StandardContext() {
		this.pipeline.setBasic(new StandardContextValve());
	}

public void invoke(Request request, Response response) {
	this.pipeline.invoke(request, response);
}

	public Container map(Request request, Response response) {
		mapper.map(request);
	}
}

public class StandardContextValve {
	Public void invoke(Request request, Response response, ValveContext context)
{
	Wrapper wrapper = (Wrapper)context.map(request);
	wrapper.invoke(request, response);
}
}

public class StandardWrapper implements Wrapper
{	
	private String servletClass;
	private bolean singleThreadModel  = false;
	
public StandardWrapper() {
	this.pipeline.setBasic(new StandardWrapperValve());
}
	public Servlet allocate() {…}
	public Servlet deallocate() {…}

	public void invoke(Request request, Response response) {
		this.pipeline.invoke(request, response);
}
}

Public class StandardWrapperValve 
{
	Public void invoke(Request request, Response response, ValveContext context)
{
		filterChain.process(request, response);
	Servlet servlet = wrapper.allocate();
	servlet.service(request, response);
}
}

3.    Tomcat并发服务器

public class HttpConnector implements Connector, Runnable 
{
private Stack<HttpProcessor> processors = new Stack<HttpProcessor>();
public void run() {
		while (!stopped) {
			Socket socket = socket = serverSocket.accept();
			HttpProcessor processor = createProcessor();
			if (processor == null) {  // 无法处理当前请求，关闭连接
				socket.close();				
			}
			processor.assign(socket);
		}
	}
}

public class HttpProcessor implements Runnable 
{
	public void run() {
		while (!stopped) {
			Socket socket = await();
			process(socket);
			this.connector.recycle(this);
		}
	}

	private void process(Socket socket) {
		this.connector.getContainer().invoke(this.request, this.response);
	}
}