构建一个即时消息应用（三）：对话

本文是该系列的第三篇。

公司主营业务：做网站、网站建设、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。创新互联公司是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。创新互联公司推出江南免费做网站回馈大家。

  • 第一篇：模式
  • 第二篇：OAuth

在我们的即时消息应用中，消息表现为两个参与者对话的堆叠。如果你想要开始一场对话，就应该向应用提供你想要交谈的用户，而当对话创建后（如果该对话此前并不存在），就可以向该对话发送消息。

就前端而言，我们可能想要显示一份近期对话列表。并在此处显示对话的最后一条消息以及另一个参与者的姓名和头像。

在这篇帖子中，我们将会编写一些端点endpoint来完成像“创建对话”、“获取对话列表”以及“找到单个对话”这样的任务。

首先，要在主函数 main() 中添加下面的路由。

 
 
 
    
  
  
  
  1. router.HandleFunc("POST", "/api/conversations", requireJSON(guard(createConversation)))
    2. 
  
  
  
  2. router.HandleFunc("GET", "/api/conversations", guard(getConversations))
    3. 
  
  
  
  3. router.HandleFunc("GET", "/api/conversations/:conversationID", guard(getConversation))
    4.

这三个端点都需要进行身份验证，所以我们将会使用 guard() 中间件。我们也会构建一个新的中间件，用于检查请求内容是否为 JSON 格式。

JSON 请求检查中间件

 
 
 
    
  
  
  
  1. func requireJSON(handler http.HandlerFunc) http.HandlerFunc {
    2. 
  
  
  
  2.  return func(w http.ResponseWriter, r *http.Request) {
    3. 
  
  
  
  3.  if ct := r.Header.Get("Content-Type"); !strings.HasPrefix(ct, "application/json") {
    4. 
  
  
  
  4.  http.Error(w, "Content type of application/json required", http.StatusUnsupportedMediaType)
    5. 
  
  
  
  5.  return
    6. 
  
  
  
  6.  }
    7. 
  
  
  
  7.  handler(w, r)
    8. 
  
  
  
  8.  }
    9. 
  
  
  
  9. }
    10.

如果请求request不是 JSON 格式，那么它会返回 415 Unsupported Media Type（不支持的媒体类型）错误。

创建对话

 
 
 
    
  
  
  
  1. type Conversation struct {
    2. 
  
  
  
  2.  ID string `json:"id"`
    3. 
  
  
  
  3.  OtherParticipant *User `json:"otherParticipant"`
    4. 
  
  
  
  4.  LastMessage *Message `json:"lastMessage"`
    5. 
  
  
  
  5.  HasUnreadMessages bool `json:"hasUnreadMessages"`
    6. 
  
  
  
  6. }
    7.

就像上面的代码那样，对话中保持对另一个参与者和最后一条消息的引用，还有一个 bool 类型的字段，用来告知是否有未读消息。

 
 
 
    
  
  
  
  1. type Message struct {
    2. 
  
  
  
  2.  ID string `json:"id"`
    3. 
  
  
  
  3.  Content string `json:"content"`
    4. 
  
  
  
  4.  UserID string `json:"-"`
    5. 
  
  
  
  5.  ConversationID string `json:"conversationID,omitempty"`
    6. 
  
  
  
  6.  CreatedAt time.Time `json:"createdAt"`
    7. 
  
  
  
  7.  Mine bool `json:"mine"`
    8. 
  
  
  
  8.  ReceiverID string `json:"-"`
    9. 
  
  
  
  9. }
    10.

我们会在下一篇文章介绍与消息相关的内容，但由于我们这里也需要用到它，所以先定义了 Message 结构体。其中大多数字段与数据库表一致。我们需要使用 Mine 来断定消息是否属于当前已验证用户所有。一旦加入实时功能，ReceiverID 可以帮助我们过滤消息。

