初阶JavaEE(15)（Cookie 和 Session、理解会话机制 (Session)、实现用户登录网页、上传文件网页、常用的代码片段）

接上次博客：初阶JavaEE（14）表白墙程序-CSDN博客

Cookie 和 Session

你还记得我们之前提到的Cookie吗？

Cookie是HTTP请求header中的一个属性，是一种用于在浏览器和服务器之间持久存储数据的机制，允许网站在多次HTTP请求之间保持状态它。

我们先来回忆一些知识点：

1. HTTP 协议的无状态特性

HTTP协议是一种无状态协议，每个客户端请求都在单独的事务中处理，服务器不会记住前一次请求的信息。
无状态特性意味着默认情况下，服务器无法直接识别不同请求之间的关联关系。

2. Cookie 的作用

Cookie是一种在客户端存储数据的机制，用于在多次HTTP请求之间保持状态信息。
Cookie通常存储在浏览器端，包含有关用户或应用程序的数据。
服务器可以在HTTP响应头中设置Cookie，然后浏览器会将这些Cookie存储在客户端，并在将来的请求中将它们包括在HTTP请求头中。

3. 令牌概念

令牌是一种标识或身份验证凭据，通常存储在Cookie中。
令牌可以用于标识用户的身份或跟踪用户的会话状态。
类比就诊卡：用户登录网站后，服务器颁发一个令牌，就像患者得到就诊卡一样。

4. Cookie 的使用场景

用于记录用户的身份认证状态，例如用户登录后，服务器会发送包含身份验证令牌的Cookie。
用于跟踪用户的行为，例如购物车功能，保存在Cookie中，以在用户下次访问时还原购物车内容。

总之，网页无法访问主机的文件要想存储数据就得通过其他的方式。Cookie中保存的数据也是键值对的格式（用户自定义）。我们最终还是需要把这个键值对发送回服务器，因为服务器要使用Cookie来完成一些业务逻辑。

其中有一个特殊的情况，我们是会使用Cookie来存储当前用户的信息。

回忆我们之前举过的例子: 去医院挂号的就诊卡就相当于Cookie，里面存储了用户的身份信息。

挂号与Cookie设置：
- 患者挂号时提供身份证，就像用户在网站上登录时提供用户名和密码。在挂号后，患者得到了一张就诊卡，就像网站在登录成功后发送一个Cookie到用户的浏览器。
- 这张就诊卡相当于Cookie，其中包含有患者的身份信息，它被存储在患者的钱包中，就像Cookie存储在浏览器中。
就诊过程与Cookie的使用：
- 患者在不同科室进行检查、诊断和开药，不需要再次出示身份证，而是凭借就诊卡来识别患者，就像用户在浏览网站的不同页面时，浏览器会将Cookie自动包括在每个HTTP请求中，以识别用户。
- 这种方式使患者（或用户）的身份信息持久存在，而不必在每个步骤中重复验证身份。
注销操作与Cookie销毁：
- 如果患者不再需要就诊卡，可以选择注销它，就像用户在网站上注销帐户或清除浏览器中的Cookie。
- 注销就诊卡会销毁与患者的身份关联，类似于注销操作导致Cookie失效。
新就诊卡与新Cookie：
- 如果患者再次需要医院服务，可以申请一张新的就诊卡，这将为他们提供一个新的“令牌”，就像用户重新登录网站后会生成一个新的Cookie。
- 这是一种维护隐私和安全性的方式，以及确保用户/患者可以得到新的标识。

那除了身份标识，剩下的信息：基本信息、当前诊断信息、开的药品信息单子、既往病历、账户余额……，每个用户/患者都有一份这样的数据，这些数据在服务器中如何组织呢？

这些信息必然是要存储在数据库的，但是也不仅仅存储在数据库中。

在服务器代码的逻辑展开执行的过程中，这些数据也就会被从数据库中查询出来。

我们先把数据临时的保存到某个内存结构中，后续有什么修改之类的，就会去修改内存、重写写入数据库。

什么内存结构呢？——Session （会话）。

理解会话机制 (Session)

Cookie是客户端存储数据的机制；
Session是服务器存储的数据的机制（不算持久化存储）。

这两者之间往往会配合使用，在cookie中存储的用户身份标识，也经常会被理解成Session ld。服务器会存储很多的Session，每个用户都有一个自己的Session，也有不同的Session ld。

