Halo 開源專案學習（五）：評論與點贊-有解無憂

基本介紹

博客系統中，用戶瀏覽文章時可以在文章下方發表自己的觀點，與博主或其他用戶進行互動，也可以為喜歡的文章點贊，下面我們一起分析一下 Halo 專案中評論和點贊功能的實作程序，

發表評論

評論可以是對文章的評論，對頁面的評論，也可以是對評論的評論（通常稱為回復），因此專案中需要對評論的類別進行劃分，評論的物體類 BaseComment 中設定了幾個重要的屬性：type、postId、parentId，其中 type 用于區分文章和頁面，type 為 0 表示對文章的評論，為 1 表示對頁面的評論；postId 用于指定評論屬于哪一篇文章或頁面；parentId 表示當前評論的 "父評論"，如果當前評論是對某個 "父評論" 的回復，那么 parentId 為該 "父評論" 的 id，如果評論文章，那么 parentId 為 0，

進入博客首頁，點開一篇文章，在下方發表評論：

點擊 "評論" 按鈕后，觸發 api/content/posts/comments 請求：

該請求由 PostController 中的 comment 方法處理：

@PostMapping("comments")
@ApiOperation("Comments a post")
@CacheLock(autoDelete = false, traceRequest = true)
public BaseCommentDTO comment(@RequestBody PostCommentParam postCommentParam) {
    // 驗證當前 IP 是否處于封禁狀態
    postCommentService.validateCommentBlackListStatus();

    // 對評論的內容進行轉義
    // Escape content
    postCommentParam.setContent(HtmlUtils
        .htmlEscape(postCommentParam.getContent(), StandardCharsets.UTF_8.displayName()));
    // 創建評論
    return postCommentService.convertTo(postCommentService.createBy(postCommentParam));
}

comment 方法首先會檢查當前發送評論的 IP 是否處于封禁狀態，如果未處于封禁狀態，那么系統會對評論的內容進行 HTML 轉義，轉義完成后創建該評論，首先介紹一下 Halo 的 "封禁評論" 機制，封禁的目的是防止惡意 IP 搶占和浪費博客系統的資源，進入 validateCommentBlackListStatus 方法，查看驗證 IP 的具體程序：

public void validateCommentBlackListStatus() {
    // 查看當前 IP 的封禁狀態
    CommentViolationTypeEnum banStatus =
        commentBlackListService.commentsBanStatus(ServletUtils.getRequestIp());
    // 獲取系統設定的封禁時間
    Integer banTime = optionService
        .getByPropertyOrDefault(CommentProperties.COMMENT_BAN_TIME, Integer.class, 10);
    // 如果當前 IP 處于封禁狀態, 提示用戶稍后重試
    if (banStatus == CommentViolationTypeEnum.FREQUENTLY) {
        throw new ForbiddenException(String.format("您的評論過于頻繁，請%s分鐘之后再試，", banTime));
    }
}

上述代碼中，服務器首先查詢當前 IP 的封禁狀態，如果狀態為 FREQUENTLY，那么就認為當前 IP 的評論過于頻繁，然后提示用戶稍后重試，該程序是一種 "限流" 機制，其重點在于如何設計 "頻繁評論" 的評判標準，直白一點就是如何 "限流"？限流的方式有很多種，如利用快取或記憶體佇列等，Halo 中使用資料庫來實作限流策略，這個設計思路也是非常值得學習的，commentsBanStatus 方法的處理邏輯如下：

