<template>
  <div class="forum-home">
    <h1>论坛管理</h1>

    <div class="controls">
      <input
          v-model="searchTitle"
          placeholder="搜索帖子标题"
          @keyup.enter="searchPosts"
          class="search-input"
      />
      <button @click="searchPosts" class="btn">搜索</button>
      <button @click="refreshPosts" class="btn btn-refresh">刷新</button>

      <!-- 查看全部举报按钮 -->
      <button @click="openAllReports" class="btn btn-report-all">查看全部举报</button>
    </div>

    <div v-if="loading" class="loading">加载中...</div>
    <div v-else>
      <ul class="posts-list">
        <li
            v-for="post in posts"
            :key="post.id"
            @click="goPostDetail(post.id)"
            class="post-card"
        >
          <!-- 红点 -->
          <span
              v-if="reportedPostIds.has(post.id)"
              class="red-dot"
              title="该帖子有举报"
          ></span>

          <h3 class="post-title">{{ post.title }}</h3>
          <p class="post-info">
            作者ID: {{ post.userId }} |
            用户名: {{ post.username }} |
            发布时间: {{ formatDateTime(post.createdAt) }}
          </p>

          <button class="btn btn-delete" @click.stop="deletePost(post.id)">
            删除
          </button>

          <button class="btn btn-report" @click.stop="openReportList(post)">
            查看举报
          </button>
        </li>
      </ul>

      <div v-if="posts.length === 0" class="no-data">无数据</div>
    </div>

    <!-- 单个帖子举报弹窗 -->
    <div
        v-if="showPostReportsModal"
        class="modal-overlay"
        @click.self="closePostReportList"
    >
      <div class="modal-content">
        <h3>举报列表 - 帖子：《{{ currentPost?.title }}》</h3>

        <div v-if="postReportLoading" class="loading">加载举报中...</div>
        <ul v-else-if="reportsForPost.length" class="report-list">
          <li v-for="report in reportsForPost" :key="report.id" class="report-item">
            <p><strong>举报人ID：</strong> {{ report.reporterId }}</p>
            <p><strong>举报内容：</strong> {{ report.reason }}</p>
            <p><strong>举报时间：</strong> {{ formatDateTime(report.createdAt) }}</p>
          </li>
        </ul>

        <div v-else class="no-data">暂无举报</div>

        <button class="btn btn-cancel" @click="closePostReportList">关闭</button>
      </div>
    </div>

    <!-- 查看所有举报弹窗 -->
    <div
        v-if="showAllReportsModal"
        class="modal-overlay"
        @click.self="closeAllReportList"
    >
      <div class="modal-content">
        <h3>全部举报列表</h3>

        <div v-if="allReportLoading" class="loading">加载举报中...</div>
        <ul v-else-if="allReports.length" class="report-list">
          <li v-for="report in allReports" :key="report.id" class="report-item">
            <p>
              <strong>被举报帖子：</strong>
              <span
                  class="report-post-title"
                  @click="goPostDetail(report.postId)"
                  title="点击查看帖子详情"
              >《{{ report.postTitle }}》</span
              >
            </p>
            <p>
              <strong>举报人：</strong> {{ report.reporterUsername }} (ID:
              {{ report.reporterId }})
            </p>
            <p><strong>举报内容：</strong> {{ report.reason }}</p>
            <p><strong>举报时间：</strong> {{ formatDateTime(report.createdAt) }}</p>
          </li>
        </ul>

        <div v-else class="no-data">暂无举报</div>

        <button class="btn btn-cancel" @click="closeAllReportList">关闭</button>
      </div>
    </div>
  </div>
</template>

<script setup>
import { ref, onMounted } from "vue";
import axios from "axios";
import { useRouter } from "vue-router";
import dayjs from "dayjs";

const formatDateTime = (isoString) => {
  if (!isoString) return "";
  return dayjs(isoString).format("YYYY年MM月DD日 HH:mm:ss");
};

// 帖子列表及搜索
const searchTitle = ref("");
const posts = ref([]);
const loading = ref(false);

const router = useRouter();

// 新增：被举报帖子ID集合
const reportedPostIds = ref(new Set());

// 获取带举报帖子ID的函数
const fetchReportedPostIds = async () => {
  try {
    const res = await axios.get("http://localhost:8080/forum/post/reports", {
      params: { size: 1000 }, // 根据需要调整条数限制
    });
    // 假设接口返回格式如 [{id, postId, reporterId, reason, ...}, ...]
    const ids = res.data.map((report) => report.postId);
    reportedPostIds.value = new Set(ids);
  } catch (err) {
    console.error("获取带举报帖子ID失败:", err);
    reportedPostIds.value = new Set();
  }
};

