diff --git a/src/main/java/com/example/myproject/MyProjectApplication.java b/src/main/java/com/example/myproject/MyProjectApplication.java
index 49cd5f0..eb58082 100644
--- a/src/main/java/com/example/myproject/MyProjectApplication.java
+++ b/src/main/java/com/example/myproject/MyProjectApplication.java
@@ -5,10 +5,14 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 
+
+
 @SpringBootApplication
 @MapperScan("com.example.myproject.mapper")  // 扫描 Mapper 接口
+
 public class MyProjectApplication {
     public static void main(String[] args) {
         SpringApplication.run(MyProjectApplication.class, args);
     }
 }
+
diff --git a/src/main/java/com/example/myproject/controller/CommentController.java b/src/main/java/com/example/myproject/controller/CommentController.java
deleted file mode 100644
index f8eb135..0000000
--- a/src/main/java/com/example/myproject/controller/CommentController.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.entity.Comments;
-import com.example.myproject.service.CommentService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.List;
-import java.util.Map;
-
-@RestController
-@RequestMapping("/echo/forum/posts")
-public class CommentController {
-
-    @Autowired
-    private CommentService commentService;
-
-    // 添加评论
-    @PostMapping("/{post_id}/comments")
-    public String addComment(@PathVariable("post_id") Long postId, @RequestBody Comments comment) {
-        // 添加评论
-        commentService.addComment(postId, comment);
-        return "Comment added successfully!";
-    }
-
-    //获取所有评论
-    @GetMapping("/{post_id}/getAllComments")
-    public List<Map<String, Object>> getCommentsByPostId(@PathVariable("post_id") Long postId) {
-        // 获取评论并填充用户信息
-        return commentService.getCommentsByPostId(postId);
-    }
-
-}
diff --git a/src/main/java/com/example/myproject/controller/DynamicController.java b/src/main/java/com/example/myproject/controller/DynamicController.java
deleted file mode 100644
index db1d0a2..0000000
--- a/src/main/java/com/example/myproject/controller/DynamicController.java
+++ /dev/null
@@ -1,107 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.entity.UserDynamic;
-import com.example.myproject.service.DynamicService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-
-import java.util.List;
-import java.util.Map;
-
-@RestController
-@RequestMapping("/echo/dynamic")
-public class DynamicController {
-
-    @Autowired
-    private DynamicService dynamicService;
-
-    // 创建好友动态接口
-    @PostMapping("/{user_id}/createDynamic")
-    public Map<String, Object> createDynamic(@PathVariable("user_id") Long userId,
-                                             @RequestParam(value = "title", required = false) String title,
-                                             @RequestParam(value = "content") String content,
-                                             @RequestParam(value = "image_url", required = false) MultipartFile[] imageFiles) {
-        return dynamicService.createDynamic(userId, title, content, imageFiles);
-    }
-
-    //删除好友动态
-    @DeleteMapping("/me/deleteDynamic/{dynamic_id}")
-    public ResponseEntity<String> deleteDynamic(@PathVariable("dynamic_id") Long dynamicId) {
-        dynamicService.deleteDynamic(dynamicId);
-        return ResponseEntity.ok("动态删除成功");
-    }
-
-    //好友动态评论
-    @PostMapping("/{user_id}/feeds/{dynamic_id}/comments")
-    public ResponseEntity<Map<String, Object>> addComment(
-            @PathVariable("user_id") Long userId,
-            @PathVariable("dynamic_id") Long dynamicId,
-            @RequestBody Map<String, String> content) {
-
-        String commentContent = content.get("content");  // 获取评论内容
-        Map<String, Object> response = dynamicService.addComment(userId, dynamicId, commentContent);
-
-        return ResponseEntity.ok(response);
-    }
-
-    //获取某个好友的所有动态
-    @GetMapping("/{user_id}/getAdynamic")
-    public ResponseEntity<Map<String, Object>> getAllUserDynamics(@PathVariable("user_id") Long userId) {
-        Map<String, Object> response = dynamicService.getAllUserDynamics(userId);
-
-        if (response == null || response.isEmpty()) {
-            return ResponseEntity.noContent().build();
-        }
-
-        // 返回响应
-        return ResponseEntity.ok(response);
-    }
-
-    @GetMapping("/{user_id}/getAllDynamics")
-    public ResponseEntity<Map<String, Object>> getAllUserAndFriendsDynamics(@PathVariable("user_id") Long userId) {
-        // 获取当前用户所有好友的ID
-        List<Long> friendIds = dynamicService.getAllFriendIds(userId);
-        friendIds.add(userId);
-        Map<String, Object> response = dynamicService.getAllUserAndFriendsDynamics(friendIds);
-
-        if (response == null || response.isEmpty()) {
-            return ResponseEntity.noContent().build();
-        }
-
-        return ResponseEntity.ok(response);
-    }
-
-    //点赞好友动态
-    @PostMapping("/like")
-    public ResponseEntity<String> likeDynamic(@RequestBody Map<String, Long> request) {
-        Long userId = request.get("userId");
-        Long dynamicId = request.get("dynamicId");
-        // 执行点赞
-        boolean success = dynamicService.likeDynamic(userId, dynamicId);
-
-        if (success) {
-            return ResponseEntity.ok("Like successful");
-        } else {
-            return ResponseEntity.badRequest().body("Like failed");
-        }
-    }
-
-    @DeleteMapping("/unlike")
-    public ResponseEntity<String> unlikeDynamic(@RequestBody Map<String, Long> request) {
-        Long userId = request.get("userId");
-        Long dynamicId = request.get("dynamicId");
-
-        // 执行取消点赞
-        boolean success = dynamicService.unlikeDynamic(userId, dynamicId);
-
-        if (success) {
-            return ResponseEntity.ok("Unlike successful");
-        } else {
-            return ResponseEntity.badRequest().body("Unlike failed");
-        }
-    }
-
-
-}
diff --git a/src/main/java/com/example/myproject/controller/GroupController.java b/src/main/java/com/example/myproject/controller/GroupController.java
deleted file mode 100644
index a0830b6..0000000
--- a/src/main/java/com/example/myproject/controller/GroupController.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.entity.Group;
-import com.example.myproject.entity.GroupComments;
-import com.example.myproject.service.GroupService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@RestController
-@RequestMapping("/echo/groups")
-public class GroupController {
-
-    @Autowired
-    private GroupService groupService;
-
-    @PostMapping("/createGroup")
-    public ResponseEntity<Map<String, Object>> createGroup(@RequestBody Group groupRequest) {
-        // 调用服务层方法创建小组
-        System.out.println("Received group name: " + groupRequest.getGroupName());
-        return groupService.createGroup(groupRequest);
-    }
-
-
-    // 加入小组接口
-    @PostMapping("/{group_id}/join")
-    public ResponseEntity<Map<String, Object>> joinGroup(@PathVariable("group_id") Long groupId,
-                                                         @RequestBody Map<String, Long> requestBody) {
-        Long userId = requestBody.get("user_id");
-        return groupService.joinGroup(groupId, userId);
-    }
-
-    // 退出小组接口
-    @PostMapping("/{group_id}/leave")
-    public ResponseEntity<Map<String, Object>> leaveGroup(@PathVariable("group_id") Long groupId,
-                                                          @RequestBody Map<String, Long> requestBody) {
-        Long userId = requestBody.get("user_id");
-        return groupService.leaveGroup(groupId, userId);
-    }
-
-    // 获取小组成员接口
-    @GetMapping("/{group_id}/members")
-    public ResponseEntity<Map<String, Object>> getGroupMembers(@PathVariable("group_id") Long groupId) {
-        return groupService.getGroupMembers(groupId);
-    }
-
-    //发布帖子
-    @PostMapping("/{group_id}/createPost")
-    public ResponseEntity<Map<String, Object>> createPost(
-            @PathVariable("group_id") Long groupId,
-            @RequestParam("user_id") Long userId,
-            @RequestParam("content") String content,
-            @RequestParam("title") String title,
-            @RequestParam(value = "images", required = false) MultipartFile[] imageFiles) {
-
-        Map<String, Object> response = groupService.createPost(groupId, userId, content, title, imageFiles);
-        return ResponseEntity.ok(response);
-    }
-
-    //获取某个小组内的所有帖子
-    @GetMapping("/{group_id}/getAllPosts")
-    public ResponseEntity<Map<String, Object>> getAllPosts(@PathVariable("group_id") Long groupId) {
-        Map<String, Object> response = groupService.getAllPosts(groupId);
-        return ResponseEntity.ok(response);
-    }
-
-    //获取所有小组名称
-    @PostMapping("/getAllGroups")
-    public ResponseEntity<Map<String, Object>> searchGroups(@RequestBody Map<String, Object> params) {
-        Map<String, Object> response = groupService.searchGroups(params);
-        return ResponseEntity.ok(response);
-    }
-
-    // 点赞帖子
-    @PostMapping("/{group_post_id}/like")
-    public ResponseEntity<Map<String, Object>> likePost(
-            @PathVariable("group_post_id") Long groupPostId) {
-        Map<String, Object> response = groupService.likePost(groupPostId);
-        return ResponseEntity.ok(response);
-    }
-
-    // 取消点赞
-    @PostMapping("/{group_post_id}/unlike")
-    public ResponseEntity<Map<String, Object>> unlikePost(
-            @PathVariable("group_post_id") Long groupPostId) {
-        Map<String, Object> response = groupService.unlikePost(groupPostId);
-        return ResponseEntity.ok(response);
-    }
-
-    // 添加评论接口
-    @PostMapping("/{group_post_id}/comment")
-    public ResponseEntity<Map<String, Object>> addComment(
-
-            @PathVariable("group_post_id") Long postId,
-            @RequestBody GroupComments comment) {
-
-        Map<String, Object> response = groupService.addComment(postId, comment);
-        return ResponseEntity.ok(response);
-    }
-
-}
diff --git a/src/main/java/com/example/myproject/controller/LevelController.java b/src/main/java/com/example/myproject/controller/LevelController.java
deleted file mode 100644
index 8781246..0000000
--- a/src/main/java/com/example/myproject/controller/LevelController.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.service.LevelService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.Map;
-
-@RequestMapping("/echo/level")
-@RestController
-public class LevelController {
-
-    @Autowired
-    private LevelService levelService;
-
-    @GetMapping("/getExperience")
-    public Map<String, Object> getExperience(@RequestParam Long user_id) {
-        return levelService.getUserExperience(user_id);
-    }
-
-    @PostMapping("/updateExperience")
-    public Map<String, Object> updateExperience(@RequestBody Map<String, Object> params) {
-        Long userId = Long.valueOf(params.get("user_id").toString());
-        Integer experience = Integer.valueOf(params.get("experience").toString());
-        String source = params.get("source").toString();
-
-        return levelService.updateExperience(userId, experience, source);
-    }
-
-    // 检查用户是否满足升级条件
-    @GetMapping("/upgrade-check")
-    public Map<String, Object> checkUpgrade(@RequestParam Long user_id) {
-        return levelService.checkUpgrade(user_id);
-    }
-
-    @PostMapping("/upgrades")
-    public Map<String, Object> upgradeUserLevel(@RequestBody Map<String, Object> request) {
-        Long userId = Long.valueOf(request.get("user_id").toString());
-        Boolean canUpgrade = (Boolean) request.get("can_upgrade");
-        return levelService.upgradeUserLevel(userId, canUpgrade);
-    }
-}
diff --git a/src/main/java/com/example/myproject/controller/PostController.java b/src/main/java/com/example/myproject/controller/PostController.java
deleted file mode 100644
index 63fcbe8..0000000
--- a/src/main/java/com/example/myproject/controller/PostController.java
+++ /dev/null
@@ -1,94 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.entity.Post;
-import com.example.myproject.service.PostService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.*;
-import org.springframework.web.multipart.MultipartFile;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
-@RestController
-@RequestMapping("/echo/forum/posts")
-public class PostController {
-
-    @Autowired
-    private PostService postService;
-
-    //创建新帖子（已完成）
-    @PostMapping("/{user_id}/createPost")
-    public Map<String, Object> createPost(
-            @PathVariable("user_id") Long userId,
-            @RequestParam(value = "postContent") String postContent,
-            @RequestParam(value = "title", required = false) String title,
-            @RequestParam(value = "imageUrl") MultipartFile[] imageFiles) {
-        return postService.createPost(userId, postContent, title, imageFiles);
-    }
-
-    //编辑帖子（已完成）
-    @PutMapping("/{post_id}/editPost")
-    public String updatePost(@PathVariable("post_id") Long postId, @RequestBody Post post) {
-        postService.updatePost(postId, post);
-        return "Post updated successfully!";
-    }
-
-    //删除帖子（已完成）
-    @DeleteMapping("/{post_id}/deletePost")
-    public String deletePost(@PathVariable("post_id") Long postId) {
-        postService.deletePost(postId);
-        return "Post deleted successfully!";
-    }
-
-    //点赞帖子（已完成）
-    @PostMapping("/{post_id}/like")
-    public String likePost(@PathVariable("post_id") Long postId, @RequestBody Map<String, Long> requestBody) {
-
-        Long userId = requestBody.get("user_id");
-        postService.likePost(postId, userId);
-
-        return "Post liked successfully!";
-    }
-
-    //取消点赞（已完成）
-    @PostMapping("/{post_id}/unlike")
-    public String unlikePost(@PathVariable("post_id") Long postId, @RequestBody Map<String, Long> requestBody) {
-        Long userId = requestBody.get("user_id");
-        postService.unlikePost(postId, userId);
-
-        return "Post unliked successfully!";
-    }
-
-    //获取帖子列表（已完成）
-    @GetMapping("/getAllPosts")
-    public Map<String, Object> getAllPosts() {
-        return postService.getAllPosts();  // 调用服务层的 getAllPosts 方法
-    }
-
-    @GetMapping("/{postId}/getPost")
-    public Map<String, Object> getPostById(@PathVariable Long postId) {
-        return postService.getPostById(postId);
-    }
-
-
-    //收藏帖子（已完成）
-    @PostMapping("/{post_id}/collect")
-    public String collectPost(@PathVariable("post_id") Long postId, @RequestBody Map<String, Long> requestBody) {
-        Long userId = requestBody.get("user_id");
-        postService.collectPost(postId, userId);
-
-        return "Post collected successfully!";
-    }
-
-
-    //取消收藏（已完成）
-    @DeleteMapping("/{post_id}/uncollect")
-    public String uncollectPost(@PathVariable("post_id") Long postId, @RequestBody Map<String, Long> requestBody) {
-        Long userId = requestBody.get("user_id");
-        postService.uncollectPost(postId, userId);
-        return "Post uncollected successfully!";
-    }
-
-
-}
diff --git a/src/main/java/com/example/myproject/controller/TaskController.java b/src/main/java/com/example/myproject/controller/TaskController.java
deleted file mode 100644
index 2e01b0c..0000000
--- a/src/main/java/com/example/myproject/controller/TaskController.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.service.TaskService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.Map;
-
-@RestController
-@RequestMapping("/echo/task/tutorial")
-public class TaskController {
-
-    @Autowired
-    private TaskService taskService;
-
-    //获取当前用户的新手任务列表
-    @GetMapping("/getAllTasks")
-    public Map<String, Object> getAllTasks(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        return taskService.getAllTasksForUser(userId);
-    }
-
-    @PostMapping("/updateStatus")
-    public Map<String, Object> updateTaskStatus(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        String taskId = request.get("task_id").toString();
-        return taskService.updateTaskStatus(userId, taskId);
-    }
-
-    //获取当前经验和任务奖励
-    @GetMapping("/getExperience")
-    public Map<String, Object> getExperience(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        return taskService.getUserExperience(userId);
-    }
-
-    //获取当前的指引步骤
-    @GetMapping("/getNewStep")
-    public Map<String, Object> getNewStep(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        return taskService.getNewStep(userId);
-    }
-
-    //更新进度
-    @PostMapping("/updateProgress")
-    public Map<String, Object> updateProgress(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        String taskId = request.get("task_id").toString();
-        Integer progress = Integer.parseInt(request.get("progress").toString());
-        return taskService.updateTaskProgress(userId, taskId, progress);
-    }
-
-    //领取任务奖励
-    @PostMapping("/rewardClaim")
-    public Map<String, Object> rewardClaim(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        String taskId = request.get("task_id").toString();
-        return taskService.claimReward(userId, taskId);
-    }
-
-    //检查任务奖励状态
-    @PostMapping("/rewardReview")
-    public Map<String, Object> rewardReview(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        String taskId = request.get("task_id").toString();
-        return taskService.checkRewardStatus(userId, taskId);
-    }
-}
diff --git a/src/main/java/com/example/myproject/controller/UserController.java b/src/main/java/com/example/myproject/controller/UserController.java
index 224c138..acda403 100644
--- a/src/main/java/com/example/myproject/controller/UserController.java
+++ b/src/main/java/com/example/myproject/controller/UserController.java
@@ -1,155 +1,190 @@
 package com.example.myproject.controller;
 
-import com.example.myproject.entity.Users;
-import com.example.myproject.repository.UserRepository;
-import com.example.myproject.service.DynamicService;
-import com.example.myproject.service.TaskService;
+import cn.dev33.satoken.annotation.SaCheckLogin;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.example.myproject.common.base.PageUtil;
+import com.example.myproject.dto.param.TorrentParam;
+import com.example.myproject.dto.vo.TorrentVO;
+import com.example.myproject.entity.TorrentEntity;
+import com.example.myproject.mapper.UserMapper;
+import com.example.myproject.mapper.VerificationTokenMapper;
+import com.example.myproject.entity.User;
+import com.example.myproject.entity.VerificationToken;
+import com.example.myproject.service.EmailService;
 import com.example.myproject.service.UserService;
+import com.example.myproject.common.base.Result;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Content;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.authentication.AuthenticationManager;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.AuthenticationException;
+import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.Map;
-import java.util.Optional;
-
+import javax.annotation.Resource;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
 import java.util.List;
-import java.util.ArrayList;
-
 
 @RestController
