Golang implémente des commentaires à plusieurs niveaux

Avec l'essor des médias sociaux et des plateformes de contenu, les systèmes de commentaires à plusieurs niveaux sont devenus un moyen important d'interaction entre les utilisateurs et la communauté sur diverses plateformes. Il est relativement simple de mettre en œuvre un système de commentaires multi-niveaux sur le front-end, mais il est relativement compliqué à mettre en œuvre sur le back-end. Cet article explique comment utiliser Golang pour implémenter des commentaires à plusieurs niveaux.

Idées d'implémentation

Les commentaires à plusieurs niveaux sont en fait un affichage d'une structure arborescente, et chaque commentaire peut être utilisé comme nœud. Les systèmes d'examen à plusieurs niveaux peuvent être mis en œuvre à l'aide d'arbres arborescents et binaires, les structures de données de base des structures arborescentes. Dans cet article, nous choisissons d’utiliser un arbre binaire structuré en arborescence pour l’implémentation.

Le nœud de l'arbre binaire se compose de deux nœuds enfants gauche et droit. Le nœud gauche est le premier nœud enfant du nœud actuel et le nœud droit est le deuxième nœud enfant du nœud actuel. Par conséquent, chaque fois que nous ajoutons un commentaire, nous devons uniquement prêter attention au nœud parent du commentaire actuel et à ses nœuds enfants gauche et droit.

Conception de base de données

Afin de mettre en œuvre un système de commentaires à plusieurs niveaux, la relation parent-enfant de chaque commentaire doit être stockée dans la base de données. En général, nous pouvons utiliser deux manières de stocker les structures arborescentes :

1. Utiliser des associations multi-tables
2. Utiliser des relations d'auto-référencement dans une seule table

Dans cet article, nous choisissons d'utiliser la deuxième méthode, c'est-à-dire dans Utiliser des relations autoréférentielles dans une seule table.

La structure du tableau de commentaires (commentaire) est la suivante :

