feat: 点赞相关rabbitMQ

2025-12-30 01:23:54 +08:00
parent 0d96f8df88
commit 3800373166
5 changed files with 380 additions and 43 deletions
--- a/backend/internal/video/like_handler.go
+++ b/backend/internal/video/like_handler.go
@@ -7,12 +7,11 @@ import (
 )

 type LikeHandler struct {
-	service      *LikeService
-	videoService *VideoService
+	service *LikeService
 }

-func NewLikeHandler(service *LikeService, videoService *VideoService) *LikeHandler {
-	return &LikeHandler{service: service, videoService: videoService}
+func NewLikeHandler(service *LikeService) *LikeHandler {
+	return &LikeHandler{service: service}
 }

 func (lh *LikeHandler) Like(c *gin.Context) {
@@ -40,10 +39,6 @@ func (lh *LikeHandler) Like(c *gin.Context) {
 		c.JSON(500, gin.H{"error": err.Error()})
 		return
 	}
-	if err := lh.videoService.UpdatePopularity(c.Request.Context(), req.VideoID, 1); err != nil {
-		c.JSON(500, gin.H{"error": err.Error()})
-		return
-	}
 	c.JSON(200, gin.H{"message": "like success"})
 }

@@ -72,10 +67,6 @@ func (lh *LikeHandler) Unlike(c *gin.Context) {
 		c.JSON(500, gin.H{"error": err.Error()})
 		return
 	}
-	if err := lh.videoService.UpdatePopularity(c.Request.Context(), req.VideoID, -1); err != nil {
-		c.JSON(500, gin.H{"error": err.Error()})
-		return
-	}
 	c.JSON(200, gin.H{"message": "unlike success"})
 }

--- a/backend/internal/video/like_repo.go
+++ b/backend/internal/video/like_repo.go
@@ -2,7 +2,9 @@ package video

 import (
 	"context"
+	"errors"

+	"github.com/go-sql-driver/mysql"
 	"gorm.io/gorm"
 )

@@ -24,6 +26,31 @@ func (r *LikeRepository) Unlike(ctx context.Context, like *Like) error {
 		Delete(&Like{}).Error
 }

