[Tomcat6.0源码]Servlet API之Request

最新推荐文章于 2023-12-28 22:23:35 发布
最新推荐文章于 2023-12-28 22:23:35 发布
阅读量1.3k 收藏 1
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/woorh/article/details/8065189
本文深入探讨Servlet中request请求参数的传递过程，从ApplicationFilterChain内部调用开始，解析如何通过get和post方法获取参数，并最终存储在HashMap结构中供后续使用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在写servlet的时候，会继承HttpServlet，重写它的doPost、doGet()，这两个方法都有两个参数HttpServletRequest、HttpServletResponse。request中保存的是请求报文的信息。以getParameter()为例，看看数据是如何在在两个servlet中传递的。

一、request的来源

tomcat最终调用到我们自己编写的servelt是在ApplicationFilterChain.internalDoFilter()中，执行完所有过滤器后再执行servlet的service方法：

                    servlet.service((HttpServletRequest) request,
                                    (HttpServletResponse) response);
此处的request是ApplicationFilterChain.doFilter()传递进来的。而doFilter方法是在StandardWrapperValve.invoke()中调用的： 

                            filterChain.doFilter(request.getRequest(), 
                                    response.getResponse());
而request做为StandardWrapperValve.invoke的参数，其来源按请求处理的顺序可以追溯到CoyoteAdapter.service中： 

connector.getContainer().getPipeline().getFirst().invoke(request, response);
此request为org.apache.catalina.connector.Request对象： 

            request = (Request) connector.createRequest();
            request.setCoyoteRequest(req);
而这个req为org.apache.coyote.Request对象。

二、Requst似乎找到源头了，org.apache.catalina.connector.Request.getParameter():

    public String getParameter(String name) {

        if (!parametersParsed)
            parseParameters();

        return coyoteRequest.getParameters().getParameter(name);

    }
如果没有解析过参数，则先解析parseParameters()： 

    protected void parseParameters() {

        parametersParsed = true;

        Parameters parameters = coyoteRequest.getParameters();
        // Set this every time in case limit has been changed via JMX
        parameters.setLimit(getConnector().getMaxParameterCount());

        // getCharacterEncoding() may have been overridden to search for
        // hidden form field containing request encoding
        String enc = getCharacterEncoding();

        boolean useBodyEncodingForURI = connector.getUseBodyEncodingForURI();
        if (enc != null) {
            parameters.setEncoding(enc);
            if (useBodyEncodingForURI) {
                parameters.setQueryStringEncoding(enc);
            }
        } else {
            parameters.setEncoding
                (org.apache.coyote.Constants.DEFAULT_CHARACTER_ENCODING);
            if (useBodyEncodingForURI) {
                parameters.setQueryStringEncoding
                    (org.apache.coyote.Constants.DEFAULT_CHARACTER_ENCODING);
            }
        }

        parameters.handleQueryParameters();

        if (usingInputStream || usingReader)
            return;

        if (!getMethod().equalsIgnoreCase("POST"))
            return;

        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 (!("application/x-www-form-urlencoded".equals(contentType)))
            return;

        boolean success = false;
        int len = getContentLength();

        try {
            if (len > 0) {
                int maxPostSize = connector.getMaxPostSize();
                if ((maxPostSize > 0) && (len > maxPostSize)) {
                    if (context.getLogger().isDebugEnabled()) {
                        context.getLogger().debug(
                                sm.getString("coyoteRequest.postTooLarge"));
                    }
                    return;
                }
                byte[] formData = null;
                if (len < CACHED_POST_LEN) {
                    if (postData == null)
                        postData = new byte[CACHED_POST_LEN];
                    formData = postData;
                } else {
                    formData = new byte[len];
                }
                try {
                    if (readPostBody(formData, len) != len) {
                        return;
                    }
                } catch (IOException e) {
                    // Client disconnect
                    if (context.getLogger().isDebugEnabled()) {
                        context.getLogger().debug(
                                sm.getString("coyoteRequest.parseParameters"), e);
                    }
                    return;
                }
                parameters.processParameters(formData, 0, len);
            } else if ("chunked".equalsIgnoreCase(
                    coyoteRequest.getHeader("transfer-encoding"))) {
                byte[] formData = null;
                try {
                    formData = readChunkedPostBody();
                } catch (IOException e) {
                    // Client disconnect or chunkedPostTooLarge error
                    if (context.getLogger().isDebugEnabled()) {
                        context.getLogger().debug(
                                sm.getString("coyoteRequest.parseParameters"), e);
                    }
                    return;
                }
                if (formData != null) {
                    parameters.processParameters(formData, 0, formData.length);
                }
            }
            success = true;
        } finally {
            if (!success) {
                parameters.setParseFailed(true);
            }
        }

    }