CREATE TABLE `comment` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `parent_id` int(11) DEFAULT NULL COMMENT '父级评论id',
  `content` varchar(255) DEFAULT NULL COMMENT '评论内容',
  `created_at` datetime DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`),
  KEY `parent_id` (`parent_id`),
  CONSTRAINT `comment_ibfk_1` FOREIGN KEY (`parent_id`) REFERENCES `comment` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='评论表'

Dans la structure du tableau ci-dessus, parent_id表示当前评论的父节点id，如果当前评论是一级评论，则parent_id为null。id为当前评论的id，content为评论内容，created_at est l'heure de création.

Implémentation du code

Lien vers la base de données

Tout d'abord, vous devez utiliser les pilotes base de données/sql et mysql dans Golang pour créer un lien vers la base de données :

dsn := "root:123456@tcp(127.0.0.1:3306)/test"
db, err := sql.Open("mysql", dsn)
if err != nil {
   fmt.Printf("mysql connect error %s", err.Error())
   return
}

Insérer des commentaires

Lors de l'insertion d'un commentaire, vous devez déterminer si le commentaire actuel est utilisé comme nœud parent ou comme nœud enfant.

Si le commentaire actuel est utilisé comme nœud parent, il est inséré directement dans la base de données. Si le commentaire actuel est un nœud enfant, le nœud droit du nœud parent doit être mis à jour.

// 添加评论
func AddComment(comment Comment) error {
   if comment.ParentID == 0 {
       _, err := db.Exec("INSERT INTO comment(parent_id, content, created_at) VALUES(?, ?, ?)", nil, comment.Content, comment.CreatedAt)
       if err != nil {
           return err
       }
   } else {
       var rightNode *int
       err := db.QueryRow("SELECT right_node FROM comment WHERE id = ?", comment.ParentID).Scan(&rightNode)
       if err != nil {
           return err
       }
       tx, err := db.Begin()
       if err != nil {
           return err
       }
       // 更新右节点
       _, err = tx.Exec("UPDATE comment SET right_node = right_node + 2 WHERE right_node > ?", rightNode)
       if err != nil {
           tx.Rollback()
           return err
       }
       _, err = tx.Exec("UPDATE comment SET left_node = left_node + 2 WHERE left_node > ?", rightNode)
       if err != nil {
           tx.Rollback()
           return err
       }
       _, err = tx.Exec("INSERT INTO comment(parent_id, left_node, right_node, content, created_at) VALUES(?, ?, ?, ?, ?)", comment.ParentID, rightNode, rightNode+1, comment.Content, comment.CreatedAt)
       if err != nil {
           tx.Rollback()
           return err
       }
       tx.Commit()
   }
   return nil
}

Requête de commentaires

Lors de l'interrogation de commentaires, vous devez les trier selon l'ordre gauche et droit des nœuds pour obtenir une liste de commentaires arborescente. Lors de l'interrogation de commentaires, étant donné que les nœuds gauche et droit doivent être utilisés pour le tri, les colonnes des nœuds gauche et droit doivent être ajoutées aux conditions de requête. De plus, vous devez également utiliser un champ de niveau pour indiquer à quel niveau de nœud se trouve le nœud actuel afin de faciliter l'affichage frontal.

type Comment struct {
   ID        int    `json:"id"`
   ParentID  int    `json:"parent_id"`
   Content   string `json:"content"`
   LeftNode  int    `json:"left_node"`
   RightNode int    `json:"right_node"`
   Level     int    `json:"level"`
   CreatedAt string `json:"created_at"`
}

// 获取评论列表
func GetComments() ([]Comment, error) {
   rows, err := db.Query("SELECT id, parent_id, content, created_at, left_node, right_node, (COUNT (parent.id) -1) AS level FROM comment AS node, comment AS parent WHERE node.left_node BETWEEN parent.left_node AND parent.right_node GROUP BY node.id ORDER BY left_node")
   if err != nil {
       return nil, err
   }
   defer rows.Close()

   var comments []Comment
   for rows.Next() {
       var comment Comment
       err := rows.Scan(&comment.ID, &comment.ParentID, &comment.Content, &comment.CreatedAt, &comment.LeftNode, &comment.RightNode, &comment.Level)
       if err != nil {
           return nil, err
       }
       comments = append(comments, comment)
   }
   return comments, nil
}

Supprimer les commentaires

Lors de la suppression d'un commentaire, vous devez déterminer si le commentaire actuel est un nœud parent ou un nœud enfant. S'il s'agit d'un nœud parent, vous devez supprimer l'intégralité du sous-arbre.

// 删除评论
func DeleteComment(id int) error {
   tx, err := db.Begin()
   if err != nil {
       return err
   }
   var leftNode int
   var rightNode int
   err = tx.QueryRow("SELECT left_node, right_node FROM comment WHERE id = ?", id).Scan(&leftNode, &rightNode)
   if err != nil {
       tx.Rollback()
       return err
   }
   if leftNode == 1 && rightNode > 1 {
       // 删除子树
       _, err = tx.Exec("DELETE FROM comment WHERE left_node >= ? AND right_node <= ?;", leftNode, rightNode)
       if err != nil {
           tx.Rollback()
           return err
       }
       err = tx.Commit()
       if err != nil {
           tx.Rollback()
           return err
       }
   } else {
       // 删除单个节点
       _, err = tx.Exec("DELETE FROM comment WHERE id = ?", id)
       if err != nil {
           tx.Rollback()
           return err
       }
       err = tx.Commit()
       if err != nil {
           tx.Rollback()
           return err
       }
   }
   return nil
}

Conclusion

Grâce à l'implémentation du code ci-dessus, nous pouvons rapidement créer un système de commentaires à plusieurs niveaux entièrement fonctionnel. Bien entendu, il ne s'agit que d'une méthode de mise en œuvre de base. Dans les scénarios réels, l'optimisation et l'expansion correspondantes doivent être effectuées en fonction des besoins spécifiques.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!