服务器会通过类似于哈希表这样的键值对来存储Session，Session ld就是key，Session 本身就是value，在Session里面又可以存储各种用户自身的信息（程序猿自定义的）。

截止到现在，我们已经学到的大量的概念都是和“键值对”有关的：

是的，许多计算机科学和编程中的概念都与键值对（key-value pairs）有关，这种数据结构非常常见，用于存储和组织各种类型的数据。在不同的上下文中，键值对可以被用来处理和表示不同种类的信息，如：

Query String： 在URL中，查询字符串通常是一组键值对，用于向服务器传递参数和数据。
Header： HTTP请求和响应头部是由键值对组成的，它们包含了关于请求或响应的元信息。
Body (Form)： 在HTML表单提交中，表单字段通常用键值对的方式传递给服务器，以便处理表单数据。
Body (JSON)： JSON（JavaScript Object Notation）是一种数据格式，它以键值对的形式表示数据对象的属性和值。
Cookie： Cookie 是一种客户端存储数据的机制，通常由键值对组成，用于跟踪用户和存储会话信息。
Session： 会话数据通常是通过键值对的方式管理，用于在用户与服务器之间保持状态和信息。
Session 数据内容： Session 数据内容通常以键值对的形式组织，其中键表示属性或字段名称，值表示相应的数据值，用于存储用户状态和相关信息。

键值对是一种灵活且通用的数据结构，可用于处理各种不同的数据需求，从简单的查询参数到复杂的数据对象。它们在编程和数据存储中起到关键作用，使数据的组织和访问更加方便和有效。

综上，可以说，键值对贯穿整个编程生涯，是一个非常重要的概念。

我们可以通过Servlet API 来操作上述结构：

Cookie是浏览器的机制，Servlet提供了API来获取Cookie；

Session是服务器的机制，Servlet内部已经实现好了，也提供了API供我们使用。

我们马上来看看Session的具体内容和相关使用。

Session是什么？

Session 是一种在服务器端存储数据的机制，用于跟踪用户在网站上的活动和状态。
它通常不涉及持久化存储，而是在用户与服务器的会话期间保持数据。
Session 可以存储用户的状态信息、身份认证信息以及其他用户特定的数据。
Session机制通常依赖于Cookie来识别用户，但实际的用户数据存储在服务器上。
服务器为每个用户创建一个唯一的会话，并将会话ID存储在Cookie中。该会话ID用于将用户与其数据关联。

Cookie vs. Session：

Cookie 是一种客户端存储数据的机制，通常是小型文本文件，存储在用户的浏览器中。
Session 存储在服务器端，通常以键值对的形式存储在服务器内存中。
通常，会话（Session）与 Cookie 配合使用，其中 Cookie 中存储用户身份标识或会话 ID，服务器使用会话 ID 来检索或存储与该用户相关的数据。

核心方法

HttpServletRequest 类中的相关方法

1、HttpSession getSession() 方法：

getSession() 方法用于在服务器中获取会话（Session）对象。能够完成从Cookie中获取到Session ID并且查询出对应的Session的过程。
这个方法有两个不同的重载形式：getSession(boolean create) 和 getSession()。
如果 create 参数为 true，则在服务器上创建一个新的会话（如果不存在的话），并返回该会话对象；如果 create 为 false，则当不存在会话时返回 null。
这个方法通常用于登录等获取与客户端相关联的会话，以便在会话中存储和检索用户特定的数据。会话是一种在用户与服务器之间保持状态的机制。
Servlet中通过HttpSession这个类表示一个会话，服务器上同时具有多个会话，就会存在一个类似于这样的：HashMap<String，HttpSession>哈希表，里面的String就是Session ID，HttpSession就是Session 对象。如果当前Session ID没有从哈希表中查到，会自动创建出新的键值对（分配新的Session ID以及创建一个新的HttpSession对象）。

2、Cookie[ ] getCookies() 方法：

getCookies() 方法用于获取客户端发送给服务器的所有的Cookie对象。
它返回一个Cookie数组，包含请求中包含的所有Cookie对象。
这个方法将自动将Cookie中的格式解析为键值对，以便你可以轻松地访问和操作Cookie的值。
Cookie是一种客户端存储数据的机制，通常用于跟踪用户会话或存储其他客户端相关的信息。