-@RequestMapping("/echo/user")
+@RequestMapping("/user")
+@Api(value = "用户管理接口", tags = {"用户管理"})
 public class UserController {
 
-    @Autowired
+    @Resource
     private UserService userService;
 
     @Autowired
-    private UserRepository userRepository;
+    private AuthenticationManager authenticationManager;
 
     @Autowired
-    private DynamicService dynamicService;
+    private UserMapper userMapper; // 使用 MyBatis-Plus
 
-    // 接口：生成邀请码
-    @PostMapping("/getInviteCode")
-    public Map<String, Object> generateInviteCode(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        return userService.generateInviteCode(userId);
-    }
+    @Autowired
+    private VerificationTokenMapper verificationTokenMapper; // 替换 JPA
 
-    //注册
-    @PostMapping("/register")
-    public Map<String, Object> register(@RequestBody Map<String, Object> request) {
-        String username = (String) request.get("username");
-        String email = (String) request.get("email");
-        String password = (String) request.get("password");
-        String role = (String) request.get("role");
-        String inviteCode = (String) request.get("inviteCode");
+    private static final Logger logger = LoggerFactory.getLogger(UserController.class);
 
-        // 调用服务层的注册方法
-        String resultMessage = userService.registerUser(username, email, password, role, inviteCode);
-
-        // 返回注册结果
-        return Map.of("msg", resultMessage);
-    }
-
-    //登录
     @PostMapping("/login")
-    public Map<String, Object> login(@RequestBody Map<String, Object> request) {
-        String username = (String) request.get("username");
-        String password = (String) request.get("password");
+    @ApiOperation(value = "用户登录", notes = "使用用户名和密码进行登录")
+    public Result loginController(@RequestParam @ApiParam(value = "用户名", required = true) String username,
+                                  @RequestParam @ApiParam(value = "密码", required = true) String password) {
+        try {
+            Authentication authentication = authenticationManager.authenticate(
+                    new UsernamePasswordAuthenticationToken(username, password)
+            );
+            SecurityContextHolder.getContext().setAuthentication(authentication);
 
-        // 调用服务层的登录方法
-        String resultMessage = userService.loginUser(username, password);
+            // 使用 MyBatis-Plus 查询
+            User user = userMapper.selectOne(new QueryWrapper<User>().eq("username", username));
 
-        // 根据登录结果返回不同的响应
-        if (resultMessage.equals("登录成功")) {
-            // 查询用户信息
-            Optional<Users> user = userRepository.findByUsername(username);
-            if (user.isPresent()) {
-                // 将用户的所有信息作为返回值
-                return Map.of("msg", resultMessage, "user", user.get());
-            } else {
-                return Map.of("msg", "用户信息查询失败");
-            }
+            System.out.println("Login successful for user: " + username);
+            return Result.ok(user);
+        } catch (AuthenticationException e) {
+            return Result.error("登录失败");
+        }
+    }
+
+    @PostMapping("/register")
+    @ApiOperation(value = "用户注册", notes = "使用用户信息进行注册")
+    public Result registerController(@RequestBody @ApiParam(value = "新用户信息", required = true) User newUser) {
+        if (userService.checkEmailExists(newUser.getEmail())) {
+            return Result.error( "邮箱已被使用，请使用其他邮箱注册或找回密码！");
+        }
+        boolean success = userService.preRegisterUser(newUser);
+        if (success) {
+            User responseUser = new User();
+            responseUser.setEmail(newUser.getEmail());
+            return Result.ok();
         } else {
-            return Map.of("msg", resultMessage);
+            return Result.error("账号已存在或注册失败！");
         }
     }
 
-    //修改密码
-    @PostMapping("/password")
-    public Map<String, Object> changePassword(@RequestBody Map<String, Object> request) {
-        Long userId = Long.parseLong(request.get("user_id").toString());
-        String oldPassword = (String) request.get("old_password");
-        String newPassword = (String) request.get("new_password");
-        String confirmPassword = (String) request.get("confirm_password");
+    public static class VerificationRequest {
+        private String email;
+        private String code;
 
-        // 调用服务层的修改密码方法
-        String resultMessage = userService.changePassword(userId, oldPassword, newPassword, confirmPassword);
-
-        // 返回修改结果
-        return Map.of("message", resultMessage, "status", resultMessage.equals("密码修改成功") ? "success" : "error");
+        public String getEmail() { return email; }
+        public void setEmail(String email) { this.email = email; }
+        public String getCode() { return code; }
+        public void setCode(String code) { this.code = code; }
     }
 
-    // 获取用户个人资料
-    @GetMapping("/{userId}/getProfile")
-    public Map<String, Object> getProfile(@PathVariable("userId") Long userId) {
-        return userService.getProfile(userId);
-    }
-
-    // 修改用户个人资料
-    @PutMapping("/{userId}/editProfile")
-    public Map<String, String> editProfile(
-            @PathVariable("userId") Long userId,
-            @RequestBody Map<String, Object> profileData) {
-
-        // 获取请求体中的修改数据
-        String avatarUrl = (String) profileData.get("avatarUrl");
-        String nickname = (String) profileData.get("nickname");
-        String gender = (String) profileData.get("gender");
-        String description = (String) profileData.get("description");
-        String hobbies = (String) profileData.get("hobbies");
-
-        // 调用服务层方法进行修改
-        boolean updated = userService.editProfile(userId, avatarUrl, nickname, gender, description, hobbies);
-
-        // 返回操作结果消息
-        if (updated) {
-            return Map.of("message", "用户资料更新成功");
+    @PostMapping("/verify-code")
+    @ApiOperation(value = "验证邮箱验证码", notes = "验证用户邮箱的验证码")
+    public Result verifyEmailCode(@RequestBody @ApiParam(value = "验证请求信息", required = true) VerificationRequest verificationRequest) {
+        String email = verificationRequest.getEmail();
+        String code = verificationRequest.getCode();
+        boolean isVerified = userService.verifyEmail(email, code);
+        if (isVerified) {
+            return Result.ok();
         } else {
-            return Map.of("message", "用户不存在");
+            return Result.error( "验证码错误或已过期！");
         }
     }
 
-    // 计算分享率
-    @GetMapping("/{user_id}/calculate-share-rate")
-    public Map<String, Object> calculateShareRate(@PathVariable("user_id") Long userId) {
-        return userService.calculateShareRate(userId);
+    @Autowired
+    private EmailService emailService;
+
+    public static class EmailRequest {
+        private String email;
+        public String getEmail() { return email; }
+        public void setEmail(String email) { this.email = email; }
     }
 
-    // 获取用户所有好友的基本信息
-    @GetMapping("/{userId}/friends")
-    public List<Map<String, Object>> getUserFriends(@PathVariable("userId") Long userId) {
-        List<Long> friendIds = dynamicService.getAllFriendIds(userId);  // 注意这里用的是实例对象
-        List<Map<String, Object>> friends = new ArrayList<>();
-
-        for (Long friendId : friendIds) {
-            Optional<Users> userOpt = userRepository.findById(friendId);
-            if (userOpt.isPresent()) {
-                Users user = userOpt.get();
-                Map<String, Object> friendInfo = Map.of(
-                        "id", user.getUserId(),
-                        "avatar", user.getAvatarUrl() != null ? user.getAvatarUrl() : "https://example.com/default-avatar.jpg",
-                        "nickname", user.getUsername() != null ? user.getUsername() : "未知用户",
-                        "email", user.getEmail() != null ? user.getEmail() : "未填写"
-                );
-                friends.add(friendInfo);
-            }
+    @PostMapping("/get-verification-email")
+    @ApiOperation(value = "发送验证邮件", notes = "通过电子邮件发送验证邮件")
+    public ResponseEntity<Result> sendVerificationEmail(@RequestBody @ApiParam(value = "发送验证请求", required = true) EmailRequest emailVerificationRequest) {
+        String email = emailVerificationRequest.getEmail();
+        User user = userMapper.selectOne(new QueryWrapper<User>().eq("email", email));
+        if (user == null) {
+            logger.error("未找到与该邮箱地址相关联的用户: {}", email);
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST)
+                    .body(Result.error("未找到与该邮箱地址相关联的用户"));
         }
 
-        return friends;
+        // 生成验证码
+        String token = RandomStringUtils.randomNumeric(6);
+        Instant expiryDate = Instant.now().plus(1, ChronoUnit.HOURS);
+        logger.info("生成的验证令牌: {}, 过期时间: {}", token, expiryDate);
+
+        VerificationToken verificationToken = new VerificationToken(token, user.getUsername(), email, user.getPassword(), expiryDate);
+
+        // 保存到 MyBatis-Plus 数据库
+        verificationTokenMapper.insert(verificationToken);
+
+        logger.info("验证令牌已保存，用户: {}", user.getUsername());
+        emailService.sendVerificationEmail(email, token);
+
+        return ResponseEntity.ok(Result.ok());
     }
+    @PostMapping("/checkPassword")
+    public Result<String> checkPassword(@RequestParam Long userId, @RequestParam String password) {
+        boolean isPasswordCorrect = userService.checkPassword(userId, password);
+        if (isPasswordCorrect) {
+            return Result.ok();
+        } else {
+            return Result.error("原始密码输入错误");
+        }
+    }
+
+
+//    @SaCheckLogin
+//    @Operation(summary = "用户收藏列表", description = "获取用户收藏的种子列表-分页-排序")
+//    @ApiResponse(responseCode = "0", description = "操作成功",
+//            content = {@Content(mediaType = "application/json",
+//                    schema = @Schema(implementation = TorrentVO.class))
+//            })
+//    @PostMapping("/favorite/list")
+//    public Result listFavorites(@RequestBody FavoriteParam param) {
+//        if (param.getUserId() == null) {
+//            return Result.error("缺少 userId");
+//        }
+//
+//        // 校验排序字段是否合理（可选）
+//        param.validOrder(param.getOrderKey(TorrentEntity.class));
+//
+//        PageUtil.startPage(param);
+//
+//        List<TorrentEntity> list = favoriteService.getUserFavoritesPaged(param.getUserId());
+//
+//        return Result.ok(list, PageUtil.getPage(list));
+//    }
+//
+
 
 
 }
-
-
diff --git a/src/main/java/com/example/myproject/controller/UserFollowController.java b/src/main/java/com/example/myproject/controller/UserFollowController.java
deleted file mode 100644
index f550beb..0000000
--- a/src/main/java/com/example/myproject/controller/UserFollowController.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.service.UserFollowService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.Map;
-
-@RestController
-@RequestMapping("/echo/users")
-public class UserFollowController {
-
-    @Autowired
-    private UserFollowService userFollowService;
-
-    // 用户关注接口
-    @PostMapping("/{followed_id}/follow")
-    public ResponseEntity<Map<String, Object>> follow(@PathVariable("followed_id") Long followedId,
-                                                      @RequestBody Map<String, Long> request) {
-        Long followerId = request.get("follower_id");
-        Map<String, Object> response = userFollowService.follow(followerId, followedId);
-        return ResponseEntity.ok(response);
-    }
-
-    // 取消关注接口
-    @PostMapping("/{followed_id}/unfollow")
-    public ResponseEntity<Map<String, Object>> unfollow(@PathVariable("followed_id") Long followedId,
-                                                        @RequestBody Map<String, Long> request) {
-        Long followerId = request.get("follower_id");
-        Map<String, Object> response = userFollowService.unfollow(followerId, followedId);
-        return ResponseEntity.ok(response);
-    }
-
-    // 获取某个用户的粉丝列表
-    @GetMapping("/{user_id}/followers")
-    public ResponseEntity<Map<String, Object>> getFollowers(@PathVariable("user_id") Long userId) {
-        Map<String, Object> response = userFollowService.getFollowers(userId);
-        return ResponseEntity.ok(response);
-    }
-
-    @GetMapping("/{user_id}/following")
-    public ResponseEntity<Map<String, Object>> getFollowing(@PathVariable("user_id") Long userId) {
-        Map<String, Object> response = userFollowService.getFollowing(userId);
-        return ResponseEntity.ok(response);
-    }
-}
diff --git a/src/main/java/com/example/myproject/controller/UserMessageController.java b/src/main/java/com/example/myproject/controller/UserMessageController.java
deleted file mode 100644
index c7014a7..0000000
--- a/src/main/java/com/example/myproject/controller/UserMessageController.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package com.example.myproject.controller;
-
-import com.example.myproject.service.UserMessageService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.*;
-
-import java.util.Map;
-
-@RestController
-@RequestMapping("/echo/message")
-public class UserMessageController {
-
-    @Autowired
-    private UserMessageService userMessageService;
-
-    @PostMapping("/sendMessages")
-    public ResponseEntity<Map<String, Object>> sendMessage(@RequestBody Map<String, Object> params) {
-        // 将参数转换为 Long 类型
-        Long senderId = Long.valueOf(params.get("sender_id").toString());
-        Long receiverId = Long.valueOf(params.get("receiver_id").toString());
-        String content = (String) params.get("content");
-        Map<String, Object> response = userMessageService.sendMessage(senderId, receiverId, content);
-        return ResponseEntity.ok(response);
-    }
-
-    @GetMapping("/{user_id}/getUserMessages")
-    public ResponseEntity<Map<String, Object>> getUserMessages(@PathVariable("user_id") Long userId) {
-        Map<String, Object> response = userMessageService.getUserMessages(userId);
-        return ResponseEntity.ok(response);
-    }
-
-    // 获取单条消息的详情
-    @GetMapping("/{message_id}/getAMessage")
-    public ResponseEntity<Map<String, Object>> getMessage(@PathVariable("message_id") Long messageId) {
-        Map<String, Object> response = userMessageService.getMessage(messageId);
-        return ResponseEntity.ok(response);
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/Collections.java b/src/main/java/com/example/myproject/entity/Collections.java
deleted file mode 100644
index f7a8711..0000000
--- a/src/main/java/com/example/myproject/entity/Collections.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-
-@Entity
-@Table(name = "collections")
-public class Collections {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "collectionId")
-    private Long collectionId;
-
-    @Column(name = "user_id")
-    private Long userId;
-
-    @Column(name = "postNo")
-    private Long postNo;
-
-    // Getters and Setters
-    public Long getCollectionId() {
-        return collectionId;
-    }
-
-    public void setCollectionId(Long collectionId) {
-        this.collectionId = collectionId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public Long getPostNo() {
-        return postNo;
-    }
-
-    public void setPostNo(Long postNo) {
-        this.postNo = postNo;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/Comments.java b/src/main/java/com/example/myproject/entity/Comments.java
deleted file mode 100644
index fdf89fa..0000000
--- a/src/main/java/com/example/myproject/entity/Comments.java
+++ /dev/null
@@ -1,116 +0,0 @@
-package com.example.myproject.entity;
-
-import com.fasterxml.jackson.annotation.JsonBackReference;
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "comments")
-public class Comments {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "comment_id")
-    private Long commentId;
-
-    @ManyToOne
-    @JoinColumn(name = "post_id", nullable = false)
-    @JsonBackReference
-    private Post post;
-
-    @Column(name = "content", nullable = false)
-    private String content;
-
-    @Column(name = "is_anonymous")
-    private Boolean isAnonymous;  // 是否匿名
-
-    @Column(name = "likes_count")
-    private Integer likesCount = 0;  // 点赞数
-
-    @Column(name = "reply_count")
-    private Integer replyCount = 0;  // 回复数
-
-    @Column(name = "comment_time", nullable = false)
-    private Date commentTime;  // 评论时间
-
-    @Column(name = "user_id", nullable = false)
-    private Long userId;  // 评论者的 user_id
-
-
-    @Column(name = "com_comment_id", nullable = false)
-    private Long com_comment_id;
-
-    // Getters and Setters
-
-    public Long getCommentId() {
-        return commentId;
-    }
-
-    public void setCommentId(Long commentId) {
-        this.commentId = commentId;
-    }
-
-    public Post getPost() {
-        return post;
-    }
-
-    public void setPost(Post post) {
-        this.post = post;
-    }
-
-    public String getContent() {
-        return content;
-    }
-
-    public void setContent(String content) {
-        this.content = content;
-    }
-
-    public Boolean getIsAnonymous() {
-        return isAnonymous;
-    }
-
-    public void setIsAnonymous(Boolean isAnonymous) {
-        this.isAnonymous = isAnonymous;
-    }
-
-    public Integer getLikesCount() {
-        return likesCount;
-    }
-
-    public void setLikesCount(Integer likesCount) {
-        this.likesCount = likesCount;
-    }
-
-    public Integer getReplyCount() {
-        return replyCount;
-    }
-
-    public void setReplyCount(Integer replyCount) {
-        this.replyCount = replyCount;
-    }
-
-    public Date getCommentTime() {
-        return commentTime;
-    }
-
-    public void setCommentTime(Date commentTime) {
-        this.commentTime = commentTime;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public Long getParentComment() {
-        return com_comment_id;
-    }
-
-    public void setParentComment(Long com_comment_id) {
-        this.com_comment_id = com_comment_id;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/DynamicComment.java b/src/main/java/com/example/myproject/entity/DynamicComment.java
deleted file mode 100644
index d5c84d3..0000000
--- a/src/main/java/com/example/myproject/entity/DynamicComment.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "dynamic_comment")
-public class DynamicComment {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "comment_id")
-    private Long commentId;
-
-    @Column(name = "dynamic_id")
-    private Long dynamicId;
-
-    @Column(name = "user_id")
-    private Long userId;
-
-    @Column(name = "comment_content")
-    private String commentContent;
-
-    @Column(name = "comment_time")
-    private Date commentTime;
-
-    @Column(name = "is_anonymous")
-    private Boolean isAnonymous = false;
-
-    @Column(name = "parent_comment_id")
-    private Long parentCommentId;
-
-    // Getters and Setters
-    public Long getCommentId() {
-        return commentId;
-    }
-
-    public void setCommentId(Long commentId) {
-        this.commentId = commentId;
-    }
-
-    public Long getDynamicId() {
-        return dynamicId;
-    }
-
-    public void setDynamicId(Long dynamicId) {
-        this.dynamicId = dynamicId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public String getCommentContent() {
-        return commentContent;
-    }
-
-    public void setCommentContent(String commentContent) {
-        this.commentContent = commentContent;
-    }
-
-    public Date getCommentTime() {
-        return commentTime;
-    }
-
-    public void setCommentTime(Date commentTime) {
-        this.commentTime = commentTime;
-    }
-
-    public Boolean getIsAnonymous() {
-        return isAnonymous;
-    }
-
-    public void setIsAnonymous(Boolean isAnonymous) {
-        this.isAnonymous = isAnonymous;
-    }
-
-    public Long getParentCommentId() {
-        return parentCommentId;
-    }
-
-    public void setParentCommentId(Long parentCommentId) {
-        this.parentCommentId = parentCommentId;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/DynamicLikes.java b/src/main/java/com/example/myproject/entity/DynamicLikes.java
deleted file mode 100644
index 986f903..0000000
--- a/src/main/java/com/example/myproject/entity/DynamicLikes.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "dynamic_likes")
-public class DynamicLikes {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "like_id")
-    private Long likeId;
-
-    @Column(name = "dynamic_id")
-    private Long dynamicId;
-
-    @Column(name = "user_id")
-    private Long userId;
-
-    @Column(name = "like_time")
-    private Date likeTime;
-
-    // Getters and Setters
-    public Long getLikeId() {
-        return likeId;
-    }
-
-    public void setLikeId(Long likeId) {
-        this.likeId = likeId;
-    }
-
-    public Long getDynamicId() {
-        return dynamicId;
-    }
-
-    public void setDynamicId(Long dynamicId) {
-        this.dynamicId = dynamicId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public Date getLikeTime() {
-        return likeTime;
-    }
-
-    public void setLikeTime(Date likeTime) {
-        this.likeTime = likeTime;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/ExperienceHistory.java b/src/main/java/com/example/myproject/entity/ExperienceHistory.java
deleted file mode 100644
index 8c52f6b..0000000
--- a/src/main/java/com/example/myproject/entity/ExperienceHistory.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "experience_history")
-public class ExperienceHistory {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "history_id")
-    private Long historyId;
-
-    @Column(name = "user_id", nullable = false)
-    private Long userId;
-
-    @Column(name = "experience_change", nullable = false)
-    private Integer experienceChange;  // 经验值变化量
-
-    @Column(name = "source", nullable = false)
-    private String source;  // 更新来源
-
-    @Column(name = "update_time", nullable = false)
-    private Date updateTime;  // 更新操作的时间
-
-    // Getters and Setters
-    public Long getHistoryId() {
-        return historyId;
-    }
-
-    public void setHistoryId(Long historyId) {
-        this.historyId = historyId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public Integer getExperienceChange() {
-        return experienceChange;
-    }
-
-    public void setExperienceChange(Integer experienceChange) {
-        this.experienceChange = experienceChange;
-    }
-
-    public String getSource() {
-        return source;
-    }
-
-    public void setSource(String source) {
-        this.source = source;
-    }
-
-    public Date getUpdateTime() {
-        return updateTime;
-    }
-
-    public void setUpdateTime(Date updateTime) {
-        this.updateTime = updateTime;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/FriendRelation.java b/src/main/java/com/example/myproject/entity/FriendRelation.java
deleted file mode 100644
index c086001..0000000
--- a/src/main/java/com/example/myproject/entity/FriendRelation.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "friend_relation")
-public class FriendRelation {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "relation_id")
-    private Long relationId;
-
-    @Column(name = "user_id")
-    private Long userId;
-
-    @Column(name = "friend_id")
-    private Long friendId;  // 好友ID
-
-    @Column(name = "create_time")
-    private Date createTime;  // 好友关系创建时间
-
-    // Getters and Setters
-    public Long getRelationId() {
-        return relationId;
-    }
-
-    public void setRelationId(Long relationId) {
-        this.relationId = relationId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public Long getFriendId() {
-        return friendId;
-    }
-
-    public void setFriendId(Long friendId) {
-        this.friendId = friendId;
-    }
-
-    public Date getCreateTime() {
-        return createTime;
-    }
-
-    public void setCreateTime(Date createTime) {
-        this.createTime = createTime;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/Group.java b/src/main/java/com/example/myproject/entity/Group.java
deleted file mode 100644
index ea4f2c7..0000000
--- a/src/main/java/com/example/myproject/entity/Group.java
+++ /dev/null
@@ -1,98 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "group_interests")
-public class Group {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "group_id")
-    private Long groupId;
-
-    @Column(name = "group_name")
-    private String groupName;
-
-    private String description;  // 小组简介
-
-    @Column(name = "create_time")
-    private Date createTime;  // 创建时间
-
-    @Column(name = "user_id")
-    private Long userId;  // 创建该小组的用户ID
-
-    @Column(name = "member_count")
-    private Integer memberCount;  // 小组成员人数
-
-    private String category;  // 小组类别
-
-    @Column(name = "cover_image")
-    private String coverImage;  // 小组封面图片
-
-    // Getters and Setters
-    public Long getGroupId() {
-        return groupId;
-    }
-
-    public void setGroupId(Long groupId) {
-        this.groupId = groupId;
-    }
-
-    public String getGroupName() {
-        return groupName;
-    }
-
-    public void setGroupName(String groupName) {
-        this.groupName = groupName;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
-    public Date getCreateTime() {
-        return createTime;
-    }
-
-    public void setCreateTime(Date createTime) {
-        this.createTime = createTime;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public Integer getMemberCount() {
-        return memberCount;
-    }
-
-    public void setMemberCount(Integer memberCount) {
-        this.memberCount = memberCount;
-    }
-
-    public String getCategory() {
-        return category;
-    }
-
-    public void setCategory(String category) {
-        this.category = category;
-    }
-
-    public String getCoverImage() {
-        return coverImage;
-    }
-
-    public void setCoverImage(String coverImage) {
-        this.coverImage = coverImage;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/GroupComments.java b/src/main/java/com/example/myproject/entity/GroupComments.java
deleted file mode 100644
index fcf4205..0000000
--- a/src/main/java/com/example/myproject/entity/GroupComments.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "group_comments")
-public class GroupComments {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "comment_id")
-    private Long commentId;  // 评论ID
-
-    @Column(name = "group_post_id")
-    private Long groupPostId;
-
-    @Column(name = "user_id")
-    private Long userId;
-
-    private String content;
-
-    @Column(name = "parent_comment_id")
-    private Long parentCommentId;
-
-    @Column(name = "time")
-    private Date time;  // 评论时间
-
-    // Getters and Setters
-    public Long getCommentId() {
-        return commentId;
-    }
-
-    public void setCommentId(Long commentId) {
-        this.commentId = commentId;
-    }
-
-    public Long getGroupPostId() {
-        return groupPostId;
-    }
-
-    public void setGroupPostId(Long groupPostId) {
-        this.groupPostId = groupPostId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public String getContent() {
-        return content;
-    }
-
-    public void setContent(String content) {
-        this.content = content;
-    }
-
-    public Long getParentCommentId() {
-        return parentCommentId;
-    }
-
-    public void setParentCommentId(Long parentCommentId) {
-        this.parentCommentId = parentCommentId;
-    }
-
-    public Date getTime() {
-        return time;
-    }
-
-    public void setTime(Date time) {
-        this.time = time;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/GroupMembers.java b/src/main/java/com/example/myproject/entity/GroupMembers.java
deleted file mode 100644
index e66e18c..0000000
--- a/src/main/java/com/example/myproject/entity/GroupMembers.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-
-@Entity
-@Table(name = "group_members")
-public class GroupMembers {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "relation_id")
-    private Long relationId;
-
-    @Column(name = "group_id", nullable = false)
-    private Long groupId;
-
-    @Column(name = "user_id", nullable = false)
-    private Long userId;
-
-    // Getters and Setters
-    public Long getRelationId() {
-        return relationId;
-    }
-
-    public void setRelationId(Long relationId) {
-        this.relationId = relationId;
-    }
-
-    public Long getGroupId() {
-        return groupId;
-    }
-
-    public void setGroupId(Long groupId) {
-        this.groupId = groupId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/GroupPost.java b/src/main/java/com/example/myproject/entity/GroupPost.java
deleted file mode 100644
index 89867f7..0000000
--- a/src/main/java/com/example/myproject/entity/GroupPost.java
+++ /dev/null
@@ -1,109 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "group_post")
-public class GroupPost {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "group_post_id")
-    private Long groupPostId;
-
-    @Column(name = "group_id")
-    private Long groupId;
-
-    @Column(name = "user_id")
-    private Long userId;
-
-    private String content;
-
-    private String image;
-
-    @Column(name = "like_count")
-    private Integer likeCount;
-
-    @Column(name = "comment_count")
-    private Integer commentCount;  // 帖子评论数
-
-    @Column(name = "time")
-    private Date time;  // 帖子创建时间
-
-    private String title;
-
-
-    // Getters and Setters
-    public Long getGroupPostId() {
-        return groupPostId;
-    }
-
-    public void setGroupPostId(Long groupPostId) {
-        this.groupPostId = groupPostId;
-    }
-
-    public Long getGroupId() {
-        return groupId;
-    }
-
-    public void setGroupId(Long groupId) {
-        this.groupId = groupId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public String getContent() {
-        return content;
-    }
-
-    public void setContent(String content) {
-        this.content = content;
-    }
-
-    public String getImage() {
-        return image;
-    }
-
-    public void setImage(String image) {
-        this.image = image;
-    }
-
-    public Integer getLikeCount() {
-        return likeCount;
-    }
-
-    public void setLikeCount(Integer likeCount) {
-        this.likeCount = likeCount;
-    }
-
-    public Integer getCommentCount() {
-        return commentCount;
-    }
-
-    public void setCommentCount(Integer commentCount) {
-        this.commentCount = commentCount;
-    }
-
-    public Date getTime() {
-        return time;
-    }
-
-    public void setTime(Date time) {
-        this.time = time;
-    }
-
-    public String getTitle() {
-        return title;
-    }
-
-    public void setTitle(String title) {
-        this.title = title;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/Level.java b/src/main/java/com/example/myproject/entity/Level.java
deleted file mode 100644
index 6837ef9..0000000
--- a/src/main/java/com/example/myproject/entity/Level.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package com.example.myproject.entity;
-
-
-
-import javax.persistence.*;
-
-@Entity
-@Table(name = "level")
-public class Level {
-
-    @Id
-    @Column(name = "level_id")
-    private Long levelId;  // 等级唯一标识
-
-    @Column(name = "level_name", nullable = false)
-    private String levelName;  // 等级名称
-
-    @Column(name = "required_experience", nullable = false)
-    private Long requiredExperience;  // 所需经验值
-
-    @Column(name = "required_share_ratio")
-    private Float requiredShareRatio;  // 所需分享率
-
-    @Column(name = "required_upload_gb")
-    private Float requiredUploadGb;  // 所需上传数据量
-
-    @Column(name = "required_seeding_hours")
-    private Float requiredSeedingHours;  // 所需做种时长
-
-    @Column(name = "permissions")
-    private String permissions;  // 拥有的权限
-
-    // Getters and Setters
-    public Long getLevelId() {
-        return levelId;
-    }
-
-    public void setLevelId(Long levelId) {
-        this.levelId = levelId;
-    }
-
-    public String getLevelName() {
-        return levelName;
-    }
-
-    public void setLevelName(String levelName) {
-        this.levelName = levelName;
-    }
-
-    public Long getRequiredExperience() {
-        return requiredExperience;
-    }
-
-    public void setRequiredExperience(Long requiredExperience) {
-        this.requiredExperience = requiredExperience;
-    }
-
-    public Float getRequiredShareRatio() {
-        return requiredShareRatio;
-    }
-
-    public void setRequiredShareRatio(Float requiredShareRatio) {
-        this.requiredShareRatio = requiredShareRatio;
-    }
-
-    public Float getRequiredUploadGb() {
-        return requiredUploadGb;
-    }
-
-    public void setRequiredUploadGb(Float requiredUploadGb) {
-        this.requiredUploadGb = requiredUploadGb;
-    }
-
-    public Float getRequiredSeedingHours() {
-        return requiredSeedingHours;
-    }
-
-    public void setRequiredSeedingHours(Float requiredSeedingHours) {
-        this.requiredSeedingHours = requiredSeedingHours;
-    }
-
-    public String getPermissions() {
-        return permissions;
-    }
-
-    public void setPermissions(String permissions) {
-        this.permissions = permissions;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/Likes.java b/src/main/java/com/example/myproject/entity/Likes.java
deleted file mode 100644
index 7a3dcda..0000000
--- a/src/main/java/com/example/myproject/entity/Likes.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-
-@Entity
-@Table(name = "likes")
-public class Likes {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)  // 使用自增主键
-    @Column(name = "likeId")
-    private Long likeId;
-
-    @Column(name = "user_id")
-    private Long userId;
-
-    @Column(name = "postNo")
-    private Long postNo;
-
-    // Getters and Setters
-    public Long getLikeId() {
-        return likeId;
-    }
-
-    public void setLikeId(Long likeId) {
-        this.likeId = likeId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public Long getPostNo() {
-        return postNo;
-    }
-
-    public void setPostNo(Long postNo) {
-        this.postNo = postNo;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/Post.java b/src/main/java/com/example/myproject/entity/Post.java
deleted file mode 100644
index bb94aac..0000000
--- a/src/main/java/com/example/myproject/entity/Post.java
+++ /dev/null
@@ -1,116 +0,0 @@
-package com.example.myproject.entity;
-
-import com.fasterxml.jackson.annotation.JsonManagedReference;
-
-import javax.persistence.*;
-
-import java.util.Date;
-import java.util.List;
-
-@Entity
-@Table(name = "post")
-public class Post {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "postNo")
-    private Long postNo;
-
-
-    @Column(name = "userId")
-    private Long user_id;
-
-    @Column(name = "postContent")
-    private String postContent;
-
-    @Column(name = "imageUrl")
-    private String imageUrl;
-
-    @Column(name = "postTime")
-    private Date postTime;
-
-    @Column(name = "postLikeNum")
-    private Integer postLikeNum;
-
-    @Column(name = "postCollectNum")
-    private Integer postCollectNum;
-
-    @Column(name = "title")
-    private String title;
-
-    @Column(name = "postType")
-    private String postType;
-
-    // Getters and Setters
-    public Long getPostNo() {
-        return postNo;
-    }
-
-    public void setPostNo(Long postNo) {
-        this.postNo = postNo;
-    }
-
-    public Long getUser_id() {
-        return user_id;
-    }
-
-    public void setUser_id(Long user) {
-        this.user_id = user;
-    }
-
-    public String getPostContent() {
-        return postContent;
-    }
-
-    public void setPostContent(String postContent) {
-        this.postContent = postContent;
-    }
-
-    public String getImageUrl() {
-        return imageUrl;
-    }
-
-    public void setImageUrl(String imgUrl) {
-        this.imageUrl = imgUrl;
-    }
-
-    public Date getPostTime() {
-        return postTime;
-    }
-
-    public void setPostTime(Date postTime) {
-        this.postTime = postTime;
-    }
-
-    public Integer getPostLikeNum() {
-        return postLikeNum;
-    }
-
-    public void setPostLikeNum(Integer postLikeNum) {
-        this.postLikeNum = postLikeNum;
-    }
-
-    public Integer getPostCollectNum() {
-        return postCollectNum;
-    }
-
-    public void setPostCollectNum(Integer postCollectNum) {
-        this.postCollectNum = postCollectNum;
-    }
-
-    public String getTitle() {
-        return title;
-    }
-
-    public void setTitle(String title) {
-        this.title = title;
-    }
-
-    public String getPostType() {
-        return postType;
-    }
-
-    public void setPostType(String postType) {
-        this.postType = postType;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/Task.java b/src/main/java/com/example/myproject/entity/Task.java
deleted file mode 100644
index 15796a1..0000000
--- a/src/main/java/com/example/myproject/entity/Task.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-
-@Entity
-@Table(name = "tasks")
-public class Task {
-
-    @Id
-    @Column(name = "task_id")
-    private String taskId;
-
-    @Column(name = "title", nullable = false)
-    private String title;
-
-    @Column(name = "description", nullable = false)
-    private String description;
-
-    @Column(name = "reward_experience", nullable = false)
-    private int rewardExperience;  // 任务奖励的经验
-
-    @Column(name = "reward_points", nullable = false)
-    private int rewardPoints;  // 任务奖励的积分
-
-
-    public String getTaskId() {
-        return taskId;
-    }
-
-    public void setTaskId(String taskId) {
-        this.taskId = taskId;
-    }
-
-    public String getTitle() {
-        return title;
-    }
-
-    public void setTitle(String title) {
-        this.title = title;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
-
-    public int getRewardExperience() {
-        return rewardExperience;
-    }
-
-    public void setRewardExperience(int rewardExperience) {
-        this.rewardExperience = rewardExperience;
-    }
-
-    public int getRewardPoints() {
-        return rewardPoints;
-    }
-
-    public void setRewardPoints(int rewardPoints) {
-        this.rewardPoints = rewardPoints;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/UserDynamic.java b/src/main/java/com/example/myproject/entity/UserDynamic.java
deleted file mode 100644
index a04d3ac..0000000
--- a/src/main/java/com/example/myproject/entity/UserDynamic.java
+++ /dev/null
@@ -1,100 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "user_dynamic")
-public class UserDynamic {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "dynamic_id")
-    private Long dynamicId;
-
-    @Column(name = "user_id")
-    private Long userId;  // 发布动态的用户ID
-
-    @Column(name = "title")
-    private String title;  // 动态标题
-
-    @Column(name = "content")
-    private String content;  // 动态内容
-
-    @Column(name = "image_url")
-    private String imageUrl;  // 图片URL
-
-    @Column(name = "time")
-    private Date time;  // 发布动态的时间
-
-    @Column(name = "likes_count")
-    private int likesCount = 0;  // 点赞数
-
-    @Column(name = "comments_count")
-    private int commentsCount = 0;  // 评论数
-
-
-    public Long getDynamicId() {
-        return dynamicId;
-    }
-
-    public void setDynamicId(Long dynamicId) {
-        this.dynamicId = dynamicId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public String getTitle() {
-        return title;
-    }
-
-    public void setTitle(String title) {
-        this.title = title;
-    }
-
-    public String getContent() {
-        return content;
-    }
-
-    public void setContent(String content) {
-        this.content = content;
-    }
-
-    public String getImageUrl() {
-        return imageUrl;
-    }
-
-    public void setImageUrl(String imageUrl) {
-        this.imageUrl = imageUrl;
-    }
-
-    public Date getTime() {
-        return time;
-    }
-
-    public void setTime(Date time) {
-        this.time = time;
-    }
-
-    public int getLikesCount() {
-        return likesCount;
-    }
-
-    public void setLikesCount(int likesCount) {
-        this.likesCount = likesCount;
-    }
-
-    public int getCommentsCount() {
-        return commentsCount;
-    }
-
-    public void setCommentsCount(int commentsCount) {
-        this.commentsCount = commentsCount;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/UserFollow.java b/src/main/java/com/example/myproject/entity/UserFollow.java
deleted file mode 100644
index bfc14f7..0000000
--- a/src/main/java/com/example/myproject/entity/UserFollow.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "follow")
-public class UserFollow {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "record_id")
-    private Long recordId;
-
-    @Column(name = "follower_id")
-    private Long followerId;
-
-    @Column(name = "followed_id")
-    private Long followedId;
-
-    @Column(name = "follow_time")
-    private Date followTime;
-
-    // Getters and Setters
-    public Long getId() {
-        return recordId;
-    }
-
-    public void setId(Long recordId) {
-        this.recordId = recordId;
-    }
-
-    public Long getFollowerId() {
-        return followerId;
-    }
-
-    public void setFollowerId(Long followerId) {
-        this.followerId = followerId;
-    }
-
-    public Long getFollowedId() {
-        return followedId;
-    }
-
-    public void setFollowedId(Long followedId) {
-        this.followedId = followedId;
-    }
-
-    public Date getFollowTime() {
-        return followTime;
-    }
-
-    public void setFollowTime(Date followTime) {
-        this.followTime = followTime;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/UserInviteCode.java b/src/main/java/com/example/myproject/entity/UserInviteCode.java
deleted file mode 100644
index 8343c7e..0000000
--- a/src/main/java/com/example/myproject/entity/UserInviteCode.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.time.LocalDateTime;
-
-@Entity
-@Table(name = "user_invite_code")
-public class UserInviteCode {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "invite_id")
-    private Long inviteId;
-
-    @Column(name = "user_id", nullable = false)
-    private Long userId;
-
-    @Column(name = "invite_code", nullable = false, unique = true)
-    private String inviteCode;
-
-    @Column(name = "is_used", nullable = false)
-    private Boolean isUsed = false;
-
-    @Column(name = "created_at", nullable = false)
-    private LocalDateTime createdAt;
-
-    // Getters and Setters
-    public Long getInviteId() {
-        return inviteId;
-    }
-
-    public void setInviteId(Long inviteId) {
-        this.inviteId = inviteId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public String getInviteCode() {
-        return inviteCode;
-    }
-
-    public void setInviteCode(String inviteCode) {
-        this.inviteCode = inviteCode;
-    }
-
-    public Boolean getIsUsed() {
-        return isUsed;
-    }
-
-    public void setIsUsed(Boolean isUsed) {
-        this.isUsed = isUsed;
-    }
-
-    public LocalDateTime getCreatedAt() {
-        return createdAt;
-    }
-
-    public void setCreatedAt(LocalDateTime createdAt) {
-        this.createdAt = createdAt;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/UserMessages.java b/src/main/java/com/example/myproject/entity/UserMessages.java
deleted file mode 100644
index ee7e43e..0000000
--- a/src/main/java/com/example/myproject/entity/UserMessages.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "user_messages")
-public class UserMessages {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "message_id")
-    private Long messageId;
-
-    @Column(name = "sender_id")
-    private Long senderId;
-
-    @Column(name = "receiver_id")
-    private Long receiverId;
-
-    @Column(name = "content")
-    private String content;
-
-    @Column(name = "time")
-    private Date time;
-
-
-    public Long getMessageId() {
-        return messageId;
-    }
-
-    public void setMessageId(Long messageId) {
-        this.messageId = messageId;
-    }
-
-    public Long getSenderId() {
-        return senderId;
-    }
-
-    public void setSenderId(Long senderId) {
-        this.senderId = senderId;
-    }
-
-    public Long getReceiverId() {
-        return receiverId;
-    }
-
-    public void setReceiverId(Long receiverId) {
-        this.receiverId = receiverId;
-    }
-
-    public String getContent() {
-        return content;
-    }
-
-    public void setContent(String content) {
-        this.content = content;
-    }
-
-    public Date getTime() {
-        return time;
-    }
-
-    public void setTime(Date time) {
-        this.time = time;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/UserTaskStatus.java b/src/main/java/com/example/myproject/entity/UserTaskStatus.java
deleted file mode 100644
index a66839d..0000000
--- a/src/main/java/com/example/myproject/entity/UserTaskStatus.java
+++ /dev/null
@@ -1,98 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-
-@Entity
-@Table(name = "user_task_status")
-public class UserTaskStatus {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "status_id")
-    private Long statusId;
-
-    @Column(name = "user_id", nullable = false)
-    private Long userId;
-
-    @Column(name = "task_id", nullable = false)
-    private String taskId;
-
-    @Column(name = "current_progress", nullable = false)
-    private Float currentProgress;
-
-    @Column(name = "current_experience", nullable = false)
-    private Integer currentExperience;
-
-    @Column(name = "current_points", nullable = false)
-    private Integer currentPoints;
-
-    @Column(name = "status", nullable = false)
-    private String status;
-
-    @Column(name = "is_reward_claimed", nullable = false)
-    private Boolean isRewardClaimed = false;
-
-    public Long getStatusId() {
-        return statusId;
-    }
-
-    public void setStatusId(Long statusId) {
-        this.statusId = statusId;
-    }
-
-    public Long getUserId() {
-        return userId;
-    }
-
-    public void setUserId(Long userId) {
-        this.userId = userId;
-    }
-
-    public String getTaskId() {
-        return taskId;
-    }
-
-    public void setTaskId(String taskId) {
-        this.taskId = taskId;
-    }
-
-    public Float getCurrentProgress() {
-        return currentProgress;
-    }
-
-    public void setCurrentProgress(Float currentProgress) {
-        this.currentProgress = currentProgress;
-    }
-
-    public Integer getCurrentExperience() {
-        return currentExperience;
-    }
-
-    public void setCurrentExperience(Integer currentExperience) {
-        this.currentExperience = currentExperience;
-    }
-
-    public Integer getCurrentPoints() {
-        return currentPoints;
-    }
-
-    public void setCurrentPoints(Integer currentPoints) {
-        this.currentPoints = currentPoints;
-    }
-
-    public String getStatus() {
-        return status;
-    }
-
-    public void setStatus(String status) {
-        this.status = status;
-    }
-
-    public Boolean getIsRewardClaimed() {
-        return isRewardClaimed;
-    }
-
-    public void setIsRewardClaimed(Boolean isRewardClaimed) {
-        this.isRewardClaimed = isRewardClaimed;
-    }
-}
diff --git a/src/main/java/com/example/myproject/entity/Users.java b/src/main/java/com/example/myproject/entity/Users.java
deleted file mode 100644
index ebe793f..0000000
--- a/src/main/java/com/example/myproject/entity/Users.java
+++ /dev/null
@@ -1,246 +0,0 @@
-package com.example.myproject.entity;
-
-import javax.persistence.*;
-import java.util.Date;
-
-@Entity
-@Table(name = "user")
-public class Users {
-
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    @Column(name = "user_id")
-    private Long userId;
-
-    @Column(name = "username", nullable = false,unique = true)
-    private String username;
-
-    @Column(name = "avatar_url", nullable = true)
-    private String avatarUrl;
-
-    @Column(name = "email", nullable = false)
-    private String email;
-
-    @Column(name = "password", nullable = false)
-    private String password;
-
-    @Column(name = "role", nullable = false)
-    private String role;
-
-    @Column(name = "invite_count")
-    private Integer inviteCount;
-
-    @Column(name = "level", nullable = false)
-    private Long level;
-
-    @Column(name = "upload_count")
-    private Float uploadCount;
-
-    @Column(name = "download_count")
-    private Float downloadCount;
-
-    @Column(name = "share_rate")
-    private Float shareRate;
-
-    @Column(name = "registration_date", nullable = false)
-    private Date registrationDate;
-
-    @Column(name = "last_login_time")
-    private Date lastLoginTime;
-
-    @Column(name = "user_points")
-    private Integer userPoints;
-
-    @Column(name = "is_promo")
-    private Boolean isPromo;
-
-    @Column(name = "current_experience", nullable = false)
-    private Integer currentExperience;  // 当前经验值
-
-    @Column(name = "current_seeding_hours", nullable = false)
-    private Float currentSeedingHours;  // 当前做种时长
-
-
-    @Column(name = "gender", nullable = true)
-    private String gender;  // 性别
-
-    @Column(name = "description", nullable = true)
-    private String description;  // 个人描述
-
-    @Column(name = "hobbies", nullable = true)
-    private String hobbies;
-
-    @Column(name = "registration_time", nullable = false, updatable = false)
-    @Temporal(TemporalType.TIMESTAMP)
-    private Date registrationTime;
-
-    // Getters and Setters
-    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 String getAvatarUrl() {
-        return avatarUrl;
-    }
-
-    public void setAvatarUrl(String avatarUrl) {
-        this.avatarUrl = avatarUrl;
-    }
-
-    public String getEmail() {
-        return email;
-    }
-
-    public void setEmail(String email) {
-        this.email = email;
-    }
-
-    public String getPassword() {
-        return password;
-    }
-
-    public void setPassword(String password) {
-        this.password = password;
-    }
-
-    public String getRole() {
-        return role;
-    }
-
-    public void setRole(String role) {
-        this.role = role;
-    }
-
-    public Integer getInviteCount() {
-        return inviteCount;
-    }
-
-    public void setInviteCount(Integer inviteCount) {
-        this.inviteCount = inviteCount;
-    }
-
-    public Long getLevel() {
-        return level;
-    }
-
-    public void setLevel(Long level) {
-        this.level = level;
-    }
-
-    public Float getUploadCount() {
-        return uploadCount;
-    }
-
-    public void setUploadCount(Float uploadCount) {
-        this.uploadCount = uploadCount;
-    }
-
-    public Float getDownloadCount() {
-        return downloadCount;
-    }
-
-    public void setDownloadCount(Float downloadCount) {
-        this.downloadCount = downloadCount;
-    }
-
-    public Float getShareRate() {
-        return shareRate;
-    }
-
-    public void setShareRate(Float shareRate) {
-        this.shareRate = shareRate;
-    }
-
-    public Date getRegistrationDate() {
-        return registrationDate;
-    }
-
-    public void setRegistrationDate(Date registrationDate) {
-        this.registrationDate = registrationDate;
-    }
-
-    public Date getLastLoginTime() {
-        return lastLoginTime;
-    }
-
-    public void setLastLoginTime(Date lastLoginTime) {
-        this.lastLoginTime = lastLoginTime;
-    }
-
-    public Integer getUserPoints() {
-        return userPoints;
-    }
-
-    public void setUserPoints(Integer userPoints) {
-        this.userPoints = userPoints;
-    }
-
-    public Boolean getIsPromo() {
-        return isPromo;
-    }
-
-    public void setIsPromo(Boolean isPromo) {
-        this.isPromo = isPromo;
-    }
-
-    public Integer getCurrentExperience() {
-        return currentExperience;
-    }
-
-    public void setCurrentExperience(Integer currentExperience) {
-        this.currentExperience = currentExperience;
-    }
-
-    public Float getCurrentSeedingHours() {
-        return currentSeedingHours;
-    }
-
-    public void setCurrentSeedingHours(Float currentSeedingHours) {
-        this.currentSeedingHours = currentSeedingHours;
-    }
-
-    public String getGender() {
-        return gender;
-    }
-
-    public void setGender(String gender) {
-        this.gender = gender;
-    }
-
-    public String getDescription() {
-        return description;
-    }
-
-    public void setDescription(String description) {
-        this.description = description;
-    }
-
-    public String getHobbies() {
-        return hobbies;
-    }
-
-    public void setHobbies(String hobbies) {
-        this.hobbies = hobbies;
-    }
-
-    public Date getRegistrationTime() {
-        return registrationTime;
-    }
-
-    public void setRegistrationTime(Date registrationTime) {
-        this.registrationTime = registrationTime;
-    }
-
-}
diff --git a/src/main/java/com/example/myproject/repository/CollectionsRepository.java b/src/main/java/com/example/myproject/repository/CollectionsRepository.java
deleted file mode 100644
index 4b192bd..0000000
--- a/src/main/java/com/example/myproject/repository/CollectionsRepository.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.Collections;
-import jakarta.transaction.Transactional;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Modifying;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface CollectionsRepository extends JpaRepository<Collections, Long> {
-    @Modifying
-    @Transactional
-    @Query("DELETE FROM Collections l WHERE l.userId = :userId AND l.postNo = :postNo")
-    void deleteLikeByUserIdAndPostNo(Long userId, Long postNo);
-}
diff --git a/src/main/java/com/example/myproject/repository/CommentRepository.java b/src/main/java/com/example/myproject/repository/CommentRepository.java
deleted file mode 100644
index 4f66309..0000000
--- a/src/main/java/com/example/myproject/repository/CommentRepository.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.Comments;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-
-public interface CommentRepository extends JpaRepository<Comments, Long> {
-
-}
diff --git a/src/main/java/com/example/myproject/repository/DynamicCommentRepository.java b/src/main/java/com/example/myproject/repository/DynamicCommentRepository.java
deleted file mode 100644
index f586b1d..0000000
--- a/src/main/java/com/example/myproject/repository/DynamicCommentRepository.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.DynamicComment;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-
-public interface DynamicCommentRepository extends JpaRepository<DynamicComment, Long> {
-
-    List<DynamicComment> findByDynamicId(Long dynamicId);
-}
diff --git a/src/main/java/com/example/myproject/repository/DynamicLikesRepository.java b/src/main/java/com/example/myproject/repository/DynamicLikesRepository.java
deleted file mode 100644
index 1cec003..0000000
--- a/src/main/java/com/example/myproject/repository/DynamicLikesRepository.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.DynamicLikes;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-
-public interface DynamicLikesRepository extends JpaRepository<DynamicLikes, Long> {
-
-    List<DynamicLikes> findByDynamicId(Long dynamicId);
-    DynamicLikes findByUserIdAndDynamicId(Long userId, Long dynamicId);
-}
diff --git a/src/main/java/com/example/myproject/repository/ExperienceHistoryRepository.java b/src/main/java/com/example/myproject/repository/ExperienceHistoryRepository.java
deleted file mode 100644
index 76928e5..0000000
--- a/src/main/java/com/example/myproject/repository/ExperienceHistoryRepository.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.ExperienceHistory;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface ExperienceHistoryRepository extends JpaRepository<ExperienceHistory, Long> {
-
-}
diff --git a/src/main/java/com/example/myproject/repository/FriendRelationRepository.java b/src/main/java/com/example/myproject/repository/FriendRelationRepository.java
deleted file mode 100644
index 8fcf94e..0000000
--- a/src/main/java/com/example/myproject/repository/FriendRelationRepository.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.FriendRelation;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-
-public interface FriendRelationRepository extends JpaRepository<FriendRelation, Long> {
-    // 查找当前用户的所有好友ID
-    List<FriendRelation> findByUserId(Long userId);
-}
diff --git a/src/main/java/com/example/myproject/repository/GroupCommentsRepository.java b/src/main/java/com/example/myproject/repository/GroupCommentsRepository.java
deleted file mode 100644
index 47df198..0000000
--- a/src/main/java/com/example/myproject/repository/GroupCommentsRepository.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.GroupComments;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface GroupCommentsRepository extends JpaRepository<GroupComments, Long> {
-
-}
diff --git a/src/main/java/com/example/myproject/repository/GroupMembersRepository.java b/src/main/java/com/example/myproject/repository/GroupMembersRepository.java
deleted file mode 100644
index 2d31462..0000000
--- a/src/main/java/com/example/myproject/repository/GroupMembersRepository.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.GroupMembers;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface GroupMembersRepository extends JpaRepository<GroupMembers, Long> {
-
-    // 检查用户是否已经是该小组的成员
-    boolean existsByGroupIdAndUserId(Long groupId, Long userId);
-
-    // 删除用户和小组的关联记录
-    void deleteByGroupIdAndUserId(Long groupId, Long userId);
-
-    // 通过 groupId 获取所有成员的 userId
-    List<GroupMembers> findByGroupId(Long groupId);
-}
diff --git a/src/main/java/com/example/myproject/repository/GroupPostRepository.java b/src/main/java/com/example/myproject/repository/GroupPostRepository.java
deleted file mode 100644
index 9f5a348..0000000
--- a/src/main/java/com/example/myproject/repository/GroupPostRepository.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.GroupPost;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface GroupPostRepository extends JpaRepository<GroupPost, Long> {
-
-    List<GroupPost> findByGroupId(Long groupId);
-
-}
diff --git a/src/main/java/com/example/myproject/repository/GroupRepository.java b/src/main/java/com/example/myproject/repository/GroupRepository.java
deleted file mode 100644
index 7280e50..0000000
--- a/src/main/java/com/example/myproject/repository/GroupRepository.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.Group;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.data.repository.query.Param;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface GroupRepository extends JpaRepository<Group, Long> {
-
-    // 模糊搜索小组名称并按类别筛选
-    @Query("SELECT g FROM Group g WHERE g.groupName LIKE %:name% AND (:category IS NULL OR g.category = :category)")
-    Page<Group> searchGroups(@Param("name") String name, @Param("category") String category, Pageable pageable);
-
-    // 根据类别筛选小组
-    @Query("SELECT g FROM Group g WHERE (:category IS NULL OR g.category = :category)")
-    Page<Group> searchWithFilters(@Param("category") String category, Pageable pageable);
-}
diff --git a/src/main/java/com/example/myproject/repository/LevelRepository.java b/src/main/java/com/example/myproject/repository/LevelRepository.java
deleted file mode 100644
index 12e8269..0000000
--- a/src/main/java/com/example/myproject/repository/LevelRepository.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.Level;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface LevelRepository extends JpaRepository<Level, Long> {
-
-}
diff --git a/src/main/java/com/example/myproject/repository/LikesRepository.java b/src/main/java/com/example/myproject/repository/LikesRepository.java
deleted file mode 100644
index 79146c5..0000000
--- a/src/main/java/com/example/myproject/repository/LikesRepository.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.Likes;
-import jakarta.transaction.Transactional;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.data.jpa.repository.Modifying;
-import org.springframework.data.jpa.repository.Query;
-import org.springframework.stereotype.Repository;
-
-@Repository
-public interface LikesRepository extends JpaRepository<Likes, Long> {
-    @Modifying
-    @Transactional
-    @Query("DELETE FROM Likes l WHERE l.userId = :userId AND l.postNo = :postNo")
-    void deleteLikeByUserIdAndPostNo(Long userId, Long postNo);
-}
diff --git a/src/main/java/com/example/myproject/repository/PostRepository.java b/src/main/java/com/example/myproject/repository/PostRepository.java
deleted file mode 100644
index faf2cb7..0000000
--- a/src/main/java/com/example/myproject/repository/PostRepository.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.Post;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.Optional;
-
-public interface PostRepository extends JpaRepository<Post, Long> {
-    // 根据 postNo 查找帖子
-    Optional<Post> findByPostNo(Long postNo);
-
-}
diff --git a/src/main/java/com/example/myproject/repository/TaskRepository.java b/src/main/java/com/example/myproject/repository/TaskRepository.java
deleted file mode 100644
index 25e1b66..0000000
--- a/src/main/java/com/example/myproject/repository/TaskRepository.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.Task;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-public interface TaskRepository extends JpaRepository<Task, String> {
-}
diff --git a/src/main/java/com/example/myproject/repository/UserDynamicRepository.java b/src/main/java/com/example/myproject/repository/UserDynamicRepository.java
deleted file mode 100644
index 575ae1f..0000000
--- a/src/main/java/com/example/myproject/repository/UserDynamicRepository.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.UserDynamic;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface UserDynamicRepository extends JpaRepository<UserDynamic, Long> {
-
-    List<UserDynamic> findByUserId(Long userId);
-
-}
diff --git a/src/main/java/com/example/myproject/repository/UserFollowRepository.java b/src/main/java/com/example/myproject/repository/UserFollowRepository.java
deleted file mode 100644
index 542d07f..0000000
--- a/src/main/java/com/example/myproject/repository/UserFollowRepository.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.UserFollow;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface UserFollowRepository extends JpaRepository<UserFollow, Long> {
-
-    // 查询是否存在某个用户的关注记录
-    UserFollow findByFollowerIdAndFollowedId(Long followerId, Long followedId);
-    List<UserFollow> findByFollowedId(Long followedId);
-    List<UserFollow> findByFollowerId(Long followerId);
-}
diff --git a/src/main/java/com/example/myproject/repository/UserInviteCodeRepository.java b/src/main/java/com/example/myproject/repository/UserInviteCodeRepository.java
deleted file mode 100644
index 02fa390..0000000
--- a/src/main/java/com/example/myproject/repository/UserInviteCodeRepository.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.UserInviteCode;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-import java.util.Optional;
-
-public interface UserInviteCodeRepository extends JpaRepository<UserInviteCode, Long> {
-
-    // 查找某个用户的所有邀请码
-    List<UserInviteCode> findByUserId(Long userId);
-
-    // 查找某个邀请码是否已经被使用
-    Optional<UserInviteCode> findByInviteCode(String inviteCode);
-
-    // 查找某个用户未使用的邀请码
-    List<UserInviteCode> findByUserIdAndIsUsedFalse(Long userId);
-}
diff --git a/src/main/java/com/example/myproject/repository/UserMessagesRepository.java b/src/main/java/com/example/myproject/repository/UserMessagesRepository.java
deleted file mode 100644
index bad3715..0000000
--- a/src/main/java/com/example/myproject/repository/UserMessagesRepository.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.UserMessages;
-import org.springframework.data.jpa.repository.JpaRepository;
-import org.springframework.stereotype.Repository;
-
-import java.util.List;
-
-@Repository
-public interface UserMessagesRepository extends JpaRepository<UserMessages, Long> {
-
-    // 查询当前用户的所有消息
-    List<UserMessages> findBySenderIdOrReceiverId(Long senderId, Long receiverId);
-}
diff --git a/src/main/java/com/example/myproject/repository/UserRepository.java b/src/main/java/com/example/myproject/repository/UserRepository.java
deleted file mode 100644
index 6927c5f..0000000
--- a/src/main/java/com/example/myproject/repository/UserRepository.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.Users;
-import org.springframework.data.jpa.repository.JpaRepository;
-import java.util.Optional;
-
-public interface UserRepository extends JpaRepository<Users, Long> {
-    Optional<Users> findByEmail(String email);
-    Optional<Users> findByUsername(String username);
-}
diff --git a/src/main/java/com/example/myproject/repository/UserTaskStatusRepository.java b/src/main/java/com/example/myproject/repository/UserTaskStatusRepository.java
deleted file mode 100644
index 0153946..0000000
--- a/src/main/java/com/example/myproject/repository/UserTaskStatusRepository.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package com.example.myproject.repository;
-
-import com.example.myproject.entity.UserTaskStatus;
-import org.springframework.data.jpa.repository.JpaRepository;
-
-import java.util.List;
-import java.util.Optional;
-
-public interface UserTaskStatusRepository extends JpaRepository<UserTaskStatus, Long> {
-    Optional<UserTaskStatus> findByUserIdAndTaskId(Long userId, String taskId);
-    List<UserTaskStatus> findByUserIdAndStatus(Long userId, String status);
-    Optional<UserTaskStatus> findFirstByUserIdAndStatus(Long userId, String status);
-}
diff --git a/src/main/java/com/example/myproject/service/CommentService.java b/src/main/java/com/example/myproject/service/CommentService.java
deleted file mode 100644
index c102ca2..0000000
--- a/src/main/java/com/example/myproject/service/CommentService.java
+++ /dev/null
@@ -1,125 +0,0 @@
-package com.example.myproject.service;
-
-import com.example.myproject.entity.Comments;
-import com.example.myproject.entity.Post;
-import com.example.myproject.entity.Users;
-import com.example.myproject.repository.CommentRepository;
-import com.example.myproject.repository.PostRepository;
-import com.example.myproject.repository.UserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-@Service
-public class CommentService {
-
-    @Autowired
-    private CommentRepository commentRepository;
-
-    @Autowired
-    private PostRepository postRepository;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    // 添加评论
-    public void addComment(Long postId, Comments comment) {
-        try {
-            // 查找帖子
-            Post post = postRepository.findById(postId).orElseThrow(() -> {
-                throw new RuntimeException("Post with ID " + postId + " not found");
-            });
-
-            // 查找用户
-            Users user = userRepository.findById(comment.getUserId()).orElseThrow(() -> {
-                throw new RuntimeException("User with ID " + comment.getUserId() + " not found");
-            });
-
-            // 设置评论的相关属性
-            comment.setPost(post);
-            comment.setUserId(user.getUserId());
-            comment.setCommentTime(new java.util.Date());
-
-            if (comment.getParentComment() != null && comment.getParentComment() != 0) {
-                // 查找父评论
-                Comments parentComment = commentRepository.findById(comment.getParentComment())
-                        .orElseThrow(() -> new RuntimeException("Parent comment with ID " + comment.getParentComment() + " not found"));
-                comment.setParentComment(parentComment.getCommentId());  // 设置父评论 ID
-            } else {
-                comment.setParentComment(0L);  // 设置为 0，表示没有父评论
-            }
-
-            // 保存评论
-            commentRepository.save(comment);
-        } catch (Exception e) {
-            // 捕获任何异常并打印堆栈信息
-            e.printStackTrace();
-            throw new RuntimeException("An error occurred while adding the comment: " + e.getMessage());
-        }
-    }
-
-    // 获取指定帖子的所有评论
-    public List<Map<String, Object>> getCommentsByPostId(Long postId) {
-        List<Comments> comments = commentRepository.findAll()
-                .stream()
-                .filter(comment -> comment.getPost().getPostNo().equals(postId))  // 通过 post 的 postNo 过滤评论
-                .collect(Collectors.toList());
-
-        if (comments.isEmpty()) {
-            return new ArrayList<>();
-        }
-
-        List<Map<String, Object>> result = new ArrayList<>();
-        for (Comments comment : comments) {
-            Map<String, Object> commentData = new LinkedHashMap<>();
-            commentData.put("commentId", comment.getCommentId());
-            commentData.put("post_id", comment.getPost().getPostNo());
-            commentData.put("userId", comment.getUserId());
-
-            Users user = userRepository.findById(comment.getUserId()).orElse(null);
-            commentData.put("nickname", user != null ? user.getUsername() : null);
-            commentData.put("avatar_url", user != null ? user.getAvatarUrl() : null);
-
-            commentData.put("content", comment.getContent());
-            commentData.put("isAnonymous", comment.getIsAnonymous());
-            commentData.put("likesCount", comment.getLikesCount());
-            commentData.put("replyCount", comment.getReplyCount());
-            commentData.put("commentTime", comment.getCommentTime());
-            commentData.put("parentComment", comment.getParentComment());
-
-            Map<String, Object> parentCommentData = getParentCommentData(comment.getParentComment());
-            commentData.put("parentCommentData", parentCommentData);
-
-            result.add(commentData);
-        }
-
-        return result;
-    }
-
-    // 递归查找父评论的内容
-    private Map<String, Object> getParentCommentData(Long parentCommentId) {
-        Map<String, Object> parentCommentData = new LinkedHashMap<>();
-        if (parentCommentId != null && parentCommentId != 0) {
-            // 查找父评论
-            Comments parentComment = commentRepository.findById(parentCommentId).orElse(null);
-            if (parentComment != null) {
-                parentCommentData.put("commentId", parentComment.getCommentId());
-                parentCommentData.put("content", parentComment.getContent());
-                parentCommentData.put("userId", parentComment.getUserId());
-
-                Users user = userRepository.findById(parentComment.getUserId()).orElse(null);
-                parentCommentData.put("nickname", user != null ? user.getUsername() : null);
-                parentCommentData.put("avatar_url", user != null ? user.getAvatarUrl() : null);
-
-                Map<String, Object> grandParentData = getParentCommentData(parentComment.getParentComment());
-                parentCommentData.put("parentCommentData", grandParentData);
-            }
-        }
-        return parentCommentData;
-    }
-}
diff --git a/src/main/java/com/example/myproject/service/DynamicService.java b/src/main/java/com/example/myproject/service/DynamicService.java
deleted file mode 100644
index 853604d..0000000
--- a/src/main/java/com/example/myproject/service/DynamicService.java
+++ /dev/null
@@ -1,275 +0,0 @@
-package com.example.myproject.service;
-
-import com.example.myproject.entity.*;
-import com.example.myproject.repository.*;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.*;
-
-@Service
-public class DynamicService {
-
-    @Autowired
-    private UserDynamicRepository userDynamicRepository;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Autowired
-    private DynamicCommentRepository dynamicCommentRepository;
-
-    @Autowired
-    private DynamicLikesRepository dynamicLikesRepository;
-
-    @Autowired
-    private FriendRelationRepository friendRelationRepository;
-
-    private static final String IMAGE_DIR = "uploads/post/";
-
-    // 创建好友动态
-    public Map<String, Object> createDynamic(Long userId, String title, String content, MultipartFile[] imageFiles) {
-        // 查找用户信息
-        Users user = userRepository.findById(userId)
-                .orElseThrow(() -> new RuntimeException("User not found"));
-
-        // 创建新的动态
-        UserDynamic userDynamic = new UserDynamic();
-        userDynamic.setUserId(userId);
-        userDynamic.setTitle(title != null ? title : "默认标题");
-        userDynamic.setContent(content);
-        userDynamic.setTime(new Date());
-        userDynamic.setLikesCount(0);
-        userDynamic.setCommentsCount(0);
-
-        // 处理图片上传
-        StringBuilder imageUrlsBuilder = new StringBuilder();
-        if (imageFiles != null && imageFiles.length > 0) {
-            for (int i = 0; i < imageFiles.length; i++) {
-                if (i > 0) {
-                    imageUrlsBuilder.append(",");
-                }
-                try {
-                    String imageUrl = saveImage(imageFiles[i]);
-                    imageUrlsBuilder.append(imageUrl);
-                } catch (IOException e) {
-                    throw new RuntimeException("Image upload failed: " + e.getMessage());
-                }
-            }
-        }
-
-        // 将多个图片 URL 拼接
-        userDynamic.setImageUrl(imageUrlsBuilder.toString());
-
-        // 保存数据库
-        UserDynamic savedUserDynamic = userDynamicRepository.save(userDynamic);
-
-        // 返回结果
-        Map<String, Object> response = new HashMap<>();
-        response.put("dynamicId", savedUserDynamic.getDynamicId());
-        response.put("message", "动态创建成功");
-        return response;
-    }
-
-    // 保存图片并返回图片的 URL
-    public String saveImage(MultipartFile imageFile) throws IOException {
-        String fileName = imageFile.getOriginalFilename();
-        Path path = Paths.get(IMAGE_DIR + fileName);
-        Files.createDirectories(path.getParent());
-        Files.write(path, imageFile.getBytes());
-        return "/images/" + fileName;
-    }
-
-    // 删除动态
-    public void deleteDynamic(Long dynamicId) {
-        if (userDynamicRepository.existsById(dynamicId)) {
-            userDynamicRepository.deleteById(dynamicId);
-        } else {
-            throw new RuntimeException("Dynamic with id " + dynamicId + " not found");
-        }
-    }
-
-    //好友动态评论
-    public Map<String, Object> addComment(Long userId, Long dynamicId, String commentContent) {
-        Users user = userRepository.findById(userId)
-                .orElseThrow(() -> new RuntimeException("User not found"));
-
-        UserDynamic dynamic = userDynamicRepository.findById(dynamicId)
-                .orElseThrow(() -> new RuntimeException("Dynamic not found"));
-
-        DynamicComment comment = new DynamicComment();
-        comment.setDynamicId(dynamicId);
-        comment.setUserId(userId);
-        comment.setCommentContent(commentContent);
-        comment.setCommentTime(new Date());
-
-        // 保存评论
-        DynamicComment savedComment = dynamicCommentRepository.save(comment);
-
-        // 返回成功消息
-        Map<String, Object> response = new HashMap<>();
-        response.put("comment_id", savedComment.getCommentId());
-        response.put("message", "评论成功");
-        return response;
-    }
-
-    //返回某个好友的所有动态
-    public Map<String, Object> getAllUserDynamics(Long userId) {
-        // 查找用户的所有动态
-        List<UserDynamic> userDynamics = userDynamicRepository.findByUserId(userId);
-        Map<String, Object> postData = new LinkedHashMap<>();
-        List<Map<String, Object>> dynamicList = new ArrayList<>();
-
-        // 遍历动态，获取点赞和评论
-        for (UserDynamic dynamic : userDynamics) {
-            Map<String, Object> dynamicData = new LinkedHashMap<>();
-            dynamicData.put("dynamic_id", dynamic.getDynamicId());
-            dynamicData.put("user_id", dynamic.getUserId());
-
-            Users user = userRepository.findById(dynamic.getUserId()).orElse(null);
-            if (user != null) {
-                dynamicData.put("username", user.getUsername());
-                dynamicData.put("avatar_url", user.getAvatarUrl());
-            } else {
-                dynamicData.put("username", "Unknown");
-                dynamicData.put("avatar_url", "http://example.com/default-avatar.jpg");
-            }
-
-            dynamicData.put("title", dynamic.getTitle());
-            dynamicData.put("content", dynamic.getContent());
-            dynamicData.put("images", dynamic.getImageUrl());
-            dynamicData.put("time", dynamic.getTime());
-
-            // 获取点赞
-            List<DynamicLikes> likes = dynamicLikesRepository.findByDynamicId(dynamic.getDynamicId());
-            List<Map<String, Object>> likeList = new ArrayList<>();
-            for (DynamicLikes like : likes) {
-                Map<String, Object> likeData = new HashMap<>();
-                likeData.put("user_id", like.getUserId());
-
-                // 获取点赞用户的用户名
-                Users likeUser = userRepository.findById(like.getUserId()).orElse(null);
-                if (likeUser != null) {
-                    likeData.put("username", likeUser.getUsername());
-                } else {
-                    likeData.put("username", "Unknown");
-                }
-
-                likeList.add(likeData);
-            }
-            dynamicData.put("likes", likeList);
-
-            // 获取评论
-            List<DynamicComment> comments = dynamicCommentRepository.findByDynamicId(dynamic.getDynamicId());
-            List<Map<String, Object>> commentList = new ArrayList<>();
-            for (DynamicComment comment : comments) {
-                Map<String, Object> commentData = new HashMap<>();
-                commentData.put("comment_id", comment.getCommentId());
-                commentData.put("user_id", comment.getUserId());
-
-                // 获取评论用户的用户名
-                Users commentUser = userRepository.findById(comment.getUserId()).orElse(null);
-                if (commentUser != null) {
-                    commentData.put("username", commentUser.getUsername());
-                } else {
-                    commentData.put("username", "Unknown");
-                }
-
-                commentData.put("content", comment.getCommentContent());
-                commentData.put("time", comment.getCommentTime());
-                commentList.add(commentData);
-            }
-            dynamicData.put("comments", commentList);
-
-            dynamicList.add(dynamicData);
-        }
-
-        Map<String, Object> response = new HashMap<>();
-        response.put("dynamic", dynamicList);
-        return response;
-    }
-
-    //获取当前所有好友的id
-    public List<Long> getAllFriendIds(Long userId) {
-        List<FriendRelation> friendRelations = friendRelationRepository.findByUserId(userId);
-        List<Long> friendIds = new ArrayList<>();
-
-        for (FriendRelation relation : friendRelations) {
-            // 添加好友ID
-            if (!friendIds.contains(relation.getFriendId())) {
-                friendIds.add(relation.getFriendId());
-            }
-        }
-
-        return friendIds;
-    }
-
-    public Map<String, Object> getAllUserAndFriendsDynamics(List<Long> userIds) {
-        List<Map<String, Object>> allDynamics = new ArrayList<>();
-
-        // 遍历所有用户获取他们的动态
-        for (Long userId : userIds) {
-            Map<String, Object> userDynamics = getAllUserDynamics(userId);
-            if (userDynamics != null && !userDynamics.isEmpty()) {
-                allDynamics.addAll((List<Map<String, Object>>) userDynamics.get("dynamic"));
-            }
-        }
-
-        // 返回所有动态的合集
-        Map<String, Object> response = new HashMap<>();
-        response.put("dynamic", allDynamics);
-        return response;
-    }
-
-    //点赞动态
-    public boolean likeDynamic(Long userId, Long dynamicId) {
-        // 检查该用户是否已经点赞过该动态
-        DynamicLikes existingLike = dynamicLikesRepository.findByUserIdAndDynamicId(userId, dynamicId);
-        if (existingLike != null) {
-            return false;
-        }
-
-        // 新增点赞记录
-        DynamicLikes newLike = new DynamicLikes();
-        newLike.setUserId(userId);
-        newLike.setDynamicId(dynamicId);
-        newLike.setLikeTime(new java.util.Date());
-        dynamicLikesRepository.save(newLike);
-
-        // 更新动态表的点赞数
-        UserDynamic dynamic = userDynamicRepository.findById(dynamicId).orElse(null);
-        if (dynamic != null) {
-            dynamic.setLikesCount(dynamic.getLikesCount() + 1);
-            userDynamicRepository.save(dynamic);
-        }
-
-        return true;
-    }
-
-    //取消点赞
-    public boolean unlikeDynamic(Long userId, Long dynamicId) {
-        // 查找该用户的点赞记录
-        DynamicLikes existingLike = dynamicLikesRepository.findByUserIdAndDynamicId(userId, dynamicId);
-        if (existingLike == null) {
-            return false;
-        }
-
-        // 删除点赞记录
-        dynamicLikesRepository.delete(existingLike);
-
-        // 更新动态表的点赞数
-        UserDynamic dynamic = userDynamicRepository.findById(dynamicId).orElse(null);
-        if (dynamic != null) {
-            dynamic.setLikesCount(dynamic.getLikesCount() - 1);
-            userDynamicRepository.save(dynamic);
-        }
-
-        return true;
-    }
-
-}
diff --git a/src/main/java/com/example/myproject/service/GroupService.java b/src/main/java/com/example/myproject/service/GroupService.java
deleted file mode 100644
index 016d7e0..0000000
--- a/src/main/java/com/example/myproject/service/GroupService.java
+++ /dev/null
@@ -1,382 +0,0 @@
-package com.example.myproject.service;
-
-import com.example.myproject.entity.*;
-
-import com.example.myproject.repository.*;
-import jakarta.transaction.Transactional;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.data.domain.Page;
-import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.domain.Sort;
-import org.springframework.http.ResponseEntity;
-import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
-import java.io.IOException;
-import java.nio.file.Path;
-import java.nio.file.Files;
-
-import java.util.*;
-
-@Service
-public class GroupService {
-
-    @Autowired
-    private GroupRepository groupRepository;
-
-    @Autowired
-    private GroupMembersRepository groupMembersRepository;
-
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Autowired
-    private GroupPostRepository groupPostRepository;
-
-    @Autowired
-    private GroupCommentsRepository groupCommentsRepository;
-
-    private static final String IMAGE_DIR = "uploads/groupPost/";
-
-    @Transactional
-    // 创建小组的方法
-    public ResponseEntity<Map<String, Object>> createGroup(Group groupRequest) {
-        try {
-            // 创建新的小组对象
-            Group newGroup = new Group();
-            newGroup.setGroupName(groupRequest.getGroupName());
-            newGroup.setDescription(groupRequest.getDescription());
-            newGroup.setCreateTime(new Date());
-            newGroup.setUserId(groupRequest.getUserId());
-            newGroup.setMemberCount(1);
-            newGroup.setCategory(groupRequest.getCategory());
-            newGroup.setCoverImage(groupRequest.getCoverImage());
-            Group createdGroup = groupRepository.save(newGroup);
-
-            // 返回成功响应
-            Map<String, Object> response = new HashMap<>();
-            response.put("status", "success");
-            response.put("message", "兴趣小组创建成功");
-            response.put("group_id", createdGroup.getGroupId());
-
-            return ResponseEntity.ok(response);
-        } catch (Exception e) {
-            // 返回失败响应
-            Map<String, Object> errorResponse = new HashMap<>();
-            errorResponse.put("status", "error");
-            errorResponse.put("message", "小组创建失败");
-            errorResponse.put("group_id", null);
-
-            return ResponseEntity.status(400).body(errorResponse);
-        }
-    }
-
-
-    // 加入小组
-    @Transactional
-    public ResponseEntity<Map<String, Object>> joinGroup(Long groupId, Long userId) {
-        // 查找小组
-        Optional<Group> groupOptional = groupRepository.findById(groupId);
-        if (!groupOptional.isPresent()) {
-            return ResponseEntity.status(400).body(
-                    Map.of("status", "failure", "message", "小组不存在")
-            );
-        }
-
-        Group group = groupOptional.get();
-
-        // 检查用户是否已经是该小组成员
-        if (groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
-            return ResponseEntity.status(400).body(
-                    Map.of("status", "failure", "message", "用户已经是该小组的成员")
-            );
-        }
-
-        // 插入用户和小组的关联记录
-        GroupMembers groupMembers = new GroupMembers();
-        groupMembers.setGroupId(groupId);
-        groupMembers.setUserId(userId);
-        groupMembersRepository.save(groupMembers);
-
-        // 更新小组的成员数
-        group.setMemberCount(group.getMemberCount() + 1);
-        groupRepository.save(group);
-
-        return ResponseEntity.ok().body(
-                Map.of("status", "success", "message", "成功加入小组")
-        );
-    }
-
-    // 退出小组
-    @Transactional
-    public ResponseEntity<Map<String, Object>> leaveGroup(Long groupId, Long userId) {
-        // 查找小组
-        Optional<Group> groupOptional = groupRepository.findById(groupId);
-        if (!groupOptional.isPresent()) {
-            return ResponseEntity.status(400).body(
-                    Map.of("status", "failure", "message", "小组不存在")
-            );
-        }
-
-        Group group = groupOptional.get();
-
-        // 检查用户是否是该小组成员
-        if (!groupMembersRepository.existsByGroupIdAndUserId(groupId, userId)) {
-            return ResponseEntity.status(400).body(
-                    Map.of("status", "failure", "message", "用户不是该小组的成员")
-            );
-        }
-
-        // 删除用户和小组的关联记录
-        groupMembersRepository.deleteByGroupIdAndUserId(groupId, userId);
-
-        // 更新小组的成员数
-        group.setMemberCount(group.getMemberCount() - 1);
-        groupRepository.save(group);
-
-        return ResponseEntity.ok().body(
-                Map.of("status", "success", "message", "成功退出小组")
-        );
-    }
-
-    // 获取所有成员
-    @Transactional
-    public ResponseEntity<Map<String, Object>> getGroupMembers(Long groupId) {
-        // 查找小组
-        Optional<Group> groupOptional = groupRepository.findById(groupId);
-        if (!groupOptional.isPresent()) {
-            return ResponseEntity.status(400).body(
-                    Map.of("status", "failure", "message", "小组不存在")
-            );
-        }
-
-        Group group = groupOptional.get();
-
-        // 获取所有小组成员
-        List<GroupMembers> groupMembersList = groupMembersRepository.findByGroupId(groupId);
-
-        // 创建成员返回列表
-        List<Map<String, Object>> members = new ArrayList<>();
-        for (GroupMembers groupMember : groupMembersList) {
-            Optional<Users> userOptional = userRepository.findById(groupMember.getUserId());
-            if (userOptional.isPresent()) {
-                Users user = userOptional.get();
-                members.add(Map.of(
-                        "user_id", user.getUserId(),
-                        "username", user.getUsername(),
-                        "avatar_url", user.getAvatarUrl()
-                ));
-            }
-        }
-
-        return ResponseEntity.ok().body(
-                Map.of("status", "success", "members", members)
-        );
-    }
-
-
-    //发布帖子
-    public Map<String, Object> createPost(Long groupId, Long userId, String postContent, String title, MultipartFile[] imageFiles) {
-        // 创建一个新的帖子对象
-        GroupPost post = new GroupPost();
-        post.setGroupId(groupId);
-        post.setUserId(userId);
-        post.setContent(postContent);
-        post.setTitle(title);
-        post.setTime(new Date());
-        post.setLikeCount(0);
-        post.setCommentCount(0);
-
-        // 处理图片上传，如果没有图片，返回空字符串
-        String imageUrls = handleImages(imageFiles);
-        post.setImage(imageUrls);
-
-        // 保存帖子到数据库
-        GroupPost savedPost = groupPostRepository.save(post);
-
-        // 返回结果
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("post_id", savedPost.getGroupPostId());
-        response.put("message", "帖子创建成功");
-        return response;
-    }
-
-    // 处理图片上传的方法，返回图片的 URL 字符串
-    private String handleImages(MultipartFile[] imageFiles) {
-        if (imageFiles == null || imageFiles.length == 0) {
-            return "";
-        }
-
-        StringBuilder imageUrlsBuilder = new StringBuilder();
-
-        for (int i = 0; i < imageFiles.length; i++) {
-            if (i > 0) {
-                imageUrlsBuilder.append(",");
-            }
-            try {
-                String imageUrl = saveImage(imageFiles[i]);
-                imageUrlsBuilder.append(imageUrl);
-            } catch (IOException e) {
-                throw new RuntimeException("图片上传失败: " + e.getMessage());
-            }
-        }
-        return imageUrlsBuilder.toString();
-    }
-
-    // 保存图片并返回图片的 URL
-    private String saveImage(MultipartFile imageFile) throws IOException {
-        if (imageFile == null) {
-            throw new IOException("图片文件为空");
-        }
-
-        String fileName = imageFile.getOriginalFilename();
-        Path path = Path.of(IMAGE_DIR + fileName);
-        Files.createDirectories(path.getParent());
-        Files.write(path, imageFile.getBytes());
-        return "/images/" + fileName;
-    }
-
-    // 获取小组内的所有帖子
-    public Map<String, Object> getAllPosts(Long groupId) {
-        List<GroupPost> posts = groupPostRepository.findByGroupId(groupId);
-
-        List<Map<String, Object>> postList = new ArrayList<>();
-
-        for (GroupPost post : posts) {
-            Map<String, Object> postData = new HashMap<>();
-            Users user = userRepository.findById(post.getUserId()).orElseThrow(() -> new RuntimeException("User not found"));
-            postData.put("group_post_id", post.getGroupPostId());
-            postData.put("user_id", post.getUserId());
-            postData.put("username", user.getUsername());
-            postData.put("title", post.getTitle());
-            postData.put("content", post.getContent());
-            postData.put("time", post.getTime());
-
-            postList.add(postData);
-        }
-
-        // 返回响应数据
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("status", "success");
-        response.put("posts", postList);
-        return response;
-    }
-
-
-    // 获取小组列表接口
-    public Map<String, Object> searchGroups(Map<String, Object> params) {
-        String name = (String) params.get("name");
-        String category = (String) params.get("category");
-        Integer page = (Integer) params.getOrDefault("page", 1);
-        Integer size = (Integer) params.getOrDefault("size", 10);
-        String sortBy = (String) params.getOrDefault("sort_by", "memberCount");
-
-        // 构建分页对象
-        Pageable pageable;
-
-        // 根据 `sortBy` 判断排序方式
-        if ("createTime".equals(sortBy)) {
-            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("createTime")));
-        } else if ("groupName".equals(sortBy)) {
-            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.asc("groupName")));
-        } else {
-            pageable = PageRequest.of(page - 1, size, Sort.by(Sort.Order.desc("memberCount")));
-        }
-
-        Page<Group> groups;
-        if (name != null && !name.isEmpty()) {
-            // 小组名称模糊查询
-            groups = groupRepository.searchGroups(name, category, pageable);
-        } else {
-            groups = groupRepository.searchWithFilters(category, pageable);
-        }
-
-        return buildResponse(groups);
-    }
-
-    // 构建返回的响应数据
-    private Map<String, Object> buildResponse(Page<Group> groups) {
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("status", "success");
-        response.put("total", groups.getTotalElements());
-        response.put("total_pages", groups.getTotalPages());
-        response.put("current_page", groups.getNumber() + 1);
-        response.put("items", groups.getContent());
-
-        return response;
-    }
-
-    // 点赞帖子
-    public Map<String, Object> likePost(Long GroupPostId) {
-        // 查找帖子
-        Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
-        if (!postOpt.isPresent()) {
-            throw new RuntimeException("Post not found");
-        }
-
-        GroupPost post = postOpt.get();
-
-        // 更新点赞数
-        post.setLikeCount(post.getLikeCount() + 1);
-        groupPostRepository.save(post);
-
-        // 返回成功信息
-        Map<String, Object> response = new HashMap<>();
-        response.put("status", "success");
-        response.put("message", "点赞成功");
-        return response;
-    }
-
-    // 取消点赞
-    public Map<String, Object> unlikePost(Long GroupPostId) {
-        // 查找帖子
-        Optional<GroupPost> postOpt = groupPostRepository.findById(GroupPostId);
-        if (!postOpt.isPresent()) {
-            throw new RuntimeException("Post not found");
-        }
-
-        GroupPost post = postOpt.get();
-
-        // 更新点赞数
-        if (post.getLikeCount() > 0) {
-            post.setLikeCount(post.getLikeCount() - 1);
-            groupPostRepository.save(post);
-
-            // 返回成功信息
-            Map<String, Object> response = new HashMap<>();
-            response.put("status", "success");
-            response.put("message", "取消点赞成功");
-            return response;
-        } else {
-            // 如果点赞数已经是0，则返回相应消息
-            Map<String, Object> response = new HashMap<>();
-            response.put("status", "failure");
-            response.put("message", "无法取消点赞，点赞数已经为0");
-            return response;
-        }
-    }
-
-    // 添加评论并更新帖子的评论数
-    public Map<String, Object> addComment(Long postId, GroupComments comment) {
-        // 查找帖子
-        Optional<GroupPost> postOpt = groupPostRepository.findById(postId);
-        if (!postOpt.isPresent()) {
-            throw new RuntimeException("Post not found");
-        }
-
-        GroupPost post = postOpt.get();
-
-        comment.setGroupPostId(postId);
-        comment.setTime(new java.util.Date());
-        groupCommentsRepository.save(comment);
-        post.setCommentCount(post.getCommentCount() + 1);
-        groupPostRepository.save(post);
-        Map<String, Object> response = new HashMap<>();
-        response.put("status", "success");
-        response.put("message", "评论成功");
-        return response;
-    }
-
-
-}
diff --git a/src/main/java/com/example/myproject/service/LevelService.java b/src/main/java/com/example/myproject/service/LevelService.java
deleted file mode 100644
index 92f50ed..0000000
--- a/src/main/java/com/example/myproject/service/LevelService.java
+++ /dev/null
@@ -1,140 +0,0 @@
-package com.example.myproject.service;
-
-import com.example.myproject.entity.ExperienceHistory;
-import com.example.myproject.entity.Users;
-import com.example.myproject.entity.Level;
-import com.example.myproject.repository.ExperienceHistoryRepository;
-import com.example.myproject.repository.UserRepository;
-import com.example.myproject.repository.LevelRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-
-import java.util.Date;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.HashMap;
-
-@Service
-public class LevelService {
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Autowired
-    private LevelRepository levelRepository;
-
-    @Autowired
-    private ExperienceHistoryRepository experienceHistoryRepository;
-
-
-    public Map<String, Object> getUserExperience(Long userId) {
-        // 获取用户信息
-        Users user = userRepository.findById(userId).orElseThrow(() -> new RuntimeException("User not found"));
-
-        // 获取当前等级
-        Level currentLevel = levelRepository.findById(user.getLevel()).orElseThrow(() -> new RuntimeException("Level not found"));
-
-        // 获取下一个等级的经验需求
-        Level nextLevel = levelRepository.findById(currentLevel.getLevelId() + 1).orElse(null);
-
-        // 构建响应数据
-        Map<String, Object> response = new HashMap<>();
-        response.put("current_experience", user.getCurrentExperience());
-        response.put("level", currentLevel.getLevelName());
-        response.put("next_level_experience", nextLevel != null ? nextLevel.getRequiredExperience() : 0);
-
-        return response;
-    }
-
-    public Map<String, Object> updateExperience(Long userId, Integer experience, String source) {
-        // 获取用户信息
-        Users user = userRepository.findById(userId).orElseThrow(() -> new RuntimeException("用户不存在"));
-
-        // 更新用户的经验值
-        user.setCurrentExperience(user.getCurrentExperience() + experience);
-
-        // 保存更新后的用户信息
-        userRepository.save(user);
-
-        // 创建经验更新历史记录
-        ExperienceHistory experienceHistory = new ExperienceHistory();
-        experienceHistory.setUserId(userId);
-        experienceHistory.setExperienceChange(experience);
-        experienceHistory.setSource(source);
-        experienceHistory.setUpdateTime(new Date());
-
-        // 保存更新历史
-        experienceHistoryRepository.save(experienceHistory);
-
-        // 返回更新后的经验值和消息
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("status", "success");
-        response.put("message", "经验更新成功");
-        response.put("current_experience", user.getCurrentExperience());  // 返回更新后的经验值
-
-        return response;
-    }
-
-    public Map<String, Object> checkUpgrade(Long userId) {
-        // 获取用户信息
-        Users user = userRepository.findById(userId).orElseThrow(() -> new RuntimeException("用户不存在"));
-
-        // 获取当前等级
-        Level currentLevel = levelRepository.findById(user.getLevel())
-                .orElseThrow(() -> new RuntimeException("用户等级信息不存在"));
-
-        // 获取下一个等级的经验需求
-        Level nextLevel = levelRepository.findById(currentLevel.getLevelId() + 1).orElse(null);
-
-        // 构建响应数据
-        Map<String, Object> response = new LinkedHashMap<>();
-
-        // 判断用户是否可以升级
-        boolean canUpgrade = user.getCurrentExperience() >= (nextLevel != null ? nextLevel.getRequiredExperience() : 0);
-        response.put("can_upgrade", canUpgrade);
-        // 构建响应数据
-
-        response.put("next_level_experience", nextLevel != null ? nextLevel.getRequiredExperience() : 0);
-        response.put("current_experience", user.getCurrentExperience());
-
-
-        return response;
-    }
-
-    public Map<String, Object> upgradeUserLevel(Long userId, Boolean canUpgrade) {
-        // 获取用户信息
-        Users user = userRepository.findById(userId).orElseThrow(() -> new RuntimeException("User not found"));
-
-        // 创建响应对象
-        Map<String, Object> response = new HashMap<>();
-
-        if (canUpgrade) {
-            // 获取当前等级
-            Level currentLevel = levelRepository.findById(user.getLevel())
-                    .orElseThrow(() -> new RuntimeException("Level not found"));
-
-            // 获取下一个等级的经验需求
-            Level nextLevel = levelRepository.findById(currentLevel.getLevelId() + 1).orElse(null);
-
-            if (nextLevel != null) {
-                user.setLevel(user.getLevel() + 1);
-                userRepository.save(user);
-                Level newLevel = levelRepository.findById(user.getLevel())
-                        .orElseThrow(() -> new RuntimeException("Level not found"));
-                response.put("message", "升级成功");
-                response.put("status", "success");
-                response.put("new_level", newLevel.getLevelName());
-            } else {
-                response.put("message", "用户已达到最高等级");
-                response.put("status", "error");
-            }
-        } else {
-            response.put("message", "用户不满足升级条件");
-            response.put("status", "error");
-        }
-
-        return response;
-    }
-
-}
diff --git a/src/main/java/com/example/myproject/service/PostService.java b/src/main/java/com/example/myproject/service/PostService.java
deleted file mode 100644
index feb7404..0000000
--- a/src/main/java/com/example/myproject/service/PostService.java
+++ /dev/null
@@ -1,232 +0,0 @@
-package com.example.myproject.service;
-
-import com.example.myproject.entity.Likes;
-import com.example.myproject.entity.Post;
-import com.example.myproject.entity.Users;
-import com.example.myproject.repository.CollectionsRepository;
-import com.example.myproject.repository.LikesRepository;
-import com.example.myproject.repository.PostRepository;
-import com.example.myproject.repository.UserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
-import com.example.myproject.entity.Collections;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.*;
-
-@Service
-public class PostService {
-
-    @Autowired
-    private PostRepository postRepository;
-
-    @Autowired
-    private UserRepository userRepository;
-    @Autowired
-    private LikesRepository likesRepository;
-
-    @Autowired
-    private CollectionsRepository collectionsRepository;
-
-    private static final String IMAGE_DIR = "uploads/post/";
-
-
-    //创建帖子
-    public Map<String, Object> createPost(Long userId, String postContent, String title, MultipartFile[] imageFiles) {
-        // 查找用户信息
-        Users user = userRepository.findById(Long.valueOf(userId)).orElseThrow(() -> new RuntimeException("User not found"));
-        Post post = new Post();
-        post.setUser_id(user.getUserId());
-        post.setPostTime(new Date());
-        post.setPostLikeNum(0);
-        post.setPostCollectNum(0);
-        post.setPostContent(postContent);
-        post.setTitle(title);
-
-        // 处理多张图片的上传
-        StringBuilder imageUrlsBuilder = new StringBuilder();
-        if (imageFiles != null && imageFiles.length > 0) {
-            for (int i = 0; i < imageFiles.length; i++) {
-                if (i > 0) {
-                    imageUrlsBuilder.append(",");
-                }
-                try {
-                    String imageUrl = saveImage(imageFiles[i]);
-                    imageUrlsBuilder.append(imageUrl);
-                } catch (IOException e) {
-                    throw new RuntimeException("Image upload failed: " + e.getMessage());
-                }
-            }
-        }
-        post.setImageUrl(imageUrlsBuilder.toString());
-        Post savedPost = postRepository.save(post);
-        Map<String, Object> response = new HashMap<>();
-        response.put("postNo", savedPost.getPostNo());
-        response.put("message", "帖子创建成功");
-        return response;
-    }
-
-    // 保存图片并返回图片的 URL
-    public String saveImage(MultipartFile imageFile) throws IOException {
-        String fileName = imageFile.getOriginalFilename();
-        Path path = Paths.get(IMAGE_DIR + fileName);
-        Files.createDirectories(path.getParent());
-        Files.write(path, imageFile.getBytes());
-        return "/images/" + fileName;
-    }
-
-
-    //编辑帖子
-    public void updatePost(Long postId, Post post) {
-        Post existingPost = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
-        if (post.getTitle() != null) {
-            existingPost.setTitle(post.getTitle());
-        }
-        if (post.getPostContent() != null) {
-            existingPost.setPostContent(post.getPostContent());
-        }
-        if (post.getImageUrl() != null) {
-            existingPost.setImageUrl(post.getImageUrl());
-        }
-        existingPost.setPostTime(post.getPostTime());
-        // 保存更新后的帖子
-        postRepository.save(existingPost);
-    }
-
-    //删除帖子
-    public void deletePost(Long postId) {
-        // 查找指定 ID 的帖子，如果不存在则抛出异常
-        if (!postRepository.existsById(postId)) {
-            throw new RuntimeException("Post not found");
-        }
-        // 删除该帖子
-        postRepository.deleteById(postId);
-    }
-
-    //点赞帖子（已完成）
-    public void likePost(Long postId, Long userId) {
-        // 查找指定 ID 的帖子
-        Post post = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
-        post.setPostLikeNum(post.getPostLikeNum() + 1);
-
-        // 保存帖子
-        postRepository.save(post);
-        Likes like = new Likes();
-        like.setUserId(userId);
-        like.setPostNo(postId);
-        // 保存点赞记录
-        likesRepository.save(like);
-    }
-
-    // 取消点赞帖子（已完成）
-    public void unlikePost(Long postId, Long userId) {
-        // 查找指定 ID 的帖子
-        Post post = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
-
-        // 如果点赞数大于 0，则减少点赞数
-        if (post.getPostLikeNum() > 0) {
-            post.setPostLikeNum(post.getPostLikeNum() - 1);
-        }
-
-        // 删除点赞表中对应的记录
-        likesRepository.deleteLikeByUserIdAndPostNo(userId, postId);
-
-        // 保存更新后的帖子
-        postRepository.save(post);
-    }
-
-
-    // 获取帖子列表（已完成）
-    public Map<String, Object> getAllPosts() {
-        List<Post> posts = postRepository.findAll();
-        List<Map<String, Object>> postList = new ArrayList<>();
-
-        for (Post post : posts) {
-            Map<String, Object> postMap = new LinkedHashMap<>();
-            postMap.put("postNo", post.getPostNo());
-            postMap.put("user_id", post.getUser_id());
-            postMap.put("postContent", post.getPostContent());
-            postMap.put("imgUrl", post.getImageUrl());
-            postMap.put("title", post.getTitle());
-            postMap.put("createdAt", post.getPostTime().toString());
-            postMap.put("likeCount", post.getPostLikeNum());
-            postMap.put("collectCount", post.getPostCollectNum());
-
-            postList.add(postMap);
-        }
-
-        Map<String, Object> response = new HashMap<>();
-        // 统计帖子数量
-        response.put("total", postList.size());
-        response.put("posts", postList);
-
-        return response;
-    }
-
-    public Map<String, Object> getPostById(Long postId) {
-        // 获取帖子
-        Optional<Post> postOptional = postRepository.findById(postId);
-
-        // 如果帖子存在
-        if (postOptional.isPresent()) {
-            Post post = postOptional.get();
-            Map<String, Object> postData = new LinkedHashMap<>();
-            postData.put("postNo", post.getPostNo());
-            postData.put("user_id", post.getUser_id());
-            Long userId = post.getUser_id();
-            Users user = userRepository.findById(userId).orElse(null);
-
-            if (user != null) {
-                postData.put("username", user.getUsername());
-                postData.put("avatar_url", user.getAvatarUrl());
-            } else {
-                postData.put("username", null);
-                postData.put("avatar_url", null);
-            }
-
-            postData.put("postContent", post.getPostContent());
-            postData.put("imageUrl", post.getImageUrl());
-            postData.put("postTime", post.getPostTime());
-            postData.put("postLikeNum", post.getPostLikeNum());
-            postData.put("postCollectNum", post.getPostCollectNum());
-            postData.put("title", post.getTitle());
-
-            return postData;
-        } else {
-            throw new RuntimeException("Post not found with id: " + postId);
-        }
-    }
-
-
-    //收藏
-    public void collectPost(Long postId, Long userId) {
-        Post post = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
-        post.setPostCollectNum(post.getPostCollectNum() + 1);
-        postRepository.save(post);
-
-        // 添加到收藏表
-        Collections collection = new Collections();
-        collection.setUserId(userId);
-        collection.setPostNo(postId);
-        collectionsRepository.save(collection);
-    }
-
-    //取消收藏
-    public void uncollectPost(Long postId, Long userId) {
-        Post post = postRepository.findById(postId).orElseThrow(() -> new RuntimeException("Post not found"));
-        // 减少帖子收藏数
-        if (post.getPostCollectNum() > 0) {
-            post.setPostCollectNum(post.getPostCollectNum() - 1);
-            postRepository.save(post);
-        }
-
-        // 从收藏表中删除对应记录
-        collectionsRepository.deleteLikeByUserIdAndPostNo(userId, postId);
-    }
-
-
-
-}
diff --git a/src/main/java/com/example/myproject/service/TaskService.java b/src/main/java/com/example/myproject/service/TaskService.java
deleted file mode 100644
index bd04661..0000000
--- a/src/main/java/com/example/myproject/service/TaskService.java
+++ /dev/null
@@ -1,295 +0,0 @@
-package com.example.myproject.service;
-
-import com.example.myproject.entity.Level;
-import com.example.myproject.entity.Task;
-import com.example.myproject.entity.UserTaskStatus;
-import com.example.myproject.repository.LevelRepository;
-import com.example.myproject.repository.TaskRepository;
-import com.example.myproject.repository.UserTaskStatusRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import com.example.myproject.entity.Users;
-import com.example.myproject.repository.UserRepository;
-
-import java.util.*;
-
-@Service
-public class TaskService {
-
-    @Autowired
-    private TaskRepository taskRepository;
-
-    @Autowired
-    private UserTaskStatusRepository userTaskStatusRepository;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Autowired
-    private LevelRepository levelRepository;
-
-    public Map<String, Object> getAllTasksForUser(Long userId) {
-        // 获取所有任务
-        List<Task> tasks = taskRepository.findAll();
-        List<Map<String, Object>> taskList = new ArrayList<>();
-
-        for (Task task : tasks) {
-            Optional<UserTaskStatus> userTaskStatus = userTaskStatusRepository
-                    .findByUserIdAndTaskId(userId, task.getTaskId());
-
-            Map<String, Object> taskData = new LinkedHashMap<>();
-            taskData.put("task_id", task.getTaskId());
-            taskData.put("title", task.getTitle());
-            taskData.put("description", task.getDescription());
-            taskData.put("status", userTaskStatus.isPresent() ? userTaskStatus.get().getStatus() : "pending");
-            taskData.put("progress", userTaskStatus.isPresent() ? userTaskStatus.get().getCurrentProgress() : 0);
-
-            // 奖励
-            Map<String, Integer> reward = new LinkedHashMap<>();
-            reward.put("experience", task.getRewardExperience());
-            reward.put("points", task.getRewardPoints());
-            taskData.put("reward", reward);
-
-            taskList.add(taskData);
-        }
-
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("tasks", taskList);
-        return response;
-    }
-
-    public Map<String, Object> updateTaskStatus(Long userId, String taskId) {
-        // 获取用户任务状态
-        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
-        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
-
-        // 检查任务进度
-        if (userTaskStatus.getCurrentProgress() == 100f) {
-            Optional<Task> taskOpt = taskRepository.findById(taskId);
-            Task task = taskOpt.get();
-
-            // 更新任务状态为已完成
-            userTaskStatus.setStatus("completed");
-            userTaskStatus.setCurrentExperience(task.getRewardExperience());
-            userTaskStatus.setCurrentPoints(task.getRewardPoints());
-
-            userTaskStatusRepository.save(userTaskStatus);
-
-            // 构建返回数据
-            Map<String, Object> response = new HashMap<>();
-            response.put("status", "success");
-            response.put("message", "任务状态已更新");
-
-            Map<String, Integer> currentReward = new HashMap<>();
-            currentReward.put("current_experience", task.getRewardExperience());
-            currentReward.put("current_points", task.getRewardPoints());
-            response.put("current_reward", currentReward);
-
-            return response;
-        } else {
-            Map<String, Object> errorResponse = new HashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "任务未完成，无法更新状态");
-            return errorResponse;
-        }
-    }
-
-    public Map<String, Object> getUserExperience(Long userId) {
-        // 获取用户信息
-        Optional<Users> userOpt = userRepository.findById(userId);
-        if (!userOpt.isPresent()) {
-            Map<String, Object> errorResponse = new LinkedHashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "用户不存在");
-            return errorResponse;
-        }
-
-        Users user = userOpt.get();
-        Integer currentExperience = user.getCurrentExperience();
-        Optional<Level> levelOpt = levelRepository.findById(user.getLevel());
-        String levelName = levelOpt.isPresent() ? levelOpt.get().getLevelName() : "未知等级";
-
-        List<UserTaskStatus> completedTasks = userTaskStatusRepository.findByUserIdAndStatus(userId, "completed");
-
-        int totalExperience = 0;
-        int totalPoints = 0;
-        for (UserTaskStatus taskStatus : completedTasks) {
-            Optional<Task> taskOpt = taskRepository.findById(taskStatus.getTaskId());
-            if (taskOpt.isPresent()) {
-                Task task = taskOpt.get();
-                totalExperience += task.getRewardExperience();
-                totalPoints += task.getRewardPoints();
-            }
-        }
-
-        // 构建返回数据
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("user_id", userId);
-        response.put("current_experience", currentExperience);
-        response.put("level", levelName);
-        response.put("tasks_completed", completedTasks.size());
-
-        Map<String, Integer> reward = new LinkedHashMap<>();
-        reward.put("experience", totalExperience);
-        reward.put("points", totalPoints);
-
-        response.put("reward", reward);
-
-        return response;
-    }
-
-    public Map<String, Object> getNewStep(Long userId) {
-        // 获取用户的第一个未完成任务
-        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findFirstByUserIdAndStatus(userId, "pending");
-
-        if (!userTaskStatusOpt.isPresent()) {
-            Map<String, Object> errorResponse = new LinkedHashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "用户当前没有未完成的任务");
-            return errorResponse;
-        }
-
-        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
-        String taskId = userTaskStatus.getTaskId();
-
-        // 获取该任务的描述
-        Optional<Task> taskOpt = taskRepository.findById(taskId);
-        if (!taskOpt.isPresent()) {
-            Map<String, Object> errorResponse = new LinkedHashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "任务不存在");
-            return errorResponse;
-        }
-
-        Task task = taskOpt.get();
-
-        // 获取总任务数
-        long totalTasks = taskRepository.count();
-
-        // 构建返回数据
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("current_step", taskId);
-        response.put("total_steps", totalTasks);
-        response.put("step_description", task.getDescription());
-
-        return response;
-    }
-
-    public Map<String, Object> updateTaskProgress(Long userId, String taskId, Integer progress) {
-        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
-
-        if (!userTaskStatusOpt.isPresent()) {
-            Map<String, Object> errorResponse = new LinkedHashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "任务不存在或该任务不属于用户");
-            return errorResponse;
-        }
-
-        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
-        userTaskStatus.setCurrentProgress(Float.valueOf(progress));
-        userTaskStatusRepository.save(userTaskStatus);
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("status", "success");
-        response.put("message", "进度已更新");
-
-        return response;
-    }
-
-    public Map<String, Object> claimReward(Long userId, String taskId) {
-        // 获取用户任务状态
-        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
-
-        if (!userTaskStatusOpt.isPresent()) {
-            Map<String, Object> errorResponse = new LinkedHashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "任务状态不存在");
-            return errorResponse;
-        }
-
-        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
-
-        if (userTaskStatus.getCurrentProgress() == 100f) {
-            if (userTaskStatus.getIsRewardClaimed()) {
-                Map<String, Object> errorResponse = new LinkedHashMap<>();
-                errorResponse.put("status", "failure");
-                errorResponse.put("message", "奖励已经领取过了");
-                return errorResponse;
-            }
-
-            Optional<Task> taskOpt = taskRepository.findById(taskId);
-            if (!taskOpt.isPresent()) {
-                Map<String, Object> errorResponse = new LinkedHashMap<>();
-                errorResponse.put("status", "failure");
-                errorResponse.put("message", "任务不存在");
-                return errorResponse;
-            }
-
-            Task task = taskOpt.get();
-
-            userTaskStatus.setIsRewardClaimed(true);
-            userTaskStatus.setCurrentExperience(task.getRewardExperience());
-            userTaskStatus.setCurrentPoints(task.getRewardPoints());
-
-            userTaskStatusRepository.save(userTaskStatus);
-
-            Optional<Users> userOpt = userRepository.findById(userId);
-            if (!userOpt.isPresent()) {
-                Map<String, Object> errorResponse = new LinkedHashMap<>();
-                errorResponse.put("status", "failure");
-                errorResponse.put("message", "用户不存在");
-                return errorResponse;
-            }
-
-            Users user = userOpt.get();
-
-            // 将任务奖励加到用户的积分和经验
-            user.setUserPoints(user.getUserPoints() + task.getRewardPoints());
-            user.setCurrentExperience(user.getCurrentExperience() + task.getRewardExperience());
-
-            userRepository.save(user);
-
-            Map<String, Object> response = new LinkedHashMap<>();
-            response.put("status", "success");
-            response.put("message", "奖励已领取");
-
-            Map<String, Integer> reward = new LinkedHashMap<>();
-            reward.put("experience", task.getRewardExperience());
-            reward.put("points", task.getRewardPoints());
-            response.put("reward", reward);
-
-            return response;
-        } else {
-            Map<String, Object> errorResponse = new LinkedHashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "任务未完成，无法领取奖励");
-            return errorResponse;
-        }
-    }
-
-    public Map<String, Object> checkRewardStatus(Long userId, String taskId) {
-        // 获取用户任务状态
-        Optional<UserTaskStatus> userTaskStatusOpt = userTaskStatusRepository.findByUserIdAndTaskId(userId, taskId);
-
-        if (!userTaskStatusOpt.isPresent()) {
-            Map<String, Object> errorResponse = new LinkedHashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "任务状态不存在");
-            return errorResponse;
-        }
-
-        UserTaskStatus userTaskStatus = userTaskStatusOpt.get();
-
-        // 检查奖励是否已领取
-        if (userTaskStatus.getIsRewardClaimed()) {
-            Map<String, Object> response = new LinkedHashMap<>();
-            response.put("status", "reward_issued");
-            response.put("message", "任务奖励已被领取");
-            return response;
-        }
-
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("status", "reward_not_issued");
-        response.put("message", "任务奖励未被领取");
-        return response;
-    }
-}
diff --git a/src/main/java/com/example/myproject/service/UserFollowService.java b/src/main/java/com/example/myproject/service/UserFollowService.java
deleted file mode 100644
index 6222b48..0000000
--- a/src/main/java/com/example/myproject/service/UserFollowService.java
+++ /dev/null
@@ -1,122 +0,0 @@
-package com.example.myproject.service;
-
-import com.example.myproject.entity.Users;
-import com.example.myproject.entity.UserFollow;
-import com.example.myproject.repository.UserFollowRepository;
-import com.example.myproject.repository.UserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.util.*;
-
-@Service
-public class UserFollowService {
-
-    @Autowired
-    private UserFollowRepository userFollowRepository;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    // 用户关注操作
-    public Map<String, Object> follow(Long followerId, Long followedId) {
-        if (followerId.equals(followedId)) {
-            Map<String, Object> response = new LinkedHashMap<>();
-            response.put("status", "error");
-            response.put("message", "不能关注自己");
-            return response;
-        }
-
-        // 检查是否已关注该用户
-        UserFollow existingFollow = userFollowRepository.findByFollowerIdAndFollowedId(followerId, followedId);
-        if (existingFollow == null) {
-            // 创建新的关注记录
-            UserFollow userFollow = new UserFollow();
-            userFollow.setFollowerId(followerId);
-            userFollow.setFollowedId(followedId);
-            userFollow.setFollowTime(new java.util.Date());
-
-            userFollowRepository.save(userFollow);
-
-            // 返回关注成功响应
-            Map<String, Object> response = new LinkedHashMap<>();
-            response.put("status", "success");
-            response.put("message", "关注成功");
-            return response;
-        } else {
-            Map<String, Object> response = new LinkedHashMap<>();
-            response.put("status", "error");
-            response.put("message", "已经关注该用户");
-            return response;
-        }
-    }
-
-    // 取消关注操作
-    public Map<String, Object> unfollow(Long followerId, Long followedId) {
-        UserFollow userFollow = userFollowRepository.findByFollowerIdAndFollowedId(followerId, followedId);
-
-        if (userFollow != null) {
-            userFollowRepository.delete(userFollow);
-
-            Map<String, Object> response = new LinkedHashMap<>();
-            response.put("status", "success");
-            response.put("message", "取消关注成功");
-            return response;
-        } else {
-            Map<String, Object> response = new LinkedHashMap<>();
-            response.put("status", "error");
-            response.put("message", "未找到关注关系");
-            return response;
-        }
-    }
-
-    // 获取某个用户的所有粉丝
-    public Map<String, Object> getFollowers(Long userId) {
-        List<UserFollow> followers = userFollowRepository.findByFollowedId(userId);
-
-        List<Map<String, Object>> followersList = new ArrayList<>();
-        for (UserFollow follow : followers) {
-            // 获取粉丝的用户信息
-            Users follower = userRepository.findById(follow.getFollowerId()).orElse(null);
-            if (follower != null) {
-                Map<String, Object> followerInfo = new LinkedHashMap<>();
-                followerInfo.put("user_id", follower.getUserId());
-                followerInfo.put("username", follower.getUsername());
-                followerInfo.put("avatar_url", follower.getAvatarUrl());
-                followersList.add(followerInfo);
-            }
-        }
-
-        // 返回响应数据
-        Map<String, Object> response = new LinkedHashMap<>();
-        response.put("status", "success");
-        response.put("total", followersList.size());
-        response.put("followers", followersList);
-
-        return response;
-    }
-
-    // 获取某个用户的所有关注用户
-    public Map<String, Object> getFollowing(Long userId) {
-        List<UserFollow> following = userFollowRepository.findByFollowerId(userId);
-
-        List<Map<String, Object>> followingList = new ArrayList<>();
-        for (UserFollow follow : following) {
-            // 获取被关注的用户信息
-            Users followedUser = userRepository.findById(follow.getFollowedId()).orElse(null);
-            if (followedUser != null) {
-                Map<String, Object> followingInfo = new HashMap<>();
-                followingInfo.put("user_id", followedUser.getUserId());
-                followingInfo.put("username", followedUser.getUsername());
-                followingInfo.put("avatar_url", followedUser.getAvatarUrl());
-                followingList.add(followingInfo);
-            }
-        }
-        Map<String, Object> response = new HashMap<>();
-        response.put("status", "success");
-        response.put("total", followingList.size());
-        response.put("following", followingList);
-
-        return response;
-    }
-}
diff --git a/src/main/java/com/example/myproject/service/UserMessageService.java b/src/main/java/com/example/myproject/service/UserMessageService.java
deleted file mode 100644
index 05f62e7..0000000
--- a/src/main/java/com/example/myproject/service/UserMessageService.java
+++ /dev/null
@@ -1,112 +0,0 @@
-package com.example.myproject.service;
-
-import com.example.myproject.entity.UserMessages;
-import com.example.myproject.repository.UserMessagesRepository;
-import com.example.myproject.repository.UserRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import java.util.Optional;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Date;
-import java.util.stream.Collectors;
-
-@Service
-public class UserMessageService {
-
-    @Autowired
-    private UserMessagesRepository userMessagesRepository;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    // 发送私信
-    public Map<String, Object> sendMessage(Long senderId, Long receiverId, String content) {
-        UserMessages message = new UserMessages();
-        message.setSenderId(senderId);
-        message.setReceiverId(receiverId);
-        message.setContent(content);
-        message.setTime(new Date());
-        UserMessages savedMessage = userMessagesRepository.save(message);
-
-        // 返回响应
-        Map<String, Object> response = new HashMap<>();
-        response.put("status", "success");
-        response.put("message", "私信发送成功");
-        response.put("message_id", savedMessage.getMessageId());
-        return response;
-    }
-
-    // 获取当前用户的所有消息
-    public Map<String, Object> getUserMessages(Long userId) {
-        // 查询当前用户发送和接收的所有消息
-        List<UserMessages> messages = userMessagesRepository.findBySenderIdOrReceiverId(userId, userId);
-
-        // 获取发送者和接收者的用户名
-        List<Map<String, Object>> messageDetails = messages.stream()
-                .map(message -> {
-                    Map<String, Object> messageMap = new HashMap<>();
-                    messageMap.put("message_id", message.getMessageId());
-                    messageMap.put("sender_id", message.getSenderId());
-                    messageMap.put("receiver_id", message.getReceiverId());
-                    messageMap.put("content", message.getContent());
-                    messageMap.put("timestamp", message.getTime());
-                    String senderUsername = userRepository.findById(message.getSenderId())
-                            .map(user -> user.getUsername())
-                            .orElse("Unknown");
-                    messageMap.put("sender_username", senderUsername);
-                    String receiverUsername = userRepository.findById(message.getReceiverId())
-                            .map(user -> user.getUsername())
-                            .orElse("Unknown");
-                    messageMap.put("receiver_username", receiverUsername);
-
-                    return messageMap;
-                })
-                .collect(Collectors.toList());
-
-        Map<String, Object> response = new HashMap<>();
-        response.put("status", "success");
-        response.put("messages", messageDetails);
-        return response;
-    }
-
-    // 获取单条消息的详情
-    public Map<String, Object> getMessage(Long messageId) {
-        Optional<UserMessages> optionalMessage = userMessagesRepository.findById(messageId);
-
-        if (optionalMessage.isPresent()) {
-            UserMessages message = optionalMessage.get();
-
-            // 获取发送者和接收者的用户名
-            String senderUsername = userRepository.findById(message.getSenderId())
-                    .map(user -> user.getUsername())
-                    .orElse("Unknown");
-            String receiverUsername = userRepository.findById(message.getReceiverId())
-                    .map(user -> user.getUsername())
-                    .orElse("Unknown");
-
-            // 构建响应数据
-            Map<String, Object> response = new HashMap<>();
-            Map<String, Object> messageDetails = new HashMap<>();
-            messageDetails.put("message_id", message.getMessageId());
-            messageDetails.put("sender_id", message.getSenderId());
-            messageDetails.put("sender_username", senderUsername);
-            messageDetails.put("receiver_id", message.getReceiverId());
-            messageDetails.put("receiver_username", receiverUsername);
-            messageDetails.put("content", message.getContent());
-            messageDetails.put("timestamp", message.getTime());
-
-            response.put("status", "success");
-            response.put("message", messageDetails);
-            return response;
-        } else {
-            Map<String, Object> errorResponse = new HashMap<>();
-            errorResponse.put("status", "error");
-            errorResponse.put("message", "Message not found");
-            return errorResponse;
-        }
-    }
-
-
-}
diff --git a/src/main/java/com/example/myproject/service/UserService.java b/src/main/java/com/example/myproject/service/UserService.java
index 0d37854..71435c7 100644
--- a/src/main/java/com/example/myproject/service/UserService.java
+++ b/src/main/java/com/example/myproject/service/UserService.java
@@ -1,269 +1,25 @@
 package com.example.myproject.service;
 
-import com.example.myproject.entity.Users;
-import com.example.myproject.entity.UserInviteCode;
-import com.example.myproject.repository.UserRepository;
-import com.example.myproject.repository.UserInviteCodeRepository;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-
-import java.util.*;
-
-@Service
-public class UserService {
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Autowired
-    private UserInviteCodeRepository userInviteCodeRepository;
-
-    // 生成邀请码
-    public Map<String, Object> generateInviteCode(Long userId) {
-        // 获取用户信息
-        Users user = userRepository.findById(userId).orElse(null);
-
-        // 如果用户不存在，返回错误
-        if (user == null) {
-            Map<String, Object> errorResponse = new HashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "用户不存在");
-            return errorResponse;
-        }
-
-        // 检查用户的邀请数量
-        if (user.getInviteCount() <= 0) {
-            Map<String, Object> errorResponse = new HashMap<>();
-            errorResponse.put("status", "failure");
-            errorResponse.put("message", "没有剩余的邀请码");
-            return errorResponse;
-        }
-
-        // 生成唯一的邀请码
-        String inviteCode = generateUniqueInviteCode();
-
-        // 将邀请码保存到 `user_invite_code` 表
-        UserInviteCode userInviteCode = new UserInviteCode();
-        userInviteCode.setUserId(userId);
-        userInviteCode.setInviteCode(inviteCode);
-        userInviteCode.setCreatedAt(java.time.LocalDateTime.now());
-
-        userInviteCodeRepository.save(userInviteCode);
-
-        // 更新用户的 `invite_count`，减少1
-        user.setInviteCount(user.getInviteCount() - 1);
-        userRepository.save(user);
-
-        // 返回成功信息
-        Map<String, Object> response = new HashMap<>();
-        response.put("status", "success");
-        response.put("message", "邀请码生成成功");
-        response.put("invite_code", inviteCode);
-
-        return response;
-    }
-
-    // 生成唯一的邀请码，使用26个字母（大小写）
-    private String generateUniqueInviteCode() {
-        String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-        StringBuilder inviteCode = new StringBuilder();
-
-        Random random = new Random();
-        for (int i = 0; i < 10; i++) {
-            inviteCode.append(characters.charAt(random.nextInt(characters.length())));
-        }
-
-        return inviteCode.toString();
-    }
-
-    public String registerUser(String username, String email, String password, String role, String inviteCode) {
-        // 检查邮箱是否已经注册
-        Optional<Users> existingEmailUser = userRepository.findByEmail(email);
-        if (existingEmailUser.isPresent()) {
-            return "该邮箱已被注册";
-        }
-
-        // 检查用户名是否已经存在
-        Optional<Users> existingUsernameUser = userRepository.findByUsername(username); // 需要根据用户名查询
-        if (existingUsernameUser.isPresent()) {
-            return "该用户名已被注册";
-        }
-
-        // 检查邀请码是否有效
-        if (inviteCode == null || inviteCode.isEmpty()) {
-            return "邀请码不能为空";
-        }
-
-        Optional<UserInviteCode> invite = userInviteCodeRepository.findByInviteCode(inviteCode);
-        if (invite.isEmpty() || invite.get().getIsUsed()) {
-            return "邀请码无效或已被使用";
-        }
-
-        // 设置默认等级为2（由于邀请码有效）
-        Long level = 2L;
-
-        // 设置默认头像 URL
-        String avatarUrl = "https://example.com/default-avatar.jpg";  // 默认头像
-
-        // 获取邀请码对应的用户ID
-        UserInviteCode inviteEntity = invite.get();
-        Long inviteUserId = inviteEntity.getUserId();
-
-        // 创建新用户
-        Users newUser = new Users();
-        newUser.setUsername(username);
-        newUser.setEmail(email);
-        newUser.setPassword(password);
-        newUser.setRole(role);
-        newUser.setInviteCount(0);  // 初始邀请码数量为 0
-        newUser.setLevel(level);
-        newUser.setAvatarUrl(avatarUrl);  // 设置默认头像
-        newUser.setRegistrationDate(new java.util.Date());  // 设置注册日期
-        newUser.setCurrentExperience(0);  // 默认经验为 0
-        newUser.setCurrentSeedingHours(0f);  // 默认做种时长为 0
-        newUser.setRegistrationTime(new java.util.Date());  // 设置注册时间为当前时间
-
-        // 保存用户信息
-        userRepository.save(newUser);
-
-        // 更新邀请码的使用状态
-        inviteEntity.setIsUsed(true);
-        userInviteCodeRepository.save(inviteEntity);
-
-        return "用户注册成功";
-    }
 
 
-    public String loginUser(String username, String password) {
-        // 检查用户是否存在
-        Optional<Users> userOptional = userRepository.findByUsername(username);
-        if (userOptional.isEmpty()) {
-            return "用户名不存在";
-        }
+import com.baomidou.mybatisplus.extension.service.IService;
 
-        Users user = userOptional.get();
+import com.example.myproject.entity.User;
 
-        // 检查密码是否正确
-        if (!user.getPassword().equals(password)) {
-            return "密码错误";
-        }
-
-        // 登录成功
-        return "登录成功";
-    }
-
-    public String changePassword(Long userId, String oldPassword, String newPassword, String confirmPassword) {
-        // 查找用户
-        Users user = userRepository.findById(userId).orElse(null);
-
-        if (user == null) {
-            return "用户不存在";
-        }
-
-        // 检查旧密码是否正确
-        if (!user.getPassword().equals(oldPassword)) {
-            return "旧密码错误";
-        }
-
-        // 检查新密码和确认密码是否一致
-        if (!newPassword.equals(confirmPassword)) {
-            return "新密码与确认密码不一致";
-        }
-
-        // 更新密码
-        user.setPassword(newPassword);
-        userRepository.save(user);
-
-        return "密码修改成功";
-    }
-
-    // 获取用户个人资料
-    public Map<String, Object> getProfile(Long userId) {
-        Optional<Users> userOptional = userRepository.findById(userId);
-
-        // 如果用户不存在，返回null或者可以抛出异常
-        if (userOptional.isEmpty()) {
-            return null; // 可以返回 null 或者根据需要返回错误信息
-        }
-
-        Users user = userOptional.get();
-
-        // 将需要的字段放入 Map 中
-        Map<String, Object> profile = new LinkedHashMap<>();
-        profile.put("avatarUrl", user.getAvatarUrl());
-        profile.put("username", user.getUsername());
-        profile.put("email", user.getEmail());
-        profile.put("gender", user.getGender());
-        profile.put("description", user.getDescription());
-        profile.put("hobbies", user.getHobbies());
-        profile.put("level", user.getLevel());
-        profile.put("Experience", user.getCurrentExperience());
-        profile.put("uploadCount", user.getUploadCount());
-        profile.put("downloadCount", user.getDownloadCount());
-        profile.put("shareRate", user.getShareRate());
-        profile.put("registrationTime", user.getRegistrationTime());
-
-        return profile;
-    }
-
-    // 修改用户个人资料
-    public boolean editProfile(Long userId, String avatarUrl, String nickname, String gender, String description, String hobbies) {
-        Optional<Users> userOptional = userRepository.findById(userId);
-
-        // 如果用户不存在，返回false
-        if (userOptional.isEmpty()) {
-            return false; // 用户不存在
-        }
-
-        Users user = userOptional.get();
-
-        // 更新用户资料，只有传入值才会更新对应字段
-        if (avatarUrl != null) {
-            user.setAvatarUrl(avatarUrl);
-        }
-        if (nickname != null) {
-            user.setUsername(nickname);
-        }
-        if (gender != null) {
-            user.setGender(gender);
-        }
-        if (description != null) {
-            user.setDescription(description);
-        }
-        if (hobbies != null) {
-            user.setHobbies(hobbies);
-        }
-
-        // 保存更新后的用户信息
-        userRepository.save(user);
-
-        return true; // 更新成功
-    }
-
-    public Map<String, Object> calculateShareRate(Long userId) {
-        // 查找用户
-        Users user = userRepository.findById(userId).orElse(null);
-        if (user == null) {
-            return Map.of("status", "error", "message", "用户不存在");
-        }
-
-        // 获取上传量和下载量
-        Float uploadCount = user.getUploadCount();
-        Float downloadCount = user.getDownloadCount();
-
-        // 计算分享率
-        Float shareRate = 0f;  // 默认分享率为0
-        if (downloadCount != 0) {
-            shareRate = uploadCount / downloadCount;  // 分享率 = 上传量 / 下载量
-        }
-
-        // 更新用户的分享率
-        user.setShareRate(shareRate);
-        userRepository.save(user);
-
-        // 返回结果
-        return Map.of("status", "success", "message", "分享率计算成功", "shareRate", shareRate);
-    }
+public interface UserService extends IService<User> {
+    User loginService(String username, String password);
 
 
-}
+    boolean preRegisterUser(User user);
+
+
+    boolean verifyEmail(String email, String token);
+
+
+    boolean checkEmailExists(String email);
+
+    boolean checkPassword(Long userId, String rawPassword);
+
+
+//    Integer getUserId();
+}
\ No newline at end of file
diff --git a/src/main/java/com/example/myproject/service/serviceImpl/UserDetailsServiceImpl.java b/src/main/java/com/example/myproject/service/serviceImpl/UserDetailsServiceImpl.java
index d8de4b7..4bbd5c3 100644
--- a/src/main/java/com/example/myproject/service/serviceImpl/UserDetailsServiceImpl.java
+++ b/src/main/java/com/example/myproject/service/serviceImpl/UserDetailsServiceImpl.java
@@ -1,47 +1,47 @@
-//package com.example.myproject.service.serviceImpl;
-//
-//import com.example.myproject.mapper.UserMapper;
-//import com.example.myproject.entity.User;
-//import org.springframework.beans.factory.annotation.Autowired;
-//import org.springframework.security.core.GrantedAuthority;
-//import org.springframework.security.core.authority.AuthorityUtils;
-//import org.springframework.security.core.authority.SimpleGrantedAuthority;
-//import org.springframework.security.core.userdetails.UserDetails;
-//import org.springframework.security.core.userdetails.UserDetailsService;
-//import org.springframework.security.core.userdetails.UsernameNotFoundException;
-//import org.springframework.stereotype.Service;
-//
-//import java.util.ArrayList;
-//import java.util.List;
-//
-//@Service
-//public class UserDetailsServiceImpl implements UserDetailsService {
-//
-//    @Autowired
-//    private UserMapper userMapper;
-//
-//    @Override
-//    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
-//        //username参数,是在登陆时,用户传递的表单数据username
-//        //主要读取数据库3个值 username password authorities
-//        User user= userMapper.selectByUsername(username);
-//        if (user == null) {
-//            throw new UsernameNotFoundException("用户名未找到");
-//        }
-//
-//        String authorityName = user.getRole();
-//        //为了返回一个UserDetails 使用User
-//        List<GrantedAuthority> authorities = new ArrayList<>();
-//        GrantedAuthority authority = new SimpleGrantedAuthority(authorityName);
-//        authorities.add(authority);
-//        return new org.springframework.security.core.userdetails.User(
-//                user.getUsername(),
-//                user.getPassword(),
-//                true, // accountEnabled
-//                true, // accountNonExpired
-//                true, // credentialsNonExpired
-//                true, // accountNonLocked
-//                AuthorityUtils.createAuthorityList("ROLE_USER") // 设置用户的角色或权限
-//        );
-//    }
-//}
\ No newline at end of file
+package com.example.myproject.service.serviceImpl;
+
+import com.example.myproject.mapper.UserMapper;
+import com.example.myproject.entity.User;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.AuthorityUtils;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.core.userdetails.UserDetailsService;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Service
+public class UserDetailsServiceImpl implements UserDetailsService {
+
+    @Autowired
+    private UserMapper userMapper;
+
+    @Override
+    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+        //username参数,是在登陆时,用户传递的表单数据username
+        //主要读取数据库3个值 username password authorities
+        User user= userMapper.selectByUsername(username);
+        if (user == null) {
+            throw new UsernameNotFoundException("用户名未找到");
+        }
+
+        String authorityName = user.getRole();
+        //为了返回一个UserDetails 使用User
+        List<GrantedAuthority> authorities = new ArrayList<>();
+        GrantedAuthority authority = new SimpleGrantedAuthority(authorityName);
+        authorities.add(authority);
+        return new org.springframework.security.core.userdetails.User(
+                user.getUsername(),
+                user.getPassword(),
+                true, // accountEnabled
+                true, // accountNonExpired
+                true, // credentialsNonExpired
+                true, // accountNonLocked
+                AuthorityUtils.createAuthorityList("ROLE_USER") // 设置用户的角色或权限
+        );
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/example/myproject/service/serviceImpl/UserServiceImpl.java b/src/main/java/com/example/myproject/service/serviceImpl/UserServiceImpl.java
new file mode 100644
index 0000000..d0718fe
--- /dev/null
+++ b/src/main/java/com/example/myproject/service/serviceImpl/UserServiceImpl.java
@@ -0,0 +1,122 @@
+
+package com.example.myproject.service.serviceImpl;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.example.myproject.mapper.UserMapper;
+import com.example.myproject.mapper.VerificationTokenMapper;
+import com.example.myproject.entity.User;
+import com.example.myproject.entity.VerificationToken;
+import com.example.myproject.service.EmailService;
+import com.example.myproject.service.UserService;
+import org.apache.commons.lang3.RandomStringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Service;
+import java.time.Instant;
+import java.time.temporal.ChronoUnit;
+//登录注册
+@Service
+public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
+    private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);
+    @Autowired
+    private UserMapper userMapper; // Using MyBatis-Plus mapper
+    @Autowired
+    private EmailServiceImpl emailService;
+    @Autowired
+    private VerificationTokenMapper verificationTokenMapper; // Using MyBatis-Plus mapper
+    @Autowired
+    private PasswordEncoder passwordEncoder; // Injecting password encoder
+    @Override
+    public User loginService(String username, String password) {
+        log.debug("Attempting login with username: {}, password: {}", username, password);
+        User user = userMapper.selectOne(new QueryWrapper<User>().eq("username", username).eq("password", password));
+        if (user != null) {
+            user.setPassword("");  // Clear the password before returning
+            log.debug("Login successful, User ID: {}", user.getId());
+        } else {
+            log.debug("Login failed, incorrect username or password.");
+        }
+        return user;
+    }
+    @Override
+    public boolean preRegisterUser(User user) {
+        log.debug("Pre-registering user, username: {}, email: {}", user.getUsername(), user.getEmail());
+        // 检查用户名或邮箱是否已存在
+        boolean userExists = userMapper.selectOne(new QueryWrapper<User>().eq("username", user.getUsername())) != null ||
+                userMapper.selectOne(new QueryWrapper<User>().eq("email", user.getEmail())) != null;
+        if (userExists) {
+            log.debug("Pre-registration failed, username or email already exists.");
+            return false;  // 用户名或邮箱已经存在
+        }
+        // 加密密码
+        String encryptedPassword = passwordEncoder.encode(user.getPassword());
+        // 生成验证码
+        String token = RandomStringUtils.randomNumeric(6);
+        // 设置过期时间为当前时间加一小时
+        Instant expiryDate = Instant.now().plus(1, ChronoUnit.HOURS);
+        // 创建验证令牌对象
+        VerificationToken verificationToken = new VerificationToken(
+                token,
+                user.getUsername(),
+                user.getEmail(),
+                encryptedPassword,
+                expiryDate
+        );
+        // 插入验证令牌
+        int rowsInserted = verificationTokenMapper.insert(verificationToken);
+        if (rowsInserted > 0) {
+            // 发送验证邮件
+            emailService.sendVerificationEmail(user.getEmail(), token);
+            log.debug("Pre-registration successful, verification code: {}, expiry date: {}", token, expiryDate);
+            return true;  // 注册前验证成功
+        } else {
+            log.error("Failed to insert verification token into database.");
+            return false;  // 如果插入验证令牌失败，返回失败
+        }
+    }
+    @Override
+    public boolean verifyEmail(String email, String token) {
+        log.debug("Verifying email, email: {}, token: {}", email, token);
+        VerificationToken verificationToken = verificationTokenMapper.selectOne(
+                new QueryWrapper<VerificationToken>().eq("token", token).eq("email", email)
+        );
+        if (verificationToken != null && !verificationToken.isExpired()) {
+            log.debug("Verification code is valid, username: {}", verificationToken.getUsername());
+            User user = userMapper.selectOne(new QueryWrapper<User>().eq("email", email));
+            if (user == null) {
+                user = new User();
+                user.setEmail(email);
+                user.setUsername(verificationToken.getUsername());
+                user.setPassword(verificationToken.getPassword());
+                user.setEmailVerified(true);
+                userMapper.insert(user);  // Save new user
+                log.debug("New user created, User ID: {}", user.getId());
+            } else {
+                user.setEmailVerified(true);
+                userMapper.updateById(user);  // Update existing user
+                log.debug("User email verified, User ID: {}", user.getId());
+            }
+            verificationTokenMapper.delete(new QueryWrapper<VerificationToken>().eq("token", token)); // Clean up the token
+            log.debug("Verification code deleted.");
+            return true;
+        }
+        log.debug("Verification code is invalid or expired.");
+        return false;
+    }
+    public boolean checkEmailExists(String email) {
+        log.debug("检查邮箱是否存在，邮箱：{}", email);
+        boolean exists = userMapper.selectCount(new QueryWrapper<User>().eq("email", email)) > 0;
+        log.debug("邮箱存在状态：{}", exists);
+        return exists;
+    }
+    public boolean checkPassword(Long userId, String password) {
+        User user = userMapper.selectById(userId);
+        if (user == null) {
+            throw new RuntimeException("用户不存在");
+        }
+        String encryptedPassword = user.getPassword();
+        return passwordEncoder.matches(password, encryptedPassword);
+    }
+}
diff --git a/src/main/java/com/example/myproject/utils/Result.java b/src/main/java/com/example/myproject/utils/Result.java
deleted file mode 100644
index e46f828..0000000
--- a/src/main/java/com/example/myproject/utils/Result.java
+++ /dev/null
@@ -1,131 +0,0 @@
-package com.example.myproject.utils;
-
-
-import org.springframework.http.ResponseEntity;
-
-public class Result<T> {
-    private String code;
-    private String msg;
-    private T data;
-
-    public String getCode() {
-        return code;
-    }
-
-    public void setCode(String code) {
-        this.code = code;
-    }
-
-    public String getMsg() {
-        return msg;
-    }
-
-    public void setMsg(String msg) {
-        this.msg = msg;
-    }
-
-    public T getData() {
-        return data;
-    }
-
-    public void setData(T data) {
-        this.data = data;
-    }
-
-    public Result() {
-    }
-
-    public Result(T data) {
-        this.data = data;
-    }
-
-    public static Result success(ResponseEntity<?> resultMap, String 兴趣小组创建成功) {
-        Result result = new Result<>();
-        result.setCode("200");
-        result.setMsg("成功");
-        return result;
-    }
-
-    public static <T> Result<T> success(T data) {
-        Result<T> result = new Result<>(data);
-        result.setCode("200");
-        result.setMsg("成功");
-        return result;
-    }
-    public static <T> Result<T> success(String msg) {
-        Result result = new Result();
-        result.setCode("200");
-        result.setMsg("成功");
-        return result;
-    }
-
-    public static <T> Result<T> success(T data,String msg) {
-        Result<T> result = new Result<>(data);
-        result.setCode("200");
-        result.setMsg(msg);
-        return result;
-    }
-
-    public static Result error(String code, String msg) {
-        Result result = new Result();
-        result.setCode(code);
-        result.setMsg(msg);
-        return result;
-    }
-    /**
-     * 创建一个表示文件大小超出限制的结果对象。
-     *
-     * @return 构造的文件过大错误结果对象
-     */
-    public static Result fileTooLarge() {
-        Result result = new Result();
-        result.setCode("413");
-        result.setMsg("文件大小超出限制。");
-        return result;
-    }
-
-    /**
-     * 创建一个表示文件格式不支持的结果对象。
-     *
-     * @return 构造的文件格式错误结果对象
-     */
-    public static Result unsupportedFileType() {
-        Result result = new Result();
-        result.setCode("415");
-        result.setMsg("不支持的文件格式。");
-        return result;
-    }
-
-    /**
-     * 创建一个表示文件未找到的结果对象。
-     *
-     * @return 构造的文件未找到错误结果对象
-     */
-    public static Result fileNotFound() {
-        Result result = new Result();
-        result.setCode("404");
-        result.setMsg("文件未找到。");
-        return result;
-    }
-
-    /**
-     * 创建一个表示文件存储错误的结果对象。
-     *
-     * @param errorMsg 详细错误信息
-     * @return 构造的文件存储错误结果对象
-     */
-    public static Result fileStorageError(String errorMsg) {
-        Result result = new Result();
-        result.setCode("500");
-        result.setMsg("文件存储错误: " + errorMsg);
-        return result;
-    }
-
-    public static Result permissionDenied() {
-        Result result = new Result();
-        result.setCode("401");
-        result.setMsg("权限不足，无法执行该操作。");
-        return result;
-    }
-
-}
