ChinaRainbowSea

Sevlet规范：HttpServlet类和 HttpServletRequest接口源码解析

每博一文案

命运总是不如人愿，但往往是在无数的痛苦总，在重重的矛盾和艰辛中，才是人成熟起来。
你，为这瞬间的辉煌，忍耐了多少暗淡无光的日月，你会死亡，但你也会证明生命有多强大。
一次邂逅，一次目光的交融，就是永远的合二为一，就是与上帝的契约；总是风暴雷电，
也无法分解这种心灵的粘结。
直到在哪远离故乡的地方发生过那场刻苦铭心的感谢悲剧后，他才理解了人活在世界上有多少幸福，
又有多少苦难！生活不能等待别人来安排，要自己去争取和奋斗；而不论其结果是喜和悲，但可以慰籍，你总不枉在这
世界上活了一场，有了这样的认识，你就会珍重生活，而不会玩世不恭；同时也会给人自身注入一种强大的内在力量......

                                            —————— 《平凡的世界》路遥

文章目录

Sevlet规范：HttpServlet类和 HttpServletRequest接口源码解析
- 每博一文案
- 1. HTTP协议解读
- - 1.1 什么是HTTP协议？
  - 1.2 HTTP请求协议的具体报文
  - 1.3 HTTP响应协议的具体报文
- 2. GET请求和POST请求有什么区别？
- - 2.1 GET请求和POST请求如何选择，什么时候使用GET请求，什么时候使用POST请求？
- 3. HttpServlet源码分析
- - 3.1 HttpServlet 处理 get 请求和 post 请求源码分析
- 4. HttpServletRequest接口详解
- - - 4.0.1 HttpServletRequest对象中都有什么信息？都包装了什么信息？
  - 4.1 获取前端用户提交的数据信息
  - 4.2 请求域对象的详解
  - 4.3 跳转（两个Servlet 共享数据）
  - 4.4 post 请求 request 乱码问题？
  - 4.5 response 响应到浏览器中的乱码问题？
  - 4.6 get 请求的 request 乱码问题？
  - 4.7 HttpServletRequest接口的其他常用方法
- 5. 补充：
- 6. 总结：
- 7. 最后：

1. HTTP协议解读

什么是协议？

协议实际上是某些人，或者某些组织提前制定好的一套规范，大家都按照这个规范来，这样可以做到沟通无障碍。

协议就是一套规范，就是一套标准。由其他人或其他组织来负责制定的。

我说的话你能听懂，你说的话，我也能听懂，这说明我们之间是有一套规范的，一套协议的，这套协议就是：中国普通话协议。我们都遵守这套协议，我们之间就可以沟通无障碍。但是如果我们遵守不同的协议规范的话，就无法通信了，比如：你说的是阿拉伯语，我说的是汉语，我听不懂你说什么，你也听不同我说什么。你我两者之间无法通信交流。

1.1 什么是HTTP协议？

HTTP协议：是W3C制定的一种超文本传输协议。（通信协议：发送消息的模板提前被制定好。）
W3C：https://www.w3.org/
- 万维网联盟组织
- 负责制定标准的：HTTP HTML4.0 HTML5 XML DOM等规范都是W3C制定的。
- 万维网之父：蒂姆·伯纳斯·李

什么是超文本？

超文本说的就是：不是普通文本，比如流媒体：声音、视频、图片等。
HTTP协议支持：不但可以传送普通字符串，同样支持传递声音、视频、图片等流媒体信息。
这种协议游走在B (浏览器)和S (服务器)之间。B向S发数据要遵循HTTP协议。S向B发数据同样需要遵循HTTP协议。这样B和S才能解耦合。

什么是解耦合？

这里指定是： B (浏览器) 不依赖 S(服务器) ，S 也不依赖 B

B/S表示：B/S结构的系统（浏览器访问WEB服务器的系统）

HTTP协议的请求 (request) 和响应(response)

浏览器向 WEB服务器发送数据，叫做：请求（request)。
WEB服务器向浏览器发送数据，叫做：响应（response）。

HTTP协议包括：

请求协议
- 浏览器向 WEB服务器发送数据的时候，这个发送的数据需要遵循一套标准，这套标准中规定了发送的数据具体格式。
响应协议
- WEB服务器向浏览器发送数据的时候，这个发送的数据需要遵循一套标准，这套标准中规定了发送的数据具体格式。

HTTP协议总结：

HTTP协议就是提前制定好的一种消息模板。

不管你是哪个品牌的浏览器，都是这么发，同样的不管你是哪个品牌的WEB服务器，都是这么发。
火狐浏览器可以向 Tomcat发送请求，也可以向Jetty服务器发送请求。浏览器不依赖具体的服务器品牌。
WEB服务器也不依赖具体的浏览器品牌。可以是FF浏览器，也可以是Chrome浏览器，可以是IE，都行。

1.2 HTTP请求协议的具体报文

注意：HTTP请求协议中有多种请求方式。这里我们说的是常用的 get 请求和 post 请求。在该文章的下文有更加详细的说明。

HTTP的请求协议（B (浏览器)-> S(服务器)）

HTTP的请求协议包括：如下 4 个部分： 请求行，请求头，空白行，请求体。

如何查看我们提交的数据报文，在浏览器当中

我们可以在提交数据的时候按 F12 快捷键查看，或者是右键鼠标浏览器，在弹出的窗口当中，选择点击检查。如下图所示：

在选择点击检查按钮之后，弹出如下窗口，选择其中的 Network （网络）选项。如下图所示：只要当我们在前端提交了数据，就可以在如下的窗口当中捕获到并显示出相应的报文信息。

测试如下，看看是否可以捕获到我们的请求报文的信息数据。如下图所示：

查看我们提交的数据信息：点击我们捕获到的报文信息，再点击 ——> Paload 选项。

如下是：HTTP请求协议的具体报文：GET请求

首先编写一个是 Get 请求提交的表单 html 文件，具体的代码编写如下：

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HTTP请求登录title>
head>
<body>
<h2>get 请求h2>
<form action="" method="get">
    username: <input type="text" name="username" /> <br>
    userpassword: <input type="password" name="userpswd" /> <br>
    <input type="submit" value="get" />
form>

<h2>post 请求h2>
<form action="" method="post">
    username: <input type="text" name="username" /> <br>
    userpassword: <input type="password" name="userpswd" /> <br>
    <input type="submit" value="post" />
form>
body>
html>

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Connection: keep-alive
# 下面一行是请求行
Host: 127.0.0.1:8080
# 下面的是请求头
Referer: http://127.0.0.1:8080/servlet08/login.html
sec-ch-ua: "Google Chrome";v="111", "Not(A:Brand";v="8", "Chromium";v="111"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36
# 下面是空白行：用于分隔请求头 与 请求体 

# 下面是请求体：向服务器发送的具体数据。
username=Hello&userpswd=123

如下是另一种的格式下 get 请求的具体报文信息

GET /servlet05/getServlet?username=lucy&userpwd=1111 HTTP/1.1                           
 # 请求行
Host: localhost:8080                                                                   
# 请求头
Connection: keep-alive
sec-ch-ua: "Google Chrome";v="95", "Chromium";v="95", ";Not A Brand";v="99"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Referer: http://localhost:8080/servlet05/index.html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
 # 空白行
  
 # 请求体

如下 post 请求信息

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7
Cache-Control: max-age=0
Connection: keep-alive
Content-Length: 25
Content-Type: application/x-www-form-urlencoded
# 请求头
Host: 127.0.0.1:8080
# 请求行
Origin: http://127.0.0.1:8080
Referer: http://127.0.0.1:8080/servlet08/login.html?username=Hello&userpswd=123
sec-ch-ua: "Google Chrome";v="111", "Not(A:Brand";v="8", "Chromium";v="111"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Sec-Fetch-Dest: document
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: same-origin
Sec-Fetch-User: ?1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36

# 空白行

# 请求体

如下是另一种的格式下 post 请求的具体报文信息

POST /servlet05/postServlet HTTP/1.1                                                 
# 请求行
Host: localhost:8080                                                                
# 请求头
Connection: keep-alive
Content-Length: 25
Cache-Control: max-age=0
sec-ch-ua: "Google Chrome";v="95", "Chromium";v="95", ";Not A Brand";v="99"
sec-ch-ua-mobile: ?0
sec-ch-ua-platform: "Windows"
Upgrade-Insecure-Requests: 1
Origin: http://localhost:8080
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.54 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Sec-Fetch-Dest: document
Referer: http://localhost:8080/servlet05/index.html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9
  # 空白行
                                                          
  # 请求体
  username=lisi&userpwd=123

请求行： 由三部分组成： 请求方式，URI ，HTTP版本号 。

请求行：第一部分：请求方式（7种）： get(常用的)，post(常用的)，delete，put，head，options，trace 。
请求行：第二部分: URI

URL : 统一资源定位符。代表网络中某个资源。注意： 可以通过 URL 定位到该资源，可以直接在浏览器当中输入URI 访问网络当中的资源）。比如： http://localhost:8080/servlet05/index.html 这是URL。