这两个方法是Servlet开发中非常常用的，它们允许开发者在处理HTTP请求时获取和操作与会话和Cookie相关的数据。getSession() 用于处理与会话相关的操作，而getCookies() 用于获取并解析请求中的Cookie数据。

HttpServletResponse 类中的相关方法

void addCookie(Cookie cookie)

void addCookie(Cookie cookie) 方法用于向HTTP响应中添加一个Cookie对象。
你可以通过创建一个 Cookie 对象并设置其属性，如名称、值、路径、域、过期时间等，然后使用 addCookie 方法将其添加到响应中。
一旦Cookie被添加到响应中，它将在响应头中以Set-Cookie标头的形式发送给客户端浏览器。
客户端浏览器会接收Cookie，并在后续的HTTP请求中将Cookie信息包含在请求头中，以便服务器可以识别和处理用户的会话或其他相关信息。

HttpSession 类中的相关方法

一个 HttpSession 对象里面包含多个键值对，我们可以往 HttpSession 中存任何我们需要的信息。

1、Object getAttribute(String name) 方法：

Object getAttribute(String name) 方法用于返回在该会话中具有指定名称的对象。
参数 name 是要查找的对象的名称。
返回值：如果在会话中存在具有指定名称的对象，该方法将返回相应的对象；如果不存在，则返回 null。
用途：通常用于检索在会话中存储的用户特定的数据。例如，你可以存储用户的用户名、配置选项、购物车内容等，并使用 getAttribute 方法获取这些数据。

2、void setAttribute(String name, Object value) 方法：

void setAttribute(String name, Object value) 方法用于将一个对象绑定到会话（Session）中，使用指定的名称。
参数 name 是要绑定对象的名称，value 是要绑定的对象。
返回值：该方法没有返回值，因为它只是将对象存储在会话中。
用途：允许你在会话中存储数据，以便在会话期间的不同请求之间共享数据。你可以存储各种类型的数据对象，如用户身份信息、购物车内容、用户首选项等。

3、boolean isNew() 方法：

boolean isNew() 方法用于判定当前的会话是否是新创建出的会话。
返回值：如果会话是新创建的，该方法返回 true；如果是已经存在的会话，则返回 false。
用途：通常用于检查会话是否刚刚开始，以便执行特定的操作。例如，你可以使用 isNew 方法来初始化用户状态或执行特定的逻辑仅在新会话期间执行。

这些方法一起提供了方便的方式来管理会话中的数据，并根据需要检查和操作会话状态。

Cookie 类中的相关方法

每个 Cookie 对象就是一个键值对。

1、String getName() 方法：

String getName() 方法用于返回Cookie的名称。
名称是Cookie的唯一标识，一旦创建后就不能再更改。这个名称是通过Set-Cookie字段设置给浏览器，用于在客户端存储和检索数据。
返回值：返回Cookie的名称，通常是一个字符串。
用途：通常，你可以使用Cookie的名称来唯一标识和获取特定的Cookie对象。

2、String getValue() 方法：

String getValue() 方法用于获取与Cookie关联的值。
每个Cookie都有一个与之关联的值，通常是一些数据，如用户名、会话ID等。
返回值：返回与Cookie关联的值，通常是一个字符串。
用途：这个方法允许你获取Cookie存储的具体数据，以便在客户端或服务器端使用。

3、setValue(String newValue) 方法：

void setValue(String newValue) 方法用于设置与Cookie关联的值。
通过这个方法，你可以更改Cookie的值，从而更新Cookie中存储的数据。
参数 newValue 是你希望设置的新值。
返回值：该方法没有返回值，因为它只是设置Cookie的值。
用途：这个方法允许你在需要时更改Cookie的内容，以实现动态数据存储。

这些方法使得在Servlet中可以方便地操作Cookie对象的名称和值，允许你根据需要获取、设置和更新Cookie的内容。

总之，

Cookie是一种键值对的数据结构，通过Cookie类的方法可以获取和设置Cookie的名称和值。
HttpServletRequest类的getCookies()方法用于获取请求中的多个Cookie键值对。
HttpServletResponse类的addCookie(Cookie cookie)方法用于将新的Cookie键值对添加到HTTP响应中，以向客户端发送Cookie数据。这些方法使得在Servlet中可以方便地操作Cookie数据。

我们基于上述的API就可以实现用户登录了！

Session 工作原理：

