diff --git a/backend/demo/Dockerfile b/backend/demo/Dockerfile
index 5d92360..3b73f3c 100644
--- a/backend/demo/Dockerfile
+++ b/backend/demo/Dockerfile
@@ -1,25 +1,66 @@
-# 构建阶段：使用 Maven 构建项目
+# 阶段 1: builder - 构建应用 JAR 包 (跳过测试)
+# 使用包含 Maven 和 JDK 的基础镜像
 FROM maven:3.9.9-eclipse-temurin-24-alpine AS builder
 
+# 设置工作目录
 WORKDIR /app
 
-# 复制项目文件（忽略 target 目录）
+# 复制 pom.xml 文件，以便 Maven 可以下载依赖
+COPY pom.xml .
+
+# 复制项目源代码，包括 main 和 test
+# 这一步是为了让 Maven 在构建和下载依赖时能够解析所有模块
+COPY src ./src
+
+# 执行 Maven clean 和 dependency:go-offline
+# clean: 清理 target 目录
+# dependency:go-offline: 下载所有项目依赖到本地 Maven 仓库，供后续阶段使用
+# -B: 非交互模式
+# 这一步不执行实际的编译和测试，主要用于缓存依赖
+RUN mvn clean dependency:go-offline -B
+
+# 执行 Maven package 构建项目，生成 JAR 包
+# -DskipTests: 跳过单元和集成测试
+RUN mvn package -DskipTests
+
+
+# 阶段 2: tester - 专用于运行和调试测试的运行时环境
+# 基于与 builder 阶段相同的 Maven/JDK 基础镜像，确保测试所需的环境一致
+FROM maven:3.9.9-eclipse-temurin-24-alpine AS tester
+
+# 设置工作目录
+WORKDIR /app
+
+# 复制 pom.xml 和完整的 src 目录 (包含测试代码)
 COPY pom.xml .
 COPY src ./src
 
-# 构建应用，跳过测试
-RUN mvn clean package -DskipTests
+# 从 builder 阶段复制已缓存的 Maven 本地仓库
+# 这样在 tester 阶段运行 Maven 时无需重新下载依赖
+COPY --from=builder /root/.m2 /root/.m2
 
-# 运行阶段：使用较小的 JDK 镜像运行应用
-FROM openjdk:17-jdk-slim-buster
+# 暴露调试端口 (可选，如果您需要远程调试测试过程)
+# 您可以在 docker compose 中映射这个端口到主机
+EXPOSE 5005
 
+# 设置默认命令，使容器启动后保持运行
+# 这样您可以方便地使用 docker exec 进入容器手动执行测试和调试命令
+# 如果您希望容器启动后自动运行测试，可以修改此命令为 ["mvn", "test"]
+CMD ["tail", "-f", "/dev/null"]
+
+
+# 阶段 3: runner - 运行最终应用 JAR 包的精简运行时环境
+# 使用轻量级的 OpenJDK JRE 镜像
+FROM openjdk:17-jdk-slim-buster AS runner
+
+# 设置工作目录
 WORKDIR /app
 
-# 从构建阶段复制打好的 jar 包
+# 从 builder 阶段复制构建好的应用 JAR 包
 COPY --from=builder /app/target/demo-0.0.1-SNAPSHOT.jar app.jar
 
-# 暴露 Spring Boot 默认端口
+# 暴露 Spring Boot 应用的默认端口
 EXPOSE 8080
 
-# 启动命令
+# 启动 Spring Boot 应用
 CMD ["java", "-jar", "app.jar"]
diff --git a/backend/demo/compose.yaml b/backend/demo/compose.yaml
index 61d6b9d..4d288a2 100644
--- a/backend/demo/compose.yaml
+++ b/backend/demo/compose.yaml
@@ -1,29 +1,74 @@
 
 services:
+  # 数据库服务
   mysql:
-    image: mysql:latest
+    image: mysql:8.0 # 建议使用具体的版本号，而不是 latest
+    container_name: mysql_db # 给容器一个易于识别的名称
     environment:
-      - MYSQL_DATABASE=mydatabase
-      - MYSQL_USER=myuser
-      - MYSQL_PASSWORD=secret
-      - MYSQL_ROOT_PASSWORD=verysecret
+      MYSQL_DATABASE: mydatabase
+      MYSQL_USER: myuser
+      MYSQL_PASSWORD: secret
+      MYSQL_ROOT_PASSWORD: verysecret
     ports:
-      - "3306:3306"
+      - "3306:3306" # 映射数据库端口，方便本地工具连接（可选，仅测试容器连接DB时可省略）
     volumes:
-      - mysql-data:/var/lib/mysql
+      - mysql-data:/var/lib/mysql # 持久化数据库数据
+    # 添加健康检查，确保数据库服务真正可用
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u$$MYSQL_USER", "-p$$MYSQL_PASSWORD"]
+      interval: 10s # 每 10 秒检查一次
+      timeout: 5s # 检查超时时间
+      retries: 5 # 重试次数
+      start_period: 30s # 在此期间不计入重试失败次数，给数据库启动时间
 
+  # 应用服务（使用 Dockerfile 的 runner 阶段）
   app:
     build:
-      context: .
-      dockerfile: Dockerfile
+      context: . # Dockerfile 所在的上下文路径
+      dockerfile: Dockerfile # Dockerfile 文件名
+      target: runner # 指定构建 Dockerfile 中的 runner 阶段
+    container_name: spring_app
     ports:
-      - "8080:8080"
+      - "8080:8080" # 映射应用端口
     environment:
-      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/mydatabase?serverTimezone=Asia/Shanghai
+      # 应用连接数据库的配置，使用数据库服务的名称作为主机名
+      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/mydatabase?serverTimezone=Asia/Shanghai&createDatabaseIfNotExist=TRUE&useSSL=FALSE&allowPublicKeyRetrieval=TRUE
       SPRING_DATASOURCE_USERNAME: myuser
       SPRING_DATASOURCE_PASSWORD: secret
+      # 其他 Spring Boot 配置...
     depends_on:
-      - mysql
+      mysql:
+        condition: service_healthy # 确保数据库服务处于健康状态才启动应用
 
+  # 测试服务（使用 Dockerfile 的 tester 阶段）
+  # 这个服务用于运行和调试需要连接数据库的测试
+  tester:
+    build:
+      context: . # Dockerfile 所在的上下文路径
+      dockerfile: Dockerfile # Dockerfile 文件名
+      target: tester # 指定构建 Dockerfile 中的 tester 阶段
+    container_name: tester
+    # 暴露调试端口，映射到主机端口，用于远程调试测试过程
+    ports:
+      - "5005:5005"
+    # 依赖于数据库服务，并等待其健康检查通过
+    depends_on:
+      mysql:
+        condition: service_healthy # 确保数据库服务处于健康状态才启动测试容器
+    environment:
+      # 测试环境连接数据库的配置，使用数据库服务的名称作为主机名
+      # 这些环境变量会覆盖 application-test.properties 中的相同配置
+      SPRING_DATASOURCE_URL: jdbc:mysql://mysql:3306/mydatabase?serverTimezone=Asia/Shanghai&createDatabaseIfNotExist=TRUE&useSSL=FALSE
+      SPRING_DATASOURCE_USERNAME: myuser
+      SPRING_DATASOURCE_PASSWORD: secret
+      # 设置 Maven 运行时的额外 JVM 参数，用于开启远程调试
+      MAVEN_OPTS: "-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5005"
+    # 默认命令：保持容器运行，方便手动进入容器执行测试和调试
+    # 如果您希望容器启动后自动运行测试，可以修改此命令为 ["mvn", "test"]
+    command: tail -f /dev/null
+
+
+# 定义数据卷用于持久化数据库数据
 volumes:
   mysql-data:
