# 实验 2-1：基于 Servlet 的用户认证功能实现

**Repository Path**: javaweb-dev-tech/lab2_1

## Basic Information

- **Project Name**: 实验 2-1：基于 Servlet 的用户认证功能实现
- **Description**: 实验 2-1：基于 Servlet 的用户认证功能实现
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 5
- **Created**: 2026-04-13
- **Last Updated**: 2026-04-23

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 实验 2-1：基于 Servlet 的用户认证功能实现

> **学生信息填写栏**
> * **班级**：_____________
> * **姓名**：_____________
> * **学号**：_____________
> * **完成日期**：2026/**/**
>
>

## 一、实验基本信息

| 项目 | 内容 |
|------|------|
| **实验名称** | 基于 Servlet 的用户认证功能实现 |
| **实验类型** | 验证性 + 设计性 |


---

## 二、实验目的

通过本次实验，学生能够：

1. **掌握 Servlet 的创建方法** - 能够独立新建 Servlet 类
2. **掌握 doPost 方法处理请求** - 能够处理 HTTP POST 请求
3. **掌握 Session 的使用** - 能够使用 Session 保存和获取用户信息
4. **掌握 JSON 数据处理** - 能够返回 JSON 格式数据
5. **理解前后端数据流** - 理解从表单提交到页面显示的完整流程

> ⚠️ **说明**：
> - 本实验使用**模拟数据**（内存中的假数据），不涉及数据库和 JDBC
> - 模板工程已提供前端页面和部分后端代码
> - 学生需要完成注册、获取用户、退出登录三个 Servlet 的实现

---

## 三、实验任务概述

### 3.1 功能流程图

```
┌──────────────┐     ┌───────────────┐     ┌──────────────┐
│   登录页面    │ ──▶ │ LoginServlet  │ ──▶ │  存入 Session  │
│  输入用户名  │     │  (已完成)     │     │   重定向到   │
│  和密码     │     │               │     │  home.html   │
└──────────────┘     └───────────────┘     └──────────────┘
                                                     │
                                                     ▼
┌──────────────┐     ┌───────────────┐     ┌──────────────┐
│  显示用户名  │ ◀── │ GetUserServlet│ ◀── │ 主页加载时   │
│  在导航栏    │     │  (待实现)     │     │  调用 API    │
└──────────────┘     └───────────────┘     └──────────────┘
```

### 3.2 需要完成的任务

| 任务 | 文件 | 状态 |
|------|------|------|
| 任务一 | LoginServlet.java | ✅ 已完成（示例代码） |
| 任务二 | RegisterServlet.java | ❌ 待实现 |
| 任务三 | GetUserServlet.java | ❌ 待实现 |
| 任务四 | LogoutServlet.java | ❌ 待创建 |

---

## 四、实验准备

### 4.1 打开项目

1. 启动 IntelliJ IDEA
2. 打开项目：`lab2-1_servlet_basic`
3. 等待 Maven 依赖下载完成

### 4.2 项目结构

```
src/main/java/edu/wtbu/cs/book/
├── controller/
│   ├── LoginServlet.java      ✅ 已完成（参考代码）
│   ├── RegisterServlet.java   ❌ 待实现
│   ├── GetUserServlet.java    ❌ 待实现
│   └── LogoutServlet.java     ❌ 待创建（新建类）
├── entity/
│   └── User.java              ✅ 已完成
└── util/
    ├── JsonUtils.java         ✅ 已完成
    ├── MD5Utils.java          ✅ 已完成
    └── MockUserStore.java     ✅ 已完成（示例代码）

src/main/webapp/
├── login.html                 ✅ 已完成
├── register.html              ✅ 已完成
├── home.html                  ✅ 已完成
└── WEB-INF/
    └── web.xml                ✅ 已完成（配置 context-path=/book）
```

---

## 五、实验步骤

### 任务一：理解示例代码

#### 5.1.1 MockUserStore.java（已提供）

这是模拟数据存储类，在内存中存储用户数据。

**位置**：`src/main/java/edu/wtbu/cs/book/util/MockUserStore.java`

**阅读重点**：
- `static {}` 静态代码块的作用
- `Map<String, User>` 如何存储用户数据
- `findByUsername()` 方法如何查询用户
- `addUser()` 方法如何添加新用户

**提示**
- 可以借助AI帮你理解代码
- Java知识点：***静态方法***、静态代码块

---

#### 5.1.2 LoginServlet.java（大部分已完成）

这是登录功能的参考实现。

