[Tomcat6.0源码]Servlet API之Request

最新推荐文章于 2022-09-07 14:15:36 发布
最新推荐文章于 2022-09-07 14:15:36 发布
阅读量1.2k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woorh/article/details/8065189
版权

在写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
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
servlet-api 源码
05-13
解压后导入source可用
index加载显示servlet数据_Tomcat,Servlet源码分析!!!
weixin_39945445的博客
12-01 74
学习主题：源码分析对应作业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 556
Tomcat有各种对象，处理请求的HttpServletRequest对象，产生响应的HttpServletResponse对象，全局的ServletContext对象，获取配置信息的ServletConfig对象。
servlet-api-3.1-源代码.zip
03-21
servlet源代码本来就是开放的，CSDN居然那么多人要积分才能下载，仅仅是搬运而已。本资源是来自从Maven的servlet-api-3.1源代码，原地址还有servlet-api、servlet-api-doc，本资源仅仅下载了源代码的部分，需要的朋友可以去以下网址下载其它内容： https://repo1.maven.org/maven2/javax/servlet/javax.servlet-api/3.1.0/
servlet-api源码赏析
Nicholas.S的博客
03-23 474
servlet简介 Servlet（Server Applet），全称Java Servlet，是用Java编写的服务器端程序。其主要功能在于交互式地浏览和修改数据，生成动态 Web内容。Servlet 运行于支持 Java的应用服务器中。从实现上讲，Servlet 可以响应任何类型的请求，但绝大多数情况下 Servlet 只用来扩展基于 HTTP协议 的 Web服务器。servlet 的工作模式...
tomcat6.0源码
01-27
《深入剖析Tomcat 6.0源码》 Tomcat 6.0是Apache软件基金会下的一个开源项目，是一款广泛使用的Java Servlet容器，它实现了Java Servlet和JavaServer Pages（JSP）规范，为Web应用程序提供了运行环境。源码分析对于...
tomcat源码基于6.0
03-11
总结，Tomcat 6.0源码分析是一个深入了解Java Web服务器运行机制的过程，这不仅有助于我们理解Web服务器的工作原理，还能帮助我们优化应用性能、排查问题，甚至为开发自定义服务器提供基础。通过深入研究`apache-...
tomcat6.0 jar包及源代码
05-15
本篇将围绕"tomcat6.0 jar包及源代码"这一主题，深入探讨Tomcat的核心组件、工作原理以及源代码解析。 首先，我们要理解Tomcat的jar包。在"apache-tomcat-6.0.16.zip"文件中，包含了Tomcat运行所需的各种jar包，如`...
tomcat源码
03-26
Tomcat6.0版本是历史上非常流行的一个版本，对于开发者来说，深入理解其源码有助于提升对Web服务运行机制、HTTP协议以及Java Servlet规范的理解。 1. **Tomcat架构** Tomcat的核心架构基于Catalina、Jasper、 ...
网上书店JSP+SQL+Tomcat
04-29
Apache Tomcat是一款开源的Java Servlet容器，它实现了Java EE中的Web部分，包括Servlet和JSP规范。在本项目中，Tomcat作为服务器运行环境，负责接收HTTP请求，解析JSP文件，执行其中的Java代码，然后将结果以HTML...
tomcat源码,servlet-api源码
12-28
7.0.59版本,直接去关联这个压缩包即可.如果版本不对http://archive.apache.org/dist/tomcat/去官网直接下也可以.
Tomcat、Servlet、HTTP、Request
DengShengL的博客
07-16 186
Tomcat： 启动： * bin/startup.bat ,双击运行该文件即可 * 访问：浏览器输入：http://localhost:8080 回车访问自己 http://别人的ip:8080 访问别人 * 可能遇到的问题： 1. 黑窗口一闪而过： * 原因： 没有正确配置JAVA_HOME环境变量 * 解决方案：正确配置JAVA_H...
Servlet-API-4.0.1目录结构，常用类接口源码
不再更新，新博客 chgl16.space
02-25 825
1. 目录结构 http子包机构 2. Servlet接口 javax.servlet.Servlet是一个接口 package javax.servlet; import java.io.IOException; public interface Servlet { void init(ServletConfig var1) throws ServletException; ...
Eclipse中查看servlet源码包
qq_52038959的博客
04-22 1117
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 1103
原文链接：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 613
文章目录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 1264
一：介绍 二：主要功能
tomcat6安装+servlet例子
YYlxid————Nothing is possible if not try～
12-10 1089
tomcat安装      下载tomcat6 地址http://tomcat.apache.org/download-60.cgi     配置环境变量 参考 http://blog.sina.com.cn/s/blog_4df2251d0100wbuv.html     在cmd终端启动tomcat成功  说明安装正确     myeclipse中添加tomcat       wind
@RequestParam 参数偶尔丢失
当个码农写bug
08-11 3502
改动过一版代码之后, 发现@RequestParam注解的参数经常丢失. 首先确认前端确实把参数传过来了, 用curl直接请求接口, 发现有时候会出现参数丢失, 重启后再用curl请求某个都是参数的接口, 无论怎么重试都不会有问题. 没办法了, 只好去跟tomcat的源码, 因为@RequestParam的参数会从request.getParameterMap()方法里取对应的值, 然后打个断...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值