[笔记]深入剖析Tomcat－tomcat的默认连接器,servlet容器

连接器

实现Connector接口

HttpConnector实例维护一个HttpProcessor实例池，个数有minProcessors和maxProcessors决定，如果HttpProcessor实例的数目达到max，则http请求则会被忽略。

public final class Bootstrap(){
    public static void main(String[] args){
        HttpConnector httpConnector = new HttpConnector();
        SimpleContainer container = new SimpleContainer();
        httpConnector.setContainer(container);
        connector.initialize();
        connector.start();
    }
}
public class HttpConnector implements Connector, Runable{
    protected int minProcessors = 5;
    private int maxProcessors = 20;
    private Stack processors = new Stack();
    
    public void start{
        while (curProcessors < minProcessors){
            if (maxProcessors>0 && curProcessors >= maxProcessors)
                break;
            HttpProcessor httpProcessor = new HttpProcessor();
            recycle(httpProcessor);
        }
    }
    
    public void run(){
        while(!loop){
            //...省略
            ServerSocket serverSocket = new(...)
            Socket socket = setverSocket.accept();
            HttpProcessor httpProcessor = createHttpProcessor(this); //从processor池中读取，如果无且小于max，则创建
            if (httpProcessor==null) //processor池中无实例
                socket.close();
            httpProcessor.assign(socket);
     }
    }
    
    public void recycle(HttpProcessor httpProcessor){
        processors.push(httpProcessor);//入栈
    }
}

public class SimpleContainer implements Container{
    //...
    public void invoke(Request request, Response response){
        URL[] urls = new URL(1);
        //...url 处理
        String servletName = null;
        //...servletName处理
        URLClassLoader loader = new URLClassLoader(urls);
        Class class = loader.loadClass(servletName);
        Servlet servlet = class.newInstance();
        servlet.service((HttpServletRequest)request, (HttpServletResponse)response);
    }
}

public class HttpProcessor implements Runable{

    public void run(){
        while(!loop){
            Socket socket = await();
            if (socket == null){
                continue;
            }
            //...
            process(socket);
            connector.recycle(this);
            synchronized (threadSync){
                threadSync.notifyAll();
            }
     }
    }
    
    private synchronized void assign(Socket socket){
        while (available){
            wait();
        }
        //...
        this.socket = socket;
        available = true;
        notifyAll(); //唤醒await处理
    }
    
    private synchronized Socket await(){
        while (!available){
            wait();
        }
        Socket socket = this.scoket;
        available = false;
        notifyAll(); //告诉assign，处理完成，可以接收下一个
        return socket;
    }
    
    public void process(Socket socket){
        
        //parse request header parameters and so on..., response
        //process, call container.invoke
    }
}

servlet容器

context应用程序

public final class Bootstrap{
    public static void main(String[] args){
        HttpConnector httpConnector = new HttpConnector();
        Wrapper wrapper1 = new SimpleWrapper();//实际处理servlet，context子容器
        wrapper1.setName("wrapper1");
        wrapper1.setServletClass("ClientServlet1");
        Wrapper wrapper2 = new SimpleWrapper();
        wrapper2.setName("wrapper2");
        wrapper2.setServletClass("ClientServlet2");
        
        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("/Primitive", "wrapper1");
        context.addServletMapping("/Moder", "wrapper2");
        
        httpConnector.initialize();
        httpConnector.start();
    }
}

//     1.调用context的invoke
public class SimpleContext implements Context, Container{
    // addServletMapping
    //findServletMapping
    //addMapper
    //map();返回负责处理当前的wrapper实例
    public void invoke(Request request, Response response){
        pipeline.invoke(request, response); //    
    }
}

//      2.调用管道invoke方法
public class SimplePipeline {
    public class SimplePipelineValveContext implements ValveContext{
        //invokeNext
    }
    public void invoke(Request request, Response response){
        (new SimplePipelineValveContext()).invokeNext(request, response); //会调用添加到context实例中的阀，调用基础阀SimpleContextValve的invoke方法，
    }
}

//     4.调用基础阀invoke
public class SimpleContextValve implements valve{
    public void invoke(Request request, Response response){
        Wrapper wrapper = context.map(request, true); //使用context的映射器查找wrapper
        wrapper.invoke(request, response);//再调用invoke方法
    }
}

//    子容器基础阀invoke
public class SimpleWraperValve implements valve{
public void invoke(Request request, Response response){
    Wrapper wrapper = context.map(request, true); //使用context的映射器查找wrapper
    wrapper.invoke(request, response);//再调用invoke方法
}
}

//        5.调用子容器的invoke
public class SimpleWrapper implements Wrapper{
    private SimplePipeline pipeline = new SimplePipeline();
    pipeline.setBasic(new SimpleWraperValve);
    public void invoke(Request request, Response response){
        pipeline.invoke(request, response); //context的子容器，
    }
}

public class SimpleContextMapper implements Mapper{
    //...
    public Container map(Request request, boolean update){
        String contextPath = ((HttpRequest)request.getRequest().getContextPath();
        String relativeURI= request.getDecodeRequestURI().subString(contextPath.length()); //get ServletPath
        String name = context.findServletMapping(relativeURI);
        return (Wrapper)context.findChild(name);     
    }
}

//     3.调用context容器 阀的invoke
public class ClientIPLoggerValve implements Valve, Contained{
    //...
    @Override
    public void invoke(Request arg0, Response arg1, ValveContext valveContext) throws IOException,
            ServletException {
        valveContext.invokeNext(Request arg0, Response arg1);  //传递给管道中的下一个阀
        // TODO Auto-generated method stub    
    }
}

public class HeaderLoggerValve implements Valve{
    //...

    @Override
    public String getInfo() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Valve getNext() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void invoke(Request arg0, Response arg1) throws IOException,
            ServletException {
        // TODO Auto-generated method stub
        
    }
}