parameters.handleQueryParameters();解析的是通过get方法传递的参数（将参数添加在请求地址后）。Parameter.handleQueryParameters(): 

    public void handleQueryParameters() {
        if( didQueryParameters ) return;

        didQueryParameters=true;

        if( queryMB==null || queryMB.isNull() )
            return;
        
        if(log.isDebugEnabled()) {
            log.debug("Decoding query " + decodedQuery + " " +
                    queryStringEncoding);
        }

        try {
            decodedQuery.duplicate( queryMB );
        } catch (IOException e) {
            // Can't happen, as decodedQuery can't overflow
            e.printStackTrace();
        }
        processParameters( decodedQuery, queryStringEncoding );
    }
处理的queryMB中的数据，queryMB是什么时候赋值的呢？queryMB是parameter的属性，而parameter是coyoteRequest的属性，coyoteRequest来自CoyoteAdapter.service()： 

            request.setCoyoteRequest(req);
CoyoteAdapter.service()由Http11Processer.process()调用。req来自Http11Processer的构造函数中： 

        request = new Request();
        inputBuffer = new InternalInputBuffer(request, headerBufferSize);
        request.setInputBuffer(inputBuffer);

Http11Processer.process()：

                inputBuffer.parseRequestLine();
                request.setStartTime(System.currentTimeMillis());
                keptAlive = true;
                if (disableUploadTimeout) {
                    socket.setSoTimeout(soTimeout);
                } else {
                    socket.setSoTimeout(timeout);
                }
                // Set this every time in case limit has been changed via JMX
                request.getMimeHeaders().setLimit(endpoint.getMaxHeaderCount());
                inputBuffer.parseHeaders();

inputBuffer.parseRequestLine();将截取请求报文的第一行进行解析，而inputBuffer.parseHeaders()即解析其他报文头信息。先看看一个简单的socket请求报文：

GET /helloServlet?user=World HTTP/1.1
accept:image/jpeg, application/x-ms-application, image/gif, application/xaml+xml, image/pjpeg, application/x-ms-xbap, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*
referer:http://localhost:8080/formTest.html
accept-language:zh-CN
user-agent:Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C)
accept-encoding:gzip, deflate
host:localhost:8080
connection:Keep-Alive

InternalInputBuffer.parseRequestLine()将解析“GET /helloServlet?user=World HTTP/1.1”

    public void parseRequestLine()
        throws IOException {

        int start = 0;

        //
        // Skipping blank lines
        //

        byte chr = 0;
        do {

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            chr = buf[pos++];

        } while ((chr == Constants.CR) || (chr == Constants.LF));

        pos--;

        // Mark the current buffer position
        start = pos;

        //
        // Reading the method name
        // Method name is always US-ASCII
        //

        boolean space = false;

        while (!space) {

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            // Spec says no CR or LF in method name
            if (buf[pos] == Constants.CR || buf[pos] == Constants.LF) {
                throw new IllegalArgumentException(
                        sm.getString("iib.invalidmethod"));
            }
            // Spec says single SP but it also says be tolerant of HT
            if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
                space = true;
                request.method().setBytes(buf, start, pos - start);
            }

            pos++;

        }

        
        // Spec says single SP but also says be tolerant of multiple and/or HT
        while (space) {
            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }
            if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
                pos++;
            } else {
                space = false;
            }
        }

        // Mark the current buffer position
        start = pos;
        int end = 0;
        int questionPos = -1;

        //
        // Reading the URI
        //

        boolean eol = false;

        while (!space) {

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            // Spec says single SP but it also says be tolerant of HT
            if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
                space = true;
                end = pos;
            } else if ((buf[pos] == Constants.CR) 
                       || (buf[pos] == Constants.LF)) {
                // HTTP/0.9 style request
                eol = true;
                space = true;
                end = pos;
            } else if ((buf[pos] == Constants.QUESTION) 
                       && (questionPos == -1)) {
                questionPos = pos;
            }

            pos++;

        }

        request.unparsedURI().setBytes(buf, start, end - start);
        if (questionPos >= 0) {
            request.queryString().setBytes(buf, questionPos + 1, 
                                           end - questionPos - 1);
            request.requestURI().setBytes(buf, start, questionPos - start);
        } else {
            request.requestURI().setBytes(buf, start, end - start);
        }

        // Spec says single SP but also says be tolerant of multiple and/or HT
        while (space) {
            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }
            if (buf[pos] == Constants.SP || buf[pos] == Constants.HT) {
                pos++;
            } else {
                space = false;
            }
        }

        // Mark the current buffer position
        start = pos;
        end = 0;

        //
        // Reading the protocol
        // Protocol is always US-ASCII
        //

        while (!eol) {

            // Read new bytes if needed
            if (pos >= lastValid) {
                if (!fill())
                    throw new EOFException(sm.getString("iib.eof.error"));
            }

            if (buf[pos] == Constants.CR) {
                end = pos;
            } else if (buf[pos] == Constants.LF) {
                if (end == 0)
                    end = pos;
                eol = true;
            }

            pos++;

        }

        if ((end - start) > 0) {
            request.protocol().setBytes(buf, start, end - start);
        } else {
            request.protocol().setString("");
        }

    }