当用户第一次访问网站时，服务器为该用户创建一个唯一的 Session ID，并将其存储在 Cookie 中或作为URL参数传递给客户端。
服务器会为每个用户维护一个 Session 对象，通常使用哈希表（键值对）来存储。
用户在网站上的各种操作和请求会包含该 Session ID，以便服务器可以识别用户的会话。
服务器使用 Session ID 从 Session 存储中检索或存储与用户相关的数据。
Session 数据可以包括用户身份、购物车内容、语言偏好等。

Session 的生命周期：

Session 数据在用户会话期间保持活动，通常在用户登录到网站并退出登录后终止。
它可以具有固定的超时时间，如果用户在一段时间内没有活动，会话可能会被服务器终止。
Session 也可以在用户关闭浏览器时终止，或者在服务器重启时丢失。

Session 的用途：

身份验证和授权：Session 可用于存储用户登录状态和权限信息，以确保用户已登录并有权限执行某些操作。
购物车和订单管理：Session 可用于存储用户的购物车内容和订单信息。
用户配置和首选项：Session 可以存储用户的语言偏好、主题选择和其他配置信息。
临时数据存储：Session 可用于在用户会话期间存储临时数据，以便在不同页面之间共享。

安全性考虑：

Session 数据存储在服务器端，通常比 Cookie 更安全，因为它不容易被修改或窃取。
但要确保在使用 Session 时采取适当的安全措施，如防止会话固定攻击和数据泄露。

总结：

Session 是一种在服务器端存储数据的机制，用于跟踪用户活动和状态。
通常与 Cookie 配合使用，通过存储会话 ID 来维护用户的会话数据。
Session 可用于身份验证、购物车管理、用户首选项和其他用途。

接下来我们就来写一个“登录”程序：

实现的大致顺序如下：

1、登录页面的构建：

2、通过一个Servlet处理上述的登录请求：通过这个Servlet读取用户名和密码，并且验证是否登陆成功。如果登录成功，就会给当前这个用户创建一个对话，并且把得到的Session ID通过Cookie返回给客户端（客户端就把Cookie保存起来了）。并且还会保存一些用户当前的信息。

3、网站主页，通过另一个Servlet生成的动态页面，把刚才这里的用户数据给显示到页面上。

实现用户登录

实现简单的用户登录逻辑。

这个代码中主要是通过 HttpSession 类完成，并不需要我们手动操作 Cookie 对象。

1、先来写一个登录页面

你懂的，先把该配置的目录还有文件配置好：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>登录</title>
</head>
<body>
    <!-- 使用 form 表单, 实现登录效果 -->
    <form action="login" method="post">
        <input type="text" name="username">
        <input type="text" name="password">
        <input type="submit" value="登录">
    </form>
</body>
</html>

配置好Tomcat之后运行起来是这样的：

此处我们可以约定一下：

2、创建 LoginServlet 类，处理登录请求：

package org.example;

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

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 读取请求传来的参数 (用户名和密码)
        //    最好先给请求设置一下字符集. 否则如果 username 是中文, 此处的 getParameter 可能会乱码.
        req.setCharacterEncoding("utf8");
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        // 2. 验证用户名密码, 是否是正确的. 一般来说, 验证用户名密码, 是要通过数据库的.
        //    此处为了简单一点, 先把用户名和密码, 写死. 比如此处假设正确的用户名是 zhangsan, 正确的密码是 123
        //    此处还要注意, 上述 getParameter 可能会拿到 null .  为了避免空指针异常, 下面这种比较方式是更合适的写法.
        //    equqls内部能够针对参数为null做好处理
        if (!"zhangsan".equals(username) || !"123".equals(password)) {
            // 登录失败
            // 给用户返回一个提示.
            resp.setContentType("text/html; charset=utf8");
            resp.getWriter().write("当前的用户名或者密码错误!");
            return;
        }
        // 3. 登录成功了, 给这个用户创建一个会话出来.
        //    可以给会话中保存一些自定义的数据, 通过 Attribute 的方式来保存.
        //
        HttpSession session = req.getSession(true);
        //    此处 Attribute 也是键值对. 这里的内容存储什么都可以. 程序员自定义的.
        //    这样的数据存储好了之后, 后续跳转到其他的页面, 也随时可以把这个数据从会话中取出来.
        session.setAttribute("username", username);
        session.setAttribute("loginTime", System.currentTimeMillis());
        // 4. 此时相当于登录成功!! 让页面跳转到网站首页.
        resp.sendRedirect("index");
    }
}