+
diff --git a/backend/demo/db/SQLScript.sql b/backend/demo/db/SQLScript.sql
new file mode 100644
index 0000000..13977af
--- /dev/null
+++ b/backend/demo/db/SQLScript.sql
@@ -0,0 +1,43 @@
+-- 创建数据库（如果不存在）
+-- 请确保您的Docker Compose配置中的数据库名称与此处一致
+CREATE DATABASE IF NOT EXISTS mydatabase CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- 切换到目标数据库
+USE mydatabase;
+
+-- 删除表（如果已存在），以便重新创建
+DROP TABLE IF EXISTS `user`;
+
+-- 创建用户表
+CREATE TABLE `user` (
+    `id` BIGINT NOT NULL AUTO_INCREMENT COMMENT '用户ID，主键，自增长',
+    `username` VARCHAR(50) NOT NULL UNIQUE COMMENT '用户名，唯一，不可为空',
+    `password` VARCHAR(100) NOT NULL COMMENT '密码，存储加密后的密码，不可为空',
+    `email` VARCHAR(100) NULL DEFAULT NULL COMMENT '邮箱地址',
+    `status` INT NOT NULL DEFAULT 1 COMMENT '用户状态，例如 0:禁用, 1:启用，默认为1',
+    `score` INT NOT NULL DEFAULT 0 COMMENT '用户积分，默认为0',
+    `role` VARCHAR(20) NOT NULL DEFAULT 'USER' COMMENT '用户角色，例如 ADMIN, USER，默认为USER',
+    `create_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+    `update_time` TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+    PRIMARY KEY (`id`),
+    UNIQUE KEY `uk_username` (`username`) -- 确保用户名唯一
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci COMMENT='用户表';
+
+-- 可选：插入一条测试用户数据
+-- 请注意：这里的密码 'password123' 是明文，您需要用您应用中配置的BCryptPasswordEncoder加密后的密码替换它
+-- 例如，使用 Spring Security 的 BCryptPasswordEncoder 对 'your_secure_password' 进行加密
+-- SELECT '$2a$10$YOUR_BCRYPT_HASH_HERE'; -- 替换这里的哈希值
+
+INSERT INTO `user` (`username`, `password`, `email`, `status`, `score`, `role`, `create_time`, `update_time`)
+VALUES (
+    'testuser',
+    '$$2a$10$EEBnvonhdTGA0StQHdxMUeAQyxm1uvJOKkHu01Pe0B9a2vfGH3cge', -- 请用加密后的密码替换此处的占位符
+    'test@example.com',
+    1, -- 启用状态
+    100, -- 初始积分
+    'USER', -- 默认角色
+    CURRENT_TIMESTAMP,
+    CURRENT_TIMESTAMP
+);
+
+
diff --git a/backend/demo/pom.xml b/backend/demo/pom.xml
index bac660b..6eccaf5 100644
--- a/backend/demo/pom.xml
+++ b/backend/demo/pom.xml
@@ -97,7 +97,39 @@
   <version>0.11.5</version>
   <scope>runtime</scope>
 </dependency>
+ <dependency>
+    <groupId>com.turn</groupId>
+    <artifactId>ttorrent-bencoding</artifactId>
+    <version>1.3.0-SNAPSHOT</version>
+  </dependency>
 
+  <!-- 通用工具模块（info_hash、文件结构等） -->
+  <dependency>
+    <groupId>com.turn</groupId>
+    <artifactId>ttorrent-common</artifactId>
+    <version>1.3.0-SNAPSHOT</version>
+  </dependency>
+
+  <!-- 网络通信支持（用于 Scrape/Tracker 通信） -->
+  <dependency>
+    <groupId>com.turn</groupId>
+    <artifactId>ttorrent-network</artifactId>
+    <version>1.0</version>
+  </dependency>
+
+  <!-- Tracker 服务（你自己部署的 announce 接口服务） -->
+  <dependency>
+    <groupId>com.turn</groupId>
+    <artifactId>ttorrent-tracker</artifactId>
+    <version>1.3.0-SNAPSHOT</version>
+  </dependency>
+
+  <!-- 客户端支持（如果你需要服务器自动发种、做种） -->
+  <dependency>
+    <groupId>com.turn</groupId>
+    <artifactId>ttorrent-client</artifactId>
+    <version>1.3.0-SNAPSHOT</version>
+  </dependency>
 </dependencies>
 
 <build>
diff --git a/backend/demo/src/main/java/com/example/demo/config/SecurityConfig.java b/backend/demo/src/main/java/com/example/demo/config/SecurityConfig.java
index bfd7b1b..b3e7f91 100644
--- a/backend/demo/src/main/java/com/example/demo/config/SecurityConfig.java
+++ b/backend/demo/src/main/java/com/example/demo/config/SecurityConfig.java
@@ -5,6 +5,8 @@
 import org.springframework.security.authentication.AuthenticationManager;
 import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
 import org.springframework.security.config.http.SessionCreationPolicy;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.security.crypto.password.PasswordEncoder;
@@ -12,13 +14,17 @@
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 
 import com.example.demo.security.JwtAuthenticationFilter;
-import com.example.demo.security.JwtTokenUtil;
 
+/**
+ * Spring Security 配置类，用于定义安全策略和相关的 Bean。
+ */
 @Configuration
+@EnableWebSecurity // 启用 Spring Security 的 Web 安全功能
 public class SecurityConfig {
 
     /**
-     * 密码加密器，用于注册用户时对密码加密、登录时校验
+     * 密码加密器，用于注册用户时对密码加密、登录时校验。
+     * 使用 BCryptPasswordEncoder，一种安全的密码哈希算法。
      */
     @Bean
     public PasswordEncoder passwordEncoder() {
@@ -27,7 +33,7 @@
 
     /**
      * 将 Spring Security 的 AuthenticationManager 暴露为 Bean，
-     * 方便在 AuthController 或其它地方手动调用。
+     * 方便在 AuthController 或其它地方手动调用进行认证。
      */
     @Bean
     public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
@@ -35,17 +41,43 @@
     }
 
     /**
-     * 核心安全策略：禁用 CSRF、无状态 Session、开放登录接口、其余接口需认证。
+     * 核心安全策略配置。
+     * 配置内容包括：禁用 CSRF、禁用 Session 管理（使用 JWT 无状态）、
+     * 配置请求的授权规则，并将自定义的 JWT 认证过滤器添加到过滤器链中。
+     *
+     * @param http HttpSecurity 配置对象
+     * @param jwtFilter 自定义的 JWT 认证过滤器，通过 Spring 容器注入
+     * @return 配置好的 SecurityFilterChain
+     * @throws Exception 配置过程中可能抛出的异常
      */
     @Bean
-public SecurityFilterChain filterChain(HttpSecurity http,
-                                       JwtTokenUtil tokenUtil,
-                                       JWTProperties props) throws Exception {
-    JwtAuthenticationFilter jwtFilter = new JwtAuthenticationFilter(tokenUtil, props);
-    http
-      // 省略其他配置…
-      .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
-    return http.build();
-}
-}
+    public SecurityFilterChain filterChain(HttpSecurity http,
+                                           JwtAuthenticationFilter jwtFilter // 直接注入 JwtAuthenticationFilter Bean
+                                           ) throws Exception {
+        http
+            // 禁用 CSRF (跨站请求伪造) 保护，因为 JWT 是无状态的，不需要 CSRF 保护
+            .csrf(AbstractHttpConfigurer::disable)
+            // 配置 Session 管理策略为无状态，不使用 Session
+            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+            // 配置请求的授权规则
+            .authorizeHttpRequests(auth -> auth
+                // 允许对 /auth/** 路径下的所有请求进行匿名访问 (例如登录、注册接口)
+                .requestMatchers("/auth/**").permitAll()
+                // 其他所有请求都需要进行身份认证
+                .anyRequest().authenticated()
+            )
+            // 禁用默认的表单登录功能，因为我们使用 JWT 进行认证
+            .formLogin(AbstractHttpConfigurer::disable)
+            // 禁用默认的 HTTP Basic 认证
+            .httpBasic(AbstractHttpConfigurer::disable)
+            // 将自定义的 JwtAuthenticationFilter 添加到 UsernamePasswordAuthenticationFilter 之前
+            // 确保在进行基于用户名密码的认证之前，先进行 JWT 认证
+            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
 
+        // 构建并返回配置好的 SecurityFilterChain
+        return http.build();
+    }
+
+    // 注意：JwtAuthenticationFilter 需要被 Spring 扫描到并作为 Bean 管理
+    // 确保 JwtAuthenticationFilter 类上有 @Component 或其他 Spring Bean 相关的注解
+}
diff --git a/backend/demo/src/main/java/com/example/demo/controller/AuthController.java b/backend/demo/src/main/java/com/example/demo/controller/AuthController.java
index 08411d7..d7dfe50 100644
--- a/backend/demo/src/main/java/com/example/demo/controller/AuthController.java
+++ b/backend/demo/src/main/java/com/example/demo/controller/AuthController.java
@@ -4,8 +4,11 @@
 import java.util.List;
 import java.util.Map;
 
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AuthenticationManager; // 导入 AuthenticationManager
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; // 导入 UsernamePasswordAuthenticationToken
+import org.springframework.security.core.Authentication; // 导入 Authentication
+import org.springframework.security.core.context.SecurityContextHolder; // 导入 SecurityContextHolder
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.validation.BindingResult;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -27,16 +30,18 @@
 public class AuthController {
 
     private final UserService userService;
-    private final PasswordEncoder passwordEncoder;
+    private final PasswordEncoder passwordEncoder; // 虽然在AuthController中不再直接用于比对，但如果UserServiceImpl需要，这里保留注入
     private final JwtTokenUtil jwtTokenUtil;
+    private final AuthenticationManager authenticationManager; // 注入 AuthenticationManager
 
-    @Autowired
     public AuthController(UserService userService,
                           PasswordEncoder passwordEncoder,
-                          JwtTokenUtil jwtTokenUtil) {
+                          JwtTokenUtil jwtTokenUtil,
+                          AuthenticationManager authenticationManager) { // 注入 AuthenticationManager
         this.userService = userService;
         this.passwordEncoder = passwordEncoder;
         this.jwtTokenUtil = jwtTokenUtil;
+        this.authenticationManager = authenticationManager; // 初始化 AuthenticationManager
     }
 
     @PostMapping("/login")
@@ -46,12 +51,40 @@
 
         if (bindingResult.hasErrors()) {
             String errMsg = bindingResult.getFieldErrors().stream()
-                .map(fe -> fe.getField() + ": " + fe.getDefaultMessage())
-                .reduce((a, b) -> a + "; " + b)
-                .orElse("Invalid parameters");
+                    .map(fe -> fe.getField() + ": " + fe.getDefaultMessage())
+                    .reduce((a, b) -> a + "; " + b)
+                    .orElse("Invalid parameters");
             return ResponseEntity.badRequest().body(Map.of("error", errMsg));
         }
 
+        try {
+            // 使用 AuthenticationManager 进行认证
+            // 这会触发 UserServiceImpl 中的 loadUserByUsername 方法的调用，并比较密码
+            Authentication authentication = authenticationManager.authenticate(
+                    new UsernamePasswordAuthenticationToken(
+                            loginRequest.getUsername(),
+                            loginRequest.getPassword()
+                    )
+            );
+            // 将认证信息设置到 Spring Security 的上下文中
+            SecurityContextHolder.getContext().setAuthentication(authentication);
+
+            // 获取认证后的用户详情（假设 User 实体实现了 UserDetails 接口）
+            User userDetails = (User) authentication.getPrincipal();
+
+            // 调用 UserService 方法生成登录响应（包括 JWT Token）
+            LoginResponseDTO response = userService.generateLoginResponse(userDetails);
+
+            return ResponseEntity.ok(response);
+
+        } catch (Exception e) {
+            // 认证失败（用户名不存在或密码错误），抛出自定义认证异常
+            // GlobalExceptionHandler 会捕获 AuthException 并返回 401
+            throw new AuthException("用户名或密码错误", e);
+        }
+
+        // 移除原有的手动查找用户和密码比对逻辑
+        /*
         User user = userService.lambdaQuery()
                 .eq(User::getUsername, loginRequest.getUsername())
                 .one();
@@ -70,5 +103,6 @@
         response.setRoles(List.of(user.getRole()));
 
         return ResponseEntity.ok(response);
+        */
     }
-}
+}
\ No newline at end of file
diff --git a/backend/demo/src/main/java/com/example/demo/controller/TorrentController.java b/backend/demo/src/main/java/com/example/demo/controller/TorrentController.java
new file mode 100644
index 0000000..0bd501a
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/controller/TorrentController.java
@@ -0,0 +1,130 @@
+// src/main/java/com/example/demo/controller/TorrentController.java
+package com.example.demo.controller;
+
+import java.io.IOException; // 导入 DTO
+import java.nio.file.Path; // 导入服务接口
+import java.nio.file.Paths; // 导入 ttorrent 的异常
+
+import org.springframework.beans.factory.annotation.Value; // 导入 @Value 用于读取配置
+import org.springframework.core.io.Resource; // 导入 Resource
+import org.springframework.core.io.UrlResource; // 导入 UrlResource
+import org.springframework.http.HttpHeaders; // 导入 HttpHeaders
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType; // 导入 MediaType
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.example.demo.dto.TorrentInfoDTO;
+import com.example.demo.service.TorrentService;
+import com.turn.ttorrent.bcodec.InvalidBEncodingException;
+
+/**
+ * 处理 .torrent 文件上传和下载的 RESTful 控制器。
+ */
+@RestController // 组合了 @Controller 和 @ResponseBody，表示这是一个 RESTful 控制器
+@RequestMapping("/api") // 定义所有处理方法的根路径
+public class TorrentController {
+
+    private final TorrentService torrentService;
+
+    @Value("${file.upload-dir}") // 从 application.properties 中注入文件上传目录
+    private String uploadDir;
+
+    // 通过构造函数注入 TorrentService
+    public TorrentController(TorrentService torrentService) {
+        this.torrentService = torrentService;
+    }
+
+    /**
+     * 处理 .torrent 文件的上传请求。
+     *
+     * @param file 上传的 MultipartFile 对象，通过 @RequestParam("file") 绑定。
+     * @return 包含 TorrentInfoDTO 的 ResponseEntity，表示操作结果。
+     */
+    @PostMapping("/torrents") // 映射到 /api/torrents 的 POST 请求
+    public ResponseEntity<TorrentInfoDTO> uploadTorrent(@RequestParam("file") MultipartFile file) {
+        // 1. 接收 HTTP 请求 (通过 @PostMapping 和 @RequestParam)
+
+        // 2. 校验参数
+        if (file.isEmpty()) {
+            TorrentInfoDTO errorDto = new TorrentInfoDTO();
+            errorDto.setMessage("上传文件不能为空。");
+            return new ResponseEntity<>(errorDto, HttpStatus.BAD_REQUEST);
+        }
+
+        // 校验文件类型 (可选，但推荐)
+        if (!file.getOriginalFilename().toLowerCase().endsWith(".torrent")) {
+            TorrentInfoDTO errorDto = new TorrentInfoDTO();
+            errorDto.setMessage("只允许上传 .torrent 文件。");
+            return new ResponseEntity<>(errorDto, HttpStatus.UNSUPPORTED_MEDIA_TYPE);
+        }
+
+        try {
+            // 3. 调用 Service 层处理业务逻辑
+            TorrentInfoDTO result = torrentService.handleUpload(file);
+
+            // 4. 返回 TorrentInfoDTO 给前端
+            return new ResponseEntity<>(result, HttpStatus.OK);
+        } catch (InvalidBEncodingException e) {
+            // 捕获 .torrent 文件解析错误
+            TorrentInfoDTO errorDto = new TorrentInfoDTO();
+            errorDto.setMessage("文件解析失败，请确保它是有效的 .torrent 文件: " + e.getMessage());
+            return new ResponseEntity<>(errorDto, HttpStatus.BAD_REQUEST);
+        } catch (IllegalArgumentException e) {
+            // 捕获服务层抛出的非法参数异常 (如文件为空)
+            TorrentInfoDTO errorDto = new TorrentInfoDTO();
+            errorDto.setMessage("处理文件时发生错误: " + e.getMessage());
+            return new ResponseEntity<>(errorDto, HttpStatus.BAD_REQUEST);
+        } catch (IOException e) {
+            // 捕获文件读写或保存失败的异常
+            TorrentInfoDTO errorDto = new TorrentInfoDTO();
+            errorDto.setMessage("文件上传或保存失败: " + e.getMessage());
+            return new ResponseEntity<>(errorDto, HttpStatus.INTERNAL_SERVER_ERROR);
+        } catch (Exception e) {
+            // 捕获其他未知异常
+            TorrentInfoDTO errorDto = new TorrentInfoDTO();
+            errorDto.setMessage("文件上传过程中发生未知错误: " + e.getMessage());
+            e.printStackTrace(); // 打印堆栈跟踪以便调试
+            return new ResponseEntity<>(errorDto, HttpStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    /**
+     * 实现 .torrent 文件的下载功能。
+     * 根据 infoHash 找到对应的 .torrent 文件并提供下载。
+     *
+     * @param infoHash 洪流的 info hash，用于查找服务器上的文件。
+     * @param fileName 原始文件名 (用于设置下载时的文件名，实际查找文件仍依赖 infoHash)。
+     * @return 包含 .torrent 文件内容的 ResponseEntity。
+     */
+   // 修正后的 downloadTorrent 方法片段
+@GetMapping("/downloads/{infoHash}/{fileName}")
+public ResponseEntity<Resource> downloadTorrent(@PathVariable String infoHash, @PathVariable String fileName) {
+    try {
+        Path fileStorageLocation = Paths.get(uploadDir).toAbsolutePath().normalize();
+        Path filePath = fileStorageLocation.resolve(infoHash + ".torrent").normalize();
+        Resource resource = new UrlResource(filePath.toUri()); // 这一行不会抛出 MalformedURLException
+
+        if (resource.exists() && resource.isReadable()) {
+            String contentType = "application/x-bittorrent";
+            String headerValue = "attachment; filename=\"" + fileName + "\"";
+
+            return ResponseEntity.ok()
+                    .contentType(MediaType.parseMediaType(contentType))
+                    .header(HttpHeaders.CONTENT_DISPOSITION, headerValue)
+                    .body(resource);
+        } else {
+            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+        }
+    } catch (IOException e) { // 只保留 IOException
+        return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+    // MalformedURLException 相关的 catch 块已移除
+}
+}
\ No newline at end of file
diff --git a/backend/demo/src/main/java/com/example/demo/dto/TorrentInfoDTO.java b/backend/demo/src/main/java/com/example/demo/dto/TorrentInfoDTO.java
new file mode 100644
index 0000000..45cd326
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/dto/TorrentInfoDTO.java
@@ -0,0 +1,87 @@
+// src/main/java/com/example/demo/dto/TorrentInfoDTO.java
+package com.example.demo.dto;
+
+import java.io.Serializable;
+
+public class TorrentInfoDTO implements Serializable {
+    private String fileName;
+    private long fileSize;
+    private String infoHash;
+    private String magnetUri;
+    private String downloadUrl;
+    private String message; // For success or error messages
+
+    // Constructors
+    public TorrentInfoDTO() {
+    }
+
+    public TorrentInfoDTO(String fileName, long fileSize, String infoHash, String magnetUri, String downloadUrl, String message) {
+        this.fileName = fileName;
+        this.fileSize = fileSize;
+        this.infoHash = infoHash;
+        this.magnetUri = magnetUri;
+        this.downloadUrl = downloadUrl;
+        this.message = message;
+    }
+
+    // Getters and Setters
+    public String getFileName() {
+        return fileName;
+    }
+
+    public void setFileName(String fileName) {
+        this.fileName = fileName;
+    }
+
+    public long getFileSize() {
+        return fileSize;
+    }
+
+    public void setFileSize(long fileSize) {
+        this.fileSize = fileSize;
+    }
+
+    public String getInfoHash() {
+        return infoHash;
+    }
+
+    public void setInfoHash(String infoHash) {
+        this.infoHash = infoHash;
+    }
+
+    public String getMagnetUri() {
+        return magnetUri;
+    }
+
+    public void setMagnetUri(String magnetUri) {
+        this.magnetUri = magnetUri;
+    }
+
+    public String getDownloadUrl() {
+        return downloadUrl;
+    }
+
+    public void setDownloadUrl(String downloadUrl) {
+        this.downloadUrl = downloadUrl;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    @Override
+    public String toString() {
+        return "TorrentInfoDTO{" +
+               "fileName='" + fileName + '\'' +
+               ", fileSize=" + fileSize +
+               ", infoHash='" + infoHash + '\'' +
+               ", magnetUri='" + magnetUri + '\'' +
+               ", downloadUrl='" + downloadUrl + '\'' +
+               ", message='" + message + '\'' +
+               '}';
+    }
+}
\ No newline at end of file
diff --git a/backend/demo/src/main/java/com/example/demo/entity/TorrentInfo.java b/backend/demo/src/main/java/com/example/demo/entity/TorrentInfo.java
new file mode 100644
index 0000000..da39654
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/entity/TorrentInfo.java
@@ -0,0 +1,118 @@
+// src/main/java/com/example/demo/entity/TorrentInfo.java
+package com.example.demo.entity;
+
+import java.time.LocalDateTime;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+@TableName("torrent_info") // 映射到数据库中的 torrent_info 表
+public class TorrentInfo {
+
+    @TableId(value = "id", type = IdType.AUTO) // 标记为主键，并设置为数据库自增
+    private Long id;
+
+    @TableField("info_hash") // 映射到数据库中的 info_hash 列
+    private String infoHash; // 洪流的唯一标识符（信息哈希）
+
+    @TableField("file_name") // 映射到数据库中的 file_name 列
+    private String fileName; // 原始文件名
+
+    @TableField("file_size") // 映射到数据库中的 file_size 列
+    private Long fileSize; // 文件大小（字节）
+
+    @TableField("magnet_uri") // 映射到数据库中的 magnet_uri 列
+    private String magnetUri; // 生成的磁力链接
+
+    @TableField("download_url") // 映射到数据库中的 download_url 列
+    private String downloadUrl; // .torrent 文件的下载 URL
+
+    @TableField("upload_time") // 映射到数据库中的 upload_time 列
+    private LocalDateTime uploadTime; // 上传时间
+
+    // 默认构造函数，MyBatis-Plus 需要
+    public TorrentInfo() {
+    }
+
+    // 带有所有字段的构造函数（不包含 ID 和 uploadTime，因为它们是自动生成的）
+    public TorrentInfo(String infoHash, String fileName, Long fileSize, String magnetUri, String downloadUrl) {
+        this.infoHash = infoHash;
+        this.fileName = fileName;
+        this.fileSize = fileSize;
+        this.magnetUri = magnetUri;
+        this.downloadUrl = downloadUrl;
+        this.uploadTime = LocalDateTime.now(); // 设置当前上传时间
+    }
+
+    // Getters and Setters
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getInfoHash() {
+        return infoHash;
+    }
+
+    public void setInfoHash(String infoHash) {
+        this.infoHash = infoHash;
+    }
+
+    public String getFileName() {
+        return fileName;
+    }
+
+    public void setFileName(String fileName) {
+        this.fileName = fileName;
+    }
+
+    public Long getFileSize() {
+        return fileSize;
+    }
+
+    public void setFileSize(Long fileSize) {
+        this.fileSize = fileSize;
+    }
+
+    public String getMagnetUri() {
+        return magnetUri;
+    }
+
+    public void setMagnetUri(String magnetUri) {
+        this.magnetUri = magnetUri;
+    }
+
+    public String getDownloadUrl() {
+        return downloadUrl;
+    }
+
+    public void setDownloadUrl(String downloadUrl) {
+        this.downloadUrl = downloadUrl;
+    }
+
+    public LocalDateTime getUploadTime() {
+        return uploadTime;
+    }
+
+    public void setUploadTime(LocalDateTime uploadTime) {
+        this.uploadTime = uploadTime;
+    }
+
+    @Override
+    public String toString() {
+        return "TorrentInfo{" +
+               "id=" + id +
+               ", infoHash='" + infoHash + '\'' +
+               ", fileName='" + fileName + '\'' +
+               ", fileSize=" + fileSize +
+               ", magnetUri='" + magnetUri + '\'' +
+               ", downloadUrl='" + downloadUrl + '\'' +
+               ", uploadTime=" + uploadTime +
+               '}';
+    }
+}
\ No newline at end of file
diff --git a/backend/demo/src/main/java/com/example/demo/entity/User.java b/backend/demo/src/main/java/com/example/demo/entity/User.java
index bcbe6de..ba308af 100644
--- a/backend/demo/src/main/java/com/example/demo/entity/User.java
+++ b/backend/demo/src/main/java/com/example/demo/entity/User.java
@@ -1,7 +1,13 @@
 package com.example.demo.entity;
 
-import java.io.Serializable;
-import java.time.LocalDateTime;
+import java.time.LocalDateTime; // Keep import if Serializable is used elsewhere, otherwise remove
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List; // 用于返回空的权限集合，如果用户没有角色/权限
+
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority; // 用于构建权限列表
+import org.springframework.security.core.userdetails.UserDetails;
 
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableId;
@@ -9,7 +15,8 @@
 
 
 @TableName("user")
-public class User implements Serializable {
+// 实现UserDetails接口 (UserDetails extends Serializable, so Serializable is redundant here)
+public class User implements UserDetails { 
     private static final long serialVersionUID = 1L;
 
     @TableId(type = IdType.AUTO)
@@ -21,16 +28,18 @@
 
     private String email;
 
-    private Integer status; 
+    private Integer status; // 假设status字段表示用户状态，例如 0:禁用, 1:启用
 
-    private Integer score; 
+    private Integer score;
 
-    private String role; 
+    private String role; // 假设role字段存储用户的角色，例如 "ADMIN", "USER"
 
     private LocalDateTime createTime;
 
     private LocalDateTime updateTime;
 
+    // --- Getters and Setters ---
+
     public Long getId() {
         return id;
     }
@@ -39,6 +48,7 @@
         this.id = id;
     }
 
+    @Override // 实现UserDetails接口的getUsername方法
     public String getUsername() {
         return username;
     }
@@ -47,6 +57,7 @@
         this.username = username;
     }
 
+    @Override // 实现UserDetails接口的getPassword方法
     public String getPassword() {
         return password;
     }
@@ -102,4 +113,49 @@
     public void setUpdateTime(LocalDateTime updateTime) {
         this.updateTime = updateTime;
     }
+
+    // --- 实现 UserDetails 接口的方法 ---
+
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        // 根据用户的角色构建权限列表
+        List<GrantedAuthority> authorities = new ArrayList<>();
+        if (this.role != null && !this.role.isEmpty()) {
+            // Spring Security 推荐角色以 "ROLE_" 开头
+            authorities.add(new SimpleGrantedAuthority("ROLE_" + this.role));
+        }
+        // 如果用户没有角色，返回一个空的集合
+        return authorities;
+    }
+
+    @Override
+    public boolean isAccountNonExpired() {
+        // 根据您的业务逻辑判断账户是否过期
+        // 例如，如果您的User实体有过期时间字段，可以在这里检查
+        // 这里简单返回true，表示账户永不过期
+        return true;
+    }
+
+    @Override
+    public boolean isAccountNonLocked() {
+        // 根据您的业务逻辑判断账户是否被锁定
+        // 例如，如果您的User实体有锁定状态字段，可以在这里检查
+        // 这里简单返回true，表示账户永不锁定
+        return true;
+    }
+
+    @Override
+    public boolean isCredentialsNonExpired() {
+        // 根据您的业务逻辑判断凭证（密码）是否过期
+        // 例如，如果您的User实体有密码最后修改时间字段，可以在这里检查
+        // 这里简单返回true，表示凭证永不过期
+        return true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        // 根据您的业务逻辑判断账户是否启用
+        // 假设status字段为1表示启用
+        return this.status != null && this.status == 1;
+    }
 }
diff --git a/backend/demo/src/main/java/com/example/demo/mapper/TorrentInfoMapper.java b/backend/demo/src/main/java/com/example/demo/mapper/TorrentInfoMapper.java
new file mode 100644
index 0000000..3f4f245
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/mapper/TorrentInfoMapper.java
@@ -0,0 +1,13 @@
+// src/main/java/com/example/demo/mapper/TorrentInfoMapper.java
+package com.example.demo.mapper;
+
+import org.apache.ibatis.annotations.Mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.example.demo.entity.TorrentInfo; // MyBatis 的 Mapper 注解
+
+@Mapper // 标记这是一个 MyBatis Mapper 接口
+public interface TorrentInfoMapper extends BaseMapper<TorrentInfo> {
+    // BaseMapper 提供了基本的 CRUD 操作，例如 insert(), selectById(), selectList(), deleteById() 等。
+    // 无需编写任何实现代码。
+}
\ No newline at end of file
diff --git a/backend/demo/src/main/java/com/example/demo/mapper/UserMapper.java b/backend/demo/src/main/java/com/example/demo/mapper/UserMapper.java
index 94ba7a8..0198c39 100644
--- a/backend/demo/src/main/java/com/example/demo/mapper/UserMapper.java
+++ b/backend/demo/src/main/java/com/example/demo/mapper/UserMapper.java
@@ -1,8 +1,9 @@
 package com.example.demo.mapper;
 
+import org.apache.ibatis.annotations.Mapper;
+
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.example.demo.entity.User;
-import org.apache.ibatis.annotations.Mapper;
 
 /**
  * UserMapper 接口
@@ -11,6 +12,10 @@
  */
 @Mapper
 public interface UserMapper extends BaseMapper<User> {
+
+    User findById(Long id);
+
+    User findByUsername(String username);
     
     // List<User> selectByStatus(@Param("status") Integer status);
 }
diff --git a/backend/demo/src/main/java/com/example/demo/result.txt b/backend/demo/src/main/java/com/example/demo/result.txt
new file mode 100644
index 0000000..bd1dd30
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/result.txt
@@ -0,0 +1,1031 @@
+--- Start File Content ---
+
+--- Content of: ./config/JWTProperties.java ---
+package com.example.demo.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+/**
+ * JWT 配置属性，从 application.properties 中 jwt 开头的配置加载
+ */
+@Component
+@ConfigurationProperties(prefix = "jwt")
+public class JWTProperties {
+    /**
+     * 用于签名的密钥
+     */
+    private String secret;
+
+    /**
+     * Token 过期时长，单位毫秒
+     */
+    private long expirationMs;
+
+    /**
+     * HTTP Header 中放置 JWT 的字段名
+     */
+    private String header = "Authorization";
+
+    /**
+     * Header 中 Token 的前缀
+     */
+    private String tokenPrefix = "Bearer ";
+
+    /**
+     * 签发者信息（可选）
+     */
+    private String issuer;
+
+    /**
+     * 接收者信息（可选）
+     */
+    private String audience;
+
+    // --- getters & setters ---
+
+    public String getSecret() {
+        return secret;
+    }
+
+    public void setSecret(String secret) {
+        this.secret = secret;
+    }
+
+    public long getExpirationMs() {
+        return expirationMs;
+    }
+
+    public void setExpirationMs(long expirationMs) {
+        this.expirationMs = expirationMs;
+    }
+
+    public String getHeader() {
+        return header;
+    }
+
+    public void setHeader(String header) {
+        this.header = header;
+    }
+
+    public String getTokenPrefix() {
+        return tokenPrefix;
+    }
+
+    public void setTokenPrefix(String tokenPrefix) {
+        this.tokenPrefix = tokenPrefix;
+    }
+
+    public String getIssuer() {
+        return issuer;
+    }
+
+    public void setIssuer(String issuer) {
+        this.issuer = issuer;
+    }
+
+    public String getAudience() {
+        return audience;
+    }
+
+    public void setAudience(String audience) {
+        this.audience = audience;
+    }
+}
+
+--- End of: ./config/JWTProperties.java ---
+
+--- Content of: ./config/SecurityConfig.java ---
+package com.example.demo.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
+import org.springframework.security.config.http.SessionCreationPolicy;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.web.SecurityFilterChain;
+import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
+
+import com.example.demo.security.JwtAuthenticationFilter;
+
+/**
+ * Spring Security 配置类，用于定义安全策略和相关的 Bean。
+ */
+@Configuration
+@EnableWebSecurity // 启用 Spring Security 的 Web 安全功能
+public class SecurityConfig {
+
+    /**
+     * 密码加密器，用于注册用户时对密码加密、登录时校验。
+     * 使用 BCryptPasswordEncoder，一种安全的密码哈希算法。
+     */
+    @Bean
+    public PasswordEncoder passwordEncoder() {
+        return new BCryptPasswordEncoder();
+    }
+
+    /**
+     * 将 Spring Security 的 AuthenticationManager 暴露为 Bean，
+     * 方便在 AuthController 或其它地方手动调用进行认证。
+     */
+    @Bean
+    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
+        return config.getAuthenticationManager();
+    }
+
+    /**
+     * 核心安全策略配置。
+     * 配置内容包括：禁用 CSRF、禁用 Session 管理（使用 JWT 无状态）、
+     * 配置请求的授权规则，并将自定义的 JWT 认证过滤器添加到过滤器链中。
+     *
+     * @param http HttpSecurity 配置对象
+     * @param jwtFilter 自定义的 JWT 认证过滤器，通过 Spring 容器注入
+     * @return 配置好的 SecurityFilterChain
+     * @throws Exception 配置过程中可能抛出的异常
+     */
+    @Bean
+    public SecurityFilterChain filterChain(HttpSecurity http,
+                                           JwtAuthenticationFilter jwtFilter // 直接注入 JwtAuthenticationFilter Bean
+                                           ) throws Exception {
+        http
+            // 禁用 CSRF (跨站请求伪造) 保护，因为 JWT 是无状态的，不需要 CSRF 保护
+            .csrf(AbstractHttpConfigurer::disable)
+            // 配置 Session 管理策略为无状态，不使用 Session
+            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+            // 配置请求的授权规则
+            .authorizeHttpRequests(auth -> auth
+                // 允许对 /auth/** 路径下的所有请求进行匿名访问 (例如登录、注册接口)
+                .requestMatchers("/auth/**").permitAll()
+                // 其他所有请求都需要进行身份认证
+                .anyRequest().authenticated()
+            )
+            // 禁用默认的表单登录功能，因为我们使用 JWT 进行认证
+            .formLogin(AbstractHttpConfigurer::disable)
+            // 禁用默认的 HTTP Basic 认证
+            .httpBasic(AbstractHttpConfigurer::disable)
+            // 将自定义的 JwtAuthenticationFilter 添加到 UsernamePasswordAuthenticationFilter 之前
+            // 确保在进行基于用户名密码的认证之前，先进行 JWT 认证
+            .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);
+
+        // 构建并返回配置好的 SecurityFilterChain
+        return http.build();
+    }
+
+    // 注意：JwtAuthenticationFilter 需要被 Spring 扫描到并作为 Bean 管理
+    // 确保 JwtAuthenticationFilter 类上有 @Component 或其他 Spring Bean 相关的注解
+}
+
+--- End of: ./config/SecurityConfig.java ---
+
+--- Content of: ./controller/AuthController.java ---
+package com.example.demo.controller;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AuthenticationManager; // 导入 AuthenticationManager
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; // 导入 UsernamePasswordAuthenticationToken
+import org.springframework.security.core.Authentication; // 导入 Authentication
+import org.springframework.security.core.context.SecurityContextHolder; // 导入 SecurityContextHolder
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.validation.BindingResult;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.example.demo.dto.LoginRequestDTO;
+import com.example.demo.dto.LoginResponseDTO;
+import com.example.demo.entity.User;
+import com.example.demo.exception.AuthException;
+import com.example.demo.security.JwtTokenUtil;
+import com.example.demo.service.UserService;
+
+import jakarta.validation.Valid;
+
+@RestController
+@RequestMapping("/api/auth")
+public class AuthController {
+
+    private final UserService userService;
+    private final PasswordEncoder passwordEncoder; // 虽然在AuthController中不再直接用于比对，但如果UserServiceImpl需要，这里保留注入
+    private final JwtTokenUtil jwtTokenUtil;
+    private final AuthenticationManager authenticationManager; // 注入 AuthenticationManager
+
+    public AuthController(UserService userService,
+                          PasswordEncoder passwordEncoder,
+                          JwtTokenUtil jwtTokenUtil,
+                          AuthenticationManager authenticationManager) { // 注入 AuthenticationManager
+        this.userService = userService;
+        this.passwordEncoder = passwordEncoder;
+        this.jwtTokenUtil = jwtTokenUtil;
+        this.authenticationManager = authenticationManager; // 初始化 AuthenticationManager
+    }
+
+    @PostMapping("/login")
+    public ResponseEntity<?> login(
+            @Valid @RequestBody LoginRequestDTO loginRequest,
+            BindingResult bindingResult) {
+
+        if (bindingResult.hasErrors()) {
+            String errMsg = bindingResult.getFieldErrors().stream()
+                    .map(fe -> fe.getField() + ": " + fe.getDefaultMessage())
+                    .reduce((a, b) -> a + "; " + b)
+                    .orElse("Invalid parameters");
+            return ResponseEntity.badRequest().body(Map.of("error", errMsg));
+        }
+
+        try {
+            // 使用 AuthenticationManager 进行认证
+            // 这会触发 UserServiceImpl 中的 loadUserByUsername 方法的调用，并比较密码
+            Authentication authentication = authenticationManager.authenticate(
+                    new UsernamePasswordAuthenticationToken(
+                            loginRequest.getUsername(),
+                            loginRequest.getPassword()
+                    )
+            );
+            // 将认证信息设置到 Spring Security 的上下文中
+            SecurityContextHolder.getContext().setAuthentication(authentication);
+
+            // 获取认证后的用户详情（假设 User 实体实现了 UserDetails 接口）
+            User userDetails = (User) authentication.getPrincipal();
+
+            // 调用 UserService 方法生成登录响应（包括 JWT Token）
+            LoginResponseDTO response = userService.generateLoginResponse(userDetails);
+
+            return ResponseEntity.ok(response);
+
+        } catch (Exception e) {
+            // 认证失败（用户名不存在或密码错误），抛出自定义认证异常
+            // GlobalExceptionHandler 会捕获 AuthException 并返回 401
+            throw new AuthException("用户名或密码错误", e);
+        }
+
+        // 移除原有的手动查找用户和密码比对逻辑
+        /*
+        User user = userService.lambdaQuery()
+                .eq(User::getUsername, loginRequest.getUsername())
+                .one();
+
+        if (user == null || !passwordEncoder.matches(loginRequest.getPassword(), user.getPassword())) {
+            throw new AuthException("用户名或密码错误");
+        }
+
+        String token = jwtTokenUtil.generateToken(user.getId(), user.getUsername(), user.getRole());
+
+        LoginResponseDTO response = new LoginResponseDTO();
+        response.setToken(token);
+        response.setExpiresAt(Instant.now().plusMillis(jwtTokenUtil.getExpiration()));
+        response.setUserId(user.getId());
+        response.setUsername(user.getUsername());
+        response.setRoles(List.of(user.getRole()));
+
+        return ResponseEntity.ok(response);
+        */
+    }
+}
+--- End of: ./controller/AuthController.java ---
+
+--- Content of: ./DemoApplication.java ---
+package com.example.demo;
+
+import org.mybatis.spring.annotation.MapperScan;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+@SpringBootApplication
+@MapperScan("com.example.demo.mapper")
+public class DemoApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(DemoApplication.class, args);
+	}
+
+}
+
+--- End of: ./DemoApplication.java ---
+
+--- Content of: ./dto/LoginRequestDTO.java ---
+package com.example.demo.dto;
+
+import java.io.Serializable;
+
+import jakarta.validation.constraints.NotBlank;
+
+
+public class LoginRequestDTO implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @NotBlank(message = "用户名不能为空")
+    private String username;
+
+    @NotBlank(message = "密码不能为空")
+    private String password;
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+}
+--- End of: ./dto/LoginRequestDTO.java ---
+
+--- Content of: ./dto/LoginResponseDTO.java ---
+package com.example.demo.dto;
+
+import java.io.Serializable;
+import java.time.Instant;
+import java.util.List;
+
+public class LoginResponseDTO implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    /** 登录成功后返回的 JWT 或会话标识 */
+    private String token;
+
+    /** Token 过期时间戳 */
+    private Instant expiresAt;
+
+    /** 用户 ID，可选 */
+    private Long userId;
+
+    /** 用户名，可选 */
+    private String username;
+
+    /** 用户角色列表，可选 */
+    private List<String> roles;
+
+    public String getToken() {
+        return token;
+    }
+
+    public void setToken(String token) {
+        this.token = token;
+    }
+
+    public Instant getExpiresAt() {
+        return expiresAt;
+    }
+
+    public void setExpiresAt(Instant expiresAt) {
+        this.expiresAt = expiresAt;
+    }
+
+    public Long getUserId() {
+        return userId;
+    }
+
+    public void setUserId(Long userId) {
+        this.userId = userId;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public List<String> getRoles() {
+        return roles;
+    }
+
+    public void setRoles(List<String> roles) {
+        this.roles = roles;
+    }
+}
+
+--- End of: ./dto/LoginResponseDTO.java ---
+
+--- Content of: ./entity/User.java ---
+package com.example.demo.entity;
+
+import java.time.LocalDateTime; // Keep import if Serializable is used elsewhere, otherwise remove
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List; // 用于返回空的权限集合，如果用户没有角色/权限
+
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority; // 用于构建权限列表
+import org.springframework.security.core.userdetails.UserDetails;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+
+@TableName("user")
+// 实现UserDetails接口 (UserDetails extends Serializable, so Serializable is redundant here)
+public class User implements UserDetails { 
+    private static final long serialVersionUID = 1L;
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    private String username;
+
+    private String password;
+
+    private String email;
+
+    private Integer status; // 假设status字段表示用户状态，例如 0:禁用, 1:启用
+
+    private Integer score;
+
+    private String role; // 假设role字段存储用户的角色，例如 "ADMIN", "USER"
+
+    private LocalDateTime createTime;
+
+    private LocalDateTime updateTime;
+
+    // --- Getters and Setters ---
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    @Override // 实现UserDetails接口的getUsername方法
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    @Override // 实现UserDetails接口的getPassword方法
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public Integer getStatus() {
+        return status;
+    }
+
+    public void setStatus(Integer status) {
+        this.status = status;
+    }
+
+    public Integer getScore() {
+        return score;
+    }
+
+    public void setScore(Integer score) {
+        this.score = score;
+    }
+
+    public String getRole() {
+        return role;
+    }
+
+    public void setRole(String role) {
+        this.role = role;
+    }
+
+    public LocalDateTime getCreateTime() {
+        return createTime;
+    }
+
+    public void setCreateTime(LocalDateTime createTime) {
+        this.createTime = createTime;
+    }
+
+    public LocalDateTime getUpdateTime() {
+        return updateTime;
+    }
+
+    public void setUpdateTime(LocalDateTime updateTime) {
+        this.updateTime = updateTime;
+    }
+
+    // --- 实现 UserDetails 接口的方法 ---
+
+    @Override
+    public Collection<? extends GrantedAuthority> getAuthorities() {
+        // 根据用户的角色构建权限列表
+        List<GrantedAuthority> authorities = new ArrayList<>();
+        if (this.role != null && !this.role.isEmpty()) {
+            // Spring Security 推荐角色以 "ROLE_" 开头
+            authorities.add(new SimpleGrantedAuthority("ROLE_" + this.role));
+        }
+        // 如果用户没有角色，返回一个空的集合
+        return authorities;
+    }
+
+    @Override
+    public boolean isAccountNonExpired() {
+        // 根据您的业务逻辑判断账户是否过期
+        // 例如，如果您的User实体有过期时间字段，可以在这里检查
+        // 这里简单返回true，表示账户永不过期
+        return true;
+    }
+
+    @Override
+    public boolean isAccountNonLocked() {
+        // 根据您的业务逻辑判断账户是否被锁定
+        // 例如，如果您的User实体有锁定状态字段，可以在这里检查
+        // 这里简单返回true，表示账户永不锁定
+        return true;
+    }
+
+    @Override
+    public boolean isCredentialsNonExpired() {
+        // 根据您的业务逻辑判断凭证（密码）是否过期
+        // 例如，如果您的User实体有密码最后修改时间字段，可以在这里检查
+        // 这里简单返回true，表示凭证永不过期
+        return true;
+    }
+
+    @Override
+    public boolean isEnabled() {
+        // 根据您的业务逻辑判断账户是否启用
+        // 假设status字段为1表示启用
+        return this.status != null && this.status == 1;
+    }
+}
+
+--- End of: ./entity/User.java ---
+
+--- Content of: ./exception/AuthException.java ---
+package com.example.demo.exception;
+
+/**
+ * 自定义认证/授权异常
+ */
+public class AuthException extends RuntimeException {
+    public AuthException(String message) {
+        super(message);
+    }
+
+    public AuthException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
+
+--- End of: ./exception/AuthException.java ---
+
+--- Content of: ./exception/GlobalExceptionHandler.java ---
+package com.example.demo.exception;
+
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.FieldError;
+import org.springframework.web.bind.MethodArgumentNotValidException;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@ControllerAdvice
+public class GlobalExceptionHandler {
+
+    /** 处理自定义认证异常 */
+    @ExceptionHandler(AuthException.class)
+    public ResponseEntity<Map<String, String>> handleAuthException(AuthException ex) {
+        Map<String, String> body = Map.of("error", ex.getMessage());
+        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(body);
+    }
+
+    /** 处理请求参数校验失败 */
+    @ExceptionHandler(MethodArgumentNotValidException.class)
+    public ResponseEntity<Map<String, String>> handleValidationExceptions(MethodArgumentNotValidException ex) {
+        Map<String, String> errors = new HashMap<>();
+        for (FieldError fe : ex.getBindingResult().getFieldErrors()) {
+            errors.put(fe.getField(), fe.getDefaultMessage());
+        }
+        return ResponseEntity.badRequest().body(errors);
+    }
+
+    /** 处理其它未捕获的异常 */
+    @ExceptionHandler(Exception.class)
+    public ResponseEntity<Map<String, String>> handleAllExceptions(Exception ex) {
+        Map<String, String> body = Map.of("error", "Internal server error");
+        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(body);
+    }
+}
+
+--- End of: ./exception/GlobalExceptionHandler.java ---
+
+--- Content of: ./mapper/UserMapper.java ---
+package com.example.demo.mapper;
+
+import org.apache.ibatis.annotations.Mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.example.demo.entity.User;
+
+/**
+ * UserMapper 接口
+ * 
+ * 继承 MyBatis-Plus 提供的 BaseMapper，实现基本的 CRUD 操作
+ */
+@Mapper
+public interface UserMapper extends BaseMapper<User> {
+
+    User findById(Long id);
+
+    User findByUsername(String username);
+    
+    // List<User> selectByStatus(@Param("status") Integer status);
+}
+
+
+--- End of: ./mapper/UserMapper.java ---
+
+--- Content of: ./security/JwtAuthenticationFilter.java ---
+package com.example.demo.security;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+import org.springframework.web.filter.OncePerRequestFilter;
+
+import com.example.demo.config.JWTProperties;
+import com.example.demo.exception.AuthException;
+
+import io.jsonwebtoken.Claims;
+import jakarta.servlet.FilterChain;
+import jakarta.servlet.ServletException;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+@Component 
+public class JwtAuthenticationFilter extends OncePerRequestFilter {
+
+    private final JwtTokenUtil tokenUtil;
+    private final JWTProperties props;
+
+    public JwtAuthenticationFilter(JwtTokenUtil tokenUtil, JWTProperties props) {
+        this.tokenUtil = tokenUtil;
+        this.props = props;
+    }
+
+    @Override
+    protected void doFilterInternal(HttpServletRequest request,
+                                    HttpServletResponse response,
+                                    FilterChain chain)
+            throws ServletException, IOException {
+
+        String headerValue = request.getHeader(props.getHeader());
+        if (!StringUtils.hasText(headerValue) || !headerValue.startsWith(props.getTokenPrefix())) {
+            chain.doFilter(request, response);
+            return;
+        }
+
+        String token = headerValue.substring(props.getTokenPrefix().length());
+        if (!tokenUtil.validateToken(token)) {
+            throw new AuthException("Invalid or expired JWT token");
+        }
+
+        Claims claims = tokenUtil.parseClaims(token);
+        String username =tokenUtil.getUsername(token);
+        Long userId = tokenUtil.getUserId(token);
+        String role = tokenUtil.getRole(token);
+
+        UsernamePasswordAuthenticationToken auth =
+            new UsernamePasswordAuthenticationToken(
+                userId, 
+                null, 
+                List.of(new SimpleGrantedAuthority(role))
+            );
+        SecurityContextHolder.getContext().setAuthentication(auth);
+
+        chain.doFilter(request, response);
+    }
+}
+
+--- End of: ./security/JwtAuthenticationFilter.java ---
+
+--- Content of: ./security/JwtTokenUtil.java ---
+package com.example.demo.security;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Date;
+import java.util.Map;
+
+import org.springframework.stereotype.Component;
+
+import com.example.demo.config.JWTProperties;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.JwtException;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.security.Keys;
+@Component
+public class JwtTokenUtil {
+
+    private final JWTProperties props;
+    private final byte[] secretBytes;
+
+    public JwtTokenUtil(JWTProperties props) {
+        this.props = props;
+        this.secretBytes = props.getSecret().getBytes(StandardCharsets.UTF_8);
+    }
+
+    /** 生成 JWT */
+    public String generateToken(Long userId, String username, String role) {
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + props.getExpirationMs());
+
+        return Jwts.builder()
+                .setSubject(username)
+                .setIssuer(props.getIssuer())
+                .setAudience(props.getAudience())
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .addClaims(Map.of("userId", userId, "role", role))
+                .signWith(Keys.hmacShaKeyFor(secretBytes), SignatureAlgorithm.HS256)
+                .compact();
+    }
+
+    /** 验证并解析 Token，抛出异常则验证失败 */
+    public Claims parseClaims(String token) {
+        return Jwts.parserBuilder()
+                .setSigningKey(secretBytes)
+                .build()
+                .parseClaimsJws(token)
+                .getBody();
+    }
+
+    /** 校验 Token 是否有效 */
+    public boolean validateToken(String token) {
+        try {
+            parseClaims(token);
+            return true;
+        } catch (JwtException e) {
+            return false;
+        }
+    }
+
+    /** 从 Token 获取用户名（Subject） */
+    public String getUsername(String token) {
+        return parseClaims(token).getSubject();
+    }
+
+    /** 从 Token 获取用户 ID */
+    public Long getUserId(String token) {
+        Object id = parseClaims(token).get("userId");
+        return id == null ? null : Long.valueOf(id.toString());
+    }
+
+    /** 从 Token 获取角色 */
+    public String getRole(String token) {
+        return parseClaims(token).get("role", String.class);
+    }
+
+    /**
+     * 获取 JWT 的过期时间（毫秒）
+     * 修复：返回 JWTProperties 中配置的过期时间
+     */
+    public long getExpiration() {
+         return props.getExpirationMs();
+    }
+}
+
+--- End of: ./security/JwtTokenUtil.java ---
+
+--- Content of: ./service/UserService.java ---
+package com.example.demo.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.example.demo.dto.LoginResponseDTO;
+import com.example.demo.entity.User; // 导入 LoginResponseDTO
+
+/**
+ * User 业务层接口
+ * 继承了 MyBatis-Plus 的 IService，并定义了自定义的用户业务方法。
+ */
+public interface UserService extends IService<User> {
+    // 自定义方法：根据ID查找用户
+    User findById(Long id);
+
+    // 自定义方法：根据用户名查找用户
+    User findByUsername(String username);
+
+    // 自定义方法：创建新用户
+    User createUser(User user);
+
+    // 新增方法：生成用户登录响应（包括 JWT Token）
+    // 这个方法在 AuthController 中被调用，因此必须在接口中声明
+    LoginResponseDTO generateLoginResponse(User userDetails);
+
+    // 如果需要其他自定义方法，可以在这里再添加
+}
+
+--- End of: ./service/UserService.java ---
+
+--- Content of: ./service/impl/UserServiceImpl.java ---
+package com.example.demo.service.impl;
+
+// 导入UserService接口
+import java.time.Instant;
+import java.util.List;
+
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.example.demo.dto.LoginResponseDTO;
+import com.example.demo.entity.User;
+import com.example.demo.mapper.UserMapper;
+import com.example.demo.security.JwtTokenUtil;
+import com.example.demo.service.UserService;
+
+
+/**
+ * 用户业务逻辑服务实现类
+ * 继承了MyBatis-Plus的ServiceImpl，并实现了UserService接口和Spring Security的UserDetailsService接口。
+ * 利用ServiceImpl提供的通用CRUD方法，并实现自定义的用户业务操作和加载用户详情。
+ * 用户登录认证逻辑已移至 Controller 层，以解决循环依赖问题。
+ */
+@Service
+// 继承ServiceImpl，指定Mapper和实体类型。
+// 这样就自动拥有了IService中大部分通用方法的实现。
+public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService, UserDetailsService {
+
+    // 当继承ServiceImpl后，ServiceImpl内部已经注入了BaseMapper，
+    // 通常不需要在这里再次声明UserMapper，除非您需要调用UserMapper中自定义的非BaseMapper方法。
+    // private final UserMapper userMapper; // 如果继承ServiceImpl，这行通常可以移除
+
+    // 注入密码编码器，用于密码加密和校验
+    private final PasswordEncoder passwordEncoder;
+    // 移除 AuthenticationManager 注入，认证逻辑已移至 Controller
+    // private final AuthenticationManager authenticationManager;
+    // 注入JWT工具类，用于生成和解析Token
+    private final JwtTokenUtil jwtTokenUtil;
+
+
+    /**
+     * 构造函数注入非BaseMapper的依赖
+     * ServiceImpl会自动注入BaseMapper
+     * @param passwordEncoder 密码编码器
+     * // 移除 authenticationManager 参数
+     * @param jwtTokenUtil JWT工具类
+     */
+    // @Autowired // 当只有一个构造函数时，@Autowired 可选
+    public UserServiceImpl(PasswordEncoder passwordEncoder,
+                           // AuthenticationManager authenticationManager, // 移除此参数
+                           JwtTokenUtil jwtTokenUtil) {
+        // 当继承ServiceImpl时，不需要在构造函数中注入并初始化BaseMapper
+        // this.userMapper = userMapper; // 移除这行
+
+        this.passwordEncoder = passwordEncoder;
+        // this.authenticationManager = authenticationManager; // 移除此初始化
+        this.jwtTokenUtil = jwtTokenUtil;
+    }
+
+    /**
+     * 根据用户ID查找用户
+     * 实现UserService接口中的findById方法。
+     * 可以直接使用ServiceImpl提供的getById方法。
+     * @param id 用户ID
+     * @return 找到的用户实体，如果不存在则返回null
+     */
+    @Override
+    public User findById(Long id) {
+        // 直接使用ServiceImpl提供的通用getById方法
+        return this.getById(id);
+        // 如果UserMapper有自定义的findById方法且需要使用，可以通过getBaseMapper()调用：
+        // return this.getBaseMapper().findById(id);
+    }
+
+    /**
+     * 根据用户名查找用户
+     * 实现UserService接口中的findByUsername方法。
+     * 可以使用ServiceImpl提供的getOne方法结合Wrapper进行条件查询。
+     * @param username 用户名
+     * @return 找到的用户实体，如果不存在则返回null
+     */
+    @Override
+    public User findByUsername(String username) {
+        // 使用ServiceImpl提供的通用getOne方法结合QueryWrapper进行条件查询
+        return this.getOne(new QueryWrapper<User>().eq("username", username));
+        // 如果UserMapper有自定义的findByUsername方法且需要使用，可以通过getBaseMapper()调用：
+        // return this.getBaseMapper().findByUsername(username);
+    }
+
+    /**
+     * 创建新用户
+     * 实现UserService接口中的createUser方法。
+     * 可以使用ServiceImpl提供的save方法。
+     * @param user 待创建的用户实体
+     * @return 创建成功的用户实体
+     */
+    @Override
+    public User createUser(User user) {
+        // 在保存前对用户密码进行加密
+        user.setPassword(passwordEncoder.encode(user.getPassword()));
+
+        // 使用ServiceImpl提供的通用save方法将用户插入数据库
+        this.save(user);
+        return user;
+    }
+
+    /**
+     * 实现Spring Security的UserDetailsService接口方法
+     * 根据用户名加载用户详情。
+     * 这个方法会被Spring Security的认证流程调用。
+     * @param username 用户名
+     * @return 实现UserDetails接口的用户详情对象
+     * @throws UsernameNotFoundException 如果用户不存在
+     */
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        // 调用findByUsername方法从数据库查找用户
+        User user = findByUsername(username);
+        if (user == null) {
+            // 如果用户不存在，抛出UsernameNotFoundException
+            throw new UsernameNotFoundException("User not found with username: " + username);
+        }
+
+        // 返回Spring Security需要的UserDetails对象。
+        // 假设您的User实体类实现了UserDetails接口，并且其getAuthorities()方法正确返回了权限列表。
+        return user;
+    }
+
+    /**
+     * 用户登录认证成功后，生成JWT Token和构建响应DTO。
+     * 这个方法实现了UserService接口中声明的 generateLoginResponse 方法。
+     * @param userDetails 认证成功的用户详情（User实体）
+     * @return 包含JWT Token和相关信息的登录响应DTO
+     */
+    @Override // 添加 @Override 注解，明确表示实现接口方法
+    public LoginResponseDTO generateLoginResponse(User userDetails) {
+        // 使用JwtTokenUtil生成JWT Token
+        String token = jwtTokenUtil.generateToken(userDetails.getId(), userDetails.getUsername(), userDetails.getRole());
+
+        // 构建登录响应DTO
+        LoginResponseDTO response = new LoginResponseDTO();
+        response.setToken(token);
+        // 调用 JwtTokenUtil 的 getExpiration() 方法获取过期时间毫秒数
+        response.setExpiresAt(Instant.now().plusMillis(jwtTokenUtil.getExpiration()));
+        response.setUserId(userDetails.getId());
+        response.setUsername(userDetails.getUsername());
+        response.setRoles(List.of(userDetails.getRole())); // 假设角色是单个字符串，如果多个角色需要调整
+
+        return response;
+    }
+
+
+    // 当继承ServiceImpl后，IService中的通用方法（如 save, updateById, list, page 等）
+    // 已经由ServiceImpl提供默认实现，无需在此重复编写。
+    // 如果您需要对IService中的某个通用方法进行定制（例如在保存前进行额外处理），
+    // 可以在这里@Override该方法并添加您的逻辑，然后调用super.方法名(...)来执行ServiceImpl的默认逻辑。
+    /*
+    @Override
+    public boolean saveBatch(Collection<User> entityList, int batchSize) {
+        // 在调用ServiceImpl的批量保存前/后添加自定义逻辑
+        // ...
+        return super.saveBatch(entityList, batchSize); // 调用ServiceImpl的默认实现
+    }
+
+    // ... 其他IService中的方法实现
+    */
+}
+
+--- End of: ./service/impl/UserServiceImpl.java ---
+
+--- End File Content ---
diff --git a/backend/demo/src/main/java/com/example/demo/security/JwtAuthenticationFilter.java b/backend/demo/src/main/java/com/example/demo/security/JwtAuthenticationFilter.java
index 108e966..520908c 100644
--- a/backend/demo/src/main/java/com/example/demo/security/JwtAuthenticationFilter.java
+++ b/backend/demo/src/main/java/com/example/demo/security/JwtAuthenticationFilter.java
@@ -47,7 +47,7 @@
         }
 
         Claims claims = tokenUtil.parseClaims(token);
-        String username = claims.getSubject();
+        String username =tokenUtil.getUsername(token);
         Long userId = tokenUtil.getUserId(token);
         String role = tokenUtil.getRole(token);
 
diff --git a/backend/demo/src/main/java/com/example/demo/security/JwtTokenUtil.java b/backend/demo/src/main/java/com/example/demo/security/JwtTokenUtil.java
index 3f44d8a..7a9be5a 100644
--- a/backend/demo/src/main/java/com/example/demo/security/JwtTokenUtil.java
+++ b/backend/demo/src/main/java/com/example/demo/security/JwtTokenUtil.java
@@ -75,7 +75,11 @@
         return parseClaims(token).get("role", String.class);
     }
 
+    /**
+     * 获取 JWT 的过期时间（毫秒）
+     * 修复：返回 JWTProperties 中配置的过期时间
+     */
     public long getExpiration() {
-        throw new UnsupportedOperationException("Not supported yet.");
+         return props.getExpirationMs();
     }
 }
diff --git a/backend/demo/src/main/java/com/example/demo/service/TorrentService.java b/backend/demo/src/main/java/com/example/demo/service/TorrentService.java
new file mode 100644
index 0000000..b863798
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/service/TorrentService.java
@@ -0,0 +1,26 @@
+// src/main/java/com/example/demo/service/TorrentService.java
+package com.example.demo.service;
+
+import java.io.IOException;
+
+import org.springframework.web.multipart.MultipartFile;
+
+import com.example.demo.dto.TorrentInfoDTO;
+import com.turn.ttorrent.bcodec.InvalidBEncodingException; // 导入 InvalidBEncodingException
+
+/**
+ * 处理 .torrent 文件上传及相关业务逻辑的服务接口。
+ */
+public interface TorrentService {
+
+    /**
+     * 处理上传的 .torrent 文件，解析其内容，保存到数据库，并生成相关链接。
+     *
+     * @param file 上传的 MultipartFile 对象
+     * @return 包含解析信息、磁力链接和下载 URL 的 TorrentInfoDTO
+     * @throws IOException 如果文件读取或保存失败
+     * @throws InvalidBEncodingException 如果 .torrent 文件内容不符合 B 编码规范
+     * @throws IllegalArgumentException 如果文件为空或解析后的元数据不完整
+     */
+    TorrentInfoDTO handleUpload(MultipartFile file) throws IOException, InvalidBEncodingException, IllegalArgumentException;
+}
\ No newline at end of file
diff --git a/backend/demo/src/main/java/com/example/demo/service/UserService.java b/backend/demo/src/main/java/com/example/demo/service/UserService.java
index 60e8aef..e4c5d7b 100644
--- a/backend/demo/src/main/java/com/example/demo/service/UserService.java
+++ b/backend/demo/src/main/java/com/example/demo/service/UserService.java
@@ -1,13 +1,26 @@
 package com.example.demo.service;
 
-
 import com.baomidou.mybatisplus.extension.service.IService;
-import com.example.demo.entity.User;
+import com.example.demo.dto.LoginResponseDTO;
+import com.example.demo.entity.User; // 导入 LoginResponseDTO
 
 /**
  * User 业务层接口
+ * 继承了 MyBatis-Plus 的 IService，并定义了自定义的用户业务方法。
  */
 public interface UserService extends IService<User> {
-    // 如果需要自定义方法，可以在这里再添加，例如：
-    // User findByUsername(String username);
+    // 自定义方法：根据ID查找用户
+    User findById(Long id);
+
+    // 自定义方法：根据用户名查找用户
+    User findByUsername(String username);
+
+    // 自定义方法：创建新用户
+    User createUser(User user);
+
+    // 新增方法：生成用户登录响应（包括 JWT Token）
+    // 这个方法在 AuthController 中被调用，因此必须在接口中声明
+    LoginResponseDTO generateLoginResponse(User userDetails);
+
+    // 如果需要其他自定义方法，可以在这里再添加
 }
diff --git a/backend/demo/src/main/java/com/example/demo/service/impl/TorrentServiceImpl.java b/backend/demo/src/main/java/com/example/demo/service/impl/TorrentServiceImpl.java
new file mode 100644
index 0000000..eb00160
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/service/impl/TorrentServiceImpl.java
@@ -0,0 +1,126 @@
+// src/main/java/com/example/demo/service/impl/TorrentServiceImpl.java
+package com.example.demo.service.impl;
+
+import java.io.IOException;
+import java.nio.file.Files; // 导入 DTO
+import java.nio.file.Path; // 导入实体类
+import java.nio.file.Paths; // 导入 Mapper
+
+import org.springframework.beans.factory.annotation.Value; // 导入服务接口
+import org.springframework.stereotype.Service; // 导入工具类
+import org.springframework.transaction.annotation.Transactional; // 导入 ttorrent 的异常
+import org.springframework.web.multipart.MultipartFile; // 导入 @Value 用于读取配置
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.example.demo.dto.TorrentInfoDTO; // 导入事务注解
+import com.example.demo.entity.TorrentInfo;
+import com.example.demo.mapper.TorrentInfoMapper;
+import com.example.demo.service.TorrentService; // 用于文件操作
+import com.example.demo.util.TorrentUtils;  // 用于文件路径
+import com.turn.ttorrent.bcodec.InvalidBEncodingException; // 用于文件路径
+
+/**
+ * TorrentService 接口的实现类，负责处理 .torrent 文件的上传、解析、持久化及链接生成。
+ */
+@Service // 标记这是一个 Spring Service 组件
+public class TorrentServiceImpl implements TorrentService {
+
+    private final TorrentInfoMapper torrentInfoMapper;
+
+    @Value("${file.upload-dir}") // 从 application.properties 中注入文件上传目录
+    private String uploadDir;
+
+    // 通过构造函数注入 Mapper
+    public TorrentServiceImpl(TorrentInfoMapper torrentInfoMapper) {
+        this.torrentInfoMapper = torrentInfoMapper;
+    }
+
+    @Override
+    @Transactional // 确保文件保存和数据库操作的原子性
+    public TorrentInfoDTO handleUpload(MultipartFile file) throws IOException, InvalidBEncodingException, IllegalArgumentException {
+        if (file.isEmpty()) {
+            throw new IllegalArgumentException("上传文件不能为空。");
+        }
+
+        // 1. 调用 TorrentUtils 解析 .torrent 文件
+        TorrentUtils.TorrentParsedInfo parsedInfo;
+        try {
+            parsedInfo = TorrentUtils.parseTorrentFile(file);
+        } catch (InvalidBEncodingException e) {
+            throw new IllegalArgumentException("无法解析 .torrent 文件，文件格式不正确: " + e.getMessage(), e);
+        } catch (IOException e) {
+            throw new IOException("读取上传文件失败: " + e.getMessage(), e);
+        }
+
+        String infoHash = parsedInfo.getInfoHash();
+        String fileName = parsedInfo.getFileName();
+        long fileSize = parsedInfo.getFileSize();
+
+        // 2. 检查 infoHash 是否已存在，避免重复上传相同的洪流
+        QueryWrapper<TorrentInfo> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("info_hash", infoHash); // 根据 info_hash 查询
+        TorrentInfo existingTorrent = torrentInfoMapper.selectOne(queryWrapper);
+
+        if (existingTorrent != null) {
+            System.out.println("Torrent with infoHash " + infoHash + " already exists. Returning existing info.");
+            // 如果已存在，直接返回现有信息对应的 DTO
+            return new TorrentInfoDTO(
+                    existingTorrent.getFileName(),
+                    existingTorrent.getFileSize(),
+                    existingTorrent.getInfoHash(),
+                    existingTorrent.getMagnetUri(),
+                    existingTorrent.getDownloadUrl(),
+                    "该洪流已存在，返回现有信息。"
+            );
+        }
+
+        // 3. 保存 .torrent 文件到服务器文件系统
+        // 使用 infoHash 作为文件名，确保唯一性，并保留原始扩展名 .torrent
+        String storedFileName = infoHash + ".torrent";
+        Path uploadPath = Paths.get(uploadDir).toAbsolutePath().normalize();
+        Path filePath = uploadPath.resolve(storedFileName);
+
+        try {
+            Files.createDirectories(uploadPath); // 如果目录不存在则创建
+            Files.copy(file.getInputStream(), filePath); // 将文件流复制到目标路径
+            System.out.println("Torrent file saved to: " + filePath.toString());
+        } catch (IOException e) {
+            // 如果文件保存失败，需要回滚之前的数据库操作 (如果前面有的话)
+            // @Transactional 会自动处理
+            throw new IOException("无法保存 .torrent 文件到磁盘: " + e.getMessage(), e);
+        }
+
+        // 4. 生成 magnet 链接 & downloadUrl
+        String magnetUri = String.format("magnet:?xt=urn:btih:%s&dn=%s", infoHash, fileName);
+        // downloadUrl 指向后端实际的下载接口
+        String downloadUrl = String.format("/api/downloads/%s/%s", infoHash, fileName);
+
+        // 5. 组装实体 TorrentInfo
+        TorrentInfo torrentInfo = new TorrentInfo(
+                infoHash,
+                fileName,
+                fileSize,
+                magnetUri,
+                downloadUrl
+        );
+
+        // 6. 调用 Mapper.insert() 持久化一条记录到数据库
+        int insertedRows = torrentInfoMapper.insert(torrentInfo);
+        if (insertedRows != 1) {
+            throw new RuntimeException("保存洪流信息到数据库失败。");
+        }
+        System.out.println("Saved TorrentInfo to database: " + torrentInfo);
+
+        // 7. 构造 DTO 返回给前端
+        TorrentInfoDTO dto = new TorrentInfoDTO(
+                torrentInfo.getFileName(),
+                torrentInfo.getFileSize(),
+                torrentInfo.getInfoHash(),
+                torrentInfo.getMagnetUri(),
+                torrentInfo.getDownloadUrl(),
+                "Torrent uploaded and processed successfully!"
+        );
+
+        return dto;
+    }
+}
\ No newline at end of file
diff --git a/backend/demo/src/main/java/com/example/demo/service/impl/UserServiceImpl.java b/backend/demo/src/main/java/com/example/demo/service/impl/UserServiceImpl.java
index 5bd1693..1fc434c 100644
--- a/backend/demo/src/main/java/com/example/demo/service/impl/UserServiceImpl.java
+++ b/backend/demo/src/main/java/com/example/demo/service/impl/UserServiceImpl.java
@@ -1,23 +1,171 @@
 package com.example.demo.service.impl;
 
-// UserServiceImpl.java
+// 导入UserService接口
+import java.time.Instant;
+import java.util.List;
 
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.example.demo.dto.LoginResponseDTO;
 import com.example.demo.entity.User;
 import com.example.demo.mapper.UserMapper;
+import com.example.demo.security.JwtTokenUtil;
 import com.example.demo.service.UserService;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
+
 
 /**
- * User 业务层默认实现
+ * 用户业务逻辑服务实现类
+ * 继承了MyBatis-Plus的ServiceImpl，并实现了UserService接口和Spring Security的UserDetailsService接口。
+ * 利用ServiceImpl提供的通用CRUD方法，并实现自定义的用户业务操作和加载用户详情。
+ * 用户登录认证逻辑已移至 Controller 层，以解决循环依赖问题。
  */
 @Service
-@Transactional(rollbackFor = Exception.class)
-public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
-    // 如果你在接口中声明了自定义方法，这里可以重写并实现：
-    // @Override
-    // public User findByUsername(String username) {
-    //     return lambdaQuery().eq(User::getUsername, username).one();
-    // }
+// 继承ServiceImpl，指定Mapper和实体类型。
+// 这样就自动拥有了IService中大部分通用方法的实现。
+public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService, UserDetailsService {
+
+    // 当继承ServiceImpl后，ServiceImpl内部已经注入了BaseMapper，
+    // 通常不需要在这里再次声明UserMapper，除非您需要调用UserMapper中自定义的非BaseMapper方法。
+    // private final UserMapper userMapper; // 如果继承ServiceImpl，这行通常可以移除
+
+    // 注入密码编码器，用于密码加密和校验
+    private final PasswordEncoder passwordEncoder;
+    // 移除 AuthenticationManager 注入，认证逻辑已移至 Controller
+    // private final AuthenticationManager authenticationManager;
+    // 注入JWT工具类，用于生成和解析Token
+    private final JwtTokenUtil jwtTokenUtil;
+
+
+    /**
+     * 构造函数注入非BaseMapper的依赖
+     * ServiceImpl会自动注入BaseMapper
+     * @param passwordEncoder 密码编码器
+     * // 移除 authenticationManager 参数
+     * @param jwtTokenUtil JWT工具类
+     */
+    // @Autowired // 当只有一个构造函数时，@Autowired 可选
+    public UserServiceImpl(PasswordEncoder passwordEncoder,
+                           // AuthenticationManager authenticationManager, // 移除此参数
+                           JwtTokenUtil jwtTokenUtil) {
+        // 当继承ServiceImpl时，不需要在构造函数中注入并初始化BaseMapper
+        // this.userMapper = userMapper; // 移除这行
+
+        this.passwordEncoder = passwordEncoder;
+        // this.authenticationManager = authenticationManager; // 移除此初始化
+        this.jwtTokenUtil = jwtTokenUtil;
+    }
+
+    /**
+     * 根据用户ID查找用户
+     * 实现UserService接口中的findById方法。
+     * 可以直接使用ServiceImpl提供的getById方法。
+     * @param id 用户ID
+     * @return 找到的用户实体，如果不存在则返回null
+     */
+    @Override
+    public User findById(Long id) {
+        // 直接使用ServiceImpl提供的通用getById方法
+        return this.getById(id);
+        // 如果UserMapper有自定义的findById方法且需要使用，可以通过getBaseMapper()调用：
+        // return this.getBaseMapper().findById(id);
+    }
+
+    /**
+     * 根据用户名查找用户
+     * 实现UserService接口中的findByUsername方法。
+     * 可以使用ServiceImpl提供的getOne方法结合Wrapper进行条件查询。
+     * @param username 用户名
+     * @return 找到的用户实体，如果不存在则返回null
+     */
+    @Override
+    public User findByUsername(String username) {
+        // 使用ServiceImpl提供的通用getOne方法结合QueryWrapper进行条件查询
+        return this.getOne(new QueryWrapper<User>().eq("username", username));
+        // 如果UserMapper有自定义的findByUsername方法且需要使用，可以通过getBaseMapper()调用：
+        // return this.getBaseMapper().findByUsername(username);
+    }
+
+    /**
+     * 创建新用户
+     * 实现UserService接口中的createUser方法。
+     * 可以使用ServiceImpl提供的save方法。
+     * @param user 待创建的用户实体
+     * @return 创建成功的用户实体
+     */
+    @Override
+    public User createUser(User user) {
+        // 在保存前对用户密码进行加密
+        user.setPassword(passwordEncoder.encode(user.getPassword()));
+
+        // 使用ServiceImpl提供的通用save方法将用户插入数据库
+        this.save(user);
+        return user;
+    }
+
+    /**
+     * 实现Spring Security的UserDetailsService接口方法
+     * 根据用户名加载用户详情。
+     * 这个方法会被Spring Security的认证流程调用。
+     * @param username 用户名
+     * @return 实现UserDetails接口的用户详情对象
+     * @throws UsernameNotFoundException 如果用户不存在
+     */
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        // 调用findByUsername方法从数据库查找用户
+        User user = findByUsername(username);
+        if (user == null) {
+            // 如果用户不存在，抛出UsernameNotFoundException
+            throw new UsernameNotFoundException("User not found with username: " + username);
+        }
+
+        // 返回Spring Security需要的UserDetails对象。
+        // 假设您的User实体类实现了UserDetails接口，并且其getAuthorities()方法正确返回了权限列表。
+        return user;
+    }
+
+    /**
+     * 用户登录认证成功后，生成JWT Token和构建响应DTO。
+     * 这个方法实现了UserService接口中声明的 generateLoginResponse 方法。
+     * @param userDetails 认证成功的用户详情（User实体）
+     * @return 包含JWT Token和相关信息的登录响应DTO
+     */
+    @Override // 添加 @Override 注解，明确表示实现接口方法
+    public LoginResponseDTO generateLoginResponse(User userDetails) {
+        // 使用JwtTokenUtil生成JWT Token
+        String token = jwtTokenUtil.generateToken(userDetails.getId(), userDetails.getUsername(), userDetails.getRole());
+
+        // 构建登录响应DTO
+        LoginResponseDTO response = new LoginResponseDTO();
+        response.setToken(token);
+        // 调用 JwtTokenUtil 的 getExpiration() 方法获取过期时间毫秒数
+        response.setExpiresAt(Instant.now().plusMillis(jwtTokenUtil.getExpiration()));
+        response.setUserId(userDetails.getId());
+        response.setUsername(userDetails.getUsername());
+        response.setRoles(List.of(userDetails.getRole())); // 假设角色是单个字符串，如果多个角色需要调整
+
+        return response;
+    }
+
+
+    // 当继承ServiceImpl后，IService中的通用方法（如 save, updateById, list, page 等）
+    // 已经由ServiceImpl提供默认实现，无需在此重复编写。
+    // 如果您需要对IService中的某个通用方法进行定制（例如在保存前进行额外处理），
+    // 可以在这里@Override该方法并添加您的逻辑，然后调用super.方法名(...)来执行ServiceImpl的默认逻辑。
+    /*
+    @Override
+    public boolean saveBatch(Collection<User> entityList, int batchSize) {
+        // 在调用ServiceImpl的批量保存前/后添加自定义逻辑
+        // ...
+        return super.saveBatch(entityList, batchSize); // 调用ServiceImpl的默认实现
+    }
+
+    // ... 其他IService中的方法实现
+    */
 }
diff --git a/backend/demo/src/main/java/com/example/demo/sh.py b/backend/demo/src/main/java/com/example/demo/sh.py
new file mode 100644
index 0000000..3be143b
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/sh.py
@@ -0,0 +1,76 @@
+import os
+
+def read_files_and_write_to_file(file_paths, output_file):
+    """
+    Reads the content of specified files and writes it to an output file.
+
+    Args:
+        file_paths (list): A list of strings, where each string is the path to a file.
+        output_file (str): The path to the file where the output will be written.
+    """
+    try:
+        # Open the output file in write mode ('w').
+        # Use 'utf-8' encoding for wide compatibility.
+        with open(output_file, 'w', encoding='utf-8') as outfile:
+            outfile.write("--- Start File Content ---\n")
+            print(f"Reading files and writing to {output_file}...") # Print to console for feedback
+
+            for file_path in file_paths:
+                if not os.path.exists(file_path):
+                    error_msg = f"Error: File not found at path: {file_path}\n"
+                    outfile.write(error_msg)
+                    print(error_msg.strip()) # Also print error to console
+                    continue
+                if not os.path.isfile(file_path):
+                    error_msg = f"Error: Path is not a file: {file_path}\n"
+                    outfile.write(error_msg)
+                    print(error_msg.strip()) # Also print error to console
+                    continue
+
+                try:
+                    with open(file_path, 'r', encoding='utf-8') as infile:
+                        content = infile.read()
+                        outfile.write(f"\n--- Content of: {file_path} ---\n")
+                        outfile.write(content)
+                        outfile.write(f"\n--- End of: {file_path} ---\n")
+                        print(f"Successfully read: {file_path}") # Print success to console
+                except Exception as e:
+                    error_msg = f"Error reading file {file_path}: {e}\n"
+                    outfile.write(error_msg)
+                    print(error_msg.strip()) # Also print error to console
+
+            outfile.write("\n--- End File Content ---\n")
+            print("Finished writing file content.")
+
+    except Exception as e:
+        print(f"Error opening or writing to output file {output_file}: {e}")
+
+
+if __name__ == "__main__":
+    # 请在这里列出您想要读取的文件路径
+    # 确保路径是相对于您运行脚本的位置，或者使用绝对路径
+    your_file_paths = [
+        './config/JWTProperties.java',
+        './config/SecurityConfig.java',
+        './controller/AuthController.java',
+        './DemoApplication.java',
+        './dto/LoginRequestDTO.java',
+        './dto/LoginResponseDTO.java',
+        './entity/User.java',
+        './exception/AuthException.java',
+        './exception/GlobalExceptionHandler.java',
+        './mapper/UserMapper.java',
+        './security/JwtAuthenticationFilter.java',
+        './security/JwtTokenUtil.java',
+        './service/UserService.java',
+        './service/impl/UserServiceImpl.java', # 假设您已经创建了这个文件
+         
+    ]
+
+    # 指定输出文件的名称
+    output_filename = "result.txt"
+
+    # 调用函数，将文件内容写入到 output_filename
+    read_files_and_write_to_file(your_file_paths, output_filename)
+
+
diff --git a/backend/demo/src/main/java/com/example/demo/util/TorrentUtils.java b/backend/demo/src/main/java/com/example/demo/util/TorrentUtils.java
new file mode 100644
index 0000000..465a167
--- /dev/null
+++ b/backend/demo/src/main/java/com/example/demo/util/TorrentUtils.java
@@ -0,0 +1,102 @@
+// src/main/java/com/example/demo/util/TorrentUtils.java
+package com.example.demo.util;
+
+import java.io.IOException; // 导入 TorrentMetadata 接口
+
+import org.springframework.web.multipart.MultipartFile; // 导入 TorrentParser 类
+
+import com.turn.ttorrent.bcodec.InvalidBEncodingException;
+import com.turn.ttorrent.common.TorrentMetadata;
+import com.turn.ttorrent.common.TorrentParser;
+
+public class TorrentUtils {
+
+    /**
+     * 解析 MultipartFile 中的 .torrent 文件，提取关键信息。
+     *
+     * 该方法利用 ttorrent-common 库中的 TorrentParser 来解析 .torrent 文件的字节内容，
+     * 并从解析得到的 TorrentMetadata 对象中提取 info hash、文件名和文件大小。
+     *
+     * @param file 上传的 MultipartFile 对象
+     * @return 包含解析信息的 TorrentParsedInfo 对象
+     * @throws IOException 如果文件读取失败
+     * @throws BDecodingException 如果 .torrent 文件内容不符合 B 编码规范
+     * @throws IllegalArgumentException 如果文件为空或解析后的元数据不完整
+     */
+    public static TorrentParsedInfo parseTorrentFile(MultipartFile file)
+            throws IOException, IllegalArgumentException {
+
+        if (file.isEmpty()) {
+            throw new IllegalArgumentException("Uploaded file is empty.");
+        }
+
+        byte[] torrentBytes = file.getBytes();
+
+        // 使用 ttorrent-common 库的 TorrentParser 来解析字节数组
+        TorrentParser parser = new TorrentParser();
+        TorrentMetadata metadata;
+        try {
+            metadata = parser.parse(torrentBytes);
+        } catch (com.turn.ttorrent.bcodec.InvalidBEncodingException e) {
+            // 将 InvalidBEncodingException 转换为 BDecodingException
+            throw new InvalidBEncodingException("Invalid B-encoding in .torrent file: " + e.getMessage());
+        } catch (RuntimeException e) {
+            // TorrentParser.parse 可能会包装 IOException 为 RuntimeException
+            if (e.getCause() instanceof IOException) {
+                throw (IOException) e.getCause();
+            }
+            throw e; // 重新抛出其他 RuntimeException
+        }
+
+        // 从 TorrentMetadata 对象中提取所需信息
+        String infoHash = metadata.getHexInfoHash(); // 获取十六进制表示的 info hash
+        String fileName = metadata.getDirectoryName(); // 获取洪流的名称（通常是目录名或单文件名）
+        long totalSize = 0;
+
+        // 计算总文件大小
+        // TorrentMetadata.getFiles() 返回 List<TorrentFile>
+        // TorrentFile 包含 size 字段
+        if (metadata.getFiles() != null && !metadata.getFiles().isEmpty()) {
+            for (com.turn.ttorrent.common.TorrentFile torrentFile : metadata.getFiles()) {
+                totalSize += torrentFile.size;
+            }
+        } else {
+            // 如果没有文件列表，可能是单文件模式，但 TorrentMetadata 接口没有直接提供总大小
+            // 在实际应用中，如果 TorrentMetadata 无法直接提供总大小，
+            // 并且 getFiles() 为空，可能需要回溯到原始的 BEValue 来获取 'length' 字段
+            // 但根据 TorrentMetadata 接口，getFiles() 应该能覆盖所有情况。
+            System.err.println("Warning: Could not determine total file size from TorrentMetadata.getFiles().");
+        }
+
+
+        // 构建并返回解析信息
+        return new TorrentParsedInfo(infoHash, fileName, totalSize);
+    }
+
+    /**
+     * 内部类，用于封装解析后的洪流信息。
+     */
+    public static class TorrentParsedInfo {
+        private final String infoHash;
+        private final String fileName;
+        private final long fileSize;
+
+        public TorrentParsedInfo(String infoHash, String fileName, long fileSize) {
+            this.infoHash = infoHash;
+            this.fileName = fileName;
+            this.fileSize = fileSize;
+        }
+
+        public String getInfoHash() {
+            return infoHash;
+        }
+
+        public String getFileName() {
+            return fileName;
+        }
+
+        public long getFileSize() {
+            return fileSize;
+        }
+    }
+}
\ No newline at end of file
diff --git a/backend/demo/src/main/resources/META-INF/additional-spring-configuration-metadata.json b/backend/demo/src/main/resources/META-INF/additional-spring-configuration-metadata.json
new file mode 100644
index 0000000..cf06b61
--- /dev/null
+++ b/backend/demo/src/main/resources/META-INF/additional-spring-configuration-metadata.json
@@ -0,0 +1,5 @@
+{"properties": [{
+  "name": "file.upload-dir",
+  "type": "java.lang.String",
+  "description": "Torrent dir for uploading'"
+}]}
\ No newline at end of file
diff --git a/backend/demo/src/main/resources/application.properties b/backend/demo/src/main/resources/application.properties
index 4472028..9bbb45b 100644
--- a/backend/demo/src/main/resources/application.properties
+++ b/backend/demo/src/main/resources/application.properties
@@ -1,5 +1,5 @@
 # ========== 数据源 ==========
-spring.datasource.url=jdbc:mysql://mysql:3306/mydatabase?serverTimezone=Asia/Shanghai
+spring.datasource.url=jdbc:mysql://mysql:3306/mydatabase?serverTimezone=Asia/Shanghai&createDatabaseIfNotExist=TRUE&useSSL=FALSE&allowPublicKeyRetrieval=TRUE
 spring.datasource.username=myuser
 spring.datasource.password=secret
 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
@@ -10,3 +10,6 @@
 
 # ========== 日志输出（可选） ==========
 logging.level.org.springframework.security=DEBUG
+
+file.upload-dir=./torrents
+
diff --git a/backend/demo/src/test/java/com/example/demo/controller/AuthControllerMockTest.java b/backend/demo/src/test/java/com/example/demo/controller/AuthControllerMockTest.java
new file mode 100644
index 0000000..fd98df3
--- /dev/null
+++ b/backend/demo/src/test/java/com/example/demo/controller/AuthControllerMockTest.java
@@ -0,0 +1,229 @@
+package com.example.demo.controller; // 请根据您的项目结构调整包名
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+import java.time.Instant;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks; // 注入 Mock 到被测试对象
+import org.mockito.Mock; // 标记为 Mock 对象
+import org.mockito.MockitoAnnotations; // 初始化 Mockito 注解
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.BadCredentialsException; // 模拟认证失败异常
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContext; // 模拟 SecurityContext
+import org.springframework.security.core.context.SecurityContextHolder; // 模拟 SecurityContextHolder
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.validation.BindingResult; // 模拟 BindingResult
+import org.springframework.validation.FieldError; // 模拟 FieldError
+
+import com.example.demo.dto.LoginRequestDTO;
+import com.example.demo.dto.LoginResponseDTO;
+import com.example.demo.entity.User;
+import com.example.demo.exception.AuthException;
+import com.example.demo.security.JwtTokenUtil;
+import com.example.demo.service.UserService;
+
+/**
+ * AuthController 的纯 Mock 测试类
+ * 不依赖 Spring 上下文或真实数据库
+ */
+public class AuthControllerMockTest {
+
+    // 使用 @Mock 注解标记需要模拟的依赖对象
+    @Mock
+    private UserService userService;
+
+    @Mock
+    private PasswordEncoder passwordEncoder; // 在 AuthController 中虽然注入了，但登录逻辑中未使用，这里依然模拟
+
+    @Mock
+    private JwtTokenUtil jwtTokenUtil;
+
+    @Mock
+    private AuthenticationManager authenticationManager;
+
+    @Mock
+    private BindingResult bindingResult; // 模拟请求体校验结果
+
+    @Mock
+    private SecurityContext securityContext; // 模拟 SecurityContext
+
+    // 使用 @InjectMocks 注解将上面 @Mock 标记的依赖注入到 AuthController 实例中
+    @InjectMocks
+    private AuthController authController;
+
+    /**
+     * 在每个测试方法执行前初始化 Mock 对象
+     */
+    @BeforeEach
+    void setUp() {
+        // 初始化所有 @Mock 注解标记的对象
+        MockitoAnnotations.openMocks(this);
+
+        // 模拟 SecurityContextHolder 的行为，使其返回我们模拟的 SecurityContext
+        // 这是为了让 SecurityContextHolder.getContext().setAuthentication() 调用时不会报错
+        when(securityContext.getAuthentication()).thenReturn(null); // 默认返回null
+        SecurityContextHolder.setContext(securityContext);
+    }
+
+    /**
+     * 测试用户登录成功场景
+     */
+    @Test
+    void testLoginSuccess() {
+        // --- 准备测试数据和模拟行为 ---
+
+        // 模拟 LoginRequestDTO
+        LoginRequestDTO loginRequest = new LoginRequestDTO();
+        loginRequest.setUsername("testuser");
+        loginRequest.setPassword("password123");
+
+        // 模拟 BindingResult 没有错误
+        when(bindingResult.hasErrors()).thenReturn(false);
+
+        // 模拟 AuthenticationManager 认证成功
+        // 创建一个模拟的 Authentication 对象
+        Authentication mockAuthentication = mock(Authentication.class);
+        // 模拟认证成功后，principal 返回 UserDetails (这里是 User 实体)
+        User mockUser = new User();
+        mockUser.setId(1L);
+        mockUser.setUsername("testuser");
+        mockUser.setRole("USER");
+        when(mockAuthentication.getPrincipal()).thenReturn(mockUser);
+
+        // 当调用 authenticationManager.authenticate() 时，返回模拟的认证对象
+        when(authenticationManager.authenticate(any(UsernamePasswordAuthenticationToken.class)))
+                .thenReturn(mockAuthentication);
+
+        // 模拟 UserService.generateLoginResponse 方法的返回值
+        LoginResponseDTO mockLoginResponse = new LoginResponseDTO();
+        mockLoginResponse.setToken("mocked_jwt_token");
+        mockLoginResponse.setExpiresAt(Instant.now().plusSeconds(3600));
+        mockLoginResponse.setUserId(mockUser.getId());
+        mockLoginResponse.setUsername(mockUser.getUsername());
+        mockLoginResponse.setRoles(Collections.singletonList(mockUser.getRole()));
+
+        when(userService.generateLoginResponse(mockUser)).thenReturn(mockLoginResponse);
+
+        // --- 执行被测试方法 ---
+        ResponseEntity<?> responseEntity = authController.login(loginRequest, bindingResult);
+
+        // --- 验证结果 ---
+
+        // 验证响应状态码是否为 200 OK
+        assertEquals(HttpStatus.OK, responseEntity.getStatusCode());
+
+        // 验证响应体是否是预期的 LoginResponseDTO
+        assertNotNull(responseEntity.getBody());
+        assertTrue(responseEntity.getBody() instanceof LoginResponseDTO);
+
+        LoginResponseDTO responseBody = (LoginResponseDTO) responseEntity.getBody();
+        assertEquals("mocked_jwt_token", responseBody.getToken());
+        assertEquals(mockUser.getId(), responseBody.getUserId());
+        assertEquals(mockUser.getUsername(), responseBody.getUsername());
+        assertEquals(Collections.singletonList(mockUser.getRole()), responseBody.getRoles());
+        assertNotNull(responseBody.getExpiresAt()); // 验证过期时间不为null
+
+        // 验证 Mock 依赖的方法是否被正确调用
+        verify(bindingResult).hasErrors(); // 验证是否检查了 BindingResult
+        verify(authenticationManager).authenticate(any(UsernamePasswordAuthenticationToken.class)); // 验证是否调用了认证管理器
+        verify(userService).generateLoginResponse(mockUser); // 验证是否调用了生成响应的方法
+        verify(securityContext).setAuthentication(mockAuthentication); // 验证认证对象是否设置到了 SecurityContext
+        verifyNoMoreInteractions(userService, passwordEncoder, jwtTokenUtil, authenticationManager); // 验证没有调用其他未预期的 Mock 方法
+    }
+
+    /**
+     * 测试用户登录失败场景：认证失败 (例如用户名或密码错误)
+     */
+    @Test
+    void testLoginFailureAuthentication() {
+        // --- 准备测试数据和模拟行为 ---
+
+        // 模拟 LoginRequestDTO
+        LoginRequestDTO loginRequest = new LoginRequestDTO();
+        loginRequest.setUsername("wronguser");
+        loginRequest.setPassword("wrongpassword");
+
+        // 模拟 BindingResult 没有错误
+        when(bindingResult.hasErrors()).thenReturn(false);
+
+        // 模拟 AuthenticationManager 认证失败，抛出 BadCredentialsException (Spring Security 认证失败的常见异常)
+        when(authenticationManager.authenticate(any(UsernamePasswordAuthenticationToken.class)))
+                .thenThrow(new BadCredentialsException("Bad credentials")); // 模拟认证失败
+
+        // --- 执行被测试方法并验证异常 ---
+        // 由于 AuthController 会捕获认证异常并抛出 AuthException，我们断言抛出了 AuthException
+        AuthException thrown = assertThrows(AuthException.class, () -> {
+            authController.login(loginRequest, bindingResult);
+        });
+
+        // 验证抛出的 AuthException 包含预期的错误信息
+        assertEquals("用户名或密码错误", thrown.getMessage());
+
+        // --- 验证 Mock 依赖的方法是否被正确调用 ---
+        verify(bindingResult).hasErrors(); // 验证是否检查了 BindingResult
+        verify(authenticationManager).authenticate(any(UsernamePasswordAuthenticationToken.class)); // 验证是否调用了认证管理器
+        verifyNoInteractions(userService); // 验证在认证失败时，没有调用 userService 的方法
+        verifyNoMoreInteractions(userService, passwordEncoder, jwtTokenUtil, authenticationManager); // 验证没有调用其他未预期的 Mock 方法
+        verify(securityContext, never()).setAuthentication(any()); // 验证认证对象没有设置到 SecurityContext
+    }
+
+    /**
+     * 测试请求参数校验失败场景
+     */
+    @Test
+    void testLoginFailureValidation() {
+        // --- 准备测试数据和模拟行为 ---
+
+        // 模拟 LoginRequestDTO (内容不重要，因为我们将模拟校验失败)
+        LoginRequestDTO loginRequest = new LoginRequestDTO();
+        loginRequest.setUsername("");
+        loginRequest.setPassword("");
+
+        // 模拟 BindingResult 有错误
+        when(bindingResult.hasErrors()).thenReturn(true);
+
+        // 模拟 BindingResult 返回的错误信息
+        FieldError usernameError = new FieldError("loginRequestDTO", "username", "用户名不能为空");
+        FieldError passwordError = new FieldError("loginRequestDTO", "password", "密码不能为空");
+        when(bindingResult.getFieldErrors()).thenReturn(List.of(usernameError, passwordError));
+
+
+        // --- 执行被测试方法 ---
+        ResponseEntity<?> responseEntity = authController.login(loginRequest, bindingResult);
+
+        // --- 验证结果 ---
+
+        // 验证响应状态码是否为 400 Bad Request
+        assertEquals(HttpStatus.BAD_REQUEST, responseEntity.getStatusCode());
+
+        // 验证响应体是否包含预期的错误信息 Map
+        assertNotNull(responseEntity.getBody());
+        assertTrue(responseEntity.getBody() instanceof java.util.Map);
+
+        @SuppressWarnings("unchecked")
+        java.util.Map<String, String> errorBody = (java.util.Map<String, String>) responseEntity.getBody();
+        assertTrue(errorBody.containsKey("error"));
+        // 可以进一步验证错误信息的具体内容，但这里只验证格式
+        // assertEquals("username: 用户名不能为空; password: 密码不能为空", errorBody.get("error")); // 如果您的错误信息拼接逻辑是这样
+
+        // --- 验证 Mock 依赖的方法是否被正确调用 ---
+        verify(bindingResult).hasErrors(); // 验证是否检查了 BindingResult
+        verify(bindingResult).getFieldErrors(); // 验证是否获取了字段错误
+        verifyNoInteractions(authenticationManager, userService, jwtTokenUtil, passwordEncoder); // 验证在校验失败时，没有调用认证、服务或 JWT 工具方法
+        verify(securityContext, never()).setAuthentication(any()); // 验证认证对象没有设置到 SecurityContext
+    }
+
+    // 您可以根据需要添加更多测试场景，例如：
+    // - 测试用户状态禁用时的行为 (如果您的 UserDetails 实现中 isEnabled() 会检查状态)
+    // - 测试不同角色返回时的 LoginResponseDTO 内容
+}
diff --git a/backend/demo/src/test/java/com/example/demo/controller/TorrentControllerTest.java b/backend/demo/src/test/java/com/example/demo/controller/TorrentControllerTest.java
new file mode 100644
index 0000000..e0f2c8d
--- /dev/null
+++ b/backend/demo/src/test/java/com/example/demo/controller/TorrentControllerTest.java
@@ -0,0 +1,228 @@
+package com.example.demo.controller;
+
+import java.io.IOException;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import static org.mockito.ArgumentMatchers.any;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import static org.mockito.Mockito.when;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.http.MediaType;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.test.web.servlet.MockMvc;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.multipart;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.example.demo.dto.TorrentInfoDTO;
+import com.example.demo.service.TorrentService;
+import com.turn.ttorrent.bcodec.InvalidBEncodingException;
+
+/**
+ * Unit tests for the {@link TorrentController} focusing on file upload.
+ * 使用 Mockito 和 MockMvc 对 TorrentController 的文件上传功能进行单元测试。
+ */
+@ExtendWith(MockitoExtension.class) // 使用 MockitoExtension 来初始化 mocks 和 injectMocks
+class TorrentControllerTest {
+
+    private MockMvc mockMvc; // MockMvc 用于模拟 HTTP 请求
+
+    @Mock // 创建 TorrentService 的 mock 对象
+    private TorrentService torrentService;
+
+    @InjectMocks // 创建 TorrentController 实例并注入 mock 的 TorrentService
+    private TorrentController torrentController;
+
+    @BeforeEach // 在每个测试方法执行前设置 MockMvc
+    void setUp() {
+        // 初始化 MockMvc，使用独立的设置，只测试 TorrentController
+        mockMvc = MockMvcBuilders.standaloneSetup(torrentController)
+                // 可以添加全局异常处理器等，如果控制器中定义了的话
+                // .setControllerAdvice(new GlobalExceptionHandler())
+                .build();
+        // 在这里可以设置 @Value("${file.upload-dir}") 的值，如果需要的话
+        // ReflectionTestUtils.setField(torrentController, "uploadDir", "test-upload-dir");
+    }
+
+    /**
+     * Test successful upload of a .torrent file.
+     * 测试成功上传 .torrent 文件的情况。
+     */
+    @Test
+    void uploadTorrent_Success() throws Exception {
+        // 1. 准备 mock 数据和行为 (Prepare mock data and behavior)
+        // 创建一个模拟的 MultipartFile
+        MockMultipartFile mockFile = new MockMultipartFile(
+                "file", // 参数名，必须与 @RequestParam("file") 一致 (Parameter name, must match @RequestParam("file"))
+                "test.torrent", // 原始文件名 (Original filename)
+                MediaType.APPLICATION_OCTET_STREAM_VALUE, // 文件类型 (File type)
+                "d8:announce39:http://tracker.example.com/announce4:info...".getBytes() // 模拟的 .torrent 文件内容 (Simulated .torrent file content)
+        );
+
+        // 创建预期的 TorrentInfoDTO 返回结果
+        TorrentInfoDTO expectedDto = new TorrentInfoDTO();
+        expectedDto.setFileName("test.torrent");
+        expectedDto.setInfoHash("mockInfoHash");
+        expectedDto.setMagnetUri("magnet:?xt=urn:btih:mockInfoHash");
+        expectedDto.setDownloadUrl("/api/downloads/mockInfoHash/test.torrent");
+        expectedDto.setMessage("文件上传成功。"); // Success message
+
+        // 当 torrentService.handleUpload 被调用时，返回预期的 DTO
+        // When torrentService.handleUpload is called, return the expected DTO
+        when(torrentService.handleUpload(any(MultipartFile.class))).thenReturn(expectedDto);
+
+        // 2. 执行请求并验证结果 (Execute the request and verify the results)
+        mockMvc.perform(multipart("/api/torrents") // 发送 POST 请求到 /api/torrents (Send POST request to /api/torrents)
+                        .file(mockFile) // 附加文件 (Attach the file)
+                        .contentType(MediaType.MULTIPART_FORM_DATA)) // 设置内容类型 (Set content type)
+                .andExpect(status().isOk()) // 验证 HTTP 状态码为 200 OK (Verify HTTP status code is 200 OK)
+                .andExpect(jsonPath("$.fileName").value("test.torrent")) // 验证返回 JSON 中的 fileName 字段 (Verify fileName field in the response JSON)
+                .andExpect(jsonPath("$.infoHash").value("mockInfoHash")) // 验证 infoHash 字段 (Verify infoHash field)
+                .andExpect(jsonPath("$.message").value("文件上传成功。")); // 验证 message 字段 (Verify message field)
+    }
+
+    /**
+     * Test uploading an empty file.
+     * 测试上传空文件的情况。
+     */
+    @Test
+    void uploadTorrent_EmptyFile() throws Exception {
+        MockMultipartFile emptyFile = new MockMultipartFile(
+                "file",
+                "empty.torrent",
+                MediaType.APPLICATION_OCTET_STREAM_VALUE,
+                new byte[0] // 空文件内容 (Empty file content)
+        );
+
+        mockMvc.perform(multipart("/api/torrents")
+                        .file(emptyFile)
+                        .contentType(MediaType.MULTIPART_FORM_DATA))
+                .andExpect(status().isBadRequest()) // 验证 HTTP 状态码为 400 Bad Request (Verify HTTP status code is 400 Bad Request)
+                .andExpect(jsonPath("$.message").value("上传文件不能为空。")); // 验证错误消息 (Verify error message)
+    }
+
+    /**
+     * Test uploading a file with an unsupported extension.
+     * 测试上传不支持的文件扩展名的情况。
+     */
+    @Test
+    void uploadTorrent_UnsupportedFileType() throws Exception {
+        MockMultipartFile wrongTypeFile = new MockMultipartFile(
+                "file",
+                "test.txt", // 非 .torrent 文件 (Not a .torrent file)
+                MediaType.TEXT_PLAIN_VALUE,
+                "This is not a torrent file.".getBytes()
+        );
+
+        mockMvc.perform(multipart("/api/torrents")
+                        .file(wrongTypeFile)
+                        .contentType(MediaType.MULTIPART_FORM_DATA))
+                .andExpect(status().isUnsupportedMediaType()) // 验证 HTTP 状态码为 415 Unsupported Media Type (Verify HTTP status code is 415 Unsupported Media Type)
+                .andExpect(jsonPath("$.message").value("只允许上传 .torrent 文件。")); // 验证错误消息 (Verify error message)
+    }
+
+    /**
+     * Test handling of InvalidBEncodingException from the service layer.
+     * 测试处理来自服务层的 InvalidBEncodingException。
+     */
+    @Test
+    void uploadTorrent_InvalidBEncodingException() throws Exception {
+        MockMultipartFile mockFile = new MockMultipartFile(
+                "file",
+                "invalid.torrent",
+                MediaType.APPLICATION_OCTET_STREAM_VALUE,
+                "invalid bencoding data".getBytes()
+        );
+
+        // 配置 torrentService.handleUpload 在被调用时抛出 InvalidBEncodingException
+        // Configure torrentService.handleUpload to throw InvalidBEncodingException when called
+        when(torrentService.handleUpload(any(MultipartFile.class)))
+                .thenThrow(new InvalidBEncodingException("Mocked BEncoding error"));
+
+        mockMvc.perform(multipart("/api/torrents")
+                        .file(mockFile)
+                        .contentType(MediaType.MULTIPART_FORM_DATA))
+                .andExpect(status().isBadRequest()) // 验证 HTTP 状态码为 400 Bad Request (Verify HTTP status code is 400 Bad Request)
+                .andExpect(jsonPath("$.message").value("文件解析失败，请确保它是有效的 .torrent 文件: Mocked BEncoding error")); // 验证错误消息 (Verify error message)
+    }
+
+    /**
+     * Test handling of IOException from the service layer.
+     * 测试处理来自服务层的 IOException。
+     */
+    @Test
+    void uploadTorrent_IOException() throws Exception {
+        MockMultipartFile mockFile = new MockMultipartFile(
+                "file",
+                "ioerror.torrent",
+                MediaType.APPLICATION_OCTET_STREAM_VALUE,
+                "d8:announce...".getBytes()
+        );
+
+        // 配置 torrentService.handleUpload 在被调用时抛出 IOException
+        // Configure torrentService.handleUpload to throw IOException when called
+        when(torrentService.handleUpload(any(MultipartFile.class)))
+                .thenThrow(new IOException("Mocked IO error"));
+
+        mockMvc.perform(multipart("/api/torrents")
+                        .file(mockFile)
+                        .contentType(MediaType.MULTIPART_FORM_DATA))
+                .andExpect(status().isInternalServerError()) // 验证 HTTP 状态码为 500 Internal Server Error (Verify HTTP status code is 500 Internal Server Error)
+                .andExpect(jsonPath("$.message").value("文件上传或保存失败: Mocked IO error")); // 验证错误消息 (Verify error message)
+    }
+
+    /**
+     * Test handling of a generic Exception from the service layer.
+     * 测试处理来自服务层的通用 Exception。
+     */
+    @Test
+    void uploadTorrent_GenericException() throws Exception {
+        MockMultipartFile mockFile = new MockMultipartFile(
+                "file",
+                "genericerror.torrent",
+                MediaType.APPLICATION_OCTET_STREAM_VALUE,
+                "d8:announce...".getBytes()
+        );
+
+        // 配置 torrentService.handleUpload 在被调用时抛出 RuntimeException
+        // Configure torrentService.handleUpload to throw RuntimeException when called
+        when(torrentService.handleUpload(any(MultipartFile.class)))
+                .thenThrow(new RuntimeException("Mocked generic error"));
+
+        mockMvc.perform(multipart("/api/torrents")
+                        .file(mockFile)
+                        .contentType(MediaType.MULTIPART_FORM_DATA))
+                .andExpect(status().isInternalServerError()) // 验证 HTTP 状态码为 500 Internal Server Error (Verify HTTP status code is 500 Internal Server Error)
+                .andExpect(jsonPath("$.message").value("文件上传过程中发生未知错误: Mocked generic error")); // 验证错误消息 (Verify error message)
+    }
+
+     /**
+     * Test handling of IllegalArgumentException from the service layer.
+     * 测试处理来自服务层的 IllegalArgumentException。
+     */
+    @Test
+    void uploadTorrent_IllegalArgumentExceptionFromService() throws Exception {
+        MockMultipartFile mockFile = new MockMultipartFile(
+                "file",
+                "illegalarg.torrent",
+                MediaType.APPLICATION_OCTET_STREAM_VALUE,
+                "d8:announce...".getBytes()
+        );
+
+        // 配置 torrentService.handleUpload 在被调用时抛出 IllegalArgumentException
+        // Configure torrentService.handleUpload to throw IllegalArgumentException when called
+        when(torrentService.handleUpload(any(MultipartFile.class)))
+                .thenThrow(new IllegalArgumentException("Mocked illegal argument from service"));
+
+        mockMvc.perform(multipart("/api/torrents")
+                        .file(mockFile)
+                        .contentType(MediaType.MULTIPART_FORM_DATA))
+                .andExpect(status().isBadRequest()) // 验证 HTTP 状态码为 400 Bad Request (Verify HTTP status code is 400 Bad Request)
+                .andExpect(jsonPath("$.message").value("处理文件时发生错误: Mocked illegal argument from service")); // 验证错误消息 (Verify error message)
+    }
+}
\ No newline at end of file
diff --git a/backend/demo/src/test/java/com/example/demo/security/JwtTokenUtilTest.java b/backend/demo/src/test/java/com/example/demo/security/JwtTokenUtilTest.java
new file mode 100644
index 0000000..e32e591
--- /dev/null
+++ b/backend/demo/src/test/java/com/example/demo/security/JwtTokenUtilTest.java
@@ -0,0 +1,281 @@
+package com.example.demo.security; // 请根据您的项目结构调整包名
+
+import java.nio.charset.StandardCharsets;
+import java.util.Date;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test; // Import MockitoSettings
+import org.junit.jupiter.api.extension.ExtendWith; // Import Strictness
+import org.mockito.Mock;
+import static org.mockito.Mockito.when;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import com.example.demo.config.JWTProperties;
+
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.ExpiredJwtException;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.SignatureAlgorithm;
+import io.jsonwebtoken.security.Keys;
+import io.jsonwebtoken.security.SignatureException;
+
+/**
+ * 单元测试 JwtTokenUtil，手动实例化并注入 Mock 依赖
+ */
+@ExtendWith(MockitoExtension.class)
+// Add this annotation to make stubbings in this test class lenient
+@MockitoSettings(strictness = Strictness.LENIENT)
+public class JwtTokenUtilTest {
+
+    @Mock
+    private JWTProperties jwtProperties;
+
+    private JwtTokenUtil jwtTokenUtil;
+
+    private byte[] testSecretBytes;
+    // Ensure secret key is long enough for HS256 (at least 32 bytes or 256 bits)
+    private final String testSecret = "ThisIsATestSecretKeyForMockingPurposesAndItNeedsToBeLongEnoughToMeetHS256Requirements";
+    private final long testExpirationMs = 3600000L; // 1 hour
+
+    /**
+     * Initialize Mock objects' behavior and test data before each test method.
+     * With @ExtendWith(MockitoExtension.class), mock objects are initialized
+     * before this method runs.
+     */
+    @BeforeEach
+    void setUp() {
+        // Stub JWTProperties to provide data before creating the instance
+        // Using lenient() or @MockitoSettings(strictness = Strictness.LENIENT)
+        // allows stubbings that are not used by every test method.
+        when(jwtProperties.getSecret()).thenReturn(testSecret);
+        when(jwtProperties.getExpirationMs()).thenReturn(testExpirationMs);
+        when(jwtProperties.getIssuer()).thenReturn("test-issuer");
+        when(jwtProperties.getAudience()).thenReturn("test-audience");
+        when(jwtProperties.getHeader()).thenReturn("Authorization");
+        when(jwtProperties.getTokenPrefix()).thenReturn("Bearer ");
+
+        // Create the instance to be tested, injecting the mocked properties
+        // This is done AFTER stubbing the necessary methods for the constructor.
+        jwtTokenUtil = new JwtTokenUtil(jwtProperties);
+
+        // Calculate testSecretBytes (used for manually parsing/building tokens in tests)
+        testSecretBytes = testSecret.getBytes(StandardCharsets.UTF_8);
+    }
+
+    @Test
+    void testGenerateToken() {
+        Long userId = 123L;
+        String username = "testuser";
+        String role = "USER";
+
+        String token = jwtTokenUtil.generateToken(userId, username, role);
+
+        assertNotNull(token);
+        assertFalse(token.isEmpty());
+
+        // Verify the generated token can be correctly parsed and contains expected Claims
+        Claims claims = Jwts.parserBuilder()
+                .setSigningKey(testSecretBytes) // Use the derived secret bytes
+                .build()
+                .parseClaimsJws(token)
+                .getBody();
+
+        assertEquals(username, claims.getSubject());
+        assertEquals("test-issuer", claims.getIssuer());
+        assertEquals("test-audience", claims.getAudience());
+        assertNotNull(claims.getIssuedAt());
+        assertNotNull(claims.getExpiration());
+        assertTrue(claims.getExpiration().getTime() > claims.getIssuedAt().getTime());
+        assertEquals(userId.intValue(), claims.get("userId", Integer.class));
+        assertEquals(role, claims.get("role", String.class));
+    }
+
+    @Test
+    void testParseClaimsValidToken() {
+        Long userId = 456L;
+        String username = "anotheruser";
+        String role = "ADMIN";
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String validToken = Jwts.builder()
+                .setSubject(username)
+                .setIssuer("test-issuer")
+                .setAudience("test-audience")
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .addClaims(Map.of("userId", userId, "role", role))
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        Claims claims = jwtTokenUtil.parseClaims(validToken);
+
+        assertNotNull(claims);
+        assertEquals(username, claims.getSubject());
+        assertEquals("test-issuer", claims.getIssuer());
+        assertEquals("test-audience", claims.getAudience());
+        assertEquals(userId.intValue(), claims.get("userId", Integer.class));
+        assertEquals(role, claims.get("role", String.class));
+    }
+
+    @Test
+    void testParseClaimsInvalidSignature() {
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String invalidToken = Jwts.builder()
+                .setSubject("someuser")
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                // Use a different secret key for signing
+                .signWith(Keys.hmacShaKeyFor("AnotherSecretKeyAnotherSecretKey".getBytes(StandardCharsets.UTF_8)), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertThrows(SignatureException.class, () -> jwtTokenUtil.parseClaims(invalidToken));
+    }
+
+    @Test
+    void testParseClaimsExpiredToken() {
+        // Create an expired token
+        Date past = new Date(System.currentTimeMillis() - testExpirationMs - 1000); // Expiration time is in the past
+        Date expiry = new Date(past.getTime() + 1000); // Expires shortly after being issued
+        String expiredToken = Jwts.builder()
+                .setSubject("expireduser")
+                .setIssuedAt(past)
+                .setExpiration(expiry)
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertThrows(ExpiredJwtException.class, () -> jwtTokenUtil.parseClaims(expiredToken));
+    }
+
+    @Test
+    void testValidateTokenValid() {
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String validToken = Jwts.builder()
+                .setSubject("validuser")
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .addClaims(Map.of("userId", 789L, "role", "GUEST"))
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertTrue(jwtTokenUtil.validateToken(validToken));
+    }
+
+    @Test
+    void testValidateTokenInvalidSignature() {
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String invalidToken = Jwts.builder()
+                .setSubject("invaliduser")
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .signWith(Keys.hmacShaKeyFor("AnotherSecretKeyAnotherSecretKey".getBytes(StandardCharsets.UTF_8)), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertFalse(jwtTokenUtil.validateToken(invalidToken));
+    }
+
+    @Test
+    void testValidateTokenExpired() {
+        Date past = new Date(System.currentTimeMillis() - testExpirationMs - 1000);
+        Date expiry = new Date(past.getTime() + 1000);
+        String expiredToken = Jwts.builder()
+                .setSubject("expireduser")
+                .setIssuedAt(past)
+                .setExpiration(expiry)
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertFalse(jwtTokenUtil.validateToken(expiredToken));
+    }
+
+    @Test
+    void testGetUsername() {
+        String username = "extractuser";
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String token = Jwts.builder()
+                .setSubject(username)
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertEquals(username, jwtTokenUtil.getUsername(token));
+    }
+
+    @Test
+    void testGetUserId() {
+        Long userId = 999L;
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String token = Jwts.builder()
+                .setSubject("someuser")
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .addClaims(Map.of("userId", userId))
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertEquals(userId, jwtTokenUtil.getUserId(token));
+    }
+
+    @Test
+    void testGetUserIdWhenClaimMissing() {
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String token = Jwts.builder()
+                .setSubject("userwithoutid")
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertNull(jwtTokenUtil.getUserId(token));
+    }
+
+    @Test
+    void testGetRole() {
+        String role = "MANAGER";
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String token = Jwts.builder()
+                .setSubject("someuser")
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .addClaims(Map.of("role", role))
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertEquals(role, jwtTokenUtil.getRole(token));
+    }
+
+    @Test
+    void testGetRoleWhenClaimMissing() {
+        Date now = new Date();
+        Date expiry = new Date(now.getTime() + testExpirationMs);
+        String token = Jwts.builder()
+                .setSubject("userwithoutrole")
+                .setIssuedAt(now)
+                .setExpiration(expiry)
+                .signWith(Keys.hmacShaKeyFor(testSecretBytes), SignatureAlgorithm.HS256)
+                .compact();
+
+        assertNull(jwtTokenUtil.getRole(token));
+    }
+
+    @Test
+    void testGetExpiration() {
+        assertEquals(testExpirationMs, jwtTokenUtil.getExpiration());
+    }
+}
diff --git a/backend/demo/src/test/java/com/example/demo/service/impl/TorrentServiceImplTest.java b/backend/demo/src/test/java/com/example/demo/service/impl/TorrentServiceImplTest.java
new file mode 100644
index 0000000..69eb5ba
--- /dev/null
+++ b/backend/demo/src/test/java/com/example/demo/service/impl/TorrentServiceImplTest.java
@@ -0,0 +1,462 @@
+// src/test/java/com/example/demo/service/impl/TorrentServiceImplTest.java
+package com.example.demo.service.impl;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.util.Comparator;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import static org.mockito.ArgumentMatchers.any;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import static org.mockito.Mockito.CALLS_REAL_METHODS;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.when;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.test.util.ReflectionTestUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.example.demo.dto.TorrentInfoDTO;
+import com.example.demo.entity.TorrentInfo;
+import com.example.demo.mapper.TorrentInfoMapper;
+import com.example.demo.util.TorrentUtils;
+import com.example.demo.util.TorrentUtils.TorrentParsedInfo;
+import com.turn.ttorrent.bcodec.InvalidBEncodingException;
+
+/**
+ * Test class for TorrentServiceImpl.
+ * Uses JUnit 5 and Mockito for unit testing.
+ */
+@ExtendWith(MockitoExtension.class) // Enables Mockito annotations for JUnit 5
+class TorrentServiceImplTest {
+
+    @Mock // Creates a mock instance of TorrentInfoMapper
+    private TorrentInfoMapper torrentInfoMapper;
+
+    // @InjectMocks injects the mocks into the TorrentServiceImpl instance
+    // It will try to inject 'torrentInfoMapper' into the constructor of TorrentServiceImpl
+    @InjectMocks
+    private TorrentServiceImpl torrentService;
+
+    // This field will be injected into the service using ReflectionTestUtils
+    private String uploadDir = "test_temp_upload_dir";
+
+    /**
+     * Setup method executed before each test.
+     * It injects the 'uploadDir' value and ensures the test directory is clean.
+     *
+     * @throws IOException if directory operations fail
+     */
+    @BeforeEach
+    void setUp() throws IOException {
+        // Inject the 'uploadDir' field into the torrentService instance.
+        // This simulates Spring's @Value injection for testing purposes.
+        ReflectionTestUtils.setField(torrentService, "uploadDir", uploadDir);
+
+        // Define the path for the temporary upload directory used in tests.
+        Path testUploadPath = Paths.get(uploadDir);
+
+        // Clean up the directory before each test to ensure a consistent state.
+        if (Files.exists(testUploadPath)) {
+            // Use try-with-resources for the stream to ensure it's closed
+            try (Stream<Path> walk = Files.walk(testUploadPath)) {
+                walk.sorted(Comparator.reverseOrder()) // Process deeper paths first
+                    .forEach(path -> {
+                        try {
+                            Files.delete(path); // Delete file or empty directory
+                        } catch (IOException e) {
+                            System.err.println("Failed to delete path " + path + ": " + e.getMessage());
+                            // In a real scenario, you might want to re-throw or handle more robustly
+                            // if cleanup failure is critical for subsequent tests.
+                        }
+                    });
+            } // Stream is closed here
+        }
+        // Always create the directory for the current test.
+        Files.createDirectories(testUploadPath);
+    }
+
+    /**
+     * Test case for successfully handling a new torrent file upload.
+     * Verifies parsing, file saving, database insertion, and DTO creation.
+     *
+     * @throws Exception if any unexpected error occurs during the test
+     */
+    @Test
+    @DisplayName("Should successfully handle a new torrent file upload")
+    void handleUpload_NewTorrent_Success() throws Exception {
+        // 1. Prepare a mock MultipartFile for input
+        MockMultipartFile mockFile = new MockMultipartFile(
+            "file", // parameter name
+            "example.torrent", // original filename
+            "application/x-bittorrent", // content type
+            "dummy torrent content".getBytes() // file content as bytes
+        );
+
+        // 2. Prepare mock data for TorrentUtils.TorrentParsedInfo result
+        String testInfoHash = "AABBCCDDEEFF11223344556677889900AABBCCDD";
+        String testFileName = "MyAwesomeMovie.mp4";
+        long testFileSize = 1024000L; // 1 MB
+
+        TorrentParsedInfo mockParsedInfo = new TorrentParsedInfo(
+            testInfoHash,
+            testFileName,
+            testFileSize
+        );
+
+        // Mock static method call for TorrentUtils.parseTorrentFile
+        // Mockito.mockStatic is used to mock static methods. It needs to be in a try-with-resources block.
+        try (MockedStatic<TorrentUtils> mockedTorrentUtils = Mockito.mockStatic(TorrentUtils.class)) {
+            // Define the behavior of the static method when called with any MultipartFile.
+            mockedTorrentUtils.when(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)))
+                              .thenReturn(mockParsedInfo);
+
+            // 3. Mock TorrentInfoMapper behavior
+            // Simulate that no existing torrent is found in the database for the given infoHash.
+            when(torrentInfoMapper.selectOne(any(QueryWrapper.class))).thenReturn(null);
+            // Simulate successful insertion into the database (insert method returns 1 for success).
+            when(torrentInfoMapper.insert(any(TorrentInfo.class))).thenReturn(1);
+
+            // 4. Call the service method under test
+            TorrentInfoDTO result = torrentService.handleUpload(mockFile);
+
+            // 5. Assertions: Verify the returned DTO and side effects
+
+            // Ensure the result DTO is not null.
+            assertNotNull(result, "Returned DTO should not be null");
+            // Verify that the DTO contains the correct parsed information.
+            assertEquals(testFileName, result.getFileName(), "File name in DTO should match parsed info");
+            assertEquals(testFileSize, result.getFileSize(), "File size in DTO should match parsed info");
+            assertEquals(testInfoHash, result.getInfoHash(), "Info hash in DTO should match parsed info");
+            // Verify that magnet URI and download URL are correctly formatted and contain the info hash.
+            assertTrue(result.getMagnetUri().contains(testInfoHash), "Magnet URI should contain info hash");
+            assertTrue(result.getDownloadUrl().contains(testInfoHash), "Download URL should contain info hash");
+            // Verify the success message.
+            assertEquals("Torrent uploaded and processed successfully!", result.getMessage(), "Success message should be present");
+
+            // Verify interactions with mocks
+            // Verify that selectOne was called exactly once with any QueryWrapper.
+            verify(torrentInfoMapper, times(1)).selectOne(any(QueryWrapper.class));
+            // Verify that insert was called exactly once with any TorrentInfo object.
+            verify(torrentInfoMapper, times(1)).insert(any(TorrentInfo.class));
+            // Verify that TorrentUtils.parseTorrentFile was called exactly once.
+            mockedTorrentUtils.verify(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)), times(1));
+
+            // Verify file was saved to the correct location on disk
+            Path expectedFilePath = Paths.get(uploadDir, testInfoHash + ".torrent");
+            assertTrue(Files.exists(expectedFilePath), "Torrent file should be saved to disk");
+            // Optionally, verify the content of the saved file if needed
+            // assertEquals("dummy torrent content", new String(Files.readAllBytes(expectedFilePath)));
+        }
+    }
+
+    /**
+     * Test case for handling a torrent file that already exists in the database.
+     * Verifies that existing information is returned and no new file is saved or DB entry created.
+     *
+     * @throws Exception if any unexpected error occurs during the test
+     */
+    @Test
+    @DisplayName("Should return existing info if torrent already exists")
+    void handleUpload_ExistingTorrent_ReturnsExistingInfo() throws Exception {
+        // 1. Prepare a mock MultipartFile for input (content doesn't matter much here)
+        MockMultipartFile mockFile = new MockMultipartFile(
+            "file",
+            "existing.torrent",
+            "application/x-bittorrent",
+            "some content".getBytes()
+        );
+
+        // 2. Prepare mock data for TorrentUtils.TorrentParsedInfo result
+        String existingInfoHash = "EXISTINGHASH11223344556677889900EXISTINGHASH";
+        String existingFileName = "ExistingMovie.mkv";
+        long existingFileSize = 5000000L; // 5 MB
+
+        TorrentParsedInfo mockParsedInfo = new TorrentParsedInfo(
+            existingInfoHash,
+            existingFileName,
+            existingFileSize
+        );
+
+        // 3. Prepare an existing TorrentInfo entity that would be returned by the mapper
+        TorrentInfo existingTorrentInDb = new TorrentInfo(
+            existingInfoHash,
+            existingFileName,
+            existingFileSize,
+            "magnet:?xt=urn:btih:" + existingInfoHash + "&dn=" + existingFileName,
+            "/api/downloads/" + existingInfoHash + "/" + existingFileName
+        );
+        existingTorrentInDb.setId(1L); // Simulate an ID from the database
+        existingTorrentInDb.setUploadTime(LocalDateTime.now().minusDays(1)); // Simulate an existing upload time
+
+        // Mock static method call for TorrentUtils.parseTorrentFile
+        try (MockedStatic<TorrentUtils> mockedTorrentUtils = Mockito.mockStatic(TorrentUtils.class)) {
+            mockedTorrentUtils.when(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)))
+                              .thenReturn(mockParsedInfo);
+
+            // 4. Mock TorrentInfoMapper behavior: Simulate that the torrent DOES exist
+            when(torrentInfoMapper.selectOne(any(QueryWrapper.class))).thenReturn(existingTorrentInDb);
+
+            // 5. Call the service method
+            TorrentInfoDTO result = torrentService.handleUpload(mockFile);
+
+            // 6. Assertions
+            assertNotNull(result, "Returned DTO should not be null");
+            // Verify that the DTO contains the information from the existing DB entry.
+            assertEquals(existingFileName, result.getFileName(), "File name should match existing DB entry");
+            assertEquals(existingFileSize, result.getFileSize(), "File size should match existing DB entry");
+            assertEquals(existingInfoHash, result.getInfoHash(), "Info hash should match existing DB entry");
+            assertEquals(existingTorrentInDb.getMagnetUri(), result.getMagnetUri(), "Magnet URI should match existing DB entry");
+            assertEquals(existingTorrentInDb.getDownloadUrl(), result.getDownloadUrl(), "Download URL should match existing DB entry");
+            // Verify the specific message for existing torrents.
+            assertEquals("该洪流已存在，返回现有信息。", result.getMessage(), "Message should indicate existing torrent");
+
+            // Verify interactions with mocks
+            // selectOne should be called once to check for existence.
+            verify(torrentInfoMapper, times(1)).selectOne(any(QueryWrapper.class));
+            // insert should NOT be called because the torrent already exists.
+            verify(torrentInfoMapper, never()).insert(any(TorrentInfo.class));
+            // TorrentUtils.parseTorrentFile should still be called once to get the info hash.
+            mockedTorrentUtils.verify(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)), times(1));
+
+            // Verify that no new file was saved to disk
+            Path expectedFilePath = Paths.get(uploadDir, existingInfoHash + ".torrent");
+            assertFalse(Files.exists(expectedFilePath), "Torrent file should NOT be saved to disk if already exists");
+        }
+    }
+
+    /**
+     * Test case for uploading an empty MultipartFile.
+     * Expects an IllegalArgumentException.
+     */
+    @Test
+    @DisplayName("Should throw IllegalArgumentException for empty file upload")
+    void handleUpload_EmptyFile_ThrowsIllegalArgumentException() {
+        // Prepare an empty mock MultipartFile
+        MockMultipartFile emptyFile = new MockMultipartFile(
+            "file",
+            "empty.torrent",
+            "application/x-bittorrent",
+            new byte[0] // Empty content
+        );
+
+        // Assert that calling handleUpload with an empty file throws IllegalArgumentException.
+        IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
+            torrentService.handleUpload(emptyFile);
+        }, "Should throw IllegalArgumentException for empty file");
+
+        // Verify the error message.
+        assertEquals("上传文件不能为空。", thrown.getMessage(), "Error message should indicate empty file");
+
+        // Verify no interactions with mocks (as the check happens early)
+        verifyNoInteractions(torrentInfoMapper);
+        // We don't need to mock TorrentUtils here as the check happens before its call.
+    }
+
+    /**
+     * Test case for when TorrentUtils.parseTorrentFile throws InvalidBEncodingException.
+     * Expects an IllegalArgumentException with a specific message.
+     *
+     * @throws IOException if an unexpected IO error occurs
+     */
+    @Test
+    @DisplayName("Should throw IllegalArgumentException when TorrentUtils throws InvalidBEncodingException")
+    void handleUpload_InvalidBEncoding_ThrowsIllegalArgumentException() throws IOException {
+        MockMultipartFile mockFile = new MockMultipartFile(
+            "file",
+            "corrupt.torrent",
+            "application/x-bittorrent",
+            "corrupt content".getBytes()
+        );
+
+        // Mock static method call for TorrentUtils.parseTorrentFile to throw InvalidBEncodingException
+        try (MockedStatic<TorrentUtils> mockedTorrentUtils = Mockito.mockStatic(TorrentUtils.class)) {
+            mockedTorrentUtils.when(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)))
+                              .thenThrow(new InvalidBEncodingException("Malformed B-encoded data"));
+
+            // Assert that calling handleUpload throws IllegalArgumentException.
+            IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, () -> {
+                torrentService.handleUpload(mockFile);
+            }, "Should throw IllegalArgumentException for invalid B-encoding");
+
+            // Verify the error message.
+            assertTrue(thrown.getMessage().contains("无法解析 .torrent 文件，文件格式不正确"), "Error message should indicate invalid format");
+            assertTrue(thrown.getCause() instanceof InvalidBEncodingException, "Cause should be InvalidBEncodingException");
+
+            // Verify interactions
+            verifyNoInteractions(torrentInfoMapper); // No DB interaction if parsing fails
+            mockedTorrentUtils.verify(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)), times(1));
+        }
+    }
+
+    /**
+     * Test case for when TorrentUtils.parseTorrentFile throws IOException during file reading.
+     * Expects an IOException.
+     */
+    @Test
+    @DisplayName("Should throw IOException when TorrentUtils throws IOException during parsing")
+    void handleUpload_IOExceptionDuringParsing_ThrowsIOException() {
+        // Prepare a basic mock file. Only isEmpty() is relevant here before parsing.
+        MockMultipartFile mockFile = new MockMultipartFile(
+            "file",
+            "error.torrent",
+            "application/x-bittorrent",
+            "dummy content".getBytes() // Content doesn't matter as parsing is mocked to fail immediately
+        );
+
+        // Mock static method call for TorrentUtils.parseTorrentFile to throw IOException
+        try (MockedStatic<TorrentUtils> mockedTorrentUtils = Mockito.mockStatic(TorrentUtils.class)) {
+            mockedTorrentUtils.when(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)))
+                              .thenThrow(new IOException("Simulated parsing IO error"));
+
+            // Assert that calling handleUpload throws IOException.
+            IOException thrown = assertThrows(IOException.class, () -> {
+                torrentService.handleUpload(mockFile);
+            }, "Should throw IOException for parsing IO error");
+
+            // Verify the error message.
+            assertTrue(thrown.getMessage().contains("读取上传文件失败"), "Error message should indicate file read failure");
+            assertTrue(thrown.getCause() instanceof IOException, "Cause should be IOException");
+
+            // Verify interactions
+            verifyNoInteractions(torrentInfoMapper); // No DB interaction if parsing fails
+            mockedTorrentUtils.verify(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)), times(1));
+        }
+    }
+
+    /**
+     * Test case for when file saving to disk fails (IOException).
+     * Verifies that an IOException is thrown and database operations are not committed.
+     *
+     * @throws Exception if any unexpected error occurs during the test
+     */
+    @Test
+    @DisplayName("Should throw IOException when file saving to disk fails")
+    void handleUpload_FileSaveFails_ThrowsIOException() throws Exception {
+        MockMultipartFile mockFile = new MockMultipartFile(
+            "file",
+            "save_fail.torrent",
+            "application/x-bittorrent",
+            "content".getBytes()
+        );
+
+        String testInfoHash = "FAILHASH11223344556677889900FAILHASH";
+        String testFileName = "FailSave.txt";
+        long testFileSize = 500L;
+
+        TorrentParsedInfo mockParsedInfo = new TorrentParsedInfo(
+            testInfoHash,
+            testFileName,
+            testFileSize
+        );
+
+        // Use MockedStatic for Files.copy to simulate IO failure
+        try (MockedStatic<TorrentUtils> mockedTorrentUtils = Mockito.mockStatic(TorrentUtils.class);
+             MockedStatic<Files> mockedFiles = Mockito.mockStatic(Files.class, CALLS_REAL_METHODS)) { // CALLS_REAL_METHODS allows other Files methods to work normally
+
+            // Mock TorrentUtils.parseTorrentFile
+            mockedTorrentUtils.when(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)))
+                              .thenReturn(mockParsedInfo);
+
+            // Mock torrentInfoMapper.selectOne
+            when(torrentInfoMapper.selectOne(any(QueryWrapper.class))).thenReturn(null);
+
+            // Mock Files.copy to throw IOException when called with any InputStream and Path
+            // Note: mockFile.getInputStream() returns a ByteArrayInputStream
+            mockedFiles.when(() -> Files.copy(any(ByteArrayInputStream.class), any(Path.class)))
+                       .thenThrow(new IOException("Simulated file copy error"));
+
+            // Now, call the service method
+            IOException thrown = assertThrows(IOException.class, () -> {
+                torrentService.handleUpload(mockFile);
+            }, "Should throw IOException when file saving fails");
+
+            assertTrue(thrown.getMessage().contains("无法保存 .torrent 文件到磁盘"), "Error message should indicate file save failure");
+
+            // Verify interactions
+            verify(torrentInfoMapper, times(1)).selectOne(any(QueryWrapper.class));
+            // insert should NOT be called if file saving fails (due to @Transactional rollback)
+            verify(torrentInfoMapper, never()).insert(any(TorrentInfo.class));
+            mockedTorrentUtils.verify(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)), times(1));
+            mockedFiles.verify(() -> Files.copy(any(ByteArrayInputStream.class), any(Path.class)), times(1));
+
+            // No need to check Files.exists as we mocked the copy operation.
+        }
+    }
+
+    /**
+     * Test case for when the database insert operation fails (e.g., returns 0 rows affected).
+     * Expects a RuntimeException.
+     *
+     * @throws Exception if any unexpected error occurs during the test
+     */
+    @Test
+    @DisplayName("Should throw RuntimeException when database insert fails")
+    void handleUpload_DatabaseInsertFails_ThrowsRuntimeException() throws Exception {
+        MockMultipartFile mockFile = new MockMultipartFile(
+            "file",
+            "db_fail.torrent",
+            "application/x-bittorrent",
+            "db content".getBytes()
+        );
+
+        String testInfoHash = "DBFAILHASH11223344556677889900DBFAIL";
+        String testFileName = "DBFail.txt";
+        long testFileSize = 700L;
+
+        TorrentParsedInfo mockParsedInfo = new TorrentParsedInfo(
+            testInfoHash,
+            testFileName,
+            testFileSize
+        );
+
+        try (MockedStatic<TorrentUtils> mockedTorrentUtils = Mockito.mockStatic(TorrentUtils.class)) {
+            mockedTorrentUtils.when(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)))
+                              .thenReturn(mockParsedInfo);
+
+            when(torrentInfoMapper.selectOne(any(QueryWrapper.class))).thenReturn(null);
+            // Simulate database insert failure (insert method returns 0 rows affected).
+            when(torrentInfoMapper.insert(any(TorrentInfo.class))).thenReturn(0);
+
+            // Assert that calling handleUpload throws RuntimeException.
+            RuntimeException thrown = assertThrows(RuntimeException.class, () -> {
+                torrentService.handleUpload(mockFile);
+            }, "Should throw RuntimeException when DB insert fails");
+
+            // Verify the error message.
+            assertEquals("保存洪流信息到数据库失败。", thrown.getMessage(), "Error message should indicate DB insert failure");
+
+            // Verify interactions
+            verify(torrentInfoMapper, times(1)).selectOne(any(QueryWrapper.class));
+            verify(torrentInfoMapper, times(1)).insert(any(TorrentInfo.class));
+            mockedTorrentUtils.verify(() -> TorrentUtils.parseTorrentFile(any(MultipartFile.class)), times(1));
+
+            // Verify that the file was saved (as the DB failure happens after file saving)
+            Path expectedFilePath = Paths.get(uploadDir, testInfoHash + ".torrent");
+            assertTrue(Files.exists(expectedFilePath), "Torrent file should be saved even if DB insert fails (before rollback)");
+            // In a real scenario with @Transactional, the file save might also be rolled back
+            // if the file system operation was part of a transactional resource, but typically it's not.
+            // Here, we verify the file exists as the exception occurs AFTER file saving.
+        }
+    }
+}
\ No newline at end of file
diff --git a/backend/demo/src/test/java/com/example/demo/util/TorrentByteReader.java b/backend/demo/src/test/java/com/example/demo/util/TorrentByteReader.java
new file mode 100644
index 0000000..c6bacbb
--- /dev/null
+++ b/backend/demo/src/test/java/com/example/demo/util/TorrentByteReader.java
@@ -0,0 +1,72 @@
+// src/main/java/com/example/demo/util/TorrentByteReader.java
+package com.example.demo.util;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import com.turn.ttorrent.common.TorrentMetadata;
+import com.turn.ttorrent.common.TorrentParser;
+
+public class TorrentByteReader {
+
+    public static void main(String[] args) {
+        // TODO: 请将此处替换为您真实的单个 .torrent 文件路径
+        String torrentFilePathString = "C:\\Users\\Acer\\Desktop\\复杂度的渐近表示.pdf.torrent";
+        // 示例：String torrentFilePathString = "/home/user/torrents/my_single_file.torrent";
+
+        Path torrentFilePath = Paths.get(torrentFilePathString);
+
+        try {
+            // 读取 .torrent 文件的所有字节
+            byte[] torrentBytes = Files.readAllBytes(torrentFilePath);
+
+            // 使用 ttorrent 库解析 .torrent 文件，获取 infoHash、文件名和文件大小
+            TorrentParser parser = new TorrentParser();
+            TorrentMetadata metadata = parser.parseFromFile(new File(torrentFilePathString));
+
+            String infoHash = metadata.getHexInfoHash();
+            String fileName = metadata.getDirectoryName(); // 对于单文件，通常是文件名
+            long fileSize = metadata.getFiles().stream().mapToLong(f -> f.size).sum();
+
+            System.out.println("=====================================================================");
+            System.out.println("请将以下数据复制并粘贴到您的测试文件中的相应 TODO 位置：");
+            System.out.println("=====================================================================");
+
+            System.out.println("\n// REAL_SINGLE_FILE_TORRENT_BYTES:");
+            System.out.print("public static final byte[] REAL_SINGLE_FILE_TORRENT_BYTES = {");
+            for (int i = 0; i < torrentBytes.length; i++) {
+                System.out.printf("(byte)0x%02X", torrentBytes[i]);
+                if (i < torrentBytes.length - 1) {
+                    System.out.print(", ");
+                    if ((i + 1) % 16 == 0) { // 每 16 个字节换行，提高可读性
+                        System.out.print("\n    ");
+                    }
+                }
+            }
+            System.out.println("};");
+
+            System.out.println("\n// REAL_SINGLE_FILE_INFO_HASH:");
+            System.out.printf("public static final String REAL_SINGLE_FILE_INFO_HASH = \"%s\";%n", infoHash);
+
+            System.out.println("\n// REAL_SINGLE_FILE_NAME:");
+            System.out.printf("public static final String REAL_SINGLE_FILE_NAME = \"%s\";%n", fileName);
+
+            System.out.println("\n// REAL_SINGLE_FILE_SIZE:");
+            System.out.printf("public static final long REAL_SINGLE_FILE_SIZE = %dL;%n", fileSize);
+
+            System.out.println("\n=====================================================================");
+            System.out.println("请确保您填充的数据与您实际的 .torrent 文件内容完全匹配。");
+            System.out.println("=====================================================================");
+
+        } catch (IOException e) {
+            System.err.println("读取文件失败，请检查文件路径和权限: " + e.getMessage());
+            e.printStackTrace();
+        } catch (Exception e) { // 捕获 ttorrent 解析可能抛出的异常
+            System.err.println("解析 .torrent 文件失败: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+}
\ No newline at end of file