方法中的request即org.apache.coyote.Request，在Http11Processor构造方法中就已经设置好了。queryMB就在这里设置的：

            request.queryString().setBytes(buf, questionPos + 1, 
                                           end - questionPos - 1);
org.apache.coyote.Request的构造方法就将queryMB和parameter关联了： 

    public Request() {

        parameters.setQuery(queryMB);
        parameters.setURLDecoder(urlDecoder);

    }
所以这样queryMB就保存到了parameter对象中了。Parameter.handleQueryParameters()中调用processParameters( decodedQuery, queryStringEncoding )进行处理： 

    public void processParameters( MessageBytes data, String encoding ) {
        if( data==null || data.isNull() || data.getLength() <= 0 ) return;

        if( data.getType() != MessageBytes.T_BYTES ) {
            data.toBytes();
        }
        ByteChunk bc=data.getByteChunk();
        processParameters( bc.getBytes(), bc.getOffset(),
                           bc.getLength(), getCharset(encoding));
    }
进而调用重构方法processParameters( bc.getBytes(), bc.getOffset(), bc.getLength(), getCharset(encoding));
    private void processParameters(byte bytes[], int start, int len,
                                  Charset charset) {
        
        if(log.isDebugEnabled()) {
            try {
                log.debug(sm.getString("parameters.bytes",
                        new String(bytes, start, len, DEFAULT_CHARSET.name())));
            } catch (UnsupportedEncodingException uee) {
                // Not possible. All JVMs must support ISO-8859-1
            }
        }

        int decodeFailCount = 0;
            
        int pos = start;
        int end = start + len;

        while(pos < end) {
            parameterCount ++;

            if (limit > -1 && parameterCount > limit) {
                parseFailed = true;
                log.info(sm.getString("parameters.maxCountFail",
                        Integer.valueOf(limit)));
                break;
            }
            int nameStart = pos;
            int nameEnd = -1;
            int valueStart = -1;
            int valueEnd = -1;

            boolean parsingName = true;
            boolean decodeName = false;
            boolean decodeValue = false;
            boolean parameterComplete = false;

            do {
                switch(bytes[pos]) {
                    case '=':
                        if (parsingName) {
                            // Name finished. Value starts from next character
                            nameEnd = pos;
                            parsingName = false;
                            valueStart = ++pos;
                        } else {
                            // Equals character in value
                            pos++;
                        }
                        break;
                    case '&':
                        if (parsingName) {
                            // Name finished. No value.
                            nameEnd = pos;
                        } else {
                            // Value finished
                            valueEnd  = pos;
                        }
                        parameterComplete = true;
                        pos++;
                        break;
                    case '%':
                    case '+':
                        // Decoding required
                        if (parsingName) {
                            decodeName = true;
                        } else {
                            decodeValue = true;
                        }
                        pos ++;
                        break;
                    default:
                        pos ++;
                        break;
                }
            } while (!parameterComplete && pos < end);

            if (pos == end) {
                if (nameEnd == -1) {
                    nameEnd = pos;
                } else if (valueStart > -1 && valueEnd == -1){
                    valueEnd = pos;
                }
            }
            
            if (log.isDebugEnabled() && valueStart == -1) {
                try {
                    log.debug(sm.getString("parameters.noequal",
                            Integer.valueOf(nameStart),
                            Integer.valueOf(nameEnd),
                            new String(bytes, nameStart, nameEnd-nameStart,
                                    DEFAULT_CHARSET.name())));
                } catch (UnsupportedEncodingException uee) {
                    // Not possible. All JVMs must support ISO-8859-1
                }
            }
            
            if (nameEnd <= nameStart ) {
                if (valueStart == -1) {
                    // &&
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("parameters.emptyChunk"));
                    }
                    // Do not flag as error
                    continue;
                }
                // &=foo&
                if (log.isInfoEnabled()) {
                    if (valueEnd >= nameStart && log.isDebugEnabled()) {
                        String extract = null;
                        try {
                            extract = new String(bytes, nameStart,
                                    valueEnd - nameStart,
                                    DEFAULT_CHARSET.name());
                        } catch (UnsupportedEncodingException uee) {
                            // Not possible. All JVMs must support ISO-8859-1
                        }
                        log.info(sm.getString("parameters.invalidChunk",
                                Integer.valueOf(nameStart),
                                Integer.valueOf(valueEnd),
                                extract));
                    } else {
                        log.info(sm.getString("parameters.invalidChunk",
                                Integer.valueOf(nameStart),
                                Integer.valueOf(nameEnd),
                                null));
                    }
                }
                parseFailed = true;
                continue;
                // invalid chunk - it's better to ignore
            }
            
            tmpName.setBytes(bytes, nameStart, nameEnd - nameStart);
            if (valueStart >= 0) {
                tmpValue.setBytes(bytes, valueStart, valueEnd - valueStart);
            } else {
                tmpValue.setBytes(bytes, 0, 0);
            }

            // Take copies as if anything goes wrong originals will be
            // corrupted. This means original values can be logged.
            // For performance - only done for debug
            if (log.isDebugEnabled()) {
                try {
                    origName.append(bytes, nameStart, nameEnd - nameStart);
                    if (valueStart >= 0) {
                        origValue.append(bytes, valueStart, valueEnd - valueStart);
                    } else {
                        origValue.append(bytes, 0, 0);
                    }
                } catch (IOException ioe) {
                    // Should never happen...
                    log.error(sm.getString("parameters.copyFail"), ioe);
                }
            }
            
            try {
                String name;
                String value;

                if (decodeName) {
                    urlDecode(tmpName);
                }
                tmpName.setCharset(charset);
                name = tmpName.toString();

                if (valueStart >= 0) {
                    if (decodeValue) {
                        urlDecode(tmpValue);
                    }
                    tmpValue.setCharset(charset);
                    value = tmpValue.toString();
                } else {
                    value = "";
                }

                addParam(name, value);
            } catch (IOException e) {
                parseFailed = true;
                decodeFailCount++;
                if (decodeFailCount == 1 || log.isDebugEnabled()) {
                    if (log.isDebugEnabled()) {
                        log.debug(sm.getString("parameters.decodeFail.debug",
                                origName.toString(), origValue.toString()), e);
                    } else if (log.isInfoEnabled()) {
                        log.info(sm.getString("parameters.decodeFail.info",
                                tmpName.toString(), tmpValue.toString()), e);
                    }
                }
            }

            tmpName.recycle();
            tmpValue.recycle();
            // Only recycle copies if we used them
            if (log.isDebugEnabled()) {
                origName.recycle();
                origValue.recycle();
            }
        }

        if (decodeFailCount > 1 && !log.isDebugEnabled()) {
            log.info(sm.getString("parameters.multipleDecodingFail",
                    Integer.valueOf(decodeFailCount)));
        }
    }