const fetchPosts = async (title = "") => {
  loading.value = true;
  try {
    const res = await axios.get("http://localhost:8080/forum/posts", {
      params: { title },
    });
    posts.value = res.data;
    // 先拿帖子数据，再请求举报帖子ID
    await fetchReportedPostIds();
  } catch (err) {
    console.error(err);
    posts.value = [];
    reportedPostIds.value = new Set();
  } finally {
    loading.value = false;
  }
};

const searchPosts = () => {
  fetchPosts(searchTitle.value);
};

const refreshPosts = () => {
  fetchPosts(searchTitle.value);
};

const goPostDetail = (postId) => {
  router.push(`/admin/post/${postId}`);
};

const deletePost = async (postId) => {
  if (!confirm("确定要删除该帖子吗？")) {
    return;
  }
  try {
    await axios.delete(`http://localhost:8080/forum/post/${postId}`);
    alert("删除成功");
    fetchPosts(searchTitle.value);
  } catch (error) {
    console.error(error);
    alert("删除失败");
  }
};

// **************** 单个帖子举报弹窗 ****************
const showPostReportsModal = ref(false);
const currentPost = ref(null);
const reportsForPost = ref([]);
const postReportLoading = ref(false);

const openReportList = async (post) => {
  currentPost.value = post;
  showPostReportsModal.value = true;
  postReportLoading.value = true;
  reportsForPost.value = [];
  try {
    const res = await axios.get(
        `http://localhost:8080/forum/post/reports/${post.id}`
    );
    reportsForPost.value = res.data || [];
  } catch (error) {
    console.error("获取帖子举报列表失败:", error);
    reportsForPost.value = [];
  } finally {
    postReportLoading.value = false;
  }
};

const closePostReportList = () => {
  showPostReportsModal.value = false;
  currentPost.value = null;
  reportsForPost.value = [];
};

// **************** 查看全部举报弹窗 ****************
const showAllReportsModal = ref(false);
const allReports = ref([]);
const allReportLoading = ref(false);

const openAllReports = async () => {
  showAllReportsModal.value = true;
  allReportLoading.value = true;
  allReports.value = [];
  try {
    const res = await axios.get("http://localhost:8080/forum/post/reports", {
      params: { size: 100 },
    });
    allReports.value = res.data || [];
  } catch (error) {
    console.error("获取全部举报失败:", error);
    allReports.value = [];
  } finally {
    allReportLoading.value = false;
  }
};

const closeAllReportList = () => {
  showAllReportsModal.value = false;
  allReports.value = [];
};

onMounted(() => {
  fetchPosts();
});
</script>

<style scoped>
.forum-home {
  max-width: 1200px;
  margin: 0 auto;
  padding: 20px;
  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
  color: #333;
}

.controls {
  display: flex;
  align-items: center;
  gap: 10px;
  margin-bottom: 20px;
}

.search-input {
  flex: 1;
  padding: 8px 12px;
  font-size: 16px;
  border: 1px solid #ccc;
  border-radius: 4px;
  transition: border-color 0.3s;
}
.search-input:focus {
  outline: none;
  border-color: #409eff;
  box-shadow: 0 0 5px rgba(64, 158, 255, 0.5);
}

.btn {
  padding: 8px 16px;
  border: none;
  background-color: #409eff;
  color: white;
  font-weight: 600;
  border-radius: 4px;
  cursor: pointer;
  transition: background-color 0.3s;
}
.btn:hover {
  background-color: #66b1ff;
}
.btn-refresh {
  background-color: #67c23a;
}
.btn-refresh:hover {
  background-color: #85ce61;
}

.loading,
.no-data {
  font-size: 18px;
  text-align: center;
  color: #888;
  margin-top: 40px;
}

.posts-list {
  list-style: none;
  padding: 0;
  margin: 0;
  display: flex;
  flex-direction: column;
  gap: 16px;
}

.post-card {
  background-color: #fff;
  border: 1px solid #ebeef5;
  border-radius: 8px;
  padding: 16px 20px;
  box-shadow: 0 2px 6px rgb(0 0 0 / 0.05);
  cursor: pointer;
  transition: box-shadow 0.3s, border-color 0.3s;
  position: relative;
}
.post-card:hover {
  box-shadow: 0 8px 20px rgb(0 0 0 / 0.12);
  border-color: #409eff;
}