**位置**：`src/main/java/edu/wtbu/cs/book/controller/LoginServlet.java`

**任务 1-1**：阅读 LoginServlet 代码，理解登录流程

阅读代码并理解以下步骤：
1. 设置编码和响应格式
2. 读取 JSON 请求体
3. 参数校验
4. 查询用户（使用 MockUserStore）
5. 判断用户是否存在
6. 验证密码（使用 MD5Utils）
7. **存入 Session**（需要你来完成 ⬇️）
8. 返回成功响应

---

#### 5.1.3 任务：完成 Session 存储

**任务描述**：在 LoginServlet 中，将登录成功的用户信息存入 Session。

**位置**：`src/main/java/edu/wtbu/cs/book/controller/LoginServlet.java` 第 71-75 行

**当前代码**：
```java
// 7. 登录成功 - 存入 Session
// TODO: 请在此处将用户信息存入 Session


System.out.println("用户登录成功：" + username);
```

**实现要求**：
1. 获取 Session 对象
2. 将用户对象存入 Session，键名为 `"currentUser"`
3. 设置 Session 超时时间为 30 分钟


**知识点**：
- `req.getSession()` - 获取当前请求的 Session（如果不存在则创建）
- `session.setAttribute(key, value)` - 向 Session 中存储数据
- `session.setMaxInactiveInterval(seconds)` - 设置 Session 超时时间（秒）
- `session.getAttribute(key)` - 从 Session 中获取数据（后续任务会用到）
- `session.invalidate()` - 使 Session 失效（退出登录时用到）


---

### 任务二：实现注册功能

#### 5.2.1 任务描述

完成 `RegisterServlet.java` 的实现，处理用户注册请求。

#### 5.2.2 功能要求

1. 接收前端传来的 JSON 数据（username, name, password, email）
2. 校验参数是否为空
3. 检查用户名是否已存在
4. 创建新用户（密码需要 MD5 加密）
5. 添加到模拟数据库
6. 返回 JSON 响应

#### 5.2.3 代码实现

**位置**：`src/main/java/edu/wtbu/cs/book/controller/RegisterServlet.java`

```java
package edu.wtbu.cs.book.controller;

import edu.wtbu.cs.book.entity.User;
import edu.wtbu.cs.book.util.JsonUtils;
import edu.wtbu.cs.book.util.MD5Utils;
import edu.wtbu.cs.book.util.MockUserStore;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.BufferedReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@WebServlet(name = "registerServlet", value = "/api/register")
public class RegisterServlet extends HttpServlet {

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // TODO: 请在此处实现注册逻辑
    }

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // TODO: 返回错误提示，注册请使用 POST 方法
    }

    /**
     * 读取 JSON 请求体
     * 提示：参考 LoginServlet 的 readJsonBody 方法
     */
    private Map<String, String> readJsonBody(HttpServletRequest req) throws IOException {
        // TODO: 请实现 JSON 请求体的解析
        return null;
    }
}
```

#### 5.2.4 实现提示

参考 `LoginServlet` 的代码结构，按照以下步骤实现：

```java
// 步骤 1：设置编码和响应格式
req.setCharacterEncoding("UTF-8");
resp.setContentType("application/json;charset=UTF-8");

// 步骤 2：读取 JSON 请求体
Map<String, String> params = readJsonBody(req);
String username = params.get("username");
String name = params.get("name");
String password = params.get("password");
String email = params.get("email");

// 步骤 3：参数校验
if (username == null || username.isEmpty() || ...) {
    // 返回错误响应
}

// 步骤 4：检查用户名是否已存在
User existingUser = MockUserStore.findByUsername(username);
if (existingUser != null) {
    // 用户名已存在，返回错误
}

// 步骤 5：创建新用户
User newUser = new User();
newUser.setUsername(username);
newUser.setName(name);
newUser.setPassword(MD5Utils.md5(password));  // 密码加密
newUser.setEmail(email);
newUser.setRole("user");
newUser.setUserType("student");

// 步骤 6：添加到模拟数据库
boolean success = MockUserStore.addUser(newUser);

// 步骤 7：返回响应
if (success) {
    resp.getWriter().write(JsonUtils.success("注册成功", null));
} else {
    resp.getWriter().write(JsonUtils.error("注册失败"));
}
```

---

### 任务三：实现获取用户信息功能

#### 5.3.1 任务描述

完成 `GetUserServlet.java` 的实现，从 Session 中获取当前登录用户信息。

#### 5.3.2 功能要求