public CommentViolationTypeEnum commentsBanStatus(String ipAddress) {
    /*
    N=后期可配置
    1. 獲取評論次數；
    2. 判斷N分鐘內，是否超過規定的次數限制，超過后需要每隔N分鐘才能再次評論；
    3. 如果在時隔N分鐘內，還有多次評論，可被認定為惡意攻擊者；
    4. 對惡意攻擊者進行N分鐘的封禁；
    */
    // 發送評論的 ip 在封禁是否在封禁名單中
    Optional<CommentBlackList> blackList =
        commentBlackListRepository.findByIpAddress(ipAddress);
    LocalDateTime now = LocalDateTime.now();
    Date endTime = new Date(DateTimeUtils.toEpochMilli(now));
    // 封禁的時間間隔, 也是評估是否需要封禁的時間間隔, 默認 10 分鐘
    Integer banTime = optionService
        .getByPropertyOrDefault(CommentProperties.COMMENT_BAN_TIME, Integer.class, 10);
    // now - 時間間隔
    Date startTime = new Date(DateTimeUtils.toEpochMilli(now.minusMinutes(banTime)));
    // 評論數閾值, 默認為 30 個
    Integer range = optionService
        .getByPropertyOrDefault(CommentProperties.COMMENT_RANGE, Integer.class, 30);
    // 指定時間間隔內, 當前 ip 的評論數是否超過評論數閾值
    boolean isPresent =
        postCommentRepository.countByIpAndTime(ipAddress, startTime, endTime) >= range;
    if (isPresent && blackList.isPresent()) {
        // 設定當前 IP 的解禁時間為 banTime 分鐘后
        update(now, blackList.get(), banTime);
        return CommentViolationTypeEnum.FREQUENTLY;
    } else if (isPresent) {
        // 構建 CommentBlackList 物件, 設定當前 IP 的解禁時間為 banTime 分鐘后
        CommentBlackList commentBlackList = CommentBlackList
            .builder()
            .banTime(getBanTime(now, banTime))
            .ipAddress(ipAddress)
            .build();
        super.create(commentBlackList);
        return CommentViolationTypeEnum.FREQUENTLY;
    }
    return CommentViolationTypeEnum.NORMAL;
}

查詢當前 IP 是否處于封禁黑名單（comment_black_list 表）中，
查詢系統設定的時間閾值 banTime（默認是 10 分鐘），并判斷從 banTime 分鐘前到現在，當前 IP 的評論數是否超過了評論數閾值 range（默認是 30 個），如果超過了，那么就需要對當前 IP 實施封禁措施，換句話說，如果 banTime 分鐘內，當前 IP 的評論數達到指定閾值，就對當前 IP 進行限流，這里 banTime 是評估封禁的引數，也可以稱為時間閾值，
達到限流條件后，如果當前 IP 存在于封禁黑名單，那么更新 comment_black_list 表，將其解禁時間設定為 banTime 分鐘后，雖然 comment_black_list 表中的屬性 ban_time 在專案中被稱為封禁時間，但結合代碼可以發現它的真實含義是解禁時間，如果當前 IP 不在封禁黑名單，那么創建一條新的記錄，IP 為當前請求的 IP，解禁時間為 banTime 分鐘后，實際上，封禁黑名單的業務含義設定的并不嚴謹，它的作用僅僅是在資料表中創建或更新一條記錄，且記錄的解禁時間也只是一個參考值，因為評估 "限流" 的依據是 banTime 分鐘前到現在的總評論數，與黑名單中的時間并無關聯，Halo 中的 "限流" 機制類似于一個優先佇列，佇列的容量為 range，元素的屬性包括 IP 和入隊時間，如果元素入隊的時間與當前時間的間隔達到 banTime，那么該元素出隊，如果佇列已滿，那么實施 "限流"，一旦佇列恢復出至少一個空閑位置，那么用戶便可再次發表評論，
達到限流條件后回傳封禁狀態 FREQUENTLY，否則回傳 NORMAL，

了解了封禁機制后，我們再說一說 HTML 轉義，轉義指的是對一些特殊的標簽，如 <、>、& 等進行轉義，使系統認為其屬于普通的符號，不具備標簽功能，HTML 內容轉義可以有效防止 XSS 攻擊，HtmlUtils 工具類中的 htmlEscape 方法可實作轉義操作，

接下來，我們來分析評論的創建程序，即 createBy 方法的處理邏輯：