URI ：统一资源标识符。代表网络中某个资源的名字。注意： URI 是无法定位资源的（就是无法通过直接在浏览器当中输入URI 访问网络当中的资源）。比如：/servlet05/index.html 这是URI。

URI 和 URL 什么关系，有什么区别？

URL 是包括了 URI 的。

请求行：第三部分： HTTP协议版本号

请求头： 包含：请求的主机的IP地址，主机的端口号，浏览器信息，平台信息，cookie 等信息。

空白行： 空白行是用来区分“请求头”和“请求体”

请求体： 向服务器发送的具体数据。

1.3 HTTP响应协议的具体报文

HTTP的响应协议（S(浏览器) --> B(客户端)）HTTP的响应协议包括4部分 : 状态行，响应头，空白行，响应体 。

HTTP响应协议的具体报文：

Accept-Ranges: bytes              
Connection: keep-alive
Content-Length: 598
Content-Type: text/html             # 响应头
Date: Thu, 30 Mar 2023 02:48:49 GMT
ETag: W/"598-1680144315095"
Keep-Alive: timeout=20
Last-Modified: Thu, 30 Mar 2023 02:45:15 GMT
                                   # 空白行

<!DOCTYPE html>                         # 响应体：其实就是源代码的信息
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HTTP请求登录</title>
</head>
<body>
<h2>get 请求</h2>
<form action="" method="get">
    username: <input type="text" name="username" /> <br>
    userpassword: <input type="password" name="userpswd" /> <br>
    <input type="submit" value="get" />
</form>

<h2>post 请求</h2>
<form action="" method="post">
    username: <input type="text" name="username" /> <br>
    userpassword: <input type="password" name="userpswd" /> <br>
    <input type="submit" value="post" />
</form>
</body>
</html>

另外一种 post 响应的具体数据报文信息。

HTTP/1.1 200 ok                                    #  状态行
Content-Type: text/html;charset=UTF-8              # 响应头
Content-Length: 160
Date: Mon, 08 Nov 2021 13:19:32 GMT
Keep-Alive: timeout=20
Connection: keep-alive
                                      # 空白行

<!DOCTYPE html>                         # 响应体：其实就是源代码的信息
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HTTP请求登录</title>
</head>
<body>
<h2>get 请求</h2>
<form action="" method="get">
    username: <input type="text" name="username" /> <br>
    userpassword: <input type="password" name="userpswd" /> <br>
    <input type="submit" value="get" />
</form>

<h2>post 请求</h2>
<form action="" method="post">
    username: <input type="text" name="username" /> <br>
    userpassword: <input type="password" name="userpswd" /> <br>
    <input type="submit" value="post" />
</form>
</body>
</html>

状态行 ：由三部分组成：协议版本号，状态码，状态描述信息。

状态行，第一部分： 协议版本号（HTTP/1.1）
状态行，第二部分： 状态码（HTTP）协议中规定的响应状态号，不同的响应结果对应不同的号码）。

如下是一些常见的状态码的意义：

200 ：表示请求响应成功，正常结束。

404：表示访问的资源不存在，通常是因为要么你填写的路径写错了，要么是你路径写对了，但是服务器中对应的资源并没有启动成。总之 404 错误是基本是前端错误。

405 : 表示前端发送的请求方式与后端接受处理(该请求)的方式不一致时发生的：基本上时如下两种情况：

前端是POST请求，后端的处理方式按照get方式进行处理时，发生405

前端是GET请求，后端的处理方式按照post方式进行处理时，发生405

具体的该文章后面有详细的说明。所以请不要走开。

500 表示服务器端的程序出现了异常。一般会认为是服务器端的错误导致的。

总结：

以4开始的，一般是浏览器端的错误导致的。

以5开始的，一般是服务器端的错误导致的。

状态行，第三部分： 状态的描述信息：

OK 表示正则成结束。
not found: 表示资源找不到。

空白行： 用来分隔“响应头”和“响应体”的。

响应体： 响应体就是响应的正文，这些内容是一个长的字符串，这个字符串被浏览器渲染，解释并执行，最终展示出效果。简单的说就是html 对应的源代码。

2. GET请求和POST请求有什么区别？

怎么向服务器发送Get 请求，怎么向服务器发送 Post 请求？

到目前为止，只有一种情况可以发送post 请求：就是用 form 表单，并且 form 标签当中的 method 的属性值必须为 method = "post" 才行。

其他所有情况一律都是get请求：

在浏览器地址栏上直接输入URL，敲回车，属于get请求。

在浏览器上直接点击超链接，属于get请求。

使用form表单提交数据时，form标签中没有写method属性，默认就是get

或者使用form的时候，form标签中method属性值为：method=“get”

…

GET请求和POST请求有什么区别？

Get请求：

get 请求发送数据的时候，数据会挂在URI的后面，并且在 URI 后面添加一个 "?" ，" ? " 后面的就是数据了，这样会导致发送的数据回显到浏览器的地址栏上如下显示的：。（get 请求在 “请求行”上发送数据）。

get 请求只能发送普通的字符串数据，并且发送字符串的长度有限制，不同的浏览器限制不同，这个没有明确的规范。并不能发送流媒体信息：比如：图片，声音，视频等等.
get 请求无法发送大数据量。
get 请求在 W3C 中是这样介绍的：get 请求比较适合从服务器端获取数据。
get 请求是安全的，get 请求是安全的，因为：get 请求只是为了从服务器上获取数据，不会对服务器造成威胁，注意：get请求本身是安全的，你不要用错了，用错了之后，就冤枉get 请求不安全。这不是 get 请求的问题，而是你使用的问题。比如说：一个注册表单的信息的提交，应该使用的 post 请求，而却使用的是 get 请求，导致提交的信息回显到了地址栏上了。
get 请求是支持缓存了。

补充点：

任何一个get请求最终的“响应结果”都会被浏览器缓存起来。在浏览器缓存当中：

一个get请求的路径a 对应一个资源。

一个get请求的路径b 对应一个资源。

一个get请求的路径c 对应一个资源。

…

实际上，你只要发送get请求，浏览器做的第一件事都是先从本地浏览器缓存中找，找不到的时候才会去服务器上获取。这种缓存机制目的是为了提高用户的体验。

有没有这样一个需求：我们不希望get请求走缓存，怎么办？怎么避免走缓存？我希望每一次这个get请求都去服务器上找资源，我不想从本地浏览器的缓存中取。

只要每一次get请求的请求路径不同即可。

https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=789789787897898

https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=789789787897899

https://n.sinaimg.cn/finance/590/w240h350/20211101/7cabc342ff5b9dc018b4b00cc.jpg?t=系统毫秒数

怎么解决？可以在路径的后面添加一个每时每刻都在变化的“时间戳”，这样，每一次的请求路径都不一样(缓存的路径也是不一样的)，浏览器就不走缓存了。

Post请求 ：

post 请求发送的数据的时候，在请求体当中发送的，不会回显到浏览器的地址栏上，也就是说 Post 发送的数据，在浏览器的地址栏上不能看到的。（post 请求在 “请求体”当中发送数据）。
post请求可以发送任何类型的数据，包括普通字符串，流媒体等信息：图片，视频，声音等。
post请求可以发送大数据量，理论上没有限制的。
post 请求在 W3C 是这样说的： post 请求比较适合向服务器传送数据。
post 请求是危险的，因为： post 请求时向服务器提交数据，如果这些数据是通过后门的方式进入到服务器当中，服务器是很危险的。另外post 是为了提交数据，所以一般情况下拦截请求的时候，大部分选择的是拦截（监听） post 请求。
post 是不支持缓存的。因为：（POST是用来修改服务器端的资源的。）post请求之后，服务器“响应的结果”不会被浏览器缓存起来。因为这个缓存没有意义。

2.1 GET请求和POST请求如何选择，什么时候使用GET请求，什么时候使用POST请求？

怎么选择GET请求和POST请求呢？衡量标准是什么呢？你这个请求是想获取服务器端的数据，还是想向服务器发送数据。如果你是想从服务器上获取资源，建议使用GET请求，如果你这个请求是为了向服务器提交数据，建议使用POST请求。
大部分的form表单提交，都是post方式，因为form表单中要填写大量的数据，这些数据是收集用户的信息，一般是需要传给服务器，服务器将这些数据保存/修改等。
如果表单中有敏感信息，还是建议适用post请求，因为get请求会回显敏感信息到浏览器地址栏上。（例如：密码信息）
做文件上传，一定是post请求。要传的数据不是普通文本。
其他情况都可以使用get请求。

Get 请求与 Post 请求的共性

不管你是get请求还是post请求，发送的请求数据格式是完全相同的，只不过位置不同，格式都是统一的：都是：name=value&name=value&name=value&name=value

其中的 name 表示：以 form 表单为例：form 表单中的 input 标签当中的 name 。

<form>
    <input type="text" name="username" > 
form>

其中的 value 表示的是：同样的以 form 表单为例：form 表单中的 input 标签当中的 value。