.post-title {
  margin: 0 0 8px;
  color: #409eff;
  font-weight: 700;
  font-size: 20px;
}

.post-info {
  margin: 0;
  font-size: 14px;
  color: #666;
}

.btn-delete {
  position: absolute;
  top: 16px;
  right: 20px;
  background-color: #f56c6c;
  color: white;
  border: none;
  padding: 4px 12px;
  border-radius: 4px;
  cursor: pointer;
  font-weight: 600;
  transition: background-color 0.3s;
  z-index: 10;
}
.btn-delete:hover {
  background-color: #f78989;
}

/* 新增举报按钮样式 */
.btn-report {
  position: absolute;
  top: 16px;
  right: 80px;
  background-color: #e6a23c;
  color: white;
  border: none;
  padding: 4px 12px;
  border-radius: 4px;
  cursor: pointer;
  font-weight: 600;
  transition: background-color 0.3s;
  z-index: 10;
}
.btn-report:hover {
  background-color: #ebb563;
}

/* 弹窗样式 */
.modal-overlay {
  position: fixed;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
  background-color: rgba(0, 0, 0, 0.3);
  display: flex;
  align-items: center;
  justify-content: center;
  z-index: 9999;
}

.modal-content {
  background: white;
  padding: 20px;
  border-radius: 8px;
  width: 500px;
  max-width: 95%;
  max-height: 80vh;
  overflow-y: auto;
  box-shadow: 0 4px 12px rgba(0,0,0,0.3);
}

.report-list {
  list-style: none;
  padding: 0;
  margin: 16px 0 0 0;
  max-height: 400px;
  overflow-y: auto;
  border-top: 1px solid #ebeef5;
}

.report-item {
  border-bottom: 1px solid #ebeef5;
  padding: 12px 0;
  font-size: 14px;
  color: #444;
}

.report-item p {
  margin: 4px 0;
}

.btn-cancel {
  background-color: #909399;
  color: white;
  border: none;
  padding: 8px 16px;
  border-radius: 4px;
  cursor: pointer;
  transition: background-color 0.3s;
  margin-top: 15px;
}
.btn-cancel:hover {
  background-color: #a6a9ad;
}

.btn-report-all {
  background-color: #f90;
  color: white;
  border: none;
  padding: 4px 12px;
  border-radius: 4px;
  cursor: pointer;
  font-weight: 600;
  transition: background-color 0.3s;
  margin-left: 10px;
}
.btn-report-all:hover {
  background-color: #fb3;
}

.red-dot {
  position: absolute;
  top: 14px;
  left: 14px;
  width: 10px;
  height: 10px;
  background-color: #f56c6c;
  border-radius: 50%;
  box-shadow: 0 0 3px #f56c6c;
  z-index: 20;
}

.report-post-title {
  color: #409eff;
  cursor: pointer;
  text-decoration: underline;
}

.report-post-title:hover {
  color: #66b1ff;
}
</style>
现在这个页面和全部举报列表的弹窗，都要加分页功能。下面是后端package com.example.springboot.controller;


import com.example.springboot.entity.Forum.*;
import com.example.springboot.service.ForumService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.Collections;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/forum")
public class ForumController {

    @Resource
    private ForumService forumService;

    // 发布帖子
    @PostMapping("/post")
    public String createPost(@RequestBody Post post) {
        int result = forumService.createPost(post);
        return result > 0 ? "Post created successfully" : "Post creation failed";
    }

    // 删除帖子（普通用户需要在业务层验证是否本人）
    @DeleteMapping("/post/{id}")
    public String deletePost(@PathVariable Integer id) {
        int result = forumService.deletePost(id);
        return result > 0 ? "Post deleted successfully" : "Post deletion failed";
    }

    // 修改帖子
    @PutMapping("/post")
    public String updatePost(@RequestBody Post post) {
        int result = forumService.updatePost(post);
        return result > 0 ? "Post updated successfully" : "Post update failed";
    }

    // 根据帖子ID获取帖子详情
    @GetMapping("/post/{id}")
    public Post getPostById(@PathVariable Integer id) {
        return forumService.getPostById(id);
    }

    // 模糊查询帖子标题
    @GetMapping("/posts")
    public List<Post> searchPostsByTitle(@RequestParam String title) {
        return forumService.searchPostsByTitle(title);
    }

    // 新增评论
    @PostMapping("/comment")
    public String createComment(@RequestBody Comment comment) {
        int result = forumService.createComment(comment);
        return result > 0 ? "Comment added successfully" : "Comment adding failed";
    }