服务器中可能有多个 Servlet 类，这些 Servlet 要处理不同的请求，但是现在这些 Servlet 都可以获取到刚刚这个 session 对象，进一步的就能拿到这里存储的 Attribute，也就实现了不同Servlet之间共享数据的效果。

当用户成功登录并创建了一个会话（HttpSession）后，会话中的属性（Attribute）可以在应用程序的不同Servlet中共享。每个Servlet都可以通过会话对象访问和修改这些属性，以提供一致的用户体验。

这对于在不同页面之间传递用户数据和状态信息非常有用，例如用户身份认证信息、购物车内容、用户首选项等。而且，这种数据的存储和访问是线程安全的，因为Servlet容器会确保会话的正确管理。

具体分析一下我们的代码：

Servlet声明和URL映射：
- 通过@WebServlet注解，这个Servlet被映射到URL路径/login，这意味着当用户访问网站的/login路径时，这个Servlet会被调用。
处理POST请求：
- 在doPost方法中，处理POST请求的逻辑被定义。
获取请求参数：
- 通过req.getParameter("username")和req.getParameter("password")，从请求中获取用户名和密码。
- 在这个示例中，为了简单起见，用户名和密码都是写死的（"zhangsan"和"123"），并且没有与数据库交互。
- 这段代码通过req.setCharacterEncoding("utf8")设置了请求的字符集，以防止中文用户名导致乱码。
验证用户名和密码：
- 通过比较用户名和密码是否与预定义的值匹配，来验证登录是否成功。
- 如果用户名和密码不匹配，将返回一个包含错误消息的响应，告知用户登录失败。
创建会话（Session）：
- 如果用户名和密码验证成功，将为用户创建一个会话。
- 会话对象通过req.getSession(true)来获取，如果会话不存在则会创建一个新的。
- 在会话中，存储了一些用户自定义的数据，如用户名和登录时间。这些数据以键值对的形式存储在会话中。
- 通过session.setAttribute("key", value)方法，将用户名和登录时间存储在会话中。
登录成功：
- 登录成功后，通过resp.sendRedirect("index")将用户重定向到网站的首页，即跳转到/index页面。
- 这表示用户已经成功登录，会话被创建，会话中包含用户相关的数据，用户可以访问其他受保护的页面并保持登录状态。

这段代码只是一个非常简单的用户登录处理Servlet示例，它给我们演示了如何从请求中获取参数、验证用户名和密码，如何创建和使用会话对象，以及如何将用户重定向到其他页面。在实际应用中，验证通常会与数据库交互，并会有更复杂的登录逻辑。

3、创建 IndexServlet 类：生成一个主页

package org.example;

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

// 通过这个 Servlet 生成一个 主页
@WebServlet("/index")
public class IndexServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 1. 先获取到当前用户对应的会话对象. 生成的页面要根据当前用户信息来构造.
        HttpSession session = req.getSession(false);
        if (session == null) {
            // sessionId 不存在, 或者 sessionId 没有在 hash 表中查到.
            resp.setContentType("text/html; charset=utf8");
            resp.getWriter().write("您当前尚未登录!");
            return;
        }
        // 2. 从会话中拿到之前存储的用户信息
        //    此处的强转, 需要程序员自行保证, 类型是靠谱的.
        String username = (String) session.getAttribute("username");
        Long loginTime = (Long) session.getAttribute("loginTime");
        // 3. 生成一个页面, 把上述数据显示到页面上.
        resp.setContentType("text/html; charset=utf8");
        String respBody = "欢迎你 " + username + "! 上次登录时间为: " + loginTime;
        resp.getWriter().write(respBody);
    }
}

具体分析一下上述代码：