<form>
    interest:
    smoke<input type="checkbox" name="aihao" value="s"/>
    drink <input type="checkbox" name="aihao" value="d"/>
    tangtou <input type="checkbox" name="aihao" value="tt"/>
form>

3. HttpServlet源码分析

HttpServlet类是专门为 HTTP协议准备的。比 GenericServlet更加适合 HTTP协议下的开发。
HttpServlet在哪个包下？
- 这是在 Tomcat 10 的基础上：jakarta.servlet.http.HttpServlet，而后面 Tomcat 9 之前的(包括Tomcat 9 )以内的包是在 : javax.servlet.http.HttpServlet 包下的。
到目前为止我们接触了servlet规范中哪些接口？。注意： 如下的是基于 Tomcat 10 的基础上的，而 Tomcat 9 之前的包括 9 将如下的 jakarta 替换为 javax 就可以了，具体原因大家可以移步至：javaEE Web(Tomcat)深度理解和 Servlet的本质_ChinaRainbowSea的博客-CSDN博客中。
- jakarta.servlet.Servlet 核心接口（接口）
- jakarta.servlet.ServletConfig Servlet配置信息接口（接口）
- jakarta.servlet.ServletContext Servlet上下文接口（接口）
- jakarta.servlet.ServletRequest Servlet请求接口（接口）
- jakarta.servlet.ServletResponse Servlet响应接口（接口）
- jakarta.servlet.ServletException Servlet异常（类）
- jakarta.servlet.GenericServlet 标准通用的Servlet类（抽象类）
http包下都有哪些类和接口呢？jakarta.servlet.http.*
- jakarta.servlet.http.HttpServlet （HTTP协议专用的Servlet类，抽象类）
- jakarta.servlet.http.HttpServletRequest （HTTP协议专用的处理请求对象）
- jakarta.servlet.http.HttpServletResponse （HTTP协议专用的处理响应对象）
HttpServletRequest对象中封装了什么信息？
- HttpServletRequest 简称为 request 对象。
- HttpServletRequest 中封装了请求协议的全部内容。
  - Tomcat 服务器(WEB 服务器) 将 “请求协议”中的数据全部解析出来，然后将这些数据全部封装到 request 对象当中了。也就是说，我们只要面向 HttpServletRequest 接口编程，就可以获取请求协议当中的数据了。
- HttpServletRequest，简称 request对象。
HttpServletResponse对象 是专门用来响应HTTP协议到浏览器的。

回忆Servlet生命周期？

用户第一次请求
- Tomcat服务器通过反射机制，调用无参数构造方法。创建Servlet对象。(web.xml文件中配置的Servlet类对应的对象。)
- Tomcat服务器调用Servlet对象的init方法完成初始化。
- Tomcat服务器调用Servlet对象的service方法处理请求。
用户第二次请求
- Tomcat服务器调用Servlet对象的service方法处理请求。
用户第三次请求
- Tomcat服务器调用Servlet对象的service方法处理请求。
…
- Tomcat服务器调用Servlet对象的service方法处理请求。
服务器关闭
- Tomcat服务器调用Servlet对象的destroy方法，做销毁之前的准备工作。
- Tomcat服务器销毁Servlet对象。

HttpServlet源码分析：

public class HelloServlet extends HttpServlet {
	// 用户第一次请求，创建HelloServlet对象的时候，会执行这个无参数构造方法。
	public HelloServlet() {
    }
    
    //override 重写 doGet方法
    //override 重写 doPost方法
}

public abstract class GenericServlet implements Servlet, ServletConfig,
        java.io.Serializable {
           
	// 用户第一次请求的时候，HelloServlet对象第一次被创建之后，这个init方法会执行。
    public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }
	// 用户第一次请求的时候，带有参数的init(ServletConfig config)执行之后，会执行这个没有参数的init()
	public void init() throws ServletException {
        // NOOP by default
    }
}

// HttpServlet模板类。
public abstract class HttpServlet extends GenericServlet {
    // 用户发送第一次请求的时候这个service会执行
    // 用户发送第N次请求的时候，这个service方法还是会执行。
    // 用户只要发送一次请求，这个service方法就会执行一次。
    @Override
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {

        HttpServletRequest  request;
        HttpServletResponse response;

        try {
            // 将ServletRequest和ServletResponse向下转型为带有Http的HttpServletRequest和HttpServletResponse
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }
        // 调用重载的service方法。
        service(request, response);
    }
    
    // 这个service方法的两个参数都是带有Http的。
    // 这个service是一个模板方法。
    // 在该方法中定义核心算法骨架，具体的实现步骤延迟到子类中去完成。
    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 获取请求方式
        // 这个请求方式最终可能是：""
        // 注意：request.getMethod()方法获取的是请求方式，可能是七种之一：
        // GET POST PUT DELETE HEAD OPTIONS TRACE
        String method = req.getMethod();

        // 如果请求方式是GET请求，则执行doGet方法。
        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            // 如果请求方式是POST请求，则执行doPost方法。
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }
    
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException{
        // 报405错误
        String msg = lStrings.getString("http.method_get_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 报405错误
        String msg = lStrings.getString("http.method_post_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
}

/*
通过以上源代码分析：
	假设前端发送的请求是get请求，后端程序员重写的方法是doPost
	假设前端发送的请求是post请求，后端程序员重写的方法是doGet
	会发生什么呢？
		发生405这样的一个错误。
		405表示前端的错误，发送的请求方式不对。和服务器不一致。不是服务器需要的请求方式。
	
	通过以上源代码可以知道：只要HttpServlet类中的doGet方法或doPost方法执行了，必然405.

怎么避免405的错误呢？
	后端重写了doGet方法，前端一定要发get请求。
	后端重写了doPost方法，前端一定要发post请求。
	这样可以避免405错误。
	
	这种前端到底需要发什么样的请求，其实应该后端说了算。后端让发什么方式，前端就得发什么方式。
	
有的人，你会看到为了避免405错误，在Servlet类当中，将doGet和doPost方法都进行了重写。
这样，确实可以避免405的发生，但是不建议，405错误还是有用的。该报错的时候就应该让他报错。
如果你要是同时重写了doGet和doPost，那还不如你直接重写service方法好了。这样代码还能
少写一点。
*/

3.1 HttpServlet 处理 get 请求和 post 请求源码分析

上面我们在：HTTP响应协议的具体报文模块当中提到的状态行当中的状态码部分中的一个为 405 前端用户提交的get/post请求与后端服务器不一致导致的错误。如下测试

当：前端发送的请求是 get 请求。后端程序员重写的方法是doPost

对于前端用户提交数据的html 代码设计如下：注意：这里我们前端提交的是 get请求。

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HTTP请求登录title>
head>
<body>
<h2>get 请求h2>

<form action="/servlet08//Test" method="get">
    username: <input type="text" name="username"/> <br>
    userpassword: <input type="password" name="userpswd"/> <br>
    <input type="submit" value="get"/>
form>
body>
html>

如下的是对应后端服务器 Servlet 的代码设计。注意了，这里我们 Servlet 服务器端处理的是 doPost 请求的

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class HttpServletTest extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 设置浏览器当中显示的格式
        response.setContentType("text/html;charSet=utf-8");
        PrintWriter writer = response.getWriter();

        writer.println("Hello World");

    }
}

如下运行结果： 报了 405 错误，原因是：我们前后端的处理请求的不一致。

当：前端发送的请求是post请求，后端程序员重写的方法是doGet 出现的错误

对于前端用户提交数据的html 代码设计如下：注意：这里我们前端提交的是 post请求。

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HTTP请求登录title>
head>
<body>
<h2>post 请求h2>

<form action="/servlet08//Test" method="post">
    username: <input type="text" name="username"/> <br>
    userpassword: <input type="password" name="userpswd"/> <br>
    <input type="submit" value="get"/>
form>
body>
html>

如下的是对应后端服务器 Servlet 的代码设计。注意了，这里我们 Servlet 服务器端处理的是 doGet 请求的。

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class HttpServletTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 设置浏览器当中显示的格式
        response.setContentType("text/html;charSet=utf-8");
        PrintWriter writer = response.getWriter();

        writer.println("Hello World");

    }
}

如下运行结果： 报了 405 错误，原因是：我们前后端的处理请求的不一致。

通过以上源代码分析：

假设前端发送的请求是get请求，后端程序员重写的方法是doPost

假设前端发送的请求是post请求，后端程序员重写的方法是doGet
会发生什么呢？发生405这样的一个错误。405表示前端的错误，发送的请求方式不对。和服务器不一致。不是服务器需要的请求方式。

为什么为发生 405 错误呢？

我们从HttpServlet 源码上分析：

// HttpServlet模板类。
public abstract class HttpServlet extends GenericServlet {
    // 用户发送第一次请求的时候这个service会执行
    // 用户发送第N次请求的时候，这个service方法还是会执行。
    // 用户只要发送一次请求，这个service方法就会执行一次。
    @Override
    public void service(ServletRequest req, ServletResponse res)
        throws ServletException, IOException {

        HttpServletRequest  request;
        HttpServletResponse response;

        try {
            // 将ServletRequest和ServletResponse向下转型为带有Http的HttpServletRequest和HttpServletResponse
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }
        // 调用重载的service方法。
        service(request, response);
    }
    