public COMMENT createBy(@NonNull BaseCommentParam<COMMENT> commentParam) {
    Assert.notNull(commentParam, "Comment param must not be null");

    // Check user login status and set this field
    Authentication authentication = SecurityContextHolder.getContext().getAuthentication();

    // 博主的評論
    if (authentication != null) {
        // Blogger comment
        User user = authentication.getDetail().getUser();
        commentParam.setAuthor(
            StringUtils.isBlank(user.getNickname()) ? user.getUsername() : user.getNickname());
        commentParam.setEmail(user.getEmail());
        commentParam.setAuthorUrl(
            optionService.getByPropertyOrDefault(BlogProperties.BLOG_URL, String.class, null));
    }

    // Validate the comment param manually
    ValidationUtils.validate(commentParam);
    // 普通用戶的評論
    if (authentication == null) {
        // Anonymous comment
        // Check email
        if (userService.getByEmail(commentParam.getEmail()).isPresent()) {
            throw new BadRequestException("不能使用博主的郵箱，如果您是博主，請登錄管理端進行回復，");
        }
    }

    // Convert to comment
    return create(commentParam.convertTo());
}

從 ThreadLocal 容器中獲取用戶資訊，如果用戶資訊不為空，那么當前發表評論的用戶為博主，因為普通用戶是不需要登錄的，確認博主身份后在 commentParam 引數中封裝博主的資訊，
校驗 commentParam 引數是否符合 BaseCommentParam 類中制定的規則，例如評論者的昵稱不能為空，郵箱格式必須正確等，
如果步驟 1 中用戶資訊為空，那么當前評論來自于普通用戶，許多博客系統對普通用戶的資訊并沒有太嚴格的要求，比如 Halo 中用戶發表評論時只需要填寫昵稱和郵箱，但需要注意普通用戶的郵箱不能和管理員的郵箱重復，

上述步驟中的驗證操作通過后，執行 create 方法創建評論：

public COMMENT create(@NonNull COMMENT comment) {
    Assert.notNull(comment, "Domain must not be null");

    // 確保文章是存在的
    // Check post id
    if (!ServiceUtils.isEmptyId(comment.getPostId())) {
        validateTarget(comment.getPostId());
    }

    // 如果 parentId 是非 0 的整數, 那么該評論為用戶的回復, 該評論的 "父評論" 必須存在
    // Check parent id
    if (!ServiceUtils.isEmptyId(comment.getParentId())) {
        mustExistById(comment.getParentId());
    }

    // Check user login status and set this field
    final Authentication authentication =
        SecurityContextHolder.getContext().getAuthentication();

    // 設定默認值
    // Set some default values
    if (comment.getIpAddress() == null) {
        comment.setIpAddress(ServletUtils.getRequestIp());
    }

    // 設定 useragent
    if (comment.getUserAgent() == null) {
        comment.setUserAgent(ServletUtils.getHeaderIgnoreCase(HttpHeaders.USER_AGENT));
    }
    // 設定頭像
    if (comment.getGravatarMd5() == null) {
        comment.setGravatarMd5(
            DigestUtils.md5Hex(Optional.ofNullable(comment.getEmail()).orElse("")));
    }

    // 將用戶設定的 URL 規范化
    if (StringUtils.isNotEmpty(comment.getAuthorUrl())) {
        comment.setAuthorUrl(HaloUtils.normalizeUrl(comment.getAuthorUrl()));
    }
    // 來自于博主的評論, 評論狀態直接為 PUBLISHED
    if (authentication != null) {
        // Comment of blogger
        comment.setIsAdmin(true);
        comment.setStatus(CommentStatus.PUBLISHED);
    } else {
        // Comment of guest
        // Handle comment status
        // 如果設定了評論審核, 需要將評論狀態先設定為待審核狀態
        Boolean needAudit = optionService
            .getByPropertyOrDefault(CommentProperties.NEW_NEED_CHECK, Boolean.class, true);
        comment.setStatus(needAudit ? CommentStatus.AUDITING : CommentStatus.PUBLISHED);
    }
    // 創建評論
    // Create comment
    COMMENT createdComment = super.create(comment);

    // 如果 parentId 為 0, 表示該評論是對文章的評論
    if (ServiceUtils.isEmptyId(createdComment.getParentId())) {
        if (authentication == null) {
            // 新增評論事件
            // New comment of guest
            eventPublisher.publishEvent(new CommentNewEvent(this, createdComment.getId()));
        }
    } else {
        // 回復評論事件
        // Reply comment
        eventPublisher.publishEvent(new CommentReplyEvent(this, createdComment.getId()));
    }

    return createdComment;
}