接下来让我们编写 HTTP 处理程序。尽管它有些长，但也没什么好怕的。

 
 
 
    
  
  
  
  1. func createConversation(w http.ResponseWriter, r *http.Request) {
    2. 
  
  
  
  2.  var input struct {
    3. 
  
  
  
  3.  Username string `json:"username"`
    4. 
  
  
  
  4.  }
    5. 
  
  
  
  5.  defer r.Body.Close()
    6. 
  
  
  
  6.  if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
    7. 
  
  
  
  7.  http.Error(w, err.Error(), http.StatusBadRequest)
    8. 
  
  
  
  8.  return
    9. 
  
  
  
  9.  }
    10. 
  
  
  
  10. 
  
  
  
  11.  input.Username = strings.TrimSpace(input.Username)
    12. 
  
  
  
  12.  if input.Username == "" {
    13. 
  
  
  
  13.  respond(w, Errors{map[string]string{
    14. 
  
  
  
  14.  "username": "Username required",
    15. 
  
  
  
  15.  }}, http.StatusUnprocessableEntity)
    16. 
  
  
  
  16.  return
    17. 
  
  
  
  17.  }
    18. 
  
  
  
  18. 
  
  
  
  19.  ctx := r.Context()
    20. 
  
  
  
  20.  authUserID := ctx.Value(keyAuthUserID).(string)
    21. 
  
  
  
  21. 
  
  
  
  22.  tx, err := db.BeginTx(ctx, nil)
    23. 
  
  
  
  23.  if err != nil {
    24. 
  
  
  
  24.  respondError(w, fmt.Errorf("could not begin tx: %v", err))
    25. 
  
  
  
  25.  return
    26. 
  
  
  
  26.  }
    27. 
  
  
  
  27.  defer tx.Rollback()
    28. 
  
  
  
  28. 
  
  
  
  29.  var otherParticipant User
    30. 
  
  
  
  30.  if err := tx.QueryRowContext(ctx, `
    31. 
  
  
  
  31.  SELECT id, avatar_url FROM users WHERE username = $1
    32. 
  
  
  
  32.  `, input.Username).Scan(
    33. 
  
  
  
  33.  &otherParticipant.ID,
    34. 
  
  
  
  34.  &otherParticipant.AvatarURL,
    35. 
  
  
  
  35.  ); err == sql.ErrNoRows {
    36. 
  
  
  
  36.  http.Error(w, "User not found", http.StatusNotFound)
    37. 
  
  
  
  37.  return
    38. 
  
  
  
  38.  } else if err != nil {
    39. 
  
  
  
  39.  respondError(w, fmt.Errorf("could not query other participant: %v", err))
    40. 
  
  
  
  40.  return
    41. 
  
  
  
  41.  }
    42. 
  
  
  
  42. 
  
  
  
  43.  otherParticipant.Username = input.Username
    44. 
  
  
  
  44. 
  
  
  
  45.  if otherParticipant.ID == authUserID {
    46. 
  
  
  
  46.  http.Error(w, "Try start a conversation with someone else", http.StatusForbidden)
    47. 
  
  
  
  47.  return
    48. 
  
  
  
  48.  }
    49. 
  
  
  
  49. 
  
  
  
  50.  var conversationID string
    51. 
  
  
  
  51.  if err := tx.QueryRowContext(ctx, `
    52. 
  
  
  
  52.  SELECT conversation_id FROM participants WHERE user_id = $1
    53. 
  
  
  
  53.  INTERSECT
    54. 
  
  
  
  54.  SELECT conversation_id FROM participants WHERE user_id = $2
    55. 
  
  
  
  55.  `, authUserID, otherParticipant.ID).Scan(&conversationID); err != nil && err != sql.ErrNoRows {
    56. 
  
  
  
  56.  respondError(w, fmt.Errorf("could not query common conversation id: %v", err))
    57. 
  
  
  
  57.  return
    58. 
  
  
  
  58.  } else if err == nil {
    59. 
  
  
  
  59.  http.Redirect(w, r, "/api/conversations/"+conversationID, http.StatusFound)
    60. 
  
  
  
  60.  return
    61. 
  
  
  
  61.  }
    62. 
  
  
  
  62. 
  
  
  
  63.  var conversation Conversation
    64. 
  
  
  
  64.  if err = tx.QueryRowContext(ctx, `
    65. 
  
  
  
  65.  INSERT INTO conversations DEFAULT VALUES
    66. 
  
  
  
  66.  RETURNING id
    67. 
  
  
  
  67.  `).Scan(&conversation.ID); err != nil {
    68. 
  
  
  
  68.  respondError(w, fmt.Errorf("could not insert conversation: %v", err))
    69. 
  
  
  
  69.  return
    70. 
  
  
  
  70.  }
    71. 
  
  
  
  71. 
  
  
  
  72.  if _, err = tx.ExecContext(ctx, `
    73. 
  
  
  
  73.  INSERT INTO participants (user_id, conversation_id) VALUES
    74. 
  
  
  
  74.  ($1, $2),
    75. 
  
  
  
  75.  ($3, $2)
    76. 
  
  
  
  76.  `, authUserID, conversation.ID, otherParticipant.ID); err != nil {
    77. 
  
  
  
  77.  respondError(w, fmt.Errorf("could not insert participants: %v", err))
    78. 
  
  
  
  78.  return
    79. 
  
  
  
  79.  }
    80. 
  
  
  
  80. 
  
  
  
  81.  if err = tx.Commit(); err != nil {
    82. 
  
  
  
  82.  respondError(w, fmt.Errorf("could not commit tx to create conversation: %v", err))
    83. 
  
  
  
  83.  return
    84. 
  
  
  
  84.  }
    85. 
  
  
  
  85. 
  
  
  
  86.  conversation.OtherParticipant = &otherParticipant
    87. 
  
  
  
  87. 
  
  
  
  88.  respond(w, conversation, http.StatusCreated)
    89. 
  
  
  
  89. }
    90.