    // 这个service方法的两个参数都是带有Http的。
    // 这个service是一个模板方法。
    // 在该方法中定义核心算法骨架，具体的实现步骤延迟到子类中去完成。
    protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 获取请求方式
        // 这个请求方式最终可能是：""
        // 注意：request.getMethod()方法获取的是请求方式，可能是七种之一：
        // GET POST PUT DELETE HEAD OPTIONS TRACE
        String method = req.getMethod();

        // 如果请求方式是GET请求，则执行doGet方法。
        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            // 如果请求方式是POST请求，则执行doPost方法。
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }
    
    
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException{
        // 报405错误
        String msg = lStrings.getString("http.method_get_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {
        // 报405错误
        String msg = lStrings.getString("http.method_post_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }

通过以上源代码阅读以及运行测试可以知道：只要没有重写对应 HttpServlet类中的doGet方法或doPost方法，就会报 405 错误，因为没有重写了doGet 或 doPost 方法就会执行其中的 HttpServlet 当中编写的 doGet / doPost 方法，而如果执行了的是 HttpServlet 当中 doGet / doPost 方法就会报 405 错误，提示你没有重写对应的 doGet / doPost 方法。

怎么避免405的错误呢？

后端重写了doGet方法，前端一定要发get请求。后端重写了doPost方法，前端一定要发post请求。这样可以避免405错误。这种前端到底需要发什么样的请求，其实应该后端说了算。后端让发什么方式，前端就得发什么方式。

补充

有的人，你会看到为了避免405错误，在Servlet类当中，将doGet和doPost方法都进行了重写。
这样，确实可以避免405的发生，但是不建议，405错误还是有用的。该报错的时候就应该让他报错。
如果你要是同时重写了doGet和doPost，那还不如你直接重写service方法好了。这样代码还能少写一点。

我们编写的HelloServlet直接继承HttpServlet，直接重写HttpServlet类中的service()方法行吗？

可以，只不过你享受不到405错误。享受不到HTTP协议专属的东西。

一个Servlet类的开发步骤：

第一步：编写一个Servlet类，直接继承HttpServlet

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class HttpServletTest extends HttpServlet {
}

第二步：重写doGet方法或者重写doPost方法，到底重写谁，javaweb程序员说了算。注意：前后端请求处理是要保持一致的。

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class HttpServletTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 设置浏览器当中显示的格式
        response.setContentType("text/html;charSet=utf-8");
        PrintWriter writer = response.getWriter();

        writer.println("Hello World");

    }
}

第三步：将Servlet类配置到web.xml文件当中。


<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">


    <servlet>
        <servlet-name>HttpServletTestservlet-name>
        <servlet-class>com.RainbowSea.servlet.HttpServletTestservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>HttpServletTestservlet-name>
        <url-pattern>/Testurl-pattern>
    servlet-mapping>
web-app>

第四步：准备前端的页面（form表单），form表单中指定请求路径即可

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HTTP请求登录title>
head>
<body>
<h2>get 请求h2>

<form action="/servlet08//Test" method="get">
    username: <input type="text" name="username"/> <br>
    userpassword: <input type="password" name="userpswd"/> <br>
    <input type="submit" value="get"/>
form>
body>
html>

4. HttpServletRequest接口详解

HttpServletRequest是一个接口，全限定名称：jakarta.servlet.http.HttpServletRequest 这个是基于 Tomcat 10 下的对应的包路径，如果是 Tomcat 9 (包括9)就是将其中的 jakarta 修改为 javax 就可以了。
HttpServletRequest接口是Servlet规范中的一员。

HttpServletRequest接口的父接口：ServletRequest

public interface HttpServletRequest extends ServletRequest {}

HttpServletRequest接口的实现类谁写的? HttpServletRequest对象是谁给创建的？
- 通过测试：就是通过 request.getClass() 方法获取到该接口的实现类， org.apache.catalina.connector.RequestFacade 实现了 HttpServletRequest接口
```
public class RequestFacade implements HttpServletRequest {}
```

测试结果说明：Tomcat服务器（WEB服务器、WEB容器）实现了HttpServletRequest接口，还是说明了Tomcat服务器实现了Servlet规范。而对于我们javaweb程序员来说，实际上不需要关心这个，我们只需要面向接口编程即可。我们关心的是HttpServletRequest接口中有哪些方法，这些方法可以完成什么功能！！！！

4.0.1 HttpServletRequest对象中都有什么信息？都包装了什么信息？

HttpServletRequest 对象是 Tomcat 服务i其负责创建的，这个对象中封装了如下信息，以及如下 HTTP的请求协议？
实际上是用户发送请求的时候，遵循了HTTP协议，发送的是遵循了HTTP的请求协议的信息内容(name=value&name=value&…)，Tomcat 服务器会将客户端遵循HTTP协议发送的信息内容获取到，并将其数据全部解析出来，然后Tomcat服务器把这些信息封装到 HttpServletRequest 对象当中，传给了我们 Javaweb 程序员。
所以 Javaweb 程序员面向 HttpServletRequest 接口编程，调用其中的方法就可以获取到用户发送的请求信息了。

4.1 获取前端用户提交的数据信息

request和response对象的生命周期？

request对象和response对象，一个是请求对象，一个是响应对象。这两个对象只在当前请求中有效。

一次请求对应一个request。

两次请求则对应两个request。

…

我们后端如何怎么获取前端浏览器用户提交的数据？

想要获取到前端浏览器用户提交的数据，使用interface ServletRequest 接口当中抽象方法，也就是HttpServletRequest 实现了 ServletRequest 接口的具体实现类中重写其中的抽象方法。

Map<String,String[]> getParameterMap() 这个是获取用户提交的数据，并存储到Map集合当中<前端的name,前端的value>
Enumeration<String> getParameterNames() 这个是获取Map集合中所有的key就是前端中所有的name 值 
String[] getParameterValues(String name) 根据(前端的name值)key获取Map集合的(前端的value值)value
String getParameter(String name)  获取value这个一维数组当中的第一个元素。这个方法最常用。
// 以上的4个方法，和获取用户提交的数据有关系
// 注意： 这里为什么 value 的值是用String[] 数组存储的。后面有说明。

思考：如果是你，前端的form表单提交了数据之后，你准备怎么存储这些数据，你准备采用什么样的数据结构去存储这些数据呢？

前端提交的数据格式：username=abc&userpwd=111&aihao=learn&aihao=programme&aihao=playbasketball

注意： 前端表单提交数据的时候，假设提交了120这样的“数字”，其实是以字符串"120"的方式提交的，所以服务器端获取到的一定是一个字符串的"120"，而不是一个数字。（前端永远提交的是字符串，后端获取的也永远是字符串。）所以都是用 String字符串。

我会采用Map集合来存储：

Map<String,String>
    key存储String
    value存储String
    这种想法对吗？不对。
    如果采用以上的数据结构存储会发现key重复的时候value覆盖。比如这里的 name=aihao 是多选框内容，有多个值aihao=s&aihao=d&aihao=tt
    key         value
    ---------------------
    username    abc
    userpwd     111
    aihao       learn
    aihao       programme
    aihao       playbasketball
    这样是不行的，因为map的key不能重复。
Map<String, String[]>
    key存储String
    value存储String[]  // 将 value 值用 String 数组存储起来。这样就避免了上述的key 重复后 value内容上的覆盖，而没有都存储起来的缺点。
    key				value
    -------------------------------
    username		{"abc"}
    userpwd			{"111"}
    aihao			{"learn","programme","playbasketball"}

举例使用上述四个方法获取前端用户提交的数据

第一步：编写设计好 html 前端显示页面，如下：注意，这里我们前端使用的是 post 请求，后端的Servlet 就要用 doPost 请求处理，前后端保持一致，不然报 405错误。

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>user registertitle>
head>
<body>
<h1>user registerh1>


<form action="/servlet08//Request" method="post">
    username:<input type="text" name="username"/><br>
    password:<input type="password" name="userpassword"/> <br>
    interest:
    学习:<input type="checkbox" name="aihao" value="learn"/>
    编程: <input type="checkbox" name="aihao" value="programme"/>
    打篮球: <input type="checkbox" name="aihao" value="playbasketball"/>
    <br>
    <input type="submit" value="register"/>
form>
body>
html>

第二步： 编写对应处理前端用户提交的请求的 Servlet ，注意前后端请求处理保持一致 : 这里举例使用的是上述四个获取用户请求的其中的一个方法:

Map<String,String[]> getParameterMap() 这个是获取用户提交的数据，并存储到Map集合当中<前端的name,前端的value>

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class RequestServletTest extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 获取到前端用户提交的数据信息(name,value)，并存储到Map集合当中去。
        Map<String, String[]> parameterMap = request.getParameterMap();

        // 遍历存储了前端用户提交数据的Map集合
        // 获取到 Map 当中所有的 key 值(也就是前端的用户提交的所有的name 值)
        Set<String> strings = parameterMap.keySet();

        // 获取到 set 的迭代器
        Iterator<String> iterator = strings.iterator();
        while(iterator.hasNext()) {
            String name = iterator.next();
            System.out.print(name +"=");

            // 根据 key 获取到对应的 value值 (也就是前端用户提交的value值数据)
            String[] value = parameterMap.get(name);
            // 遍历 value 数组
            for(String s : value) {
                System.out.print(s);
            }
            System.out.println();
        }


    }
}