1. 从 Session 获取当前用户
2. 如果未登录，返回 401 错误
3. 如果已登录，返回用户信息（不包含密码）

#### 5.3.3 代码实现

**位置**：`src/main/java/edu/wtbu/cs/book/controller/GetUserServlet.java`

```java
package edu.wtbu.cs.book.controller;

import edu.wtbu.cs.book.entity.User;
import edu.wtbu.cs.book.util.JsonUtils;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

@WebServlet(name = "getUserServlet", value = "/api/user")
public class GetUserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // TODO: 请在此处实现获取当前用户逻辑
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        // TODO: 调用 doGet 方法
    }
}
```

#### 5.3.4 实现提示

```java
// 步骤 1：设置响应格式
resp.setContentType("application/json;charset=UTF-8");

// 步骤 2：从 Session 获取当前用户
HttpSession session = req.getSession(false);
if (session == null || session.getAttribute("currentUser") == null) {
    // 未登录，返回 401 错误
    Map<String, Object> result = new HashMap<>();
    result.put("code", 401);
    result.put("message", "未登录");
    result.put("data", null);
    resp.getWriter().write(JsonUtils.toJson(result));
    return;
}

// 步骤 3：获取用户信息
User user = (User) session.getAttribute("currentUser");

// 步骤 4：准备返回数据（不包含密码）
Map<String, Object> userInfo = new HashMap<>();
userInfo.put("id", user.getId());
userInfo.put("username", user.getUsername());
userInfo.put("name", user.getName());
userInfo.put("role", user.getRole());
userInfo.put("userType", user.getUserType());
userInfo.put("email", user.getEmail());

// 步骤 5：返回成功响应
resp.getWriter().write(JsonUtils.success("获取成功", userInfo));
```

---

### 任务四：实现退出登录功能

#### 5.4.1 任务描述

**新建** `LogoutServlet.java` 类，实现退出登录功能。

#### 5.4.2 功能要求

1. 新建 Servlet 类，映射 URL 为 `/api/logout`
2. 清除 Session 中的用户信息
3. 使 Session 失效
4. 返回成功响应

#### 5.4.3 接口说明

| 项目 | 说明 |
|------|------|
| **URL** | `/book/api/logout` |
| **请求方法** | GET 或 POST |
| **请求参数** | 无 |
| **成功响应** | `{"code": 200, "message": "退出成功", "data": null}` |

#### 5.4.4 实现提示

**需要用到的 API**：

- `req.getSession(false)` - 获取当前 Session（如果不存在则返回 null）
- `session.removeAttribute("currentUser")` - 清除 Session 中的用户信息
- `session.invalidate()` - 使 Session 完全失效
- `JsonUtils.toJson(result)` - 将 Map 转换为 JSON 字符串

**注意**：
- 退出登录前需要先获取 Session，但 Session 可能为 null（用户未登录）
- 先清除用户信息，再使 Session 失效
- 无论是否成功退出，都应返回成功响应

---

## 七、测试步骤

### 7.1 在 IDEA 中配置并启动 Tomcat

使用IDEA旗舰版内置tomcat 配置，或者使用使用SmartTomcat插件集成Tomcat)

应用的上下文需要配置为`/book` 

---

### 7.2 使用 Postman 进行接口测试

#### 步骤 1：测试登录接口

1. 打开 Postman，创建新请求（`New` → `HTTP Request`）
2. 设置请求方法为 `POST`
3. 输入 URL：`http://localhost:8080/book/api/login`
4. 点击 `Body` → 选择 `raw` → 下拉选择 `JSON`
5. 输入以下请求体：
```json
{
    "username": "admin",
    "password": "123456"
}
```
6. 点击 `Send` 按钮

**预期结果**：
```json
{
    "code": 200,
    "message": "登录成功",
    "data": {
        "id": 1,
        "username": "admin",
        "name": "系统管理员",
        "role": "admin",
        "userType": "admin",
        "email": "admin@library.com"
    }
}
```

#### 步骤 2：测试获取用户接口

1. 创建新请求（保持 Postman 自动保存的 Cookie）
2. 设置请求方法为 `GET`
3. 输入 URL：`http://localhost:8080/book/api/user`
4. 点击 `Send` 按钮

**预期结果**：
```json
{
    "code": 200,
    "message": "获取成功",
    "data": {
        "id": 1,
        "username": "admin",
        "name": "系统管理员",
        "role": "admin",
        "userType": "admin",
        "email": "admin@library.com"
    }
}
```

#### 步骤 3：测试注册接口