在此端点，你会向 /api/conversations 发送 POST 请求，请求的 JSON 主体中包含要对话的用户的用户名。

因此，首先需要将请求主体解析成包含用户名的结构。然后，校验用户名不能为空。

 
 
 
    
  
  
  
  1. type Errors struct {
    2. 
  
  
  
  2.  Errors map[string]string `json:"errors"`
    3. 
  
  
  
  3. }
    4.

这是错误消息的结构体 Errors，它仅仅是一个映射。如果输入空用户名，你就会得到一段带有 422 Unprocessable Entity（无法处理的实体）错误消息的 JSON 。

 
 
 
    
  
  
  
  1. {
    2. 
  
  
  
  2.  "errors": {
    3. 
  
  
  
  3.  "username": "Username required"
    4. 
  
  
  
  4.  }
    5. 
  
  
  
  5. }
    6.

然后，我们开始执行 SQL 事务。收到的仅仅是用户名，但事实上，我们需要知道实际的用户 ID 。因此，事务的第一项内容是查询另一个参与者的 ID 和头像。如果找不到该用户，我们将会返回 404 Not Found（未找到） 错误。另外，如果找到的用户恰好和“当前已验证用户”相同，我们应该返回 403 Forbidden（拒绝处理）错误。这是由于对话只应当在两个不同的用户之间发起，而不能是同一个。

然后，我们试图找到这两个用户所共有的对话，所以需要使用 INTERSECT 语句。如果存在，只需要通过 /api/conversations/{conversationID} 重定向到该对话并将其返回。

如果未找到共有的对话，我们需要创建一个新的对话并添加指定的两个参与者。最后，我们 COMMIT 该事务并使用新创建的对话进行响应。

获取对话列表