解析出键值对后，调用addParam(): 

    private void addParam( String key, String value ) {
        if( key==null ) return;
        ArrayList<String> values = paramHashValues.get(key);
        if (values == null) {
            values = new ArrayList<String>(1);
            paramHashValues.put(key, values);
        }
        values.add(value);
    }
parameter存储的数据结构是HashMap<String,ArrayList<String>>，如此相同键可以对应多个值，所以Request.getParameterValues()和Request.getParameter()区别是：前者以数组形式返回相同键的所有值，后者返回第一个值。

上面只弄明白了get方法传递的参数，那么post方法传递的参数是如何处理的？

post的报文:

POST /helloServlet HTTP/1.1
accept:image/jpeg, application/x-ms-application, image/gif, application/xaml+xml, image/pjpeg, application/x-ms-xbap, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*
referer:http://localhost:8080/formTest.html
accept-language:zh-CN
user-agent:Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C)
content-type:application/x-www-form-urlencoded
accept-encoding:gzip, deflate
host:localhost:8080
content-length:10
connection:Keep-Alive
cache-control:no-cache
cookie:JSESSIONID=7C7A6442B14FF1DE367AE6BC6D6A70F4

user=World
还是在org.apache.catalina.connector.parseParameters()中处理post请求的参数：
                byte[] formData = null;
                if (len < CACHED_POST_LEN) {
                    if (postData == null)
                        postData = new byte[CACHED_POST_LEN];
                    formData = postData;
                } else {
                    formData = new byte[len];
                }
                try {
                    if (readPostBody(formData, len) != len) {
                        return;
                    }
                } catch (IOException e) {
                    // Client disconnect
                    if (context.getLogger().isDebugEnabled()) {
                        context.getLogger().debug(
                                sm.getString("coyoteRequest.parseParameters"), e);
                    }
                    return;
                }
                parameters.processParameters(formData, 0, len);
