Tomcat源码笔记1——连接器(Tomcat4默认)

Tomcat的连接器核心组件‌，主要连接器是Tomcat的核心组件，主要对底层请求的处理，例如底层和socket和http协议的解析；

作为桥梁对接客户端和Servlet容器。将原始请求转换为标准的Tomcat Request对象，然后交于另一个组件容器，取处理具体放入业务逻辑；

容器处理之后的ServletResponse，转换为Tomcat Response对象，进行底层响应，最终返回给客户端。

主要流程

Tomcat 4中的默认连接器的工作原理

连接器在启动时，会创建serverSocket绑定端口，并实例化HttpProcessor对象池，关联一个Container对象

• 使用一个线程循环监听ServerSocket.accept()请求socket，再把socket交于HttpProcessor处理
• 在处理socket时，HttpProcessor中会调用Connector提供的方法创建request对象和response对象，解析socket的请求行和请求头后填充request
• 最后调用org.apache.catalina. Container接口的invokee(request, response)方法， 将request对象和response对象传给servlet容器。
• 调用servlet容器的invoke()方法，此方法会载入相应的servlet 类， 调用其service()方法， 管理session对象， 记录错误消息等操

Connector

Connector接口

public interface Connector {     //初始化方法     public void initialize() throws LifecycleException;     //关联一个容器类对象     public Container getContainer();     public void setContainer(Container container);     //ServerSocketFactory工厂类     public ServerSocketFactory getFactory();     public void setFactory(ServerSocketFactory factory);     //创建Request和Response对象     public Request createRequest();     public Response createResponse();     //connection的上一层容器     public Service getService();     public void setService(Service service);     //一些http相关的配置     public boolean getEnableLookups();//DNS寻找     public void setEnableLookups(boolean enableLookups);     public String getInfo();//当前connector的描述信息     public int getRedirectPort();//如果请求来自非SSL端口，并受到安全约束, 返回请求应重定向到的端口号     public void setRedirectPort(int redirectPort);     public String getScheme();//默认http     public void setScheme(String scheme);     public boolean getSecure();//安全连接标志,默认值为“false”     public void setSecure(boolean secure); }

HttpConnector实现类

作用

* 实现了initialize()接口方法

调用open()用于新创建serverSocket

* 实现了Runnable接口

run()方法内循环监听ServerSocket.accept()，再把socket交于HttpProcessor处理。processor.assign(socket);

加锁的从HttpProcessor对象池中获取一个空闲的HttpProcessor（有最大个数限制），如果获取不到则抛出异常。这样保证了HttpProcessor对象只有一个socket进入。

HttpProcessor内独占的一个后台线程会被唤醒以处理这个socket

* 实现了生命周期接口：主要为start()和stop()

start()：开启一个后台线程运行run()；初始化HttpProcessor对象池（创建HttpProcessor），并启动每一个HttpProcessor的后台run方法

stop()：用于停止connector销毁HttpProcessor.stop的所有对象；关闭serverSocket；停止后台线程

* 提供创建request、Response对象的方法

此方法会在HttpProcessor中处理socket时调用；创建时并把当前连接器传递过去，因为这3个对象会遇到一个配置变量，是在本Connector进行get/setter的

public final class HttpConnector implements Connector, Lifecycle, Runnable {     // —————————————————– Instance Variables     //其他     private int debug = 0;     private String address = null;     private int bufferSize = 2048;     //容器层次相关     private Service service = null;     protected Container container = null; //connector的下一层，一对一的关系     //Processors相关     private Vector created = new Vector(); //仅仅用于记录已经创建的processor，在stop方法内可以对此进行销毁     private int curProcessors = 0; //当前的处理类的个数     protected int minProcessors = 5;     private int maxProcessors = 20;     private Stack processors = new Stack();//当前空闲可用的processor     //ServerSocket相关     private int acceptCount = 10;//ServerSocket中的接受队列长度     private ServerSocket serverSocket = null;     private ServerSocketFactory factory = null; //默认DefaultServerSocketFactory();     private static final String info = "org.apache.catalina.connector.http.HttpConnector/1.0";     //http配置相关，大多是给HTTPprocess使用的     private boolean enableLookups = false; //DNS查询     private int connectionTimeout = Constants.DEFAULT_CONNECTION_TIMEOUT;     private int port = 9999;     private String proxyName = null;     private int proxyPort = 0;     private int redirectPort = 443;     private String scheme = "http";     private boolean secure = false;     private boolean allowChunking = true;     private boolean tcpNoDelay = true;     //生命周期相关     private StringManager sm = StringManager.getManager(Constants.Package);     private boolean initialized = false;     private boolean started = false;     private boolean stopped = false; //外部控制的     private Thread thread = null;     private String threadName = null;     private Object threadSync = new Object();     protected LifecycleSupport lifecycle = new LifecycleSupport(this);     // ————–get/setter—————————————————–     public Service get/setXXX() {         //….     }     //———-创建request/Response对象，并把当前连接器传递过去———————–     public Request createRequest() {         HttpRequestImpl request = new HttpRequestImpl();         request.setConnector(this);         return (request);     }     public Response createResponse() {         HttpResponseImpl response = new HttpResponseImpl();         response.setConnector(this);         return (response);     }     // ——————生命周期方法————————————     public void addLifecycleListener(LifecycleListener listener) {         lifecycle.addLifecycleListener(listener);     }     public LifecycleListener[] findLifecycleListeners() {         return lifecycle.findLifecycleListeners();     }     public void removeLifecycleListener(LifecycleListener listener) {         lifecycle.removeLifecycleListener(listener);     }     //在启动Catalina时，会串联的调用server->connection 的initialize、start初始化方法     //initialize用于调用open用于开启ServerSocket     public void initialize() throws LifecycleException {         if (initialized)             throw new LifecycleException ();         this.initialized=true;         Exception eRethrow = null;         try {             serverSocket = open();         } catch (IOException ioe) {             //…             eRethrow = kme;         }         if ( eRethrow != null )             throw new LifecycleException(threadName + ".open", eRethrow);     }     //start用于调用threadStart()开启后台，以监听ServerSocket；     //初始化HttpProcessor对象池     public void start() throws LifecycleException {         if (started)             throw new LifecycleException();         threadName = "HttpConnector[" + port + "]";         lifecycle.fireLifecycleEvent(START_EVENT, null); // 触发事件         started = true;         //开启后台线程         threadStart();         //创建指定数量的processors         while (curProcessors < minProcessors) {             if ((maxProcessors > 0) && (curProcessors >= maxProcessors))                 break;             HttpProcessor processor = newProcessor();             recycle(processor);         }     }     //stop用于停止connector     //销毁HttpProcessor.stop的所有对象     //关闭serverSocket     //停止后台线程     public void stop() throws LifecycleException {         if (!started)throw new LifecycleException (sm.getString("httpConnector.notStarted"));         lifecycle.fireLifecycleEvent(STOP_EVENT, null);         started = false;         for (int i = created.size() – 1; i >= 0; i–) {             HttpProcessor processor = (HttpProcessor) created.elementAt(i);             if (processor instanceof Lifecycle) {                 try {                     ((Lifecycle) processor).stop();                 } catch (LifecycleException e) {                 }             }         }         synchronized (threadSync) {             if (serverSocket != null) {                 try {                     serverSocket.close();                 } catch (IOException e) {                     ;                 }             }             threadStop();         }         serverSocket = null;     }               // ——————–后台线程方法————————–     //生命周期方法start()会调用这个方法     //开启一个后台线程，调用本类的run方法     private void threadStart() {         thread = new Thread(this, threadName);         thread.setDaemon(true); //Daemon 守护神         thread.start();     }     //生命周期方法stop()会调用这个方法,关闭后台线程     //先把stopped = true;接住就进行阻塞，以等待获得锁，这里的争用场景在：停用serverSocket和重启serverSocket（run中）都依靠stopped变量     private void threadStop() {         stopped = true;         try {             threadSync.wait(5000);         } catch (InterruptedException e) {             ;         }         thread = null;     }     //线程不断循环的，阻塞接受进来的请求以创建socket，设置对应的配置Timeout、TcpNoDelay属性     //如抛出安全性异常，则无需处理此请求，continue     //如抛出IO异常，则对serverSocket进行重启open()。则无需处理此请求，continue     //接受到一个正常的请求socket，当有空闲的Processor处理时就调用processor.assign(socket)处理，没有就关闭socket，continue     public void run() {         while (!stopped) {             Socket socket = null;             try {                 socket = serverSocket.accept();                 if (connectionTimeout > 0)  socket.setSoTimeout(connectionTimeout);                 socket.setTcpNoDelay(tcpNoDelay);             } catch (AccessControlException ace) {                 continue;             } catch (IOException e) {                 try {                     synchronized (threadSync) {                         if (started && !stopped)                         if (!stopped) {                             serverSocket.close();                             serverSocket = open();                         }                     }                 } catch (KeyManagementException kme) {                     break;                 }                 continue;             }             //接受到一个正常的请求socket，当没有空闲的Processor处理时，关闭socket，continue             //比如会关闭底层的tcp，此客户端的请求就拒绝了             HttpProcessor processor = createProcessor();             if (processor == null) {                 try {                     socket.close();                 } catch (IOException e) {}                 continue;             }             //可是处理socket             processor.assign(socket);         }         synchronized (threadSync) {             threadSync.notifyAll();         }     }     // ————–HttpProcessorr相关——————————————–     //基于对象池创建HttpProcessor     private HttpProcessor createProcessor() {         synchronized (processors) {             if (processors.size() > 0) {                 return ((HttpProcessor) processors.pop());             }             if ((maxProcessors > 0) && (curProcessors < maxProcessors)) {                 return (newProcessor());             } else {                 if (maxProcessors < 0) {                     return (newProcessor());                 } else {                     return (null);                 }             }         }     }     //创建HttpProcessor对象，调用生命周期方法start，把对象计入created集合中     private HttpProcessor newProcessor() {         HttpProcessor processor = new HttpProcessor(this, curProcessors++);         if (processor instanceof Lifecycle) {             try {                 ((Lifecycle) processor).start();             } catch (LifecycleException e) {                 return (null);             }         }         //仅仅用于记录已经创建的processor，在stop方法内可以对此进行销毁         created.addElement(processor);         return (processor);     }     //把HttpProcessor回收     void recycle(HttpProcessor processor) {         processors.push(processor);     }     // ————–ServerSocket相关——————————————–     //默认的ServerSocket工厂类使用ServerSocket类进行创建。     private ServerSocket open() throws IOException, KeyStoreException, NoSuchAlgorithmException,             CertificateException, UnrecoverableKeyException, KeyManagementException {         ServerSocketFactory factory = getFactory();         //不指定主机地址         if (address == null) {             try {                 return (factory.createSocket(port, acceptCount));             } catch (BindException be) {                 throw new BindException();             }         }         //它显式指定服务器要绑定的IP 地址, 该构造方法适用于具有多个IP 地址的主机         try {             InetAddress is = InetAddress.getByName(address);             try {                 return (factory.createSocket(port, acceptCount, is));             } catch (BindException be) {                 throw new BindException();             }         } catch (Exception e) {             try {                 return (factory.createSocket(port, acceptCount));             } catch (BindException be) {                 throw new BindException(be.getMessage() + ":" + port);             }         }     } }

HttpProcessor

主要作用

* 构造方法内借助HttpConnector创建了HttpRequestImpl和HttpResponseImpl对象