首先確保評論的合理性，即評論所屬的文章必須存在，如果評論的 parentId 是非 0 的整數，那么該評論為用戶的回復，該評論的 "父評論" 必須存在，
為評論的 ipAddress、useragent、頭像設定默認值（如果為空），并對用戶設定的 URL 做規范化處理，
如果評論來自于博主，那么將 isAdmin 設定為 true，并將評論的狀態直接設定為 PUBLISHED，如果評論來自于普通用戶且系統開啟了審核機制，那么將評論的狀態設定為待審核狀態 AUDITING，處于 AUDITING 狀態的評論需要博主審核通過后才能顯示，
在 comments 表中創建評論，并發布相應的事件，如果評論的 parentId 為 0（該評論是對文章的評論）且該評論來自于普通用戶，那么發布 "新增評論" 事件，如果 parentId 不為 0，發布 "回復評論" 事件，

create 方法執行成功后，一條評論就創建完成了 (^～^)!

查看評論

我們在瀏覽文章時，可以看到文章底下用戶的評論，其中排在前面的通常是一些高贊評論（神回復）或最新評論，如果評論數量較多，那么部分評論可能會被折疊，例如打開一篇文章：

上圖中，我們只能看到文章的 "直系" 評論（對該文章的評論），而看不到對評論的評論，當文章被點開時，前端不僅會發送 archives/{slug} 請求來獲取文章的具體內容，還會發送 api/content/posts/{postId}/comments/top_view 請求來獲取屬于該文章的 "直系" 評論，該請求由 PostController 中的 listTopComments 方法處理：

@GetMapping("{postId:\\d+}/comments/top_view")
public Page<CommentWithHasChildrenVO> listTopComments(@PathVariable("postId") Integer postId,
    @RequestParam(name = "page", required = false, defaultValue = "https://www.cnblogs.com/johnlearning/p/0") int page,
    @SortDefault(sort = "createTime", direction = DESC) Sort sort) {
    return postCommentService.pageTopCommentsBy(postId, CommentStatus.PUBLISHED,
        PageRequest.of(page, optionService.getCommentPageSize(), sort));
}

"Top comments" 指的就是 "直系" 評論，進入 pageTopCommentsBy 方法，查看列舉 Top comments 的具體程序：

public Page<CommentWithHasChildrenVO> pageTopCommentsBy(@NonNull Integer targetId,
    @NonNull CommentStatus status,
    @NonNull Pageable pageable) {
    Assert.notNull(targetId, "Target id must not be null");
    Assert.notNull(status, "Comment status must not be null");
    Assert.notNull(pageable, "Page info must not be null");

    // 根據 postId、status、parentId 查詢出所有 "直系" 評論, 非回復
    // Get all comments
    Page<COMMENT> topCommentPage = baseCommentRepository
        .findAllByPostIdAndStatusAndParentId(targetId, status, 0L, pageable);

    if (topCommentPage.isEmpty()) {
        // If the comments is empty
        return ServiceUtils.buildEmptyPageImpl(topCommentPage);
    }

    // 獲取 "直系" 評論的 id 集合
    // Get top comment ids
    Set<Long> topCommentIds =
        ServiceUtils.fetchProperty(topCommentPage.getContent(), BaseComment::getId);
    // 獲取每一條 "直系" 評論的子評論數
    // Get direct children count
    List<CommentChildrenCountProjection> directChildrenCount =
        baseCommentRepository.findDirectChildrenCount(topCommentIds, CommentStatus.PUBLISHED);
    // map 的 key 是 "直系" 評論的 id, value 是對應的子評論數
    // Convert to comment - children count map
    Map<Long, Long> commentChildrenCountMap = ServiceUtils
        .convertToMap(directChildrenCount, CommentChildrenCountProjection::getCommentId,
            CommentChildrenCountProjection::getDirectChildrenCount);

    // Convert to comment with has children vo
    return topCommentPage.map(topComment -> {
        CommentWithHasChildrenVO comment =
            new CommentWithHasChildrenVO().convertFrom(topComment);
        comment
            .setHasChildren(commentChildrenCountMap.getOrDefault(topComment.getId(), 0L) > 0);
        comment.setAvatar(buildAvatarUrl(topComment.getGravatarMd5()));
        return comment;
    });
}