1. 创建新请求
2. 设置请求方法为 `POST`
3. 输入 URL：`http://localhost:8080/book/api/register`
4. 点击 `Body` → 选择 `raw` → 选择 `JSON`
5. 输入以下请求体：
```json
{
    "username": "testuser",
    "name": "测试用户",
    "password": "123456",
    "email": "test@example.com"
}
```
6. 点击 `Send` 按钮

**预期结果**：
```json
{
    "code": 200,
    "message": "注册成功",
    "data": null
}
```

#### 步骤 4：测试退出登录接口

1. 创建新请求
2. 设置请求方法为 `POST`
3. 输入 URL：`http://localhost:8080/book/api/logout`
4. 点击 `Send` 按钮

**预期结果**：
```json
{
    "code": 200,
    "message": "退出成功",
    "data": null
}
```

---

### 7.3 前后端对接测试（浏览器界面测试）

#### 测试登录功能

1. 打开浏览器，访问：`http://localhost:8080/book/login.html`
2. 输入用户名：`admin`，密码：`123456`
3. 点击"登录"按钮
4. 点击"登录"按钮
5. **预期**：页面跳转到主页（`user/index-user.html`），导航栏显示当前用户名

#### 测试注册功能

1. 在登录页面点击"注册"链接，或访问：`http://localhost:8080/book/register.html`
2. 填写注册信息：
   - 用户名：`newuser`
   - 姓名：`新用户`
   - 密码：`123456`
   - 邮箱：`newuser@example.com`
3. 点击"注册"按钮
4. **预期**：提示"注册成功"，自动跳转到登录页

#### 测试获取用户信息

1. 登录成功后访问主页：`http://localhost:8080/book/user/index-user.html`
2. 检查页面右上角或导航栏是否显示当前用户名
3. **预期**：显示当前登录用户的姓名或用户名

#### 测试退出登录

1. 在主页点击"退出"或"注销"按钮
2. **预期**：页面跳转到登录页，Session 被清除
3. 再次访问主页，应提示未登录或跳转回登录页


---

## 八、API 接口说明

### 8.1 登录接口

| 项目 | 说明 |
|------|------|
| **接口 URL** | `/book/api/login` |
| **请求方法** | POST |
| **Content-Type** | `application/json` |

**请求参数**：

| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| `username` | String | 是 | 用户名（登录账号） |
| `password` | String | 是 | 密码（明文，后端会进行 MD5 验证） |

**请求示例**：
```json
{
    "username": "admin",
    "password": "123456"
}
```

**返回参数**：

| 参数名 | 类型 | 说明 |
|--------|------|------|
| `code` | Integer | 响应码：200=成功，400=失败 |
| `message` | String | 响应消息 |
| `data` | Object | 用户信息对象（登录成功时返回） |

**data 对象结构**：

| 字段 | 类型 | 说明 |
|------|------|------|
| `id` | Integer | 用户 ID |
| `username` | String | 用户名 |
| `name` | String | 用户姓名 |
| `role` | String | 用户角色（admin/user） |
| `userType` | String | 用户类型（student/teacher/admin） |
| `email` | String | 邮箱 |

**成功响应示例**：
```json
{
    "code": 200,
    "message": "登录成功",
    "data": {
        "id": 1,
        "username": "admin",
        "name": "系统管理员",
        "role": "admin",
        "userType": "admin",
        "email": "admin@library.com"
    }
}
```

**失败响应示例**：
```json
{
    "code": 400,
    "message": "密码错误",
    "data": null
}
```

---

### 8.2 注册接口

| 项目 | 说明 |
|------|------|
| **接口 URL** | `/book/api/register` |
| **请求方法** | POST |
| **Content-Type** | `application/json` |

**请求参数**：

| 参数名 | 类型 | 必填 | 说明 |
|--------|------|------|------|
| `username` | String | 是 | 用户名（登录账号） |
| `name` | String | 是 | 用户姓名 |
| `password` | String | 是 | 密码（后端会进行 MD5 加密存储） |
| `email` | String | 是 | 邮箱地址 |

**请求示例**：
```json
{
    "username": "testuser",
    "name": "测试用户",
    "password": "123456",
    "email": "test@example.com"
}
```

**返回参数**：

| 参数名 | 类型 | 说明 |
|--------|------|------|
| `code` | Integer | 响应码：200=成功，400=失败 |
| `message` | String | 响应消息 |
| `data` | null | 注册成功时返回 null |

**成功响应示例**：
```json
{
    "code": 200,
    "message": "注册成功",
    "data": null
}
```

