diff --git a/src/main/java/com/example/g8backend/controller/PostController.java b/src/main/java/com/example/g8backend/controller/PostController.java
index f373539..a47734a 100644
--- a/src/main/java/com/example/g8backend/controller/PostController.java
+++ b/src/main/java/com/example/g8backend/controller/PostController.java
@@ -109,4 +109,14 @@
         Long likeCount = postService.getPostLikeCount(postId);
         return ResponseEntity.ok().body(likeCount);
     }
+
+    // 搜索帖子
+    @GetMapping("/search")
+    public List<Post> searchPosts(
+            @RequestParam(required = false) String keyword,
+            @RequestParam(required = false) List<Long> tags,  // 修改为接收多个标签
+            @RequestParam(required = false) String author) {
+
+        return postService.searchPosts(keyword, tags, author);
+    }
 }
diff --git a/src/main/java/com/example/g8backend/mapper/PostMapper.java b/src/main/java/com/example/g8backend/mapper/PostMapper.java
index 6db4e67..0cba5c1 100644
--- a/src/main/java/com/example/g8backend/mapper/PostMapper.java
+++ b/src/main/java/com/example/g8backend/mapper/PostMapper.java
@@ -4,10 +4,32 @@
 import com.example.g8backend.entity.Post;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
+import org.apache.ibatis.annotations.Select;
 
 import java.util.List;
 
 @Mapper
 public interface PostMapper extends BaseMapper<Post> {
     List<Post> getPostsByUserId(@Param("userId") Long userId);
+
+    @Select("<script>" +
+            "SELECT p.* " +
+            "FROM posts p " +
+            "LEFT JOIN post_tag pt ON p.post_id = pt.post_id " +
+            "LEFT JOIN tags t ON pt.tag_id = t.tag_id " +
+            "LEFT JOIN users u ON p.user_id = u.user_id " +
+            "WHERE (p.post_title LIKE CONCAT('%', #{keyword}, '%') OR p.post_content LIKE CONCAT('%', #{keyword}, '%')) " +
+            "<if test='tagIds != null and tagIds.size() > 0'> " +
+            "AND pt.tag_id IN " +
+            "<foreach item='tagId' collection='tagIds' open='(' separator=',' close=')'> " +
+            "#{tagId} " +
+            "</foreach> " +
+            "</if>" +
+            "<if test='author != null'> " +
+            "AND u.user_name = #{author} " +
+            "</if>" +
+            "</script>")
+    List<Post> searchPosts(@Param("keyword") String keyword,
+                           @Param("tagIds") List<Long> tagIds,  // 改成接受一个tagIds列表
+                           @Param("author") String author);
 }
diff --git a/src/main/java/com/example/g8backend/service/IPostService.java b/src/main/java/com/example/g8backend/service/IPostService.java
index f914946..82c792e 100644
--- a/src/main/java/com/example/g8backend/service/IPostService.java
+++ b/src/main/java/com/example/g8backend/service/IPostService.java
@@ -14,4 +14,6 @@
     Long getPostLikeCount(Long postId);
     void likePost(Long userId, Long postId);
     void unlikePost(Long userId, Long postId);
+
+    List<Post> searchPosts(String keyword, List<Long> tagIds, String author); // 更新为支持多个标签
 }
diff --git a/src/main/java/com/example/g8backend/service/impl/PostServiceImpl.java b/src/main/java/com/example/g8backend/service/impl/PostServiceImpl.java
index d40ddd6..37db6af 100644
--- a/src/main/java/com/example/g8backend/service/impl/PostServiceImpl.java
+++ b/src/main/java/com/example/g8backend/service/impl/PostServiceImpl.java
@@ -14,7 +14,7 @@
 
 @Service
 public class PostServiceImpl extends ServiceImpl<PostMapper, Post> implements IPostService {
-    
+
     private final PostMapper postMapper;
 
     @Autowired
@@ -45,7 +45,7 @@
         }
     }
 
-    @Override 
+    @Override
     public Post updatePost(Post post) {
         updateById(post);
         return getById(post.getPostId());
@@ -73,4 +73,9 @@
     public void unlikePost(Long userId, Long postId) {
         // TODO: 需要实现post_likes表的删除
     }
-}
+
+    @Override
+    public List<Post> searchPosts(String keyword, List<Long> tagIds, String author) {
+        return postMapper.searchPosts(keyword, tagIds, author); // 调用mapper的搜索方法
+    }
+}
\ No newline at end of file