第三步： 对相关的Servlet 类配置到对应 webapp 项目的 web.xml 文件中去。


<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">


    <servlet>
        <servlet-name>RequestServletTestservlet-name>
        <servlet-class>com.RainbowSea.servlet.RequestServletTestservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>RequestServletTestservlet-name>
        <url-pattern>/Requesturl-pattern>
    servlet-mapping>
web-app>

第四步： 运行测试。

再举例： 这里的 Serlvelt 获取前端用户提交的数据使用：如下两个方法

Enumeration<String> getParameterNames() 这个是获取Map集合中所有的key就是前端中所有的name 值 
String[] getParameterValues(String name) 根据(前端的name值)key获取Map集合的(前端的value值)value

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Enumeration;


public class RequestServletTest extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        //  获取到前端用户提交的数据的所有 name 值，并存储到 Enumeration 枚举泛型中
        Enumeration<String> names = request.getParameterNames();


        while (names.hasMoreElements()) { // 判断是否还有数据，有返回 true,没有返回 false
            String name = names.nextElement();  // 获取到其中上述 Enumeration 存储到的元素数据，
            System.out.print(name + "=");

            // 同时向下移动下标
            String[] values = request.getParameterValues(name);// 根据 name 值获取到对应的 value值，前端用户提交的。
            // 并存储到String[] 字符串数组当中去.

            // 遍历数组
            for (String v : values) {
                System.out.print(v);
            }

            System.out.println();
        }
    }
}

再举例： 这里的 Serlvelt 获取前端用户提交的数据使用：如下两个方法

String getParameter(String name)  获取value这个一维数组当中的第一个元素。这个方法最常用。
String[] getParameterValues(String name) 根据(前端的name值)key获取Map集合的(前端的value值)value

注意： 上述两个方法的，合理使用，当我们的 name 的对应多个 value 值的话，需要使用 getParameterValues() 获取到其中的多个 value 值，而如果这是时候，我们使用的是 getParameter() 方法的话，就仅仅只会获取到其中的第一个value值，无法获取到对应name 后面的 value值的。

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;


public class RequestServletTest extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // 注意：这里直接指明对应的name 值，我们最好去前端编写的html当直接复制其中的name 值
        // 不然你可以会手动编写错误，哪怕只有其中的一个字母错误了，该方法都是无法获取到对应
        // 前端提交的value数据的。所以为了避免错误，建议直接复制。
        String username = request.getParameter("username");  // 因为该name的value值只有一个
        System.out.println("username =" + username );

        String userpassword = request.getParameter("userpassword"); // 同样的该name值的value也是只有一个
        System.out.println("userpassword = " + userpassword);

        // 注意：该如下名为 aihaos 的value值是一个多个值的，需要使用数组存储起来。
        String[] aihaos = request.getParameterValues("aihao");
        System.out.print("aihaos =");
        for (String s: aihaos) {
            System.out.print(s);
        }


    }
}

直接手动编写name值的注意事项

如果我们使用如下方法，其中的参数 name 是我们手动编写的话，存在一个安全隐患，就是：如果我们手动输入的name 的值，在我们对应前端当中不存在的话(因为当其中的我们手动编写错了，比如说，多/少了字母的话)，就无法获取到其中对应的value值了。

String getParameter(String name)  获取value这个一维数组当中的第一个元素。这个方法最常用。

举例如下：

4.2 请求域对象的详解

HttpServletRequest 对象实际上又称为“请求域”对象。

这里我们回顾一下应用域对象是什么？

ServletContext 应用域对象（Servlet 上下文对象）。

什么情况下会考虑向 ServletContext 这个应用域当中绑定数据呢？

第一：所有用户的共享数据

第二：这个共享数据量很少

第三：这个共享数据很少进行修改操作，尽可能没有修改操作。

在以上三个条件都满足的情况下，使用这个应用域对象，可以大大提高我们程序执行效率。

实际上向应用域当中绑定数据，就相当于把数据放到了缓存(Cache) 当中，然后用户访问的时候直接从缓存中取，减少 IO 的操作（IO访问磁盘，其耗费的时间代价十分的大），大大提升系统的性能，所以缓存技术是提高系统性能的重要手段。

关于 ServletContext 具体的使用大家可以移步至: 解读 Servlet 源码：GenericServlet，ServletConfig，ServletContext_ChinaRainbowSea的博客-CSDN博客

你见过哪些缓存技术呢？

字符串常量池

整数型常量池[-128~127] ，但凡是在这个范围当中 Integer 对象不再创建新对象，而是直接从这个整数型常量池中获取，大大提升系统性能。

数据库连接池（提前创建好 N 个连接对象，将连接对象放到集合当中，使用连接对象的时候，直接从缓存中拿，省去了连接对象的创建过程，效率提升。）

线程池（Tomcat 服务器就是支持多线程的），所谓的线程池就是提前先创建好 N 个线程对象，将线程对象存储到集合中，然后用户直接去线程池当中获取线程对象，直接拿来用。提升系统性能。）

后期你还会学习更多的缓存技术，例如：redis、mongoDB…

拉回来，这里我们的主角是 "请求域" 对象：

“请求域”对象要比“应用域”对象范围小很多。生命周期短很多。请求域只在一次请求内有效。
一个请求对象request对应一个请求域对象。一次请求结束之后，这个请求域就销毁了。
请求域对象也有这三个方法：

void setAttribute(String name, Object obj); // 向请求域当中绑定数据。
Object getAttribute(String name); // 从请求域当中根据name获取数据。 注意: 这里的参数是 你向请求域添加数据时，设置的对应数据的，setAttribute(String name ,Object obj)一个 name 值保持一致，尽可以使用复制的方式，防止手动编写错误。导致无法找到，从而为 null 值。
void removeAttribute(String name); // 将请求域当中绑定的数据移除

// 以上的操作类似于Map集合的操作。
Map<String, Object> map;
map.put("name", obj); // 向map集合中放key和value
Object obj = map.get("name"); // 通过map集合的key获取value
map.remove("name"); // 通过Map集合的key删除key和value这个键值对。

请求域和应用域的选用原则？

尽量使用小的域对象，因为小的域对象占用的资源较少。

举例： 1.将数据存储到请求域当中，2.从请求域当中取出数据

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 设置，在浏览器上响应的格式类型
        response.setContentType("text/html;charSet=utf-8");
        PrintWriter writer = response.getWriter();
        Date nowTime = new Date();  // 创建当前时间的 Date 对象

        // 1. 将 nowTime 的数据存储(绑定)到请求域当中
        request.setAttribute("sysTime",nowTime);

        // 2. 取出请求域当中的数据: 这里的name值与上面setAttribute(String name,Object obj) 保持一致。
        Object sysTime = request.getAttribute("sysTime");

        writer.println(sysTime);  // 显示到浏览器页面当中的数据

    }
}


<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">


    <servlet>
        <servlet-name>AServletservlet-name>
        <servlet-class>com.RainbowSea.servlet.AServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>AServletservlet-name>
        <url-pattern>/Aurl-pattern>
    servlet-mapping>
web-app>

关于 request对象中两个非常容易混淆的方法：


// uri?username=zhangsan&userpwd=123&sex=1
String username = request.getParameter("username"); // 获取到的是前端用户提交的数据

// 之前一定是执行过：request.setAttribute("name", new Object())  // 将数据绑定/存储到请求域当中
Object obj = request.getAttribute("name");// 获取到的是绑定到请求域当中的数据

// 以上两个方法的区别是什么？
// 第一个方法：获取的是用户在浏览器上提交的数据。
// 第二个方法：获取的是请求域当中绑定的数据。

4.3 跳转（两个Servlet 共享数据）

如果我们想要将两个 Servlet 的请求域当中的数据共享：比如将 AServlet 类当中的请求域存储的数据，在 BServelt 类当中将其存储到AServlet 请求域当中的数据取出来。如下