  this.connector = connector;

  this.request = (HttpRequestImpl) connector.createRequest();

  this.response = (HttpResponseImpl) connector.createResponse();

* http协议的相关配置

– 接受从HttpConnector传递过来的配置：如proxyName、proxyPort 、serverPort、isChunkingAllowed()

– 默认的配置：如keepAlive(true)、http11 = true、sendAck(false)("HTTP/1.1 100 Continue）

* 使用一个自己独占的后台线程处理进来的socket(阻塞处理)，核心处理方法process(socket)

– 把底层socket输入流装饰为SocketInputStream，以借助其解析请求行和请求头

– 在request和response中setStream底层流对象：

输入SocketInputStream(socket.getInputStream()) 和 输出socket.getOutputStream()

– 解析请求

解析连接：填充远程客户端IP、设置监听的端口、是否有代理服务器或端口

解析请求行和请求头

Http1.1下判断是否需要发送100状态码和设置块编码标识

– 请求解析成功时，使用connector关联的容器，调用对应的servlet实例进行处理请求connector.getContainer().invoke(request, response);

– servlet处理完之后，需要对response进行响应，servlet也有可能在response中的流缓存填充响应体数据。所以就需要调用response.finishResponse()和request.finishRequest();

response.finishResponse()：一些状响应态的预处理，有必要就拼接响应头（当在servlet使用wirte使得缓存buffer已经占满、或使用了flush()），刷新底层流对象进行响应数据

request.finishRequest()：关闭输入流（包括Reader）

对output = socket.getOutputStream()再flush一次

– 重置HttpProcessor已经创建的HttpRequestImpl和HttpResponseImpl对象以供下次请求使用，如cookies.clear()、headers.clear()、bufferCount = 0等

– 如果在响应头添加了Connection：close，则表示断开长连接，就会跳出循环，断开连接，关闭socket

如果(SocketInputStream)input还有数据没有读取就需要skip下在close

注：在处理的过程中，如果发生错误，则会调用response.getResponse()).sendError(xxx)，那么在finishResponse中会响应错误信息给请求端

final class HttpProcessor implements Lifecycle, Runnable {     // —————-变量————————————-     //当前HttpConnector的状态：当前处理器是否被占用了     private boolean available = false;     private HttpConnector connector = null;     private int id = 0;     private int status = Constants.PROCESSOR_IDLE;     //request、response相关，http配置变量、解析     private Socket socket = null;     private HttpRequestImpl request = null;     private HttpResponseImpl response = null;     private static final String match = ";" + Globals.SESSION_PARAMETER_NAME + "=";     private static final char[] SESSION_ID = match.toCharArray();     private StringParser parser = new StringParser();     private String proxyName = null;     private int proxyPort = 0; private int serverPort = 0;     private boolean keepAlive = false;     private boolean http11 = true;     private boolean sendAck = false;     private static final byte[] ack = (new String("HTTP/1.1 100 Continue\\r\\n\\r\\n")).getBytes();     private static final byte[] CRLF = (new String("\\r\\n")).getBytes();     //private char[] lineBuffer = new char[4096];     private HttpRequestLine requestLine = new HttpRequestLine();     //后台线程     private boolean started = false;     private boolean stopped = false;     private Thread thread = null;     private String threadName = null;     private Object threadSync = new Object();     //其他     private static final String SERVER_INFO = ServerInfo.getServerInfo() + " (HTTP/1.1 Connector)";     private int debug = 0;     private LifecycleSupport lifecycle = new LifecycleSupport(this);     protected StringManager sm = StringManager.getManager(Constants.Package);     // ———————-构造方法———————-     //配置变量、Processor池都在connector定义     //通过connector提供的方法创建Request、Response     public HttpProcessor(HttpConnector connector, int id) {         super();         this.connector = connector;         this.debug = connector.getDebug();         this.id = id;         this.proxyName = connector.getProxyName();         this.proxyPort = connector.getProxyPort();         this.request = (HttpRequestImpl) connector.createRequest();         this.response = (HttpResponseImpl) connector.createResponse();         this.serverPort = connector.getPort();         this.threadName = "HttpProcessor[" + connector.getPort() + "][" + id + "]";     }     // ——————–阻塞处理进来的socket—————————     //阻塞的争议当前Processor对象     synchronized void assign(Socket socket) {         while (available) { //当前处理器对象是是否被socket占用，true表示被占用了             try {                 wait(); //当前处理器是被占用了，只能等待             } catch (InterruptedException e) {             }         }         //抢到锁了，把this.socket赋值为当前进来的socket,把available = true;使得await()方法能走下去         this.socket = socket;         available = true;         notifyAll(); //会通知await()方法里面的阻塞线程，如果后台线程还正在处理请求，此时又进来一个socket，会走到这一步，但是这里调用notifyAll没有用，因为后台线程还没回到await()方法     }     //后台线程     //阻塞的处理每一个进来的socket,使用process(socket)解析socket处理     //处理之后把当前Processor对象返回到stack中，但是run()还是在运行的     public void run() {         while (!stopped) {             // Wait for the next socket to be assigned，线程阻塞等待。socket             Socket socket = await();             if (socket == null)                 continue;             try {                 process(socket);             } catch (Throwable t) {             }             // Finish up this request。讲对象重新放入stack中             connector.recycle(this);         }         //走到这一步，说明run()方法即将结束，此时在通知threadStop，才可以把thread置为null         synchronized (threadSync) {             threadSync.notifyAll();         }     }     //阻塞等待进来的socket,并把socket交给后台线程去处理（单线程处理）     //并把available = false;使得其他socket可以占用当前Processor对象。但是后台线程需要阻塞等待的     private synchronized Socket await() {         while (!available) {             try {                 wait();             } catch (InterruptedException e) {             }         }         Socket socket = this.socket;         available = false;         notifyAll();         return (socket);     }     //——————核心方法,解析处理和响应请求———————     //处理socket     private void process(Socket socket) {         boolean ok = true;         boolean finishResponse = true;         SocketInputStream input = null;         OutputStream output = null;         //把底层socket输入流装饰为SocketInputStream，以解析请求行和请求头         try {             input = new SocketInputStream(socket.getInputStream(),connector.getBufferSize());         } catch (Exception e) {             ok = false;         }         keepAlive = true;         while (!stopped && ok && keepAlive) {             finishResponse = true;             //request和response封装流对象，setStream设置底层流对象             try {                 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) {                 ok = false;             }             // 解析request             try {                 if (ok) {                     //填充客户端的IP地址、设置代理服务器端口                     parseConnection(socket);                     parseRequest(input, output);                     if (!request.getRequest().getProtocol().startsWith("HTTP/0"))                         parseHeaders(input);//解析请求头                     if (http11) {//默认为ture,即默认为HTTP/1.1                         ackRequest(output);//直接向输入流发送output.write(TTP/1.1 100 Continue\\r\\n\\r\\n")                         if (connector.isChunkingAllowed())//块编码                             response.setAllowChunking(true);//在response设置对应的属性值                     }                 }             } catch (EOFException e) {                 ok = false;                 finishResponse = false;             } catch (XXXception e) {                 ok = false;                 ((HttpServletResponse) response.getResponse()).sendError(xxx);             }             //…             //如果解析请求行和请求头成功，ok=true，则使用Container().invoke()处理请求             try {                 if (ok) {                     connector.getContainer().invoke(request, response); // 找到对应的容器进行处理。                 }             } catch (ServletException e) {                 ((HttpServletResponse) response.getResponse()).sendError(xxx);                 ok = false;                 //…             }             //请求处理成功             if (finishResponse) {                 try {                     response.finishResponse();                 } catch (IOException/Throwabl ) {                     ok = false;                 }                 try {                     request.finishRequest();                 } catch (IOException/Throwable ) {                     ok = false;                 }                 try {                     if (output != null)                         output.flush();                 } catch (IOException e) {                     ok = false;                 }             }             // 如果在响应头添加了Connection：close，则会跳出循环，断开连接             if ( "close".equals(response.getHeader("Connection")) ) {                 keepAlive = false;             }             // End of request processing             status = Constants.PROCESSOR_IDLE;             // 重置对象信息，在长连接的情况下，可能每个请求息时不一样的             request.recycle();             response.recycle();         }         try {             //如果input还没读完，需要skip             shutdownInput(input);             socket.close();         } catch (IOException e) {             ;         } catch (Throwable e) {         }         socket = null;     }     //当存在代码目标服务器时，在request中填充对应的属性     private void parseConnection(Socket socket)             throws IOException, ServletException {         ((HttpRequestImpl) request).setInet(socket.getInetAddress());         if (proxyPort != 0)             request.setServerPort(proxyPort);         else             request.setServerPort(serverPort);//设置监听的端口         request.setSocket(socket);     }     //发送HTTP/1.1 100 continue     private void ackRequest(OutputStream output)             throws IOException {         if (sendAck)             output.write(ack);     }     //—————————生命周期方法——————     //开启processor     public void start() throws LifecycleException {         lifecycle.fireLifecycleEvent(START_EVENT, null);         started = true;         threadStart();     }     //开始processor的后台线程     private void threadStart() {         thread = new Thread(this, threadName);         thread.setDaemon(true);         thread.start();     }     //停止processor的后台线程     public void stop() throws LifecycleException {         lifecycle.fireLifecycleEvent(STOP_EVENT, null);         started = false;         threadStop();     }     //会通知后台线程的元凶     private void threadStop() {         stopped = true;         assign(null);         if (status != Constants.PROCESSOR_IDLE) {             synchronized (threadSync) {                 try {                     threadSync.wait(5000);                 } catch (InterruptedException e) {                     ;                 }             }         }         thread = null;     }     public void addLifecycleListener(LifecycleListener listener) {         lifecycle.addLifecycleListener(listener);     }     public LifecycleListener[] findLifecycleListeners() {         return lifecycle.findLifecycleListeners();     }     public void removeLifecycleListener(LifecycleListener listener) {         lifecycle.removeLifecycleListener(listener);     } }

从SocketInputStream流中获取数据

是InputStream字节流的包装类

主要作用是实现3个核心的方法

– InputStream的抽象方法read，以缓冲区buf获取的方式失效底层数据流的获取

– 并提供readRequestLine和parseHeaders方法从buff中获取所有请求头内容，并封装号对象返回

这两个方法会在HttpProcessor中进行调用，对应出请求行和请求头

public class SockexxtInputStream extends InputStream {     public SocketInputStream(InputStream is, int bufferSize) {         this.is = is;         buf = new byte[bufferSize];     }     public int read() throws IOException {} //读取一个字节     public void readRequestLine(HttpRequestLine requestLine) throws IOException { …} //解析请求行     private void parseHeaders(SocketInputStream input) throws IOException, ServletException {…} //解析请求头 }

读取一个字节read()

* 读取一个字节