**失败响应示例**：
```json
{
    "code": 400,
    "message": "用户名已存在",
    "data": null
}
```

---

### 8.3 获取当前用户接口

| 项目 | 说明 |
|------|------|
| **接口 URL** | `/book/api/user` |
| **请求方法** | GET |
| **依赖** | 需要先登录（依赖 Session） |

**请求参数**：无（从 Session 中获取当前登录用户）

**返回参数**：

| 参数名 | 类型 | 说明 |
|--------|------|------|
| `code` | Integer | 响应码：200=成功，401=未登录 |
| `message` | String | 响应消息 |
| `data` | Object | 用户信息对象（成功时返回） |

**data 对象结构**：

| 字段 | 类型 | 说明 |
|------|------|------|
| `id` | Integer | 用户 ID |
| `username` | String | 用户名 |
| `name` | String | 用户姓名 |
| `role` | String | 用户角色 |
| `userType` | String | 用户类型 |
| `email` | String | 邮箱 |

**成功响应示例**：
```json
{
    "code": 200,
    "message": "获取成功",
    "data": {
        "id": 1,
        "username": "admin",
        "name": "系统管理员",
        "role": "admin",
        "userType": "admin",
        "email": "admin@library.com"
    }
}
```

**未登录响应示例**：
```json
{
    "code": 401,
    "message": "未登录",
    "data": null
}
```

---

### 8.4 退出登录接口

| 项目 | 说明 |
|------|------|
| **接口 URL** | `/book/api/logout` |
| **请求方法** | GET 或 POST |
| **依赖** | 需要先登录（依赖 Session） |

**请求参数**：无

**返回参数**：

| 参数名 | 类型 | 说明 |
|--------|------|------|
| `code` | Integer | 响应码：200=成功 |
| `message` | String | 响应消息 |
| `data` | null | 固定返回 null |

**成功响应示例**：
```json
{
    "code": 200,
    "message": "退出成功",
    "data": null
}
```

---

## 九、Postman 接口测试

### 9.1 测试准备

1. 启动 Tomcat 服务器
2. 确认项目访问地址为：`http://localhost:8080/book`

### 9.2 测试登录接口

**步骤**：

1. 打开 Postman，创建新请求
2. 设置请求方法为 `POST`
3. 输入 URL：`http://localhost:8080/book/api/login`
4. 点击 `Body` → 选择 `raw` → 选择 `JSON`
5. 输入请求体：
```json
{
    "username": "admin",
    "password": "123456"
}
```
6. 点击 `Send` 按钮

**预期结果**：
- 响应状态码：200
- 响应体中 `code` 为 200，`message` 为 "登录成功"
- `data` 对象包含用户信息

### 9.3 测试注册接口

**步骤**：

1. 创建新请求
2. 设置请求方法为 `POST`
3. 输入 URL：`http://localhost:8080/book/api/register`
4. 点击 `Body` → 选择 `raw` → 选择 `JSON`
5. 输入请求体：
```json
{
    "username": "newuser",
    "name": "新用户",
    "password": "123456",
    "email": "newuser@example.com"
}
```
6. 点击 `Send` 按钮

**预期结果**：
- 响应状态码：200
- 响应体中 `code` 为 200，`message` 为 "注册成功"

### 9.4 测试获取用户接口

**步骤**：

1. 创建新请求
2. 设置请求方法为 `GET`
3. 输入 URL：`http://localhost:8080/book/api/user`
4. **重要**：需要先登录后才能获取到用户信息
   - 在 Postman 中，先调用登录接口，Postman 会自动保存 Cookie
   - 或者在 `Session` 标签页中手动添加 Cookie
5. 点击 `Send` 按钮

**预期结果（已登录）**：
- 响应状态码：200
- 响应体中包含当前登录用户的信息

**预期结果（未登录）**：
- 响应状态码：200
- 响应体中 `code` 为 401，`message` 为 "未登录"

### 9.5 测试退出登录接口

**步骤**：

1. 创建新请求
2. 设置请求方法为 `POST`（或 GET）
3. 输入 URL：`http://localhost:8080/book/api/logout`
4. 点击 `Send` 按钮

**预期结果**：
- 响应状态码：200
- 响应体中 `code` 为 200，`message` 为 "退出成功"

### 9.6 Postman 测试报告

完成测试后，截图保存以下内容：
1. 登录接口请求和响应
2. 注册接口请求和响应
3. 获取用户接口请求和响应
4. 退出登录接口请求和响应