Servlet声明和URL映射：
- 通过@WebServlet注解，这个Servlet被映射到URL路径/index，这意味着当用户访问网站的/index路径时，这个Servlet会被调用。
处理GET请求：
- 在doGet方法中，处理GET请求的逻辑被定义。
获取当前用户的会话对象：
- 通过req.getSession(false)来获取当前用户的会话对象。
- 如果用户没有会话，即会话不存在，或者SessionID在哈希表中没有对应的HttpSession对象，则会返回null。
- 如果session为null，说明用户尚未登录，会向用户返回一个消息提示，告知用户需要先登录才能访问主页。
从会话中获取用户信息：
- 如果会话存在（即用户已登录），则从会话中获取之前存储的用户信息。
- 通过session.getAttribute("key")方法，分别获取用户名（"username"）和上次登录时间（"loginTime"）。
- 需要注意，这里进行了类型转换，要确保类型是正确的，以避免运行时异常。这里假设存储在会话中的数据类型是正确的。
生成页面响应：
- 构建页面的响应内容，根据用户信息来显示不同的页面。
- 使用resp.getWriter().write()方法将响应内容返回给客户端。
- 在这个示例中，响应内容包括欢迎消息以及上次登录时间。

这段代码实现了一个根据用户登录状态动态生成主页的功能。如果用户已登录，它会显示欢迎消息和上次登录时间；如果用户尚未登录，它会显示一个提示消息。该示例演示了如何使用HttpSession来管理用户会话状态，以及如何在不同Servlet之间共享数据以提供个性化用户体验。内部的哈希表和SessionID的细节由Servlet容器自动处理，开发者只需要关注会话和数据的操作。

全部实现完成以后我们就可以来看看实现效果了：

1、点击登录之后就会触发一个前端的POST请求：

2、到了服务器这边：

3、重定向到主页（index）：

这个东西的应用在于：

持久的登录状态： 一旦用户成功登录，通常会话将维持一段时间，使用户在之后的访问中继续保持登录状态。这可以通过Cookie和Session来实现。Cookie通常用于在客户端存储会话标识，而Session在服务器端存储用户数据。这种持久的登录状态使得用户无需在每个页面请求中重新登录。
会话过期时间： 会话的持续时间是可以设置的。不同网站可以根据需求设置不同的会话过期时间。一些网站可能会设置长期的会话，以提供长时间的登录状态，而其他敏感性较高的网站可能会设置较短的会话，以增强安全性。
Cookie的过期时间： Cookie是在客户端存储的，可以设置Cookie的过期时间。一旦Cookie的过期时间到了，浏览器会自动删除该Cookie。这可以在创建Cookie时通过setMaxAge方法来设置。
Session的过期时间： Session是在服务器端管理的，也可以设置会话的过期时间。当会话过期，服务器会自动删除会话及其数据。过期时间可以通过Servlet容器或编程方式来设置。
共用计算机的风险： 如果多个人在同一台公共计算机上使用同一个登录状态的帐户，会产生潜在的安全风险。这是因为后续用户无需再次登录，可能会有权限进行一些敏感操作。因此，对于共用计算机，特别是在公共场所，用户应该注销或清除会话和Cookie，以确保不会被其他人滥用。

总之，通过Cookie和Session的合理管理，可以实现用户的登录状态维护，会话过期时间的设置允许网站根据需求进行调整，以平衡用户便利性和安全性。对于共用计算机的风险，用户应当采取适当的措施，如注销或清除登录状态，以保护账户的安全。

上传文件

上传文件也是日常开发中的一类常见需求。在 Servlet 中也进行了支持。

1、文件上传基础：

文件上传是通过HTTP POST请求实现的。
在HTML表单中，通常使用<input type="file">标签来创建文件上传字段。
当用户选择文件并提交表单时，浏览器将文件数据包含在POST请求中的请求体中。

2、文件上传处理：

在Servlet中，你可以通过HttpServletRequest对象的getPart方法或getParts方法来处理上传的文件。
getPart方法用于获取单个上传的文件，而getParts方法用于获取所有上传的文件。
你可以使用这些方法来获取文件的输入流，读取文件内容，并保存文件到服务器的文件系统或进行其他操作。

核心方法

HttpServletRequest 类方法

1、Part getPart(String name)：

该方法用于获取请求中给定名称（name）的文件。
它返回一个Part对象，代表上传的文件。你可以使用Part对象来获取文件名、输入流、文件大小等信息。
```
Part filePart = request.getPart("file");
```

2、Collection<Part> getParts()：

该方法用于获取请求中的所有文件。
它返回一个Collection对象，其中包含所有上传的文件（Part对象）。

你可以遍历Collection来处理多个上传的文件。

Collection<Part> parts = request.getParts();
for (Part part : parts) {
    // 处理每个上传的文件（Part）
}