端点 /api/conversations 将获取当前已验证用户的所有对话。

 
 
 
    
  
  
  
  1. func getConversations(w http.ResponseWriter, r *http.Request) {
    2. 
  
  
  
  2.  ctx := r.Context()
    3. 
  
  
  
  3.  authUserID := ctx.Value(keyAuthUserID).(string)
    4. 
  
  
  
  4. 
  
  
  
  5.  rows, err := db.QueryContext(ctx, `
    6. 
  
  
  
  6.  SELECT
    7. 
  
  
  
  7.  conversations.id,
    8. 
  
  
  
  8.  auth_user.messages_read_at < messages.created_at AS has_unread_messages,
    9. 
  
  
  
  9.  messages.id,
    10. 
  
  
  
  10.  messages.content,
    11. 
  
  
  
  11.  messages.created_at,
    12. 
  
  
  
  12.  messages.user_id = $1 AS mine,
    13. 
  
  
  
  13.  other_users.id,
    14. 
  
  
  
  14.  other_users.username,
    15. 
  
  
  
  15.  other_users.avatar_url
    16. 
  
  
  
  16.  FROM conversations
    17. 
  
  
  
  17.  INNER JOIN messages ON conversations.last_message_id = messages.id
    18. 
  
  
  
  18.  INNER JOIN participants other_participants
    19. 
  
  
  
  19.  ON other_participants.conversation_id = conversations.id
    20. 
  
  
  
  20.  AND other_participants.user_id != $1
    21. 
  
  
  
  21.  INNER JOIN users other_users ON other_participants.user_id = other_users.id
    22. 
  
  
  
  22.  INNER JOIN participants auth_user
    23. 
  
  
  
  23.  ON auth_user.conversation_id = conversations.id
    24. 
  
  
  
  24.  AND auth_user.user_id = $1
    25. 
  
  
  
  25.  ORDER BY messages.created_at DESC
    26. 
  
  
  
  26.  `, authUserID)
    27. 
  
  
  
  27.  if err != nil {
    28. 
  
  
  
  28.  respondError(w, fmt.Errorf("could not query conversations: %v", err))
    29. 
  
  
  
  29.  return
    30. 
  
  
  
  30.  }
    31. 
  
  
  
  31.  defer rows.Close()
    32. 
  
  
  
  32. 
  
  
  
  33.  conversations := make([]Conversation, 0)
    34. 
  
  
  
  34.  for rows.Next() {
    35. 
  
  
  
  35.  var conversation Conversation
    36. 
  
  
  
  36.  var lastMessage Message
    37. 
  
  
  
  37.  var otherParticipant User
    38. 
  
  
  
  38.  if err = rows.Scan(
    39. 
  
  
  
  39.  &conversation.ID,
    40. 
  
  
  
  40.  &conversation.HasUnreadMessages,
    41. 
  
  
  
  41.  &lastMessage.ID,
    42. 
  
  
  
  42.  &lastMessage.Content,
    43. 
  
  
  
  43.  &lastMessage.CreatedAt,
    44. 
  
  
  
  44.  &lastMessage.Mine,
    45. 
  
  
  
  45.  &otherParticipant.ID,
    46. 
  
  
  
  46.  &otherParticipant.Username,
    47. 
  
  
  
  47.  &otherParticipant.AvatarURL,
    48. 
  
  
  
  48.  ); err != nil {
    49. 
  
  
  
  49.  respondError(w, fmt.Errorf("could not scan conversation: %v", err))
    50. 
  
  
  
  50.  return
    51. 
  
  
  
  51.  }
    52. 
  
  
  
  52. 
  
  
  
  53.  conversation.LastMessage = &lastMessage
    54. 
  
  
  
  54.  conversation.OtherParticipant = &otherParticipant
    55. 
  
  
  
  55.  conversations = append(conversations, conversation)
    56. 
  
  
  
  56.  }
    57. 
  
  
  
  57. 
  
  
  
  58.  if err = rows.Err(); err != nil {
    59. 
  
  
  
  59.  respondError(w, fmt.Errorf("could not iterate over conversations: %v", err))
    60. 
  
  
  
  60.  return
    61. 
  
  
  
  61.  }
    62. 
  
  
  
  62. 
  
  
  
  63.  respond(w, conversations, http.StatusOK)
    64. 
  
  
  
  64. }
    65.

该处理程序仅对数据库进行查询。它通过一些联接来查询对话表……首先，从消息表中获取最后一条消息。然后依据“ID 与当前已验证用户不同”的条件，从参与者表找到对话的另一个参与者。然后联接到用户表以获取该用户的用户名和头像。最后，再次联接参与者表，并以相反的条件从该表中找出参与对话的另一个用户，其实就是当前已验证用户。我们会对比消息中的 messages_read_at 和 created_at 两个字段，以确定对话中是否存在未读消息。然后，我们通过 user_id 字段来判定该消息是否属于“我”（指当前已验证用户）。

注意，此查询过程假定对话中只有两个用户参与，它也仅仅适用于这种情况。另外,该设计也不很适用于需要显示未读消息数量的情况。如果需要显示未读消息的数量，我认为可以在 participants 表上添加一个unread_messages_count INT 字段，并在每次创建新消息的时候递增它，如果用户已读则重置该字段。

接下来需要遍历每一条记录，通过扫描每一个存在的对话来建立一个对话切片slice of conversations并在最后进行响应。

找到单个对话