---

## 十、实验报告要求

| 序号 | 内容 | 分值 |
|------|------|-------|
| 1 | 任务一：示例代码理解笔记及LoginServlet代码 | 10% |
| 2 | 任务二：RegisterServlet 代码 | 15% |
| 3 | 任务三：GetUserServlet 代码 | 15% |
| 4 | 任务四：LogoutServlet 代码 | 20% |
| 5 | API 接口测试截图（Postman）及前后端对接测试 | 20% |
| 6 | 实验总结（心得体会） | 15% |
| 7 | 使用git、码云远程仓库 | 额外10~15分 |

---

## 十二、常用 API 参考

### JsonUtils 工具类

```java
// 返回成功响应
JsonUtils.success("操作成功", data);

// 返回错误响应
JsonUtils.error(400, "错误信息");
```

### MD5Utils 工具类

```java
// 密码加密
String encryptedPassword = MD5Utils.md5(password);
```

### MockUserStore 工具类

```java
// 查询用户
User user = MockUserStore.findByUsername(username);

// 添加用户
boolean success = MockUserStore.addUser(newUser);
```

### Session 操作

```java
// 存入 Session
session.setAttribute("currentUser", user);

// 从 Session 获取
User user = (User) session.getAttribute("currentUser");

// 清除 Session
session.removeAttribute("currentUser");
session.invalidate();
```

---

## 十三、加分项目（可选）

### 13.1 项目说明

完成本实验的加分扩展项目，可以额外获得 **10-15 分** 的加分奖励。

### 13.2 任务要求

| 步骤 | 说明 |
|------|------|
| 1. Fork 仓库 | 从 Gitee 仓库 `https://gitee.com/javaweb-dev-tech/lab2_1` Fork 到自己的账号 |
| 2. 克隆代码 | 将 Fork 后的仓库克隆到本地 |
| 3. 完成实验 | 完成本实验的所有 Servlet 代码实现 |
| 4. 提交代码 | 将完成的代码 Push 到自己 Fork 的仓库 |

### 13.3 操作步骤

#### 步骤 1：Fork 仓库

1. 访问 `https://gitee.com/javaweb-dev-tech/lab2_1`
2. 点击右上角的 **Fork** 按钮
3. 等待 Fork 完成，仓库将复制到你的账号下（如：`https://gitee.com/你的用户名/lab2_1`）

#### 步骤 2：克隆代码

```bash
# 方式一：使用 HTTPS
git clone https://gitee.com/你的用户名/lab2_1.git

# 方式二：使用 SSH
git clone git@gitee.com:你的用户名/lab2_1.git
```

#### 步骤 3：完成实验代码

在克隆的项目中完成以下 4 个任务：

| 任务 | 文件 | 状态 |
|------|------|------|
| 任务一 | `LoginServlet.java` | 完成 Session 存储代码（第 72-74 行） |
| 任务二 | `RegisterServlet.java` | 实现注册功能 |
| 任务三 | `GetUserServlet.java` | 实现获取用户功能 |
| 任务四 | `LogoutServlet.java` | 新建类，实现退出登录功能 |

#### 步骤 4：提交并推送代码

```bash
# 进入项目目录
cd lab2_1

# 添加所有修改的文件
git add .

# git commit 前确认配置了 git 的 name 和email
# Git 全局设置:
git config --global user.name "你的git用户名"
git config --global user.email "你的git邮箱"

# 提交更改
git commit -m "完成实验 2-1：Servlet 用户认证功能实现"

# 推送到自己的 Gitee 仓库
git push origin master
```

### 13.4 评分标准

| 评分项 | 分值 | 说明 |
|--------|------|------|
| 成功 Fork 仓库 | 2 分 | 能提供自己 Fork 的仓库链接 |
| 代码完整性 | 5 分 | 4 个 Servlet 全部正确实现 |
| 代码提交规范 | 2 分 | Commit 信息清晰，代码结构完整 |
| 功能可运行 | 3 分 | 部署后能正常完成登录、注册、获取用户、退出功能 |
| 附加功能 | 0-3 分 | 如添加了额外的实用功能（如记住我、密码强度验证等） |

### 13.5 提交方式

完成实验后，提交以下材料：

1. **自己 Fork 的仓库链接**（如：`https://gitee.com/你的用户名/lab2_1`）
2. **实验报告**（包含功能截图和心得体会）
3. **仓库提交记录截图**（Git 提交历史页面）


<div align="center">

**祝你实验顺利！**

</div>