    // 删除评论
    @DeleteMapping("/comment/{id}")
    public String deleteComment(@PathVariable Integer id) {
        int result = forumService.deleteComment(id);
        return result > 0 ? "Comment deleted successfully" : "Comment deletion failed";
    }

    // 修改评论
    @PutMapping("/comment")
    public String updateComment(@RequestBody Comment comment) {
        int result = forumService.updateComment(comment);
        return result > 0 ? "Comment updated successfully" : "Comment update failed";
    }

    // 获取某帖子的评论列表（包含回复）
    @GetMapping("/comments/{postId}")
    public List<Comment> getCommentsByPostId(@PathVariable Integer postId) {
        return forumService.getCommentsByPostId(postId);
    }

    // 点赞帖子
    @PostMapping("/post/like")
    public String likePost(@RequestBody LikePost likePost) {
        int result = forumService.createLikePost(likePost);
        return result > 0 ? "点赞成功" : "已经点赞过或点赞失败";
    }

    // 取消点赞
    @DeleteMapping("/post/like")
    public String unlikePost(@RequestParam Integer userId, @RequestParam Integer postId) {
        int result = forumService.deleteLikePost(userId, postId);
        return result > 0 ? "取消点赞成功" : "取消点赞失败";
    }

    // 收藏帖子
    @PostMapping("/post/favorite")
    public String favoritePost(@RequestBody FavoritePost favoritePost) {
        int result = forumService.createFavoritePost(favoritePost);
        return result > 0 ? "收藏成功" : "收藏失败或已收藏";
    }

    // 取消收藏
    @DeleteMapping("/post/favorite")
    public String unfavoritePost(@RequestParam Integer userId, @RequestParam Integer postId) {
        int result = forumService.deleteFavoritePost(userId, postId);
        return result > 0 ? "取消收藏成功" : "取消收藏失败";
    }

    // 举报帖子
    @PostMapping("/post/report")
    public String reportPost(@RequestBody ReportPost reportPost) {
        int result = forumService.createReportPost(reportPost);
        return result > 0 ? "举报成功" : "举报失败";
    }

    // 管理员查看举报
    @GetMapping("/post/reports/{postId}")
    public List<ReportPost> getReportsByPostId(@PathVariable Integer postId) {
        return forumService.getReportPostsByPostId(postId);
    }

    @GetMapping("/user/{userId}/posts")
    public List<Post> getPostsByUserId(@PathVariable Integer userId) {
        List<Post> posts = forumService.getPostsByUserId(userId);

        // 这里可以查询并设置每个帖子的点赞数，点赞和收藏状态，比如（简单示例，效率不错的话可DAO一次搞定）：
        posts.forEach(post -> {
            int likeCount = forumService.getLikeCountByPostId(post.getId());


            // 查询当前用户是否点赞/收藏，改成传参可改
            // 这里暂时userId是查询者，请改成当前登录用户id
            LikePost likePost = forumService.getLikePost(userId, post.getId());
            post.setLiked(likePost != null);

            FavoritePost favPost = forumService.getFavoritePost(userId, post.getId());
            post.setFavorited(favPost != null);
        });
        return posts;
    }
    /**
     * 获取用户点赞过的帖子列表
     */
    @GetMapping("/user/{userId}/liked-posts")
    public List<Post> getLikedPostsByUserId(@PathVariable Integer userId) {
        return forumService.getLikedPostsByUserId(userId);
    }

    /**
     * 获取用户收藏过的帖子列表
     */
    @GetMapping("/user/{userId}/favorited-posts")
    public List<Post> getFavoritedPostsByUserId(@PathVariable Integer userId) {
        return forumService.getFavoritedPostsByUserId(userId);
    }

    @GetMapping("/post/like/status")
    public Map<String, Boolean> getLikeStatus(@RequestParam Integer userId, @RequestParam Integer postId) {
        boolean liked = forumService.getLikePost(userId, postId) != null;
        return Collections.singletonMap("liked", liked);
    }

    @GetMapping("/post/favorite/status")
    public Map<String, Boolean> getFavoriteStatus(@RequestParam Integer userId, @RequestParam Integer postId) {
        boolean favorited = forumService.getFavoritePost(userId, postId) != null;
        return Collections.singletonMap("favorited", favorited);
    }
    // 获取所有举报列表，支持分页
    @GetMapping("/post/reports")
    public List<ReportPost> getAllReports(
            @RequestParam(required = false, defaultValue = "0") Integer page,
            @RequestParam(required = false, defaultValue = "20") Integer size) {
        return forumService.getAllReportPosts(page, size);
    }