  总不能每次都直接调用底层的原生socket.getInputStream()，这可能会造成系统调用，每次都进行系统调用就非常浪费性能

所以Tomcat使用一个缓冲区byte buf[]，默认大小位2048，使用int count= is.read(buf, 0, buf.length)来一次尽量读取socke输入流多个内容，并缓存

这个缓存区是需要重复利用的，即缓存的内容读取之后，应该从缓存区的0位置借助存放socke输入流读取的数据

pos：可以读取的起始位置

count： 可以读取的最后位置

* 读取缓冲区的pos指定的值，如果已经读到最后的位置，那么需要从socke输入流读取接下来的的数据，post和count也会被重置

public int read() throws IOException {     if (pos >= count) {         fill(); //重头开始填充缓存，pos = 0 且 count为此次读取的字符数，一次性可能会读取非常多数据，可能也把请求头的数据也读到缓存了         if (pos >= count)             return –1;     }     return buf[pos++] & 0xff; //byte能够准确转为int } protected void fill() throws IOException {     pos = 0;     count = 0;     int nRead = is.read(buf, 0, buf.length);//注意这里从0开始存放内容     if (nRead > 0) {         count = nRead;     } }

解析请求行

由于从套接字的输入流中处理字节流是指读取从第1个字节到最后1个字节（无法从后向前读取）的内容因此readRequestLine()方法必须在readHeader()方法之前调用，

每次调用readerHeader()都会返回一个名／值对， 所以应重复调用readHeader()方法， 直到读取了所有的请求头信息

主要流程

* 使用SocketInput.readRequestLine()方法获取StreamHttpRequestLine对象

通过对请求行数据的字符解析，按照协议规则的位置（空），从socket流中解析的请求行的3个部分，并保存到StreamHttpRequestLine中

如请求行实例： POST /index?id=kaka HTTP/1.1解析的HttpRequestLine 对象内容为

this.method = POST；this.methodEnd = 结束的位置

this.url = /index?id=kaka； this.methodEnd = xx

this.protocol = HTTP/1.1; this.protocolEnd = xx

final class HttpRequestLine {     public char[] method;     public int methodEnd;     public char[] uri;     public int uriEnd;     public char[] protocol;     public int protocolEnd; }

* 通过上一步获取的StreamHttpRequestLine对象，对3个部分进行处理并存到HttpProcessor中HttpRequest对象的相关属性

  – 截取url上的参数部分以填充HttpRequest对象的属性setQueryString

  – 如果url不是以“/”开头，那么需要对url截断前部分,且对URL的格式进行修正，/../会退到上一目录、/./和//替换为/

  – 处理会话id以url参数jsessionid形式的情况，以填充HttpRequest对象的相关属性

  – 填充HttpRequest对象对应的method、url属性

//HttpProcessor private void parseRequest(SocketInputStream input, OutputStream output)         throws IOException, ServletException {     //1、解析请求行数据内容到requestLine     input.readRequestLine(requestLine);     String method = new String(requestLine.method, 0, requestLine.methodEnd);     String uri = null;     String protocol = new String(requestLine.protocol, 0, requestLine.protocolEnd);          //获取url上的QueryString设置到request对象中     int question = requestLine.indexOf("?");     if (question >= 0) {         request.setQueryString(new String(requestLine.uri, question + 1,requestLine.uriEnd – question – 1));         uri = new String(requestLine.uri, 0, question);     }     else {         request.setQueryString(null);         uri = new String(requestLine.uri, 0, requestLine.uriEnd);     }     //如果url不是以“/”开头，那么需要对url截断前部分     if (!uri.startsWith("/")) {         int pos = uri.indexOf("://");         if (pos != –1) {             pos = uri.indexOf('/', pos + 3);             if (pos == –1) {                 uri = "";             }             else {                 uri = uri.substring(pos);             }         }     }     //处理会话id以url参数jsessionid形式的情况     String match = ";jsessionid=";     int semicolon = uri.indexOf(match);     if (semicolon >= 0) {         String rest = uri.substring(semicolon + match.length());         int semicolon2 = rest.indexOf(';');         if (semicolon2 >= 0) {             request.setRequestedSessionId(rest.substring(0, semicolon2));             rest = rest.substring(semicolon2);         }         else {             request.setRequestedSessionId(rest);             rest = "";         }         request.setRequestedSessionURL(true);         uri = uri.substring(0, semicolon) + rest;     }     else {         request.setRequestedSessionId(null);         request.setRequestedSessionURL(false);     }     //对URL的格式进行修正，/../会退到上一目录、/./和//替换为/     String normalizedUri = normalize(uri);     //填充HttpRequest对象对应的method、url属性     ((HttpRequest) request).setMethod(method);     request.setProtocol(protocol);     if (normalizedUri != null) {         ((HttpRequest) request).setRequestURI(normalizedUri);     }     else {         ((HttpRequest) request).setRequestURI(uri);     }     if (normalizedUri == null) {         throw new ServletException("Invalid URI: " + uri + "'");     } }

public void readRequestLine(HttpRequestLine requestLine)         throws IOException {     // …     //从buff缓存中的每一个字节值，知道空格符     int chr = 0;     do {         try {             chr = read();         } catch (IOException e) {             chr = –1;         }     } while ((chr == CR) || (chr == LF));//定位到开头     if (chr == –1) throw new EOFException(sm.getString("requestStream.readline.error"));     pos–; //当前指针位置     // 解析method     int maxRead = requestLine.method.length;     int readStart = pos;     int readCount = 0; //表示请求方法字符串的长度     boolean space = false;     //在这里pos=1     while (!space) {         //如果读取的method的长度大于入参指定的，那么就是要默认的最大的长度进行扩展         if (readCount >= maxRead) {             if ((2 * maxRead) <= HttpRequestLine.MAX_METHOD_SIZE) {                 char[] newBuffer = new char[2 * maxRead];                 System.arraycopy(requestLine.method, 0, newBuffer, 0,maxRead);                 requestLine.method = newBuffer;                 maxRead = requestLine.method.length;             } else {                 throw new IOException (sm.getString("requestStream.readline.toolong"));             }         }         //缓存读到最后了，就需要接住从socket流中获取接下来的数据         if (pos >= count) { //count为缓存中可读的数据的个数             int val = read();             if (val == –1) {                 throw new IOException (sm.getString("requestStream.readline.error"));             }             pos = 0;             readStart = 0;         }         //发现当前字符是空格，说明moethod截取完毕了         if (buf[pos] == SP) {             space = true;         }         requestLine.method[readCount] = (char) buf[pos];         readCount++;         pos++;     }     requestLine.methodEnd = readCount – 1;     //url和协议的解析不做和method一样，接住在buffer进行获取数据并定位空格即可 }

解析请求头

POST /index?id=kaka HTTP/1.1 　　 请求行 Host: localhost   请求头 User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:10.0.2) Gecko/20100101 Firefox/10.0.2 Accept:text/html,application/xhtml+xml,application/xml;q=0.9,/;q=0.8 Accept-Language: zh-cn,zh;q=0.5 Accept-Encoding: gzip, deflate Connection: keep-alive Referer: http://localhost/ Content-Length：25 Content-Type：application/x-www-form-urlencoded 空行 username=aa&password=1234　　请求体

解析完请求行之后，就在buffer上接着解析请求头，注这里需要多次调用

主要流程

* 使用SocketInput.readHeader()方法获取一个HttpHeader对象（处理逻辑类似HttpRequestLine）

这个对象为从socket流中解析出一个请求头信息：

如content-length:25

cname = content-length; this.nameEnd = xxx; this.value = 25; this.valueEnd = xxx;

把当前请求头的填充在HttpRequest对象的请求头集合属性中

* 处理cookie、content-length、content-type请求头的情况，且填充相关属性

//HttpProcessor private void parseHeaders(SocketInputStream input)         throws IOException, ServletException {     //这里需要循环从解析所有请求头     while (true) {         HttpHeader header = new HttpHeader();;         //    从buffer获取数据并解析一行请求头         //    如果当前位置为空行，即为请求头和请求内容的分界，这停止读取数据         //    否则项读取出name、在读取value，期间还会处理一些空字符串的问题         //    如果遇到换行符且下一个字符非空说明当前的一个请求有已经读取完毕，返回HttpHeader即可         input.readHeader(header);         if (header.nameEnd == 0) {             if (header.valueEnd == 0) {                 return;//结束循环             }         }         String name = new String(header.name, 0, header.nameEnd);         String value = new String(header.value, 0, header.valueEnd);         //把当前请求头对填充相关属性到中         request.addHeader(name, value);         //处理cookie请求头、content-length、content-type情况，且填充相关属性到request中         request.setContentLength(n);         }     } //end while }

Request

Request接口体系

* Request接口

– 定义了需要关联的组件，如Connector、Context、Wrapper

– 输入流相关：Socket、InputStream、ServletInputStream的获取；关闭输入流

– 获取request实现类的外观对象：ServletRequest = RequestFacade(this)

– 网络协议的基本属性的设置Setter：Protocol、ContentLength、ContentType、ServerName等

* HttpRequest接口（在Request接口基础上增加了HTTP协议相关的属性）

– Http基本属性的设置Setter，如Cookie、Header、Locale、Parameter、Method

– 安全认证属性的设置Setter，如UserPrincipal、AuthType(String type);

– 会话相关属性的设置Setter（在请求行解析时会调用赋值），如SessionCookie、SessionId、SessionURL

– Url属性相关的设置Setter，如url上的分段QueryString、ContextPath、PathInfo、ServletPath等

* ServletRequest接口

– 输入流的获取：ServletInputStream和BufferedReader，底层都是基于socket输入流

– 参数相关变量的获取getter：如Attribute、Parameter、CharacterEncoding、Locale等

– 网络协议的基本属性的获取getter：如Protocol、Scheme、ServerName、ContentLength()、RemoteAddr

– 请求转发对象的获取getter：RequestDispatcher

* HttpServletRequest接口

– Http基本属性的设置Getter，如Cookie、Header、Method

– 安全认证属性的设置Getter，如UserPrincipal、AuthType、UserInRole等

– 会话相关属性的设置Getter，如HttpSession、SessionId等

– Url属性相关的设置Getter，如url上的分段QueryString、ContextPath、PathInfo、ServletPath等

* HttpRequestBase抽象类 （实现Request和ServletRequest接口方法）

– 主要组件的设置setter：Connector、Context、Wrapper

– 输入流的设置setter和获取getter：socket和socket输入流、ServletInputStream和BufferedReader的获取。

– 网络协议的基本属性的设置setter和获取getter

– 参数相关和RequestDispatcher为抽象方法，交于子类实现

* HttpRequestBase实现类 （在RequestBase基础上又实现了HttpRequest, HttpServletRequest 接口方法）

– Http基本属性的设置Getter，如Cookie、Header、Method

– 安全认证属性的设置Getter，如UserPrincipal、AuthType、UserInRole等

– 会话相关属性的设置Getter，基于Manage实现HttpSession、SessionId等

– Url属性相关的设置Getter，如url上的分段QueryString、ContextPath、PathInfo、ServletPath等

– 参数相关方法的实现，post方法且为undeceode类型时(表单)读取输入流，获取消息体内容解析参数；其他参数方法基于此内容实现

– 请求转发对象的获取getter：RequestDispatcher

* HttpRequestImpl （对HttpRequestBase进行增强）

– 基于HttpHeader[] headerPool实现请求头的增删改查

– 输入流程增强HttpRequestStream，继承RequestStream

RequestStream增强的是：如果在request中设置了contentlength的大小，那么不会读取超过这个值的数据大小

HttpRequestStream增强的是：进行块编码的读取

– 提供一个完成request输入流的方法，即关闭reader或stream

RequestBase抽象类

实现ServletRequest, Request两个接口的方法

主要有为：

– ServletInputStream getInputStream()

 stream = createInputStream();//最终为流对象为SocketInputStream(socket.getInputStream()) -> new RequestStream(this) //RequestStream没有做什么特别的增强

– BufferedReader getReader()

  InputStreamReader isr = new InputStreamReader(new RequestStream(this), encoding);

reader = new BufferedReader(isr);

public abstract class RequestBase implements ServletRequest, Request {     //==================================变量 =====================================     //request接口     protected String authorization = null;     protected Connector connector = null;     protected Context context = null;     protected Wrapper wrapper = null;     protected Response response = null; //HttpResponseImpl     protected Socket socket = null;     protected InputStream input = null; //SocketInputStream(socket.getInputStream())     private transient HashMap notes = new HashMap();     //ServletRequest接口     protected BufferedReader reader = null;     protected HashMap attributes = new HashMap();     protected static Locale defaultLocale = Locale.getDefault();     protected ArrayList locales = new ArrayList();     protected String characterEncoding = null; //在setContentType()中解析获得     protected String remoteAddr = null;     protected String remoteHost = null;     //公用     protected ServletInputStream stream = null;     protected int contentLength = –1;     protected String contentType = null;     protected String scheme = null;     protected boolean secure = false;     protected String serverName = null;     protected int serverPort = –1;     protected String protocol = null;     protected static final String info = "org.apache.catalina.connector.RequestBase/1.0";     //其他     protected RequestFacade facade = new RequestFacade(this);     protected static StringManager sm = StringManager.getManager(Constants.Package);     //==========================Request接口方法实现 ========================     //setter     public String set/getAuthorization/Connector/Context/Wrapper/Info/Note/ContentLength/ContentType         /setProtocol/RemoteAddr/RemoteHost/Scheme/Secure/ServerName/ServerPort()     {         //处理对应的变量         //characterEncoding中在setContentType中处理     }     //流相关     public ServletRequest getRequest() {return (facade);}//facade = new RequestFacade(this);     public void set/gettResponse(Response response) { this.response = response;}     public void set/getSocket(Socket socket) {this.socket = socket; }     public void set/getStream(InputStream input) {this.input = input;}     //最终为流对象为SocketInputStream(socket.getInputStream())     //RequestStream没有做什么特别的增强     public ServletInputStream createInputStream() throws IOException {         return (new RequestStream(this));     }     public void finishRequest() throws IOException {         if (reader != null) {             try {                 reader.close();             } catch (IOException e) {                 ;             }         }         if (stream != null) {             try {                 stream.close();             } catch (IOException e) {                 ;             }         }     }     public void recycle() {         //重置所有变量，除了facade、connector     }     //==========================ServletRequest接口方法实现 ========================     //getter     public Object get/Attributexx/CharacterEncoding/ContentLength/ContentTyp/Protocol/Locale             /getsetProtocol/RemoteAddr/RemoteHost/Scheme/Secure/ServerName/ServerPort()     {         //处理对应的变量     }     public String getRealPath(String path) {         return (servletContext.getRealPath(path));     }     //流相关     //reader和stream不能重复获取，在调用getInputStream就会报错     public ServletInputStream getInputStream() throws IOException {         if (reader != null)             throw new IllegalStateException (sm.getString("requestBase.getInputStream.ise"));         if (stream == null)             stream = createInputStream();//最终为流对象为SocketInputStream(socket.getInputStream())         return (stream);     }     //使用底层流对象SocketInputStream(socket.getInputStream())封装为BufferedReader     public BufferedReader getReader() throws IOException {         if (stream != null)             throw new IllegalStateException(sm.getString("requestBase.getReader.ise"));         if (reader == null) {             String encoding = getCharacterEncoding();             if (encoding == null) encoding = "ISO-8859-1";             InputStreamReader isr = new InputStreamReader(createInputStream(), encoding);             reader = new BufferedReader(isr);         }         return (reader);     }     //抽象方法，均是ServletRequest接口方法     public abstract String getParameter(String name);     public abstract Map getParameterMap();     public abstract Enumeration getParameterNames();     public abstract String[] getParameterValues(String name);     public abstract RequestDispatcher getRequestDispatcher(String path); }

HttpRequestBase实现类

在RequestBase基础上又实现了HttpRequest, HttpServletRequest 接口方法

主要实现：

– 请求参数的解析。基于parameters（Map）变量处理，有两个来源

  获取url上的参数串；

  处理消息体的参数，前提是post方法且内容不为空且输入流未读取过且内容原生 form 表单

– 根据路径获取转发对象RequestDispatcher，用户可以在servlet代码里获取进行请求转发

public class HttpRequestBase extends RequestBase implements HttpRequest, HttpServletRequest {     // —————————————————– Instance Variables     //http变量     protected ArrayList cookies = new ArrayList();     protected HashMap headers = new HashMap();     protected ParameterMap parameters = null;     protected String method = null;     //安全认证     protected Principal userPrincipal = null;     protected String authType = null;     //url上参数Session相关     protected String queryString = null;     protected Session session = null;     protected boolean requestedSessionCookie = false;     protected String requestedSessionId = null;     protected boolean requestedSessionURL = false;     protected String requestURI = null;     protected String decodedRequestURI = null;     protected boolean secure = false;     //url路径     protected String contextPath = "";     protected String pathInfo = null;     protected String servletPath = null;     protected HttpRequestFacade facade = new HttpRequestFacade(this);     protected static ArrayList empty = new ArrayList();     protected SimpleDateFormat formats[] = {             new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz", Locale.US),             new SimpleDateFormat("EEEEEE, dd-MMM-yy HH:mm:ss zzz", Locale.US),             new SimpleDateFormat("EEE MMMM d HH:mm:ss yyyy", Locale.US)     };     protected static final String info = "org.apache.catalina.connector.HttpRequestBase/1.0";     protected boolean parsed = false;     // ————————————————————- Properties     public ServletRequest getRequest() {return (facade);}     //遍量的setter/getter     public String getAuthType/Info/ContextPath/PathInfo/Method/…() { return (info);}     //解析请求头时会调用     public void addCookie/addHeader(Cookie cookie) {}     public void clearCookies/Headers/Locales() {}     public void recycle() {         super.recycle();         //处理facede，重置所有变量     }     //参数的处理，基于parameters变量处理，会先调用parseParameters()     public void addParametergetParameter/getParameterMap/getParameterNames/getParameterValues         /clearParameters(String name, String values[]) { }     //填充parameters变量     protected void parseParameters() {         //解析过了，就不用在解析了         if (parsed) return;         //预处理下ParameterMap         ParameterMap results = parameters;         if (results == null) results = new ParameterMap();         results.setLocked(false); //使ParameterMap暂时不可修改，但可以获取         String encoding = getCharacterEncoding();         if (encoding == null) encoding = "ISO-8859-1";         //获取url上的参数串         String queryString = getQueryString();         try {             RequestUtil.parseParameters(results, queryString, encoding);         } catch (UnsupportedEncodingException e) {             ;         }         //处理消息体的参数，前提是post方法且内容不为空且输入流未读取过且内容原生 form 表单         String contentType = getContentType();         if (contentType == null)             contentType = "";         int semicolon = contentType.indexOf(';');         if (semicolon >= 0) {             contentType = contentType.substring(0, semicolon).trim();         } else {             contentType = contentType.trim();         }         if ("POST".equals(getMethod()) && (getContentLength() > 0)                 && (this.stream == null)                 && "application/x-www-form-urlencoded".equals(contentType)) {             try {                 int max = getContentLength();                 int len = 0;                 byte buf[] = new byte[getContentLength()];                 //最终为流对象为SocketInputStream(socket.getInputStream())                 ServletInputStream is = getInputStream();                 while (len < max) {                     int next = is.read(buf, len, max – len);                     //这一步很重要，因为有时候实际接受总数len可能会小于max，这里判断以避免无限循环                     if (next < 0 ) {                         break;                     }                     len += next;                 }                 is.close();//关闭输入流                 if (len < max) {                     //实际接受总数len可能会小于max,抛出异常                     throw new RuntimeException(sm.getString("httpRequestBase.contentLengthMismatch"));                 }                 RequestUtil.parseParameters(results, buf, encoding);             } catch (UnsupportedEncodingException ue) {                 ;             } catch (IOException e) {                 throw new RuntimeException(sm.getString("httpRequestBase.contentReadFail") +                         e.getMessage());             }         }         results.setLocked(true);         parsed = true;         parameters = results;     }     //根据路径获取转发对象     public RequestDispatcher getRequestDispatcher(String path) {         if (context == null)             return (null);         if (path == null)             return (null);             //如果以“/"开头，则相对于当前ServletContext的根目录         else if (path.startsWith("/"))return (context.getServletContext().getRequestDispatcher(path));         //如果不“/"开头，则相对于当前ServletContext的父目录         String servletPath = (String) getAttribute(Globals.SERVLET_PATH_ATTR);         if (servletPath == null)             servletPath = getServletPath();         int pos = servletPath.lastIndexOf('/');         String relative = null;         if (pos >= 0) {             relative = RequestUtil.normalize                     (servletPath.substring(0, pos + 1) + path);         } else {             relative = RequestUtil.normalize(servletPath + path);         }         return (context.getServletContext().getRequestDispatcher(relative));     }     public String getPathTranslated() {         if (context == null)             return (null);         if (pathInfo == null)             return (null);         else             return (context.getServletContext().getRealPath(pathInfo));     }     public StringBuffer getRequestURL() {         StringBuffer url = new StringBuffer();         String scheme = getScheme();         int port = getServerPort();         if (port < 0)             port = 80; // Work around java.net.URL bug         url.append(scheme);         url.append("://");         url.append(getServerName());         if ((scheme.equals("http") && (port != 80))                 || (scheme.equals("https") && (port != 443))) {             url.append(':');             url.append(port);         }         url.append(getRequestURI());         return (url);     }     //会话相关     protected class PrivilegedGetSession implements PrivilegedAction {         private boolean create;         PrivilegedGetSession(boolean create) {             this.create = create;         }         public Object run() {             return doGetSession(create);         }     }     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);     }     //通过Manager创建会话     private HttpSession doGetSession(boolean create) {         if (context == null) eturn (null);         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) manager = context.getManager();         if (manager == null) return (null);      // Sessions are not supported         if (requestedSessionId != null) {             try {                 session = manager.findSession(requestedSessionId); //通过SessionId 查找 Session。             } 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 = manager.createSession();         if (session != null) return (session.getSession());         else return (null);     }     //通过Manager判断会话idshif     public boolean isRequestedSessionIdValid() {         session = manager.findSession(requestedSessionId);         //..     }     //安全认证     public boolean isUserInRole(String role) {         if (userPrincipal == null) return (false);         if (context == null) return (false);         Realm realm = context.getRealm();         if (realm == null)return (false);         if (wrapper != null) {             String realRole = wrapper.findSecurityReference(role);             if ((realRole != null) &&realm.hasRole(userPrincipal, realRole))return (true);         }         return (realm.hasRole(userPrincipal, role));     }      }

HttpRequestImpl

主要增强：

* 基于HttpHeader[] headerPool实现请求头的增删改查

* 对输入流增强为HttpRequestStream，继承RequestStream

– RequestStream增强的是：如果在request中设置了contentlength的大小，那么不会读取超过这个值的数据大小

– HttpRequestStream增强的是：进行块编码的读取

* 提供一个完成request输入流的方法，即关闭reader或stream

final class HttpRequestImpl extends HttpRequestBase {     // ————————————————————– Constants     protected static final int INITIAL_POOL_SIZE = 10;     protected static final int POOL_SIZE_INCREMENT = 5;     protected InetAddress inet = null;//远程客户端地址     protected static final String info ="org.apache.catalina.connector.http.HttpRequestImpl/1.0";     protected HttpHeader[] headerPool = new HttpHeader[INITIAL_POOL_SIZE];//类型为HttpHeader     protected int nextHeader = 0;     protected HttpHeader connectionHeader = null;     protected HttpHeader transferEncodingHeader = null;     // ————————————————————- Properties     InetAddress get/setInet/RemoteAddr/RemoteHost((InetAddress inet) { this.inet = inet;}     public String getInfo() {return (info);}     // ——————————————————— Public Methods     public void recycle() {         super.recycle();         inet = null;         nextHeader = 0;         connectionHeader = null;     }     //请求处理相关     //分配当前请求头数组中的下一个可用内存     HttpHeader allocateHeader() {         if (nextHeader == headerPool.length) {             HttpHeader[] newHeaderPool =                     new HttpHeader[headerPool.length + POOL_SIZE_INCREMENT];             for (int i = 0; i < nextHeader; i++) {                 newHeaderPool[i] = headerPool[i];             }             headerPool = newHeaderPool;         }         if (headerPool[nextHeader] == null)             headerPool[nextHeader] = new HttpHeader();         return headerPool[nextHeader];     }     void nextHeader() {         nextHeader++;     }     //在指定的下标位置存放HttpHeader对象。在进行请求头解析时也会调用                            public void addHeader(String name, String value) {         if (nextHeader == headerPool.length) {             HttpHeader[] newHeaderPool =                     new HttpHeader[headerPool.length + POOL_SIZE_INCREMENT];             for (int i = 0; i < nextHeader; i++) {                 newHeaderPool[i] = headerPool[i];             }             headerPool = newHeaderPool;         }         headerPool[nextHeader++] = new HttpHeader(name, value);     }     public void clearHeaders() {         nextHeader = 0;     }     //基于headerPool数组查询                                                public HttpHeader getHeader/getHeaderNames(HttpHeader header) { }     //流相关，一个增强输入流     public ServletInputStream createInputStream() throws IOException {         //最终为流对象为SocketInputStream(socket.getInputStream())         //RequestStream增强的是：如果在request中设置了contentlength的大小，那么不会读取超过这个值的数据大小         //HttpRequestStream增强的是：进行块编码的读取         return (new HttpRequestStream(this, (HttpResponseImpl) response));     }     //对输入流进行完成关闭，如果流没打开则需要打开     public void finishRequest() throws IOException {         if ((reader == null) && (stream == null) && (getContentLength() != 0)                 && (getProtocol() != null) && (getProtocol().equals("HTTP/1.1")))             getInputStream(); //最终为流对象为SocketInputStream(socket.getInputStream())         super.finishRequest();//关闭reader和stream     } }

输入流的装饰流程

HttpRequestStream

装饰的底层流是RequestStream，HttpRequestStream extends RequestStream

增强的是：进行块编码的读取

//ServletInputStream getInputStream()和BufferedReader getReader() 基于createInputStream()返回的进行装饰 public ServletInputStream createInputStream() throws IOException {     //最终为流对象为SocketInputStream(socket.getInputStream())     return (new HttpRequestStream(this, (HttpResponseImpl) response)); } public class HttpRequestStream extends RequestStream {     //继承RequestStream：如果在request中设置了contentlength的大小，那么不会读取超过这个值的数据大小     // HttpRequestStream自己增加块chunk的执行     public HttpRequestStream(HttpRequestImpl request, HttpResponseImpl response) {         super(request);//这里进行流的传递         String transferEncoding = request.getHeader("Transfer-Encoding");         http11 = request.getProtocol().equals("HTTP/1.1");         chunk = ((transferEncoding != null) && (transferEncoding.indexOf("chunked") != –1));         if ((!chunk) && (length == –1)) {//length为请求中设置的内容长度             // Ask for connection close             response.addHeader("Connection", "close");         }     }     public int read() throws IOException {         if (closed)             throw new IOException(sm.getString("requestStream.read.closed"));         if (chunk) {             if (endChunk)                 return (-1);             if ((chunkBuffer == null)                     || (chunkPos >= chunkLength)) {                 if (!fillChunkBuffer())                     return (-1);             }             return (chunkBuffer[chunkPos++] & 0xff);         } else {             return (super.read());         }     } }