这些方法使你能够有效地处理文件上传，并在Servlet中访问上传的文件的内容、文件名、大小等信息。在处理文件上传时，确保验证文件类型、限制文件大小，并处理潜在的安全风险，以保护应用程序的安全性。

Part 类方法

1、String getSubmittedFileName()：

该方法用于获取提交的文件名。它返回一个字符串，表示上传文件的名称。
通常用于获取上传文件的原始文件名。

2、String getContentType()：

该方法用于获取提交的文件的类型（MIME类型）。它返回一个字符串，表示上传文件的类型。
用于识别文件的内容类型，例如"image/jpeg"或"application/pdf"。

3、long getSize()：

该方法用于获取文件的大小，以字节为单位。它返回一个long值，表示上传文件的大小。

4、void write(String path)：

该方法用于将提交的文件数据写入磁盘上的文件。你需要提供文件路径作为参数，数据将被写入指定的文件。
这对于将上传的文件保存到服务器的文件系统中非常有用。

Part filePart = request.getPart("file");
String fileName = filePart.getSubmittedFileName();
String contentType = filePart.getContentType();
long fileSize = filePart.getSize();

// 将文件保存到服务器上
String savePath = "path/to/save/uploads/" + fileName;
filePart.write(savePath);

这些Part类的方法允许你访问上传文件的信息和内容，从而进行文件上传处理，包括获取文件名、文件类型、文件大小，以及将文件数据保存到服务器文件系统中。

我们可以简单运用一下这些API，实现程序，通过网页提交一个图片到服务器上。

1. 创建 upload.html，放到 webapp 目录中。

<form action="upload" enctype="multipart/form-data" method="POST" accept-charset="UTF-8">
    <meta charset="UTF-8">
    <input type="file" name="MyImage">
    <input type="submit" value="提交图片">
</form>

文件上传通常通过POST请求的表单来实现，同时需要确保表单使用multipart/form-data编码类型以支持文件上传。

这是因为multipart/form-data允许在HTTP请求中传输二进制数据，包括文件。

2. 创建 UploadServlet 类。

package org.example;

import javax.servlet.annotation.MultipartConfig;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Part;
import java.io.*;
import java.net.URLDecoder;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@MultipartConfig
@WebServlet("/upload")
public class FileUploadServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");

        // 获取上传的文件
        Part filePart = request.getPart("MyImage");

        // 获取文件名
        String fileName = getSubmittedFileName(filePart);
        // 在获取文件名之前，对文件名进行解码
        String decodedFileName = URLDecoder.decode(fileName, "UTF-8");

        // 指定服务器上的保存路径
        String savePath = getServletContext().getRealPath("/uploads/") + File.separator + fileName;

        // 将文件保存到服务器
        try (InputStream input = filePart.getInputStream();
             OutputStream output = new FileOutputStream(savePath)) {
            int bytesRead;
            byte[] buffer = new byte[4096];
            while ((bytesRead = input.read(buffer)) != -1) {
                output.write(buffer, 0, bytesRead);
            }
        }
        response.setContentType("text/html; charset=utf8");
        response.getWriter().write("文件 " + fileName + " 上传成功！");
    }

    private String getSubmittedFileName(Part part) {
        for (String cd : part.getHeader("content-disposition").split(";")) {
            if (cd.trim().startsWith("filename")) {
                String fileName = cd.substring(cd.indexOf('=') + 1).trim().replace("\"", "");
                return fileName;
            }
        }
        return null;
    }
}

这段代码是一个Servlet，用于处理文件上传的POST请求。

Servlet映射：
- 通过@WebServlet("/upload")注解，将Servlet映射到URL路径"/upload"，以便处理文件上传请求。
doPost方法：
- 当收到POST请求时，doPost方法被调用来处理文件上传。
- 首先，通过request.getPart("MyImage")获取名为"MyImage"的文件上传部分（Part对象）。
- 接着，使用自定义方法getSubmittedFileName从Part对象中获取提交的文件名。
文件保存：
- 确定了文件名后，指定了服务器上的保存路径，这个路径是基于应用程序的上下文路径。
- 然后，使用InputStream从Part对象中获取文件数据，将数据写入指定的保存路径，完成文件的保存。
响应：
- 最后，通过response.getWriter().write("文件 " + fileName + " 上传成功！")向客户端返回成功消息。
文件上传功能：
- 该Servlet实现了文件上传功能，客户端可以通过HTML表单选择文件并提交到"/upload"路径。
- 上传的文件将被保存在服务器上的"/uploads/"目录中。
- 上传成功后，Servlet返回一条成功消息。
getSubmittedFileName方法：
- 这个方法用于从Part对象的content-disposition头中提取文件名，以确保获取到正确的文件名。