    @DeleteMapping("/admin/comment/{id}")
    public String adminDeleteComment(@PathVariable Integer id) {
        int result = forumService.adminDeleteComment(id);
        return result > 0 ? "评论及其子评论删除成功" : "删除失败";
    }
}

package com.example.springboot.mapper;

import com.example.springboot.entity.Forum.*;


import org.apache.ibatis.annotations.Param;

import java.util.List;

public interface ForumMapper {
    // --- 帖子相关 ---

    // 新增帖子
    int insertPost(Post post);

    // 删除帖子（管理员可删任意，用户删自己的可通过业务层判断）
    int deletePostById(@Param("id") Integer id);

    // 更新帖子（只改标题和内容）
    int updatePost(Post post);

    // 根据id查询帖子
    Post selectPostById(@Param("id") Integer id);

    // 模糊搜索帖子标题，支持分页
    List<Post> selectPostsByTitleLike(@Param("title") String title);


    // --- 评论相关 ---

    // 新增评论
    int insertComment(Comment comment);

    // 删除评论（只能删除自己评论，管理员权限由业务层判断）
    int deleteCommentById(@Param("id") Integer id);

    // 修改评论内容
    int updateComment(Comment comment);

    // 查询某帖子下的所有评论（含回复）
    List<Comment> selectCommentsByPostId(@Param("postId") Integer postId);


    List<Comment> selectChildCommentsByParentId(@Param("parentId") Integer parentId);


    // --- 评论相关 ---

    // 点赞相关
    int insertLikePost(LikePost likePost);

    // 删除点赞
    int deleteLikePost(@Param("userId") Integer userId, @Param("postId") Integer postId);

    // 查询某用户是否已点赞该帖子
    LikePost selectLikePost(@Param("userId") Integer userId, @Param("postId") Integer postId);

    // 收藏相关
    int insertFavoritePost(FavoritePost favoritePost);

    int deleteFavoritePost(@Param("userId") Integer userId, @Param("postId") Integer postId);

    FavoritePost selectFavoritePost(@Param("userId") Integer userId, @Param("postId") Integer postId);

    // 举报相关
    int insertReportPost(ReportPost reportPost);

    // 查询某帖子的举报记录（供管理员查看）
    List<ReportPost> selectReportPostsByPostId(@Param("postId") Integer postId);

    List<Post> selectPostsByUserId(@Param("userId") Integer userId);

    int selectLikeCountByPostId(@Param("postId") Integer postId);

    /**
     * 查询用户点赞过的帖子列表（关联post和like_post表）
     */
    List<Post> selectLikedPostsByUserId(@Param("userId") Integer userId);

    /**
     * 查询用户收藏过的帖子列表（关联post和favorite_post表）
     */
    List<Post> selectFavoritedPostsByUserId(@Param("userId") Integer userId);

    List<ReportPost> selectAllReportPosts(@Param("offset") int offset, @Param("limit") int limit);
}

package com.example.springboot.service;