观察，思考如下代码：是否可以实现两个 Servlet 类的数据共享

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 设置，在浏览器上响应的格式类型
        response.setContentType("text/html;charSet=utf-8");
        PrintWriter writer = response.getWriter();
        Date nowTime = new Date();  // 创建当前时间的 Date 对象

        // 将 nowTime 的数据存储(绑定)到请求域当中
        request.setAttribute("sysTime",nowTime);

        // 这样做可以吗?
        // 在AServlet当中new 一个BServlet对象,然后调用BServlet 对象的doGet()方法,把request 对象传过去
        // 因为我们数据是存储该 request 请求域当中的。所以我们将该数据传给 BServlet ，让BServlet
        // 将其中的请求域当中的数据取出来，这么做可以吗 ? 
        BServlet bServlet = new BServlet();
        bServlet.doGet(request,response);


    }
}

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // 设置，在浏览器上响应的格式类型
        response.setContentType("text/html;charSet=utf-8");
        PrintWriter writer = response.getWriter();

        // 取出请求域当中的数据: 这里的name值与上面setAttribute(String name,Object obj) 保持一致。
        Object sysTime = request.getAttribute("sysTime");

        writer.println("sysTime = " + sysTime);  // 显示到浏览器页面当中的数据




    }
}

如下：运行结果

注意:

注意: 上述这个代码虽然可以实现功能，但是到那时 Servlet 对象不能自己由程序员来new，因为自己new 的Servlet 的对象的生命周期不受Tomcat 服务器的管理。如果不是被 Tomcat 管理了就无法实现合理的关闭销毁对应的Servlet 的资源了。

哪要如何合理的将两个 Servlet 数据共享呢 ?*

可以，使用转发机制。

将数据放到ServletContext应用域当中，当然是可以的，但是应用域范围太大，占用资源太多。不建议使用。
可以将数据放到request域当中，然后AServlet转发到BServlet，保证AServlet和BServlet在同一次请求当中，这样就可以做到两个Servlet，或者多个Servlet共享同一份数据。
转发（一次请求的核心方法）

// 第一步：获取请求转发器对象
// 注意：转发的时候，路径的写法要注意，转发的路径以“/”开始，不加项目名。/ 后接 对应转发的Servelt 在web.xml配置文件当中 uRl 映射路径即可。
RequestDispatcher dispatcher = request.getRequestDispatcher("/B");
// 第二步：调用转发器的forward方法完成跳转/转发
dispatcher.forward(request,response);

// 第一步和第二步代码可以联合在一起。
request.getRequestDispatcher("/B").forward(request,response);

举例：转发机制，将AServlett 类当中的信息转发到 BServlet 当中去

package com.RainbowSea.servlet;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;

public class AServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 设置，在浏览器上响应的格式类型
        Date nowTime = new Date();  // 创建当前时间的 Date 对象

        // 将 nowTime 的数据存储(绑定)到请求域当中
        request.setAttribute("sysTime",nowTime);

        // 第一步: 获取到转发对象，注意：/ 开始，不家项目名 , / + 对应跳转的 Servlet 当中的 web.xml 当中的url映射的路径
        RequestDispatcher requestDispatcher = request.getRequestDispatcher("/B");

        // 第二步: 调用转发器的forward方法完成跳转/转发
        requestDispatcher.forward(request,response);




    }
}

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class BServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // 设置，在浏览器上响应的格式类型
        response.setContentType("text/html;charSet=utf-8");
        PrintWriter writer = response.getWriter();

        // 取出请求域当中的数据: 这里的name值与上面setAttribute(String name,Object obj) 保持一致。
        Object sysTime = request.getAttribute("sysTime");

        writer.println("sysTime = " + sysTime);  // 显示到浏览器页面当中的数据
    }
}

转发的下一个资源必须是一个Servlet吗？

不一定，只要是Tomcat服务器当中的合法资源，都是可以转发的。例如：html…

举例：转发一个html文件

注意： 如果对应的不是 Servlet ，默认是从项目的中的web目录开始的，如果是转发web的目录下的子目录的话，需要指定对应的子目录的文件。

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 转发的下一个资源不一定是Servlet 资源，
        // 只要是Tomcat服务器当中合法的资源，都是可以转发的，例如: html...
        // 注意：转发的时候，路径的写法要注意，转发的路径以 “/” 开始，不加项目名
        // 默认是从项目的中的web目录开始的，如果是转发web的目录下的子目录的话，需要指定对应的子目录
        // 如下是含有子目录的 / 表示 web目录
        request.getRequestDispatcher("/test/test.html").forward(request,response);

    }
}

4.4 post 请求 request 乱码问题？

如下：如果我们在前端 post 请求中提交中文字符串信息，当我们在后端 Servlet 接受的时候，会存在一个乱码问题？但是英文不会存在这个现象。如下：所示

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HTTP请求登录title>
head>
<body>
<h2>Post 请求h2>

<form action="/servlet08//Test" method="post">
    username: <input type="text" name="username"/> <br>
    userpassword: <input type="password" name="userpswd"/> <br>
    <input type="submit" value="post"/>
form>
body>
html>

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class TestServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        String username = request.getParameter("username");
        System.out.println("username = " + username);

        String userpswd = request.getParameter("userpswd");
        System.out.println("userpswd = " + userpswd);

    }
}

如下我们：使用中文，提交数据出现，乱码。

解决方案：

在显示获取前端 post 请求时，执行如下代码就可以解决 post 乱码问题？ 注意： 仅仅只能解决 Post 请求的乱码问题，不能解决get请求的乱码问题。

// post请求在请求体中提交数据。
// 设置请求体的字符集。（显然这个方法是处理POST请求的乱码问题。这种方式并不能解决get请求的乱码问题。）
// Tomcat10之后，request请求体当中的字符集默认就是UTF-8，不需要设置字符集，不会出现乱码问题。
// Tomcat9前（包括9在内），如果前端请求体提交的是中文，后端获取之后出现乱码，怎么解决这个乱码？执行以下代码。
request.setCharacterEncoding("UTF-8");

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class TestServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

	// post请求在请求体中提交数据。
	// 设置请求体的字符集。（显然这个方法是处理POST请求的乱码问题。这种方式并不能解决get请求的乱码问题。）
	// Tomcat10之后，request请求体当中的字符集默认就是UTF-8，不需要设置字符集，不会出现乱码问题。
	// Tomcat9前（包括9在内），如果前端请求体提交的是中文，后端获取之后出现乱码，怎么解决这个乱码？执行以下代码。
        request.setCharacterEncoding("UTF-8");

        String username = request.getParameter("username");
        System.out.println("username = " + username);

        String userpswd = request.getParameter("userpswd");
        System.out.println("userpswd = " + userpswd);

    }
}

4.5 response 响应到浏览器中的乱码问题？

如果我们想在 Servlet 直接向前端页面中响应中文信息，会存在乱码问题。如下：

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
         // 设置在页面当显示的格式类型
		response.setContentType("text/html");
        PrintWriter writer = response.getWriter();
        writer.println(" 你好世界 ");

    }
}

解决方案：

// 在Tomcat9之前（包括9），响应中文也是有乱码的，怎么解决这个响应的乱码？可以在响应操作之前，
// 先执行如下代码，设置在页面当显示的格式，以及字符集编码
response.setContentType("text/html;charset=UTF-8");
// 在Tomcat10之后，包括10在内，响应中文的时候就不在出现乱码问题了。以上代码就不需要设置UTF-8了。

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 在Tomcat9之前（包括9），响应中文也是有乱码的，怎么解决这个响应的乱码？
        response.setContentType("text/html;charset=UTF-8");
// 在Tomcat10之后，包括10在内，响应中文的时候就不在出现乱码问题了。以上代码就不需要设置UTF-8了。
        PrintWriter writer = response.getWriter();
        writer.println(" 你好 世界 ");
    }
}

4.6 get 请求的 request 乱码问题？

如果我们使用 get 请求中，处理中文乱码问题。

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>HTTP请求登录title>
head>
<body>
<h2>get 请求h2>

<form action="/servlet08//Test" method="get">
    username: <input type="text" name="username"/> <br>
    userpassword: <input type="password" name="userpswd"/> <br>
    <input type="submit" value="get"/>
form>
body>
html>

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        String username = request.getParameter("username");
        System.out.println("username = " + username);

        String userpswd = request.getParameter("userpswd");
        System.out.println("userpswd = " + userpswd);
    }
}

解决方案：

首先找我们安装的 Tomcat 的安装目录，在 conf目录下，找到一个名为 server.xml 的文件名，如下

打开该 server.xml 文件，找到其中的如下这一段代码

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />

在该 server.xml 配置文件当中的上述对应的一段代码上，多添加上一个字符集设置 URIEncoding="UTF-8" 注意 />结尾就可以了。

    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" 
               URIEncoding="UTF-8" />

// get请求乱码问题怎么解决？
// get请求发送的时候，数据是在请求行上提交的，不是在请求体当中提交的。
// get请求乱码怎么解决
// 方案：修改CATALINA_HOME/conf/server.xml配置文件
<Connector URIEncoding="UTF-8" />
// 注意：从Tomcat8之后，URIEncoding的默认值就是UTF-8，所以GET请求也没有乱码问题了。

4.7 HttpServletRequest接口的其他常用方法

// 获取客户端的IP地址
String remoteAddr = request.getRemoteAddr();。
    
// 获取应用的根路径
String contextPath = request.getContextPath();