端点 /api/conversations/{conversationID} 会根据 ID 对单个对话进行响应。

 
 
 
    
  
  
  
  1. func getConversation(w http.ResponseWriter, r *http.Request) {
    2. 
  
  
  
  2.  ctx := r.Context()
    3. 
  
  
  
  3.  authUserID := ctx.Value(keyAuthUserID).(string)
    4. 
  
  
  
  4.  conversationID := way.Param(ctx, "conversationID")
    5. 
  
  
  
  5. 
  
  
  
  6.  var conversation Conversation
    7. 
  
  
  
  7.  var otherParticipant User
    8. 
  
  
  
  8.  if err := db.QueryRowContext(ctx, `
    9. 
  
  
  
  9.  SELECT
    10. 
  
  
  
  10.  IFNULL(auth_user.messages_read_at < messages.created_at, false) AS has_unread_messages,
    11. 
  
  
  
  11.  other_users.id,
    12. 
  
  
  
  12.  other_users.username,
    13. 
  
  
  
  13.  other_users.avatar_url
    14. 
  
  
  
  14.  FROM conversations
    15. 
  
  
  
  15.  LEFT JOIN messages ON conversations.last_message_id = messages.id
    16. 
  
  
  
  16.  INNER JOIN participants other_participants
    17. 
  
  
  
  17.  ON other_participants.conversation_id = conversations.id
    18. 
  
  
  
  18.  AND other_participants.user_id != $1
    19. 
  
  
  
  19.  INNER JOIN users other_users ON other_participants.user_id = other_users.id
    20. 
  
  
  
  20.  INNER JOIN participants auth_user
    21. 
  
  
  
  21.  ON auth_user.conversation_id = conversations.id
    22. 
  
  
  
  22.  AND auth_user.user_id = $1
    23. 
  
  
  
  23.  WHERE conversations.id = $2
    24. 
  
  
  
  24.  `, authUserID, conversationID).Scan(
    25. 
  
  
  
  25.  &conversation.HasUnreadMessages,
    26. 
  
  
  
  26.  &otherParticipant.ID,
    27. 
  
  
  
  27.  &otherParticipant.Username,
    28. 
  
  
  
  28.  &otherParticipant.AvatarURL,
    29. 
  
  
  
  29.  ); err == sql.ErrNoRows {
    30. 
  
  
  
  30.  http.Error(w, "Conversation not found", http.StatusNotFound)
    31. 
  
  
  
  31.  return
    32. 
  
  
  
  32.  } else if err != nil {
    33. 
  
  
  
  33.  respondError(w, fmt.Errorf("could not query conversation: %v", err))
    34. 
  
  
  
  34.  return
    35. 
  
  
  
  35.  }
    36. 
  
  
  
  36. 
  
  
  
  37.  conversation.ID = conversationID
    38. 
  
  
  
  38.  conversation.OtherParticipant = &otherParticipant
    39. 
  
  
  
  39. 
  
  
  
  40.  respond(w, conversation, http.StatusOK)
    41. 
  
  
  
  41. }
    42.

这里的查询与之前有点类似。尽管我们并不关心最后一条消息的显示问题，并因此忽略了与之相关的一些字段，但是我们需要根据这条消息来判断对话中是否存在未读消息。此时，我们使用 LEFT JOIN 来代替 INNER JOIN，因为 last_message_id 字段是 NULLABLE（可以为空）的；而其他情况下，我们无法得到任何记录。基于同样的理由，我们在 has_unread_messages 的比较中使用了 IFNULL 语句。最后，我们按 ID 进行过滤。

如果查询没有返回任何记录，我们的响应会返回 404 Not Found 错误，否则响应将会返回 200 OK 以及找到的对话。

本篇帖子以创建了一些对话端点结束。

在下一篇帖子中，我们将会看到如何创建并列出消息。

  • 源代码

分享题目：构建一个即时消息应用（三）：对话
文章起源：http://www.hantingmc.com/qtweb/news24/130374.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站建设知识

各行业网站

德阳东方电机技改　　 　成都小程序定制开发公司　　 　成都做网站　　 　APP定制开发　　 　广汉做网站　　 　大英泰恒网站　　 　宣传册设计　　 　德阳做网站　　 　响应式网站设计方案　　 　眉山网站建设　　 　专业网站建设　　 　德阳电信服务器托管　　 　成都app软件开发　　 　成都SEO公司　　 　成都添翼二手车　　 　成都名片印刷　　 　葆金莱自动门　　 　全网品牌营销　　 　四川國際商會　　 　犀浦门窗定制