import com.example.springboot.entity.Forum.*;
import com.example.springboot.mapper.ForumMapper;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class ForumService {

    @Resource
    private ForumMapper forumMapper;

    // ---------------- 帖子相关 ---------------- //

    public int createPost(Post post) {
        return forumMapper.insertPost(post);
    }

    public int deletePost(Integer postId) {
        return forumMapper.deletePostById(postId);
    }

    public int updatePost(Post post) {
        return forumMapper.updatePost(post);
    }

    /**
     * 根据帖子ID查询帖子详情，注意likeCount是从 like_post 表动态统计的，需要你的Mapper支持
     * 建议对应 Mapper 查询中联表统计点赞数
     */
    public Post getPostById(Integer postId) {
        return forumMapper.selectPostById(postId);
    }

    public List<Post> searchPostsByTitle(String title) {
        return forumMapper.selectPostsByTitleLike(title);
    }

    /**
     * 查询某用户的帖子列表
     * 建议 SQL 联表统计点赞数
     */
    public List<Post> getPostsByUserId(Integer userId) {
        List<Post> posts = forumMapper.selectPostsByUserId(userId);
        // 补充点赞状态和收藏状态等
        enrichPostsWithLikeFavorite(userId, posts);
        return posts;
    }


    // ---------------- 评论相关 ---------------- //

    public int createComment(Comment comment) {
        return forumMapper.insertComment(comment);
    }

    public int deleteComment(Integer commentId) {
        return forumMapper.deleteCommentById(commentId);
    }

    public int updateComment(Comment comment) {
        return forumMapper.updateComment(comment);
    }

    public List<Comment> getCommentsByPostId(Integer postId) {
        return forumMapper.selectCommentsByPostId(postId);
    }

    public int adminDeleteComment(Integer commentId) {
        List<Comment> children = forumMapper.selectChildCommentsByParentId(commentId);
        int count = 0;
        for (Comment child : children) {
            count += adminDeleteComment(child.getId());
        }
        count += forumMapper.deleteCommentById(commentId);
        return count;
    }


    // ---------------- 点赞相关 ---------------- //

    /**
     * 点赞某帖子，重复点赞会返回0表示已点赞
     * 只往 like_post 插入记录，不修改 post 表
     */
    public int createLikePost(LikePost likePost) {
        LikePost exist = forumMapper.selectLikePost(likePost.getUserId(), likePost.getPostId());
        if (exist != null) return 0;
        return forumMapper.insertLikePost(likePost);
    }

    /**
     * 取消点赞，删除 like_post 记录，不修改 post 表
     */
    public int deleteLikePost(Integer userId, Integer postId) {
        return forumMapper.deleteLikePost(userId, postId);
    }

    public LikePost getLikePost(Integer userId, Integer postId) {
        return forumMapper.selectLikePost(userId, postId);
    }

    /**
     * 查询某帖子点赞数量，动态查询 like_post 表
     */
    public int getLikeCountByPostId(Integer postId) {
        return forumMapper.selectLikeCountByPostId(postId);
    }


    // ---------------- 收藏相关 ---------------- //

    public int createFavoritePost(FavoritePost favoritePost) {
        FavoritePost exist = forumMapper.selectFavoritePost(favoritePost.getUserId(), favoritePost.getPostId());
        if (exist != null) return 0;
        return forumMapper.insertFavoritePost(favoritePost);
    }

    public int deleteFavoritePost(Integer userId, Integer postId) {
        return forumMapper.deleteFavoritePost(userId, postId);
    }

    public FavoritePost getFavoritePost(Integer userId, Integer postId) {
        return forumMapper.selectFavoritePost(userId, postId);
    }


    // ---------------- 举报相关 ---------------- //

    public int createReportPost(ReportPost reportPost) {
        // 可加重复举报校验，暂略
        return forumMapper.insertReportPost(reportPost);
    }

    public List<ReportPost> getReportPostsByPostId(Integer postId) {
        return forumMapper.selectReportPostsByPostId(postId);
    }


    // ---------------- 用户点赞和收藏的帖子列表 ---------------- //

    /**
     * 查询用户点赞过的帖子列表
     */
    public List<Post> getLikedPostsByUserId(Integer userId) {
        List<Post> posts = forumMapper.selectLikedPostsByUserId(userId);
        enrichPostsWithLikeFavorite(userId, posts);
        return posts;
    }

    /**
     * 查询用户收藏过的帖子列表
     */
    public List<Post> getFavoritedPostsByUserId(Integer userId) {
        List<Post> posts = forumMapper.selectFavoritedPostsByUserId(userId);
        enrichPostsWithLikeFavorite(userId, posts);
        return posts;
    }


    /**
     * 给帖子列表补全点赞数，点赞状态，收藏状态
     */
    private void enrichPostsWithLikeFavorite(Integer userId, List<Post> posts) {
        if (posts == null || posts.isEmpty()) return;

        boolean isLikedList = true;

        for (Post post : posts) {
            int likeCount = forumMapper.selectLikeCountByPostId(post.getId());
            post.setLikeCount(likeCount);

            if(isLikedList) {
                post.setLiked(true); // 对于我点赞的帖子的列表，这里直接赋true
            } else {
                LikePost likePost = forumMapper.selectLikePost(userId, post.getId());
                post.setLiked(likePost != null);
            }

            FavoritePost favPost = forumMapper.selectFavoritePost(userId, post.getId());
            post.setFavorited(favPost != null);

            // 如果某个帖子没有点赞，说明不是点赞过帖子列表，退出标记
            if(isLikedList && !post.getLiked()){
                isLikedList = false;
            }
        }
    }

    public List<ReportPost> getAllReportPosts(int page, int size) {
        int offset = page * size;
        return forumMapper.selectAllReportPosts(offset, size);
    }

}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.example.springboot.mapper.ForumMapper">

    <!-- 插入帖子 -->
    <insert id="insertPost" parameterType="com.example.springboot.entity.Forum.Post" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO post(user_id,title,content,created_at,updated_at)
        VALUES(#{userId}, #{title}, #{content}, NOW(), NOW())
    </insert>

    <!-- 删除帖子 -->
    <delete id="deletePostById" parameterType="int">
        DELETE FROM post WHERE id = #{id}
    </delete>

    <!-- 管理员删除帖子 -->
    <select id="selectChildCommentsByParentId" parameterType="int" resultType="com.example.springboot.entity.Forum.Comment">
        SELECT
            c.id,
            c.post_id AS postId,
            c.user_id AS userId,
            u.username,
            c.parent_comment_id AS parentCommentId,
            c.content,
            c.created_at AS createdAt,
            c.updated_at AS updatedAt
        FROM comment c
                 LEFT JOIN user u ON c.user_id = u.id
        WHERE c.parent_comment_id = #{parentId}
    </select>

    <!-- 更新帖子 -->
    <update id="updatePost" parameterType="com.example.springboot.entity.Forum.Post">
        UPDATE post
        SET title = #{title}, content = #{content}, updated_at = NOW()
        WHERE id = #{id}
    </update>

    <!-- 根据id查询帖子（带用户名） -->
    <select id="selectPostById" parameterType="int" resultMap="postResultMap">
        SELECT
            p.id,
            p.user_id AS userId,
            u.username,
            p.title,
            p.content,
            p.created_at AS createdAt,
            p.updated_at AS updatedAt,
            IFNULL(like_counts.count, 0) AS likeCount
        FROM post p
                 LEFT JOIN user u ON p.user_id = u.id
                 LEFT JOIN (
            SELECT post_id, COUNT(*) AS count FROM like_post GROUP BY post_id
        ) like_counts ON like_counts.post_id = p.id
        WHERE p.id = #{id}
    </select>

    <resultMap id="postResultMap" type="com.example.springboot.entity.Forum.Post">
        <id property="id" column="id"/>
        <result property="userId" column="userId"/>
        <result property="username" column="username"/>
        <result property="title" column="title"/>
        <result property="content" column="content"/>
        <result property="createdAt" column="createdAt"/>
        <result property="updatedAt" column="updatedAt"/>
        <result property="likeCount" column="likeCount"/>
        <result property="liked" column="liked"/>
        <result property="favorited" column="favorited"/>
    </resultMap>

    <!-- 配置resultMap对应属性映射到Post实体 -->

    <!-- 模糊搜索帖子的标题 -->
    <select id="selectPostsByTitleLike" parameterType="string" resultType="com.example.springboot.entity.Forum.Post">
        SELECT
            p.id,
            p.user_id AS userId,
            u.username,
            p.title,
            p.content,
            p.created_at AS createdAt,
            p.updated_at AS updatedAt
        FROM post p
                 LEFT JOIN user u ON p.user_id = u.id
        WHERE p.title LIKE CONCAT('%', #{title}, '%')
        ORDER BY p.created_at DESC
    </select>

    <!-- 新增评论 -->
    <insert id="insertComment" parameterType="com.example.springboot.entity.Forum.Comment" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO comment(post_id, user_id, parent_comment_id, content, created_at, updated_at)
        VALUES(#{postId}, #{userId}, #{parentCommentId}, #{content}, NOW(), NOW())
    </insert>

    <!-- 删除评论 -->
    <delete id="deleteCommentById" parameterType="int">
        DELETE FROM comment WHERE id = #{id}
    </delete>

    <!-- 修改评论内容 -->
    <update id="updateComment" parameterType="com.example.springboot.entity.Forum.Comment">
        UPDATE comment
        SET content = #{content}, updated_at = NOW()
        WHERE id = #{id}
    </update>

    <!-- 查询某帖子下所有评论（带用户名） -->
    <select id="selectCommentsByPostId" parameterType="int" resultType="com.example.springboot.entity.Forum.Comment">
        SELECT
            c.id,
            c.post_id AS postId,
            c.user_id AS userId,
            u.username,
            c.parent_comment_id AS parentCommentId,
            c.content,
            c.created_at AS createdAt,
            c.updated_at AS updatedAt
        FROM comment c
                 LEFT JOIN user u ON c.user_id = u.id
        WHERE c.post_id = #{postId}
        ORDER BY c.created_at ASC
    </select>

    <!-- 点赞 -->
    <insert id="insertLikePost" parameterType="com.example.springboot.entity.Forum.LikePost" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO like_post(user_id, post_id, created_at) VALUES(#{userId}, #{postId}, NOW())
    </insert>

    <delete id="deleteLikePost" parameterType="map">
        DELETE FROM like_post WHERE user_id = #{userId} AND post_id = #{postId}
    </delete>

    <select id="selectLikePost" parameterType="map" resultType="com.example.springboot.entity.Forum.LikePost">
        SELECT * FROM like_post WHERE user_id = #{userId} AND post_id = #{postId} LIMIT 1
    </select>

    <!-- 收藏 -->
    <insert id="insertFavoritePost" parameterType="com.example.springboot.entity.Forum.FavoritePost" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO favorite_post(user_id, post_id, created_at) VALUES(#{userId}, #{postId}, NOW())
    </insert>

    <delete id="deleteFavoritePost" parameterType="map">
        DELETE FROM favorite_post WHERE user_id = #{userId} AND post_id = #{postId}
    </delete>

    <select id="selectFavoritePost" parameterType="map" resultType="com.example.springboot.entity.Forum.FavoritePost">
        SELECT * FROM favorite_post WHERE user_id = #{userId} AND post_id = #{postId} LIMIT 1
    </select>

    <!-- 举报 -->
    <insert id="insertReportPost" parameterType="com.example.springboot.entity.Forum.ReportPost" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO report_post(reporter_id, post_id, reason, created_at) VALUES(#{reporterId}, #{postId}, #{reason}, NOW())
    </insert>

    <select id="selectReportPostsByPostId" parameterType="int" resultType="com.example.springboot.entity.Forum.ReportPost">
        SELECT * FROM report_post WHERE post_id = #{postId} ORDER BY created_at DESC
    </select>

    <!-- 查询某用户的所有帖子 -->
    <select id="selectPostsByUserId" parameterType="int" resultType="com.example.springboot.entity.Forum.Post">
        SELECT
            p.id,
            p.user_id AS userId,
            u.username,
            p.title,
            p.content,
            p.created_at AS createdAt,
            p.updated_at AS updatedAt,
            IFNULL(like_counts.count, 0) AS likeCount
        FROM post p
                 LEFT JOIN user u ON p.user_id = u.id
                 LEFT JOIN (
            SELECT post_id, COUNT(*) AS count
            FROM like_post
            GROUP BY post_id
        ) like_counts ON like_counts.post_id = p.id
        WHERE p.user_id = #{userId}
        ORDER BY p.created_at DESC
    </select>

    <!-- 查询某帖子的点赞数量 -->
    <select id="selectLikeCountByPostId" parameterType="int" resultType="int">
        SELECT COUNT(*) FROM like_post WHERE post_id = #{postId}
    </select>

    <!-- 查询用户点赞过的帖子 -->
    <select id="selectLikedPostsByUserId" parameterType="int" resultType="com.example.springboot.entity.Forum.Post">
        SELECT
            p.id,
            p.user_id AS userId,
            u.username,
            p.title,
            p.content,
            p.created_at AS createdAt,
            p.updated_at AS updatedAt
        FROM post p
                 INNER JOIN like_post lp ON p.id = lp.post_id
                 LEFT JOIN user u ON p.user_id = u.id
        WHERE lp.user_id = #{userId}
        ORDER BY lp.created_at DESC
    </select>

    <!-- 查询用户收藏过的帖子 -->
    <select id="selectFavoritedPostsByUserId" parameterType="int" resultType="com.example.springboot.entity.Forum.Post">
        SELECT
            p.id,
            p.user_id AS userId,
            u.username,
            p.title,
            p.content,
            p.created_at AS createdAt,
            p.updated_at AS updatedAt
        FROM post p
                 INNER JOIN favorite_post fp ON p.id = fp.post_id
                 LEFT JOIN user u ON p.user_id = u.id
        WHERE fp.user_id = #{userId}
        ORDER BY fp.created_at DESC
    </select>

    <select id="selectAllReportPosts" parameterType="map" resultType="com.example.springboot.entity.Forum.ReportPost">
        SELECT
            r.id, r.reporter_id AS reporterId, r.post_id AS postId, r.reason, r.created_at AS createdAt,
            u.username AS reporterUsername,
            p.title AS postTitle
        FROM report_post r
                 LEFT JOIN user u ON r.reporter_id = u.id
                 LEFT JOIN post p ON r.post_id = p.id
        ORDER BY r.created_at DESC
        LIMIT #{limit} OFFSET #{offset}
    </select>

</mapper>

已安装依赖
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.4.6</version>
</dependency>