// 获取请求方式
String method = request.getMethod();

// 获取请求的URI
String uri = request.getRequestURI();  

// 获取 servlet path
String servletPath = request.getServletPath();

举例上述方法的使用：


<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    <servlet>
        <servlet-name>TestServletservlet-name>
        <servlet-class>com.RainbowSea.servlet.TestServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>TestServletservlet-name>
        <url-pattern>/Testurl-pattern>
    servlet-mapping>
web-app>

package com.RainbowSea.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class TestServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {
        // 获取 客户端的IP地址
        String ip = request.getRemoteAddr();
        System.out.println("客户端的ip地址: " + ip);

        // 获取用户的请求方式
        String method = request.getMethod();
        System.out.println("用户的请求方式: " + method);

        // 获取webapp的根路径
        String contextPath = request.getContextPath();
        System.out.println("webapp的根路径: " + contextPath);

        // 获取请求的URI
        String requestURI = request.getRequestURI();
        System.out.println("请求的URI:" + requestURI);

        // 获取 Servlet path 路径
        String servletPath = request.getServletPath();
        System.out.println("Servlet 的路径: " + servletPath);



    }
}

5. 补充：

在WEB-INF目录下新建了一个文件：welcome.html

打开浏览器访问：http://localhost:8080/servlet07/WEB-INF/welcome.html 出现了404错误。

注意：放在WEB-INF目录下的资源是受保护的。在浏览器上不能够通过路径直接访问。所以像HTML、CSS、JS、image等静态资源一定要放到WEB-INF目录之外。

如果非要访问的话，也有方法，详细内容请关注我，后续为您更新。

6. 总结：

HTTP的请求协议包括：如下 4 个部分： 请求行，请求头，空白行，请求体。
HTTP的响应协议（S(浏览器) --> B(客户端)）HTTP的响应协议包括4部分 : 状态行，响应头，空白行，响应体 。
GET请求和POST请求有什么区别 ?
不管你是get请求还是post请求，发送的请求数据格式是完全相同的，只不过位置不同，格式都是统一的：都是：name=value&name=value&name=value&name=value
GET请求和POST请求如何选择，什么时候使用GET请求，什么时候使用POST请求？
HttpServlet类是专门为 HTTP协议准备的。比 GenericServlet更加适合 HTTP协议下的开发。
HttpServlet在哪个包下？这是在 Tomcat 10 的基础上：jakarta.servlet.http.HttpServlet，而后面 Tomcat 9 之前的(包括Tomcat 9 )以内的包是在 : javax.servlet.http.HttpServlet 包下的。
只要没有重写对应 HttpServlet类中的doGet方法或doPost方法，就会报 405 错误，因为没有重写了doGet 或 doPost 方法就会执行其中的 HttpServlet 当中编写的 doGet / doPost 方法，而如果执行了的是 HttpServlet 当中 doGet / doPost 方法就会报 405 错误，提示你没有重写对应的 doGet / doPost 方法。怎么避免405的错误呢？

后端重写了doGet方法，前端一定要发get请求。后端重写了doPost方法，前端一定要发post请求。这样可以避免405错误。这种前端到底需要发什么样的请求，其实应该后端说了算。后端让发什么方式，前端就得发什么方式。
request对象和response对象，一个是请求对象，一个是响应对象。这两个对象只在当前请求中有效。一次请求对应一个request。两次请求则对应两个request。
后端如何获取前端浏览器用户提交的数据的常用方法。

Map<String,String[]> getParameterMap() 这个是获取用户提交的数据，并存储到Map集合当中<前端的name,前端的value>
Enumeration<String> getParameterNames() 这个是获取Map集合中所有的key就是前端中所有的name 值 
String[] getParameterValues(String name) 根据(前端的name值)key获取Map集合的(前端的value值)value
String getParameter(String name)  获取value这个一维数组当中的第一个元素。这个方法最常用。
// 以上的4个方法，和获取用户提交的数据有关系
// 注意： 这里为什么 value 的值是用String[] 数组存储的。后面有说明。

HttpServletRequest 对象又称为：“请求域” 请求域”对象要比“应用域”对象范围小很多。生命周期短很多。请求域只在一次请求内有效。一个请求对象request对应一个请求域对象。一次请求结束之后，这个请求域就销毁了。如下是“请求域”的增删改操作的方法。

void setAttribute(String name, Object obj); // 向请求域当中绑定数据。
Object getAttribute(String name); // 从请求域当中根据name获取数据。 注意: 这里的参数是 你向请求域添加数据时，设置的对应数据的，setAttribute(String name ,Object obj)一个 name 值保持一致，尽可以使用复制的方式，防止手动编写错误。导致无法找到，从而为 null 值。
void removeAttribute(String name); // 将请求域当中绑定的数据移除

// 以上的操作类似于Map集合的操作。
Map<String, Object> map;
map.put("name", obj); // 向map集合中放key和value
Object obj = map.get("name"); // 通过map集合的key获取value
map.remove("name"); // 通过Map集合的key删除key和value这个键值对。

跳转（两个Servlet 共享数据）
Post 请求以及get请求，response 响应的三者的中文乱码问题。
HttpServletRequest接口的常用方法。

7. 最后：

限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善，谢谢大家，后会有期，江湖再见！！！