总之，这段代码实现了文件上传的功能，包括接收上传的文件、获取文件名、将文件保存到服务器，并向客户端发送成功消息。这是一个基本的文件上传示例，可以根据需要进行进一步的定制和改进，例如添加文件类型验证、文件大小限制等。

需要注意的是：

需要给 UploadServlet 加上 @MultipartConfig 注解，否则服务器代码无法使用 getPart 方法
getPart 的参数需要和 form 中 input 标签的 name 属性对应。
客户端一次可以提交多个文件， (使用多个 input 标签)。此时服务器可以通过 getParts 获取所有的 Part 对象。

先在我们的wepapp目录下构建一个新的子目录“upload”，用来存放我们要上传的图片文件（我已经提交了一些，你只需要创建出空的目录即可）：

不管是哪个地方的图片，都可以顺利的被提交到我们的upload目录下：

我们也可以抓个包看看：

可以看到 Content-Type 为 multipart/form-data ，这样的请求中带有一个

boundary = ---- WebKitFormBoundaryxt86TAqMzDsINVMA ，

这个 boundary 在 body 这边作为一个 “分隔线”，分隔线下面是上传的文件的属性和文件内容。

常用代码片段

最后的最后，我把一些常用代码片段罗列在这里，后续我们写代码的时候可以在这个基础上拷贝过去直接修改：

pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>Login</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.15.0</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>


    </dependencies>
</project>

web.xml：

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
    <display-name>Archetype Created Web Application</display-name>
</web-app>

hello world：

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        resp.getWriter().write("hello");
   }
}

读取请求报头：

@WebServlet("/getParameter")
public class GetParameter extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
 String contentType = req.getHeader("Content-Type");
        // 或者使用
        String contentType = req.getContentType();
   }
}

读取 GET 请求的 query string：

@WebServlet("/getParameter")
public class GetParameter extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        String userId = req.getParameter("userId");
        String classId = req.getParameter("classId");
   }
}

读取 POST 请求的 body：

@WebServlet("/postParameter")
public class PostParameter extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        resp.setContentType("text/html; charset=utf-8");
        req.setCharacterEncoding("utf-8");
        String userId = req.getParameter("userId");
        String classId = req.getParameter("classId");
        resp.getWriter().write("userId: " + userId + ", " + "classId: " +
classId);
   }
}

设置状态码：

@WebServlet("/statusServlet")
public class StatusServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        resp.setStatus(200);
   }
}

设置响应报头：

@WebServlet("/autoRefreshServlet")
public class AutoRefreshServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        resp.setHeader("Refresh", "1");
   }
}

重定向：

@WebServlet("/redirectServlet")
public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        resp.sendRedirect("http://www.sogou.com");
   }
}

登录页面：

<form action="login" method="POST">
    <input type="text" name="username">
    <input type="password" name="password">
    <input type="submit" value="提交">
</form>

创建新 Session：

@WebServlet("/login")
public class LoginServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        HttpSession session = req.getSession(true);
        session.setAttribute("username", "admin");
        session.setAttribute("loginCount", "0");
   }
}

获取已有 Session：

@WebServlet("/login")
public class LoginServlet extends HttpServlet { 
    HttpSession session = req.getSession(false);
    if (session == null) {
        // 用户没有登陆, 重定向到 login.html
        resp.sendRedirect("login.html");
        return;
   }
    // 如果已经登陆, 则从 Session 中取出数据
    String userName = (String)session.getAttribute("username");
    String countString = (String)session.getAttribute("loginCount");
}

上传文件：

@MultipartConfig
@WebServlet("/upload")
public class UploadServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException {
        Part part = req.getPart("MyImage");
        System.out.println(part.getSubmittedFileName());
        System.out.println(part.getContentType());
        System.out.println(part.getSize());
        part.write("d:/MyImage.jpg");
        resp.getWriter().write("upload ok");
   }
}

<form action="upload" enctype="multipart/form-data" method="POST">
    <input type="file" name="MyImage">
    <input type="submit" value="提交图片">
</form>