+func (r *LikeRepository) LikeIgnoreDuplicate(ctx context.Context, like *Like) (created bool, err error) {
+	if like == nil || like.VideoID == 0 || like.AccountID == 0 {
+		return false, nil
+	}
+	err = r.db.WithContext(ctx).Create(like).Error
+	if err == nil {
+		return true, nil
+	}
+	var mysqlErr *mysql.MySQLError
+	if errors.As(err, &mysqlErr) && mysqlErr.Number == 1062 {
+		return false, nil
+	}
+	return false, err
+}
+
+func (r *LikeRepository) DeleteByVideoAndAccount(ctx context.Context, videoID, accountID uint) (deleted bool, err error) {
+	if videoID == 0 || accountID == 0 {
+		return false, nil
+	}
+	res := r.db.WithContext(ctx).
+		Where("video_id = ? AND account_id = ?", videoID, accountID).
+		Delete(&Like{})
+	return res.RowsAffected > 0, res.Error
+}
+
 func (r *LikeRepository) IsLiked(ctx context.Context, videoID, accountID uint) (bool, error) {
 	var count int64
 	err := r.db.WithContext(ctx).Model(&Like{}).
--- a/backend/internal/video/like_service.go
+++ b/backend/internal/video/like_service.go
@@ -3,6 +3,8 @@ package video
 import (
 	"context"
 	"errors"
+	"feedsystem_video_go/internal/middleware/rabbitmq"
+	rediscache "feedsystem_video_go/internal/middleware/redis"
 	"time"

 	"github.com/go-sql-driver/mysql"
@@ -10,12 +12,15 @@ import (
 )

 type LikeService struct {
-	repo      *LikeRepository
-	VideoRepo *VideoRepository
+	repo         *LikeRepository
+	VideoRepo    *VideoRepository
+	cache        *rediscache.Client
+	likeMQ       *rabbitmq.LikeMQ
+	popularityMQ *rabbitmq.PopularityMQ
 }

-func NewLikeService(repo *LikeRepository, videoRepo *VideoRepository) *LikeService {
-	return &LikeService{repo: repo, VideoRepo: videoRepo}
+func NewLikeService(repo *LikeRepository, videoRepo *VideoRepository, cache *rediscache.Client, likeMQ *rabbitmq.LikeMQ, popularityMQ *rabbitmq.PopularityMQ) *LikeService {
+	return &LikeService{repo: repo, VideoRepo: videoRepo, cache: cache, likeMQ: likeMQ, popularityMQ: popularityMQ}
 }

 func isDupKey(err error) bool {
@@ -24,41 +29,152 @@ func isDupKey(err error) bool {
 }

 func (s *LikeService) Like(ctx context.Context, like *Like) error {
+	if like == nil {
+		return errors.New("like is nil")
+	}
+	if like.VideoID == 0 || like.AccountID == 0 {
+		return errors.New("video_id and account_id are required")
+	}
+
+	if s.VideoRepo != nil {
+		ok, err := s.VideoRepo.IsExist(ctx, like.VideoID)
+		if err != nil {
+			return err
+		}
+		if !ok {
+			return errors.New("video not found")
+		}
+	}
+
+	isLiked, err := s.repo.IsLiked(ctx, like.VideoID, like.AccountID)
+	if err != nil {
+		return err
+	}
+	if isLiked {
+		return errors.New("user has liked this video")
+	}
+
 	like.CreatedAt = time.Now()
-	return s.repo.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		if err := tx.Select("id").First(&Video{}, like.VideoID).Error; err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return errors.New("video not found")
-			}
-			return err
+	mysqlEnqueued := false
+	redisEnqueued := false
+	if s.likeMQ != nil {
+		if err := s.likeMQ.Like(ctx, like.AccountID, like.VideoID); err == nil {
+			mysqlEnqueued = true
 		}
-		if err := tx.Create(like).Error; err != nil {
-			if isDupKey(err) {
-				return errors.New("user has liked this video")
-			}
-			return err
-		}
-		if err := tx.Model(&Video{}).Where("id = ?", like.VideoID).
-			UpdateColumn("likes_count", gorm.Expr("likes_count + 1")).Error; err != nil {
-			return err
+	}
+	if s.popularityMQ != nil {
+		if err := s.popularityMQ.Update(ctx, like.VideoID, 1); err == nil {
+			redisEnqueued = true
 		}
+	}
+	if mysqlEnqueued && redisEnqueued {
 		return nil
-	})
+	}
+
+	// Fallback: direct MySQL write when like MQ publish fails.
+	if !mysqlEnqueued {
+		err := s.repo.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+			if err := tx.Select("id").First(&Video{}, like.VideoID).Error; err != nil {
+				if errors.Is(err, gorm.ErrRecordNotFound) {
+					return errors.New("video not found")
+				}
+				return err
+			}
+			if err := tx.Create(like).Error; err != nil {
+				if isDupKey(err) {
+					return errors.New("user has liked this video")
+				}
+				return err
+			}
+			if err := tx.Model(&Video{}).Where("id = ?", like.VideoID).
+				UpdateColumn("likes_count", gorm.Expr("likes_count + 1")).Error; err != nil {
+				return err
+			}
+			return tx.Model(&Video{}).Where("id = ?", like.VideoID).
+				UpdateColumn("popularity", gorm.Expr("popularity + 1")).Error
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	// Fallback: direct Redis update when popularity MQ publish fails.
+	if !redisEnqueued {
+		UpdatePopularityCache(ctx, s.cache, like.VideoID, 1)
+	}
+	return nil
 }

 func (s *LikeService) Unlike(ctx context.Context, like *Like) error {
-	return s.repo.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
-		del := tx.Where("video_id = ? AND account_id = ?", like.VideoID, like.AccountID).Delete(&Like{})
-		if del.Error != nil {
-			return del.Error
-		}
-		if del.RowsAffected == 0 {
-			return errors.New("user has not liked this video")
-		}
+	if like == nil {
+		return errors.New("like is nil")
+	}
+	if like.VideoID == 0 || like.AccountID == 0 {
+		return errors.New("video_id and account_id are required")
+	}

-		return tx.Model(&Video{}).Where("id = ?", like.VideoID).
-			UpdateColumn("likes_count", gorm.Expr("GREATEST(likes_count - 1, 0)")).Error
-	})
+	if s.VideoRepo != nil {
+		ok, err := s.VideoRepo.IsExist(ctx, like.VideoID)
+		if err != nil {
+			return err
+		}
+		if !ok {
+			return errors.New("video not found")
+		}
+	}
+
+	isLiked, err := s.repo.IsLiked(ctx, like.VideoID, like.AccountID)
+	if err != nil {
+		return err
+	}
+	if !isLiked {
+		return errors.New("user has not liked this video")
+	}
+
+	mysqlEnqueued := false
+	redisEnqueued := false
+	if s.likeMQ != nil {
+		if err := s.likeMQ.Unlike(ctx, like.AccountID, like.VideoID); err == nil {
+			mysqlEnqueued = true
+		}
+	}
+	if s.popularityMQ != nil {
+		if err := s.popularityMQ.Update(ctx, like.VideoID, -1); err == nil {
+			redisEnqueued = true
+		}
+	}
+	if mysqlEnqueued && redisEnqueued {
+		return nil
+	}
+
+	// Fallback: direct MySQL write when like MQ publish fails.
+	if !mysqlEnqueued {
+		err := s.repo.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+			del := tx.Where("video_id = ? AND account_id = ?", like.VideoID, like.AccountID).Delete(&Like{})
+			if del.Error != nil {
+				return del.Error
+			}
+			if del.RowsAffected == 0 {
+				return errors.New("user has not liked this video")
+			}
+
+			if err := tx.Model(&Video{}).Where("id = ?", like.VideoID).
+				UpdateColumn("likes_count", gorm.Expr("GREATEST(likes_count - 1, 0)")).Error; err != nil {
+				return err
+			}
+			return tx.Model(&Video{}).Where("id = ?", like.VideoID).
+				UpdateColumn("popularity", gorm.Expr("GREATEST(popularity - 1, 0)")).Error
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	// Fallback: direct Redis update when popularity MQ publish fails.
+	if !redisEnqueued {
+		UpdatePopularityCache(ctx, s.cache, like.VideoID, -1)
+	}
+	return nil
 }

 func (s *LikeService) IsLiked(ctx context.Context, videoID, accountID uint) (bool, error) {