readPostBod()将请求流中的报文体读到formData中: 

    protected int readPostBody(byte body[], int len)
        throws IOException {

        int offset = 0;
        do {
            int inputLen = getStream().read(body, offset, len - offset);
            if (inputLen <= 0) {
                return offset;
            }
            offset += inputLen;
        } while ((len - offset) > 0);
        
        String b = new String(body);
        
        return len;

    }
read方法从输入流中读取字节，只能往后读，前面经过InternalInputBuffer.parseRequestLine()和InternalInputBuffer.parseHeaders()方法已经将报文头解析完成，此时socket输入流中可用read方法直接读取报文体，其长度为报文头中的“content-length”。

参数的解析有点像懒加载，第一次用到才去解析，可以提高些效率。

org.apache.catalina.connector.Request类对org.apache.coyote.Request进行了封装，遵循Servlet API实现了HttpServletRequest接口。

woorh
关注
Servlet-API-4.0.1目录结构，常用类接口源码
不再更新，新博客 chgl16.space
02-25 934
1. 目录结构 http子包机构 2. Servlet接口 javax.servlet.Servlet是一个接口 package javax.servlet; import java.io.IOException; public interface Servlet { void init(ServletConfig var1) throws ServletException; ...
servlet-api 源码
05-13
解压后导入source可用
index加载显示servlet数据_Tomcat,Servlet源码分析!!!
weixin_39945445的博客
12-01 103
学习主题：源码分析对应作业1. Tomcat和Servlet源码分析(1) 写出Tomcat重要的类以及作用Tomcat架构图Server Server 服务器的意思，代表整个 tomcat 服务器，一个 tomcat 只有一个 Server Server 中包含至少一个 Service 组件，用于提供具体服务。这个在配置文件中也得到很 好的体现（port=“8005” shutdown="SH...
Tomcat的各种对象HttpServletRequest、HttpServletResponse、ServletContext、ServletConfig
cccccccmmm的博客
09-07 650
Tomcat有各种对象，处理请求的HttpServletRequest对象，产生响应的HttpServletResponse对象，全局的ServletContext对象，获取配置信息的ServletConfig对象。
【javaweb】Tomcat 9.0中的HttpServletRequest
最新发布
m0_61629312的博客
12-28 917
是 Java Servlet 中的接口，用于封装客户端请求的信息。它提供了访问客户端请求的方法，包括请求参数、请求头、请求方法等等。以下是一些用于获取请求参数的值。参数名通过字符串指定，返回字符串值或者 null（如果参数不存在）。用于获取指定请求头的值，返回字符串值或者 null（如果请求头不存在）。获取请求使用的 HTTP 方法，如 "GET"、"POST" 等。获取与此请求关联的会话，如果没有会话则创建一个新的会话。
servlet-api-3.1-源代码.zip
03-21
servlet源代码本来就是开放的，优快云居然那么多人要积分才能下载，仅仅是搬运而已。本资源是来自从Maven的servlet-api-3.1源代码，原地址还有servlet-api、servlet-api-doc，本资源仅仅下载了源代码的部分，需要的朋友可以去以下网址下载其它内容： https://repo1.maven.org/maven2/javax/servlet/javax.servlet-api/3.1.0/
tomcat6.0源码
01-27
《深入剖析Tomcat 6.0源码》 Tomcat 6.0是Apache软件基金会下的一个开源项目，是一款广泛使用的Java Servlet容器，它实现了Java Servlet和JavaServer Pages（JSP）规范，为Web应用程序提供了运行环境。源码分析对于...
深入学习Tomcat 6.0源码分析
Tomcat 6.0源码的研究对于理解Web服务器的工作原理，尤其是Java在Web服务器中的应用有着重要的意义。 **Tomcat 6.0源码知识点解析** 1. **Tomcat架构基础** Tomcat的架构是学习其源码前必须了解的。Tomcat可以...
下载Tomcat 6.0源码包，研究与开发必备
要理解Tomcat 6.0源码，首先需要对它的体系结构有所了解。Tomcat的架构可以分为几个主要组件： 1. **Server**：代表整个服务器，可以包含一个或多个服务。 2. **Service**：封装一个或多个连接器(Connector)和一个...
深入学习Apache Tomcat 6.0源码
### Apache Tomcat 6.0源码解读 #### 1. Tomcat目录结构和核心组件 Tomcat的源代码目录结构非常直观，可以分成以下几个主要部分： - `common`：存放Tomcat运行时共用的工具类、接口定义和异常处理等相关代码。 - ...
tomcat源码基于6.0
03-11
总结，Tomcat 6.0源码分析是一个深入了解Java Web服务器运行机制的过程，这不仅有助于我们理解Web服务器的工作原理，还能帮助我们优化应用性能、排查问题，甚至为开发自定义服务器提供基础。通过深入研究`apache-...
tomcat源码,servlet-api源码
12-28
7.0.59版本,直接去关联这个压缩包即可.如果版本不对http://archive.apache.org/dist/tomcat/去官网直接下也可以.
servlet-api源码赏析
Nicholas.S的博客
03-23 528
servlet简介 Servlet（Server Applet），全称Java Servlet，是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据，生成动态 Web内容。Servlet 运行于支持 Java的应用服务器中。从实现上讲，Servlet 可以响应任何类型的请求，但绝大多数情况下 Servlet 只用来扩展基于 HTTP协议 的 Web服务器。servlet 的工作模式...
Tomcat、Servlet、HTTP、Request
DengShengL的博客
07-16 229
Tomcat： 启动： * bin/startup.bat ,双击运行该文件即可 * 访问：浏览器输入：http://localhost:8080 回车访问自己 http://别人的ip:8080 访问别人 * 可能遇到的问题： 1. 黑窗口一闪而过： * 原因： 没有正确配置JAVA_HOME环境变量 * 解决方案：正确配置JAVA_H...
Eclipse中查看servlet源码包
qq_52038959的博客
04-22 1224
1. 准备工具包 servlet的源码包到这里下载。由于我使用的是Apache Tomcat 9.0.62版本所以这里面的是9.0.62的包，其他的版本也可以在里面找到。点链接进去如下图 往下滑找到zip点击下载即可 2. 导入源码包 打开eclipse，没有导入源码包的图示，会提示没有找到 可以看到路径servlet.http.HttpServlet，然后在左侧项目资源管理器下找到servlet-api.jar。如图 在servlet-api.jar处右键>>构建路径>>配置
重写HttpServletRequest兼容Tomcat
明月阁
07-03 1166
原文链接：http://www.itbus.tech/detail.html?id=8740之前Tomcat使用注意事项——Servlet版本，提到了不同的Tomcat支持的Servlet规范不一样，那么直接导致的结果就是，如果你的jar包中实现了javax.servlet.http.HttpServletRequest，就意味着这个jar包不能兼容Tomcat。怎么办呢？继承javax.servl
tomcat和http协议和servlet
weixin_46744534的博客
09-29 806
文章目录javaweb什么是javaweb？请求和响应常用的web服务器Tomcat目录介绍启动Tomcat服务器Tomcat的停止Tomcat端口号的修改idea下的操作Servlet什么是Servlet实现Servlet程序url地址到Servlet程序的访问Servlet的生命周期通过继承HttpServlet实现Servlet程序（日常） javaweb 什么是javaweb？ JavaWeb 是指，所有通过 Java 语言编写可以通过浏览器访问的程序的总称，叫 JavaWeb。 JavaWeb 是
HttpServletRequest接口
想要成为大佬的彪彪
05-24 1355
一：介绍 二：主要功能
tomcat6安装+servlet例子
YYlxid————Nothing is possible if not try～
12-10 1149
tomcat安装      下载tomcat6 地址http://tomcat.apache.org/download-60.cgi     配置环境变量 参考 http://blog.sina.com.cn/s/blog_4df2251d0100wbuv.html     在cmd终端启动tomcat成功  说明安装正确     myeclipse中添加tomcat       wind
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值