首先根據 postId、status、parentId 查詢出所有 "直系" 評論，如果為空，那么直接回傳空的 Page，否則執行下面的步驟，
將所有 "直系" 評論的 id 封裝在 Set 集合中，并獲取每一條評論的子評論數，之后構造 Map，其中 key 為 "直系" 評論的 id，value 為對應的子評論數，
利用 CommentWithHasChildrenVO 封裝每一條評論的內容，并判斷評論是否包含子評論（如果包含子評論，前端頁面會顯示 "更多" 按鈕），最后設定頭像資訊，

通過上述操作可以查看到用戶對文章的評論，如果希望看到對評論的回復，則需要點擊 "更多" 按鈕，此時前端發送 api/content/posts/{postId}/comments/{commentParentId}/children 請求，該請求由 PostController 中的 listChildrenBy 方法處理：

@GetMapping("{postId:\\d+}/comments/{commentParentId:\\d+}/children")
public List<BaseCommentDTO> listChildrenBy(@PathVariable("postId") Integer postId,
    @PathVariable("commentParentId") Long commentParentId,
    @SortDefault(sort = "createTime", direction = DESC) Sort sort) {
    // Find all children comments
    List<PostComment> postComments = postCommentService
        .listChildrenBy(postId, commentParentId, CommentStatus.PUBLISHED, sort);
    // Convert to base comment dto

    return postCommentService.convertTo(postComments);
}

上述方法中，parentId 為某一條 "直系" 評論的 id，此 id 是一個大于 0 的整數，方法會回傳該 "直系" 評論下狀態為 PUBLISHED 的所有子評論，下面我們進入 service 層中的 listChildrenBy 方法，查看具體的邏輯：

public List<COMMENT> listChildrenBy(@NonNull Integer targetId, @NonNull Long commentParentId,
    @NonNull CommentStatus status, @NonNull Sort sort) {
    Assert.notNull(targetId, "Target id must not be null");
    Assert.notNull(commentParentId, "Comment parent id must not be null");
    Assert.notNull(sort, "Sort info must not be null");

    // Get comments recursively

    // 獲取 "直系" 評論的回復
    // Get direct children
    List<COMMENT> directChildren = baseCommentRepository
        .findAllByPostIdAndStatusAndParentId(targetId, status, commentParentId);

    // Create result container
    Set<COMMENT> children = new HashSet<>();
    // 遞回獲取 "直系" 評論的回復的回復
    // Get children comments
    getChildrenRecursively(directChildren, status, children);

    // Sort children
    List<COMMENT> childrenList = new ArrayList<>(children);
    // 對結果進行排序, 按照 commentId 升序排
    childrenList.sort(Comparator.comparing(BaseComment::getId));

    return childrenList;
}

首先獲取 "直系" 評論的回復，為了便于表述，我們將 "直系" 評論稱為一級評論，那么 "直系" 評論的回復就稱為二級評論，以此類推，
由于二級評論下方也可能會有回復，即三級評論，因此需要遞回獲取所有的子評論，
獲取到子評論后將所有的評論按照 id 升序排列并回傳，

實際上在許多網站中，屬于文章的評論（"直系" 評論）和屬于評論的評論確實會做一個分級展示，但評論的評論之間一般是并列展示的：

上圖中，"直系" 評論下方有兩條子評論，其中子評論 2（"好的"）是對子評論 1（"收到"）的回復，二者在前端的排版上屬于同一級，但為了更好地理清其中的邏輯關系，我們將其分為 "二級" 和 "三級"，下面查看遞回方法 getChildrenRecursively 查找不同級別評論的程序：