你可能感兴趣的:(JavaWeb,java,servlet,tomcat,javaee)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
jdk tomcat 环境变量配置 Array_06 java jdk tomcat
Win7 下如何配置java环境变量 1。准备jdk包，win7系统，tomcat安装包（均上网下载即可） 2。进行对jdk的安装，尽量为默认路径（但要记住啊！！以防以后配置用。。。） 3。分别配置高级环境变量。电脑-->右击属性-->高级环境变量-->环境变量。分别配置 : path &nbs
Spring调SDK包报java.lang.NoSuchFieldError错误 bijian1013 java spring
在工作中调另一个系统的SDK包，出现如下java.lang.NoSuchFieldError错误。 org.springframework.web.util.NestedServletException: Handler processing failed; nested exception is java.l
LeetCode[位运算] - #136 数组中的单一数 Cwind java 题解位运算 LeetCode Algorithm
原题链接：#136 Single Number 要求：给定一个整型数组，其中除了一个元素之外，每个元素都出现两次。找出这个元素注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间难度：中等分析：题目限定了线性的时间复杂度，同时不使用额外的空间，即要求只遍历数组一遍得出结果。由于异或运算 n XOR n = 0, n XOR 0 = n，故将数组中的每个元素进
qq登陆界面开发 15700786134 qq
今天我们来开发一个qq登陆界面，首先写一个界面程序，一个界面首先是一个Frame对象，即是一个窗体。然后在这个窗体上放置其他组件。代码如下： public class First { public void initul(){ jf=ne
Linux的程序包管理器RPM 被触发 linux
在早期我们使用源代码的方式来安装软件时，都需要先把源程序代码编译成可执行的二进制安装程序，然后进行安装。这就意味着每次安装软件都需要经过预处理-->编译-->汇编-->链接-->生成安装文件--> 安装，这个复杂而艰辛的过程。为简化安装步骤，便于广大用户的安装部署程序，程序提供商就在特定的系统上面编译好相关程序的安装文件并进行打包，提供给大家下载，我们只需要根据自己的
socket通信遇到EOFException 肆无忌惮_ EOFException
java.io.EOFException at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2281) at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:
基于spring的web项目定时操作知了ing java Web
废话不多说，直接上代码，很简单配置一下项目启动就行 1，web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="h
树形结构的数据库表Schema设计矮蛋蛋 schema
原文地址： http://blog.csdn.net/MONKEY_D_MENG/article/details/6647488 程序设计过程中，我们常常用树形结构来表征某些数据的关联关系，如企业上下级部门、栏目结构、商品分类等等，通常而言，这些树状结构需要借助于数据库完成持久化。然而目前的各种基于关系的数据库，都是以二维表的形式记录存储数据信息，
maven将jar包和源码一起打包到本地仓库 alleni123 maven
http://stackoverflow.com/questions/4031987/how-to-upload-sources-to-local-maven-repository <project> ... <build> <plugins> <plugin> <groupI
java IO操作与 File 获取文件或文件夹的大小，可读，等属性！！！百合不是茶
类 File File是指文件和目录路径名的抽象表示形式。 1，何为文件：标准文件（txt doc mp3...）目录文件（文件夹）虚拟内存文件 2，File类中有可以创建文件的 createNewFile（）方法,在创建新文件的时候需要try{} catch(）{}因为可能会抛出异常；也有可以判断文件是否是一个标准文件的方法isFile();这些防抖都
Spring注入有继承关系的类（2） bijian1013 java spring
被注入类的父类有相应的属性，Spring可以直接注入相应的属性，如下所例：1.AClass类 package com.bijian.spring.test4; public class AClass { private String a; private String b; public String getA() { retu
30岁转型期你能否成为成功人士 bijian1013 成长励志
很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
【Velocity四】Velocity与Java互操作 bit1129 velocity
Velocity出现的目的用于简化基于MVC的web应用开发，用于替代JSP标签技术，那么Velocity如何访问Java代码.本篇继续以Velocity三http://bit1129.iteye.com/blog/2106142中的例子为基础， POJO package com.tom.servlets; public
【Hive十一】Hive数据倾斜优化 bit1129 hive
什么是Hive数据倾斜问题操作：join,group by,count distinct 现象：任务进度长时间维持在99%（或100%），查看任务监控页面，发现只有少量（1个或几个）reduce子任务未完成；查看未完成的子任务，可以看到本地读写数据量积累非常大，通常超过10GB可以认定为发生数据倾斜。原因：key分布不均匀倾斜度衡量：平均记录数超过50w且
在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua csrf
Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
java-3.求子数组的最大和 bylijinnan java
package beautyOfCoding; public class MaxSubArraySum { /** * 3.求子数组的最大和题目描述：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。求所有子数组的和的最大值。要求时间复杂度为O(n)。例如输入的数组为1, -2, 3, 10, -4,
Netty源码学习-FileRegion bylijinnan java netty
今天看org.jboss.netty.example.http.file.HttpStaticFileServerHandler.java 可以直接往channel里面写入一个FileRegion对象，而不需要相应的encoder： //pipeline（没有诸如“FileRegionEncoder”的handler）： public ChannelPipeline ge
使用ZeroClipboard解决跨浏览器复制到剪贴板的问题 cngolon 跨浏览器复制到粘贴板 Zero Clipboard
Zero Clipboard的实现原理 Zero Clipboard 利用透明的Flash让其漂浮在复制按钮之上，这样其实点击的不是按钮而是 Flash ，这样将需要的内容传入Flash，再通过Flash的复制功能把传入的内容复制到剪贴板。 Zero Clipboard的安装方法首先需要下载 Zero Clipboard的压缩包，解压后把文件夹中两个文件：ZeroClipboard.js
单例模式 cuishikuan 单例模式
第一种（懒汉，线程不安全）： public class Singleton { 2 private static Singleton instance; 3 pri
spring+websocket的使用 dalan_123
一、spring配置文件 <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.or
细节问题：ZEROFILL的用法范围。 dcj3sjt126com mysql
1、zerofill把月份中的一位数字比如1，2，3等加前导0 mysql> CREATE TABLE t1 (year YEAR(4), month INT(2) UNSIGNED ZEROFILL, -> day
Android开发10——Activity的跳转与传值 dcj3sjt126com Android开发
Activity跳转与传值，主要是通过Intent类，Intent的作用是激活组件和附带数据。一、Activity跳转方法一Intent intent = new Intent(A.this, B.class); startActivity(intent) 方法二Intent intent = new Intent();intent.setCla
jdbc 得到表结构、主键 eksliang jdbc 得到表结构、主键
转自博客：http://blog.csdn.net/ocean1010/article/details/7266042 假设有个con DatabaseMetaData dbmd = con.getMetaData(); rs = dbmd.getColumns(con.getCatalog(), schema, tableName, null); rs.getSt
Android 应用程序开关GPS gqdy365 android
要在应用程序中操作GPS开关需要权限： <uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS" /> 但在配置文件中添加此权限之后会报错，无法再eclipse里面正常编译，怎么办？ 1、方法一：将项目放到Android源码中编译； 2、方法二：网上有人说cl
Windows上调试MapReduce zhiquanliu mapreduce
1.下载hadoop2x-eclipse-plugin https://github.com/winghc/hadoop2x-eclipse-plugin.git 把 hadoop2.6.0-eclipse-plugin.jar 放到eclipse plugin 目录中。 2.下载 hadoop2.6_x64_.zip http://dl.iteye.com/topics/download/d2b
如何看待一些知名博客推广软文的行为？ justjavac 博客
本文来自我在知乎上的一个回答：http://www.zhihu.com/question/23431810/answer/24588621 互联网上的两种典型心态：当初求种像条狗，如今撸完嫌人丑当初搜贴像条犬，如今读完嫌人软你为啥感觉不舒服呢？难道非得要作者把自己的劳动成果免费给你用，你才舒服？就如同 Google 关闭了 Gooled Reader，那是
sql优化总结 macroli sql
为了是自己对sql优化有更好的原则性，在这里做一下总结，个人原则如有不对请多多指教。谢谢！要知道一个简单的sql语句执行效率，就要有查看方式，一遍更好的进行优化。一、简单的统计语句执行时间 declare @d datetime ---定义一个datetime的变量set @d=getdate() ---获取查询语句开始前的时间select user_id
Linux Oracle中常遇到的一些问题及命令总结超声波 oracle linux
1.linux更改主机名 (1)#hostname oracledb　　　　临时修改主机名 (2) vi /etc/sysconfig/network 　　修改hostname (3) vi /etc/hosts　　　　　　　　修改IP对应的主机名 2.linux重启oracle实例及监听的各种方法（注意操作的顺序应该是先监听，后数据库实例） &nbs
hive函数大全及使用示例 superlxw1234 hadoop hive函数
具体说明及示例参见附件文档。文档目录：目录一、关系运算： 4 1. 等值比较: = 4 2. 不等值比较: <> 4 3. 小于比较: < 4 4. 小于等于比较: <= 4 5. 大于比较: > 5 6. 大于等于比较: >= 5 7. 空值判断: IS NULL 5
Spring 4.2新特性-使用@Order调整配置类加载顺序 wiselyman spring 4
4.1 @Order Spring 4.2 利用@Order控制配置类的加载顺序 4.2 演示两个演示bean package com.wisely.spring4_2.order; public class Demo1Service { } package com.wisely.spring4_2.order; public class

Sevlet规范：HttpServlet类和 HttpServletRequest接口源码解析

Sevlet规范：HttpServlet类和 HttpServletRequest接口源码解析

每博一文案

文章目录

1. HTTP协议解读

1.1 什么是HTTP协议？

1.2 HTTP请求协议的具体报文

1.3 HTTP响应协议的具体报文

2. GET请求和POST请求有什么区别？

2.1 GET请求和POST请求如何选择，什么时候使用GET请求，什么时候使用POST请求？

3. HttpServlet源码分析

3.1 HttpServlet 处理 get 请求和 post 请求源码分析

Hello World

`"); } }`

Hello World

`"); } }`

Hello World

`"); } }`

4. HttpServletRequest接口详解

4.0.1 HttpServletRequest对象中都有什么信息？都包装了什么信息？

4.1 获取前端用户提交的数据信息

4.2 请求域对象的详解

4.3 跳转（两个Servlet 共享数据）

4.4 post 请求 request 乱码问题？

4.5 response 响应到浏览器中的乱码问题？

你好世界

`"); } }`

你好世界

`"); } }`

4.6 get 请求的 request 乱码问题？

4.7 HttpServletRequest接口的其他常用方法

5. 补充：

6. 总结：

7. 最后：

你可能感兴趣的:(JavaWeb,java,servlet,tomcat,javaee)

Sevlet规范：HttpServlet类 和 HttpServletRequest接口 源码解析

Sevlet规范：HttpServlet类 和 HttpServletRequest接口 源码解析

每博一文案

文章目录

1. HTTP协议解读

1.1 什么是HTTP协议 ？

1.2 HTTP请求协议的具体报文

1.3 HTTP响应协议的具体报文

2. GET请求和POST请求有什么区别？

2.1 GET请求和POST请求如何选择，什么时候使用GET请求，什么时候使用POST请求 ？

3. HttpServlet源码分析

3.1 HttpServlet 处理 get 请求和 post 请求 源码分析

Hello World

"); } }

Hello World

"); } }

Hello World

"); } }

4. HttpServletRequest接口详解

4.0.1 HttpServletRequest对象中都有什么信息？都包装了什么信息 ？

4.1 获取前端用户提交的数据信息

4.2 请求域对象的详解

4.3 跳转 （两个Servlet 共享数据）

4.4 post 请求 request 乱码问题 ？

4.5 response 响应到浏览器中的 乱码问题 ？

你好世界

"); } }

你好 世界

"); } }

4.6 get 请求的 request 乱码问题 ？

4.7 HttpServletRequest接口的其他常用方法

5. 补充：

6. 总结：

7. 最后：

你可能感兴趣的:(JavaWeb,java,servlet,tomcat,javaee)

Sevlet规范：HttpServlet类和 HttpServletRequest接口源码解析

Sevlet规范：HttpServlet类和 HttpServletRequest接口源码解析

1.1 什么是HTTP协议？

2.1 GET请求和POST请求如何选择，什么时候使用GET请求，什么时候使用POST请求？

3.1 HttpServlet 处理 get 请求和 post 请求源码分析

`"); } }`

`"); } }`

`"); } }`

4.0.1 HttpServletRequest对象中都有什么信息？都包装了什么信息？

4.3 跳转（两个Servlet 共享数据）

4.4 post 请求 request 乱码问题？

4.5 response 响应到浏览器中的乱码问题？

`"); } }`

你好世界

`"); } }`

4.6 get 请求的 request 乱码问题？