private void getChildrenRecursively(@Nullable List<COMMENT> topComments,
    @NonNull CommentStatus status, @NonNull Set<COMMENT> children) {
    Assert.notNull(status, "Comment status must not be null");
    Assert.notNull(children, "Children comment set must not be null");

    if (CollectionUtils.isEmpty(topComments)) {
        return;
    }
    // 當前級別評論的 id 集合
    // Convert comment id set
    Set<Long> commentIds = ServiceUtils.fetchProperty(topComments, COMMENT::getId);
    // 獲取下一級評論
    // Get direct children
    List<COMMENT> directChildren =
        baseCommentRepository.findAllByStatusAndParentIdIn(status, commentIds);
    // 獲取下下一級評論
    // Recursively invoke
    getChildrenRecursively(directChildren, status, children);
    // 將評論封裝在 Set 集合中
    // Add direct children to children result
    children.addAll(topComments);
}

首先獲取當前級別評論的 id 集合，并根據 id 集合從資料庫中獲取下一級評論，
執行遞回方法，根據下一級評論獲取下下級評論，
將當前級別的評論存入到 Set 集合，

以上便是用戶瀏覽評論時后臺服務器的處理流程，

評論的通知

Halo 中設定了評論通知的功能，當用戶發送評論時，系統會發送郵件通知博主，當博主回復用戶的評論時，如果用戶設定的 Email 是有效的郵箱，那么博主回復的內容也會被發送到用戶的郵箱中，下面以 QQ 郵箱為例，介紹一下操作程序，

首先進入 QQ 郵箱，點擊左上角的 "設定"，選擇 "賬戶"，向下拉，找到 "POP3/IMAP/SMTP/Exchange/CardDAV/CalDAV服務"，開啟 "POP3/SMTP服務"：

然后點擊生成授權碼，使用密保手機發送指定短信后就可以收到授權碼，接著進入 Halo 的管理員界面，點擊 "系統" -> "博客設定"，選擇 "SMTP 服務" 并填寫資訊，郵箱賬號填寫自己的 QQ 郵箱，密碼是生成的授權碼：

填寫完成后點擊保存，在右側的 "發送測驗" 選項中測驗是否能正常發送郵件，收件人地址需要填寫一個正確的 Email 地址，一般情況下是能夠發送成功的，此外，還需要在 "評論設定" 選項中開啟 "評論回復通知對方"，最后保存設定，這樣，當博主回復時，用戶的郵箱就可以收到博主回復的內容了：

點贊

Halo 專案中，文章的點贊量是作為一個屬性封裝在 BasePost 物體中的，因此更新點贊量的時候需要更新 posts 資料表，這種處理方式在用戶量較少的個人博客系統中是可行的，因為并發量一般不會超出資料庫的可承受范圍，而且由于普通用戶不需要登錄，所以可以不用考慮用戶的取消點贊操作，但是需要注意的是，對于擁有大量用戶的博客平臺或者社區論壇系統，此種方式就不再適用了，因為點贊操作是一個高頻呼叫的功能，頻繁操作資料庫可能會使服務器崩潰，

下面我們分析一下點贊功能的實作程序，由于默認的主題 caicai_anatole 沒有提供點贊按鈕，所以我們將主題更換為 joe2.0（其它主題也可），進入文章詳情頁，點擊 "點贊" 按鈕后，觸發 /api/content/posts/1/likes 請求，該請求由 PostController 中的 like 方法處理：

@PostMapping("{postId:\\d+}/likes")
@ApiOperation("Likes a post")
@CacheLock(autoDelete = false, traceRequest = true)
public void like(@PathVariable("postId") @CacheParam Integer postId) {
    postService.increaseLike(postId);
}

like 方法呼叫 increaseLike 方法來增加點贊量，increaseLike 方法的處理邏輯也非常簡單，就是將 id 為 postId 的文章的點贊量加一 ρ（＾ o ＾）?，

結語

本文以文章為例，介紹了評論和點贊功能的實作程序，由于對頁面的評論和點贊與之類似，因此便不再贅述了，

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/465941.html

標籤：Java

上一篇：day02 真正的高并發還得看IO多路復用

下一篇：又一款接?私活神器！Spring Boot + Vue 通用后臺管理系統，真香！！