构建一个即时消息应用（二）：OAuth

上一篇：模式。

创新互联建站主营平泉网站建设的网络公司,主营网站建设方案,App定制开发,平泉h5重庆小程序开发搭建,平泉网站营销推广欢迎平泉等地区企业咨询

在这篇帖子中，我们将会通过为应用添加社交登录功能进入后端开发。

社交登录的工作方式十分简单：用户点击链接，然后重定向到 GitHub 授权页面。当用户授予我们对他的个人信息的访问权限之后，就会重定向回登录页面。下一次尝试登录时，系统将不会再次请求授权，也就是说，我们的应用已经记住了这个用户。这使得整个登录流程看起来就和你用鼠标单击一样快。

如果进一步考虑其内部实现的话，过程就会变得复杂起来。首先，我们需要注册一个新的 GitHub OAuth 应用。

这一步中，比较重要的是回调 URL。我们将它设置为 http://localhost:3000/api/oauth/github/callback。这是因为，在开发过程中，我们总是在本地主机上工作。一旦你要将应用交付生产，请使用正确的回调 URL 注册一个新的应用。

注册以后，你将会收到“客户端 id”和“安全密钥”。安全起见，请不要与任何人分享他们

顺便让我们开始写一些代码吧。现在，创建一个 main.go 文件：

 
 
 
    
  
  
  
  1. package main
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. import (
    4. 
  
  
  
  4.  "database/sql"
    5. 
  
  
  
  5.  "fmt"
    6. 
  
  
  
  6.  "log"
    7. 
  
  
  
  7.  "net/http"
    8. 
  
  
  
  8.  "net/url"
    9. 
  
  
  
  9.  "os"
    10. 
  
  
  
  10.  "strconv"
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12.  "github.com/gorilla/securecookie"
    13. 
  
  
  
  13.  "github.com/joho/godotenv"
    14. 
  
  
  
  14.  "github.com/knq/jwt"
    15. 
  
  
  
  15.  _ "github.com/lib/pq"
    16. 
  
  
  
  16.  "github.com/matryer/way"
    17. 
  
  
  
  17.  "golang.org/x/oauth2"
    18. 
  
  
  
  18.  "golang.org/x/oauth2/github"
    19. 
  
  
  
  19. )
    20. 
  
  
  
  20.  
    21. 
  
  
  
  21. var origin *url.URL
    22. 
  
  
  
  22. var db *sql.DB
    23. 
  
  
  
  23. var githubOAuthConfig *oauth2.Config
    24. 
  
  
  
  24. var cookieSigner *securecookie.SecureCookie
    25. 
  
  
  
  25. var jwtSigner jwt.Signer
    26. 
  
  
  
  26.  
    27. 
  
  
  
  27. func main() {
    28. 
  
  
  
  28.  godotenv.Load()
    29. 
  
  
  
  29.  
    30. 
  
  
  
  30.  port := intEnv("PORT", 3000)
    31. 
  
  
  
  31.  originString := env("ORIGIN", fmt.Sprintf("http://localhost:%d/", port))
    32. 
  
  
  
  32.  databaseURL := env("DATABASE_URL", "postgresql://root@127.0.0.1:26257/messenger?sslmode=disable")
    33. 
  
  
  
  33.  githubClientID := os.Getenv("GITHUB_CLIENT_ID")
    34. 
  
  
  
  34.  githubClientSecret := os.Getenv("GITHUB_CLIENT_SECRET")
    35. 
  
  
  
  35.  hashKey := env("HASH_KEY", "secret")
    36. 
  
  
  
  36.  jwtKey := env("JWT_KEY", "secret")
    37. 
  
  
  
  37.  
    38. 
  
  
  
  38.  var err error
    39. 
  
  
  
  39.  if origin, err = url.Parse(originString); err != nil || !origin.IsAbs() {
    40. 
  
  
  
  40.  log.Fatal("invalid origin")
    41. 
  
  
  
  41.  return
    42. 
  
  
  
  42.  }
    43. 
  
  
  
  43.  
    44. 
  
  
  
  44.  if i, err := strconv.Atoi(origin.Port()); err == nil {
    45. 
  
  
  
  45.  port = i
    46. 
  
  
  
  46.  }
    47. 
  
  
  
  47.  
    48. 
  
  
  
  48.  if githubClientID == "" || githubClientSecret == "" {
    49. 
  
  
  
  49.  log.Fatalf("remember to set both $GITHUB_CLIENT_ID and $GITHUB_CLIENT_SECRET")
    50. 
  
  
  
  50.  return
    51. 
  
  
  
  51.  }
    52. 
  
  
  
  52.  
    53. 
  
  
  
  53.  if db, err = sql.Open("postgres", databaseURL); err != nil {
    54. 
  
  
  
  54.  log.Fatalf("could not open database connection: %v\n", err)
    55. 
  
  
  
  55.  return
    56. 
  
  
  
  56.  }
    57. 
  
  
  
  57.  defer db.Close()
    58. 
  
  
  
  58.  if err = db.Ping(); err != nil {
    59. 
  
  
  
  59.  log.Fatalf("could not ping to db: %v\n", err)
    60. 
  
  
  
  60.  return
    61. 
  
  
  
  61.  }
    62. 
  
  
  
  62.  
    63. 
  
  
  
  63.  githubRedirectURL := *origin
    64. 
  
  
  
  64.  githubRedirectURL.Path = "/api/oauth/github/callback"
    65. 
  
  
  
  65.  githubOAuthConfig = &oauth2.Config{
    66. 
  
  
  
  66.  ClientID: githubClientID,
    67. 
  
  
  
  67.  ClientSecret: githubClientSecret,
    68. 
  
  
  
  68.  Endpoint: github.Endpoint,
    69. 
  
  
  
  69.  RedirectURL: githubRedirectURL.String(),
    70. 
  
  
  
  70.  Scopes: []string{"read:user"},
    71. 
  
  
  
  71.  }
    72. 
  
  
  
  72.  
    73. 
  
  
  
  73.  cookieSigner = securecookie.New([]byte(hashKey), nil).MaxAge(0)
    74. 
  
  
  
  74.  
    75. 
  
  
  
  75.  jwtSigner, err = jwt.HS256.New([]byte(jwtKey))
    76. 
  
  
  
  76.  if err != nil {
    77. 
  
  
  
  77.  log.Fatalf("could not create JWT signer: %v\n", err)
    78. 
  
  
  
  78.  return
    79. 
  
  
  
  79.  }
    80. 
  
  
  
  80.  
    81. 
  
  
  
  81.  router := way.NewRouter()
    82. 
  
  
  
  82.  router.HandleFunc("GET", "/api/oauth/github", githubOAuthStart)
    83. 
  
  
  
  83.  router.HandleFunc("GET", "/api/oauth/github/callback", githubOAuthCallback)
    84. 
  
  
  
  84.  router.HandleFunc("GET", "/api/auth_user", guard(getAuthUser))
    85. 
  
  
  
  85.  
    86. 
  
  
  
  86.  log.Printf("accepting connections on port %d\n", port)
    87. 
  
  
  
  87.  log.Printf("starting server at %s\n", origin.String())
    88. 
  
  
  
  88.  addr := fmt.Sprintf(":%d", port)
    89. 
  
  
  
  89.  if err = http.ListenAndServe(addr, router); err != nil {
    90. 
  
  
  
  90.  log.Fatalf("could not start server: %v\n", err)
    91. 
  
  
  
  91.  }
    92. 
  
  
  
  92. }
    93. 
  
  
  
  93.  
    94. 
  
  
  
  94. func env(key, fallbackValue string) string {
    95. 
  
  
  
  95.  v, ok := os.LookupEnv(key)
    96. 
  
  
  
  96.  if !ok {
    97. 
  
  
  
  97.  return fallbackValue
    98. 
  
  
  
  98.  }
    99. 
  
  
  
  99.  return v
    100. 
  
  
  
  100. }
    101. 
  
  
  
  101.  
    102. 
  
  
  
  102. func intEnv(key string, fallbackValue int) int {
    103. 
  
  
  
  103.  v, ok := os.LookupEnv(key)
    104. 
  
  
  
  104.  if !ok {
    105. 
  
  
  
  105.  return fallbackValue
    106. 
  
  
  
  106.  }
    107. 
  
  
  
  107.  i, err := strconv.Atoi(v)
    108. 
  
  
  
  108.  if err != nil {
    109. 
  
  
  
  109.  return fallbackValue
    110. 
  
  
  
  110.  }
    111. 
  
  
  
  111.  return i
    112. 
  
  
  
  112. }
    113.

安装依赖项：

 
 
 
    
  
  
  
  1. go get -u github.com/gorilla/securecookie
    2. 
  
  
  
  2. go get -u github.com/joho/godotenv
    3. 
  
  
  
  3. go get -u github.com/knq/jwt
    4. 
  
  
  
  4. go get -u github.com/lib/pq
    5. 
  
  
  
  5. ge get -u github.com/matoous/go-nanoid
    6. 
  
  
  
  6. go get -u github.com/matryer/way
    7. 
  
  
  
  7. go get -u golang.org/x/oauth2
    8.

我们将会使用 .env 文件来保存密钥和其他配置。请创建这个文件，并保证里面至少包含以下内容：

 
 
 
    
  
  
  
  1. GITHUB_CLIENT_ID=your_github_client_id
    2. 
  
  
  
  2. GITHUB_CLIENT_SECRET=your_github_client_secret
    3.

我们还要用到的其他环境变量有：

  • PORT：服务器运行的端口，默认值是 3000。
  • ORIGIN：你的域名，默认值是 http://localhost:3000/。我们也可以在这里指定端口。
  • DATABASE_URL：Cockroach 数据库的地址。默认值是 postgresql://root@127.0.0.1:26257/messenger?sslmode=disable。
  • HASH_KEY：用于为 cookie 签名的密钥。没错，我们会使用已签名的 cookie 来确保安全。
  • JWT_KEY：用于签署 JSON 网络令牌Web Token的密钥。

因为代码中已经设定了默认值，所以你也不用把它们写到 .env 文件中。

在读取配置并连接到数据库之后，我们会创建一个 OAuth 配置。我们会使用 ORIGIN 信息来构建回调 URL（就和我们在 GitHub 页面上注册的一样）。我们的数据范围设置为 “read:user”。这会允许我们读取公开的用户信息，这里我们只需要他的用户名和头像就够了。然后我们会初始化 cookie 和 JWT 签名器。定义一些端点并启动服务器。

在实现 HTTP 处理程序之前，让我们编写一些函数来发送 HTTP 响应。

 
 
 
    
  
  
  
  1. func respond(w http.ResponseWriter, v interface{}, statusCode int) {
    2. 
  
  
  
  2.  b, err := json.Marshal(v)
    3. 
  
  
  
  3.  if err != nil {
    4. 
  
  
  
  4.  respondError(w, fmt.Errorf("could not marshal response: %v", err))
    5. 
  
  
  
  5.  return
    6. 
  
  
  
  6.  }
    7. 
  
  
  
  7.  w.Header().Set("Content-Type", "application/json; charset=utf-8")
    8. 
  
  
  
  8.  w.WriteHeader(statusCode)
    9. 
  
  
  
  9.  w.Write(b)
    10. 
  
  
  
  10. }
    11. 
  
  
  
  11.  
    12. 
  
  
  
  12. func respondError(w http.ResponseWriter, err error) {
    13. 
  
  
  
  13.  log.Println(err)
    14. 
  
  
  
  14.  http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
    15. 
  
  
  
  15. }
    16.

第一个函数用来发送 JSON，而第二个将错误记录到控制台并返回一个 500 Internal Server Error 错误信息。

OAuth 开始

所以，用户点击写着 “Access with GitHub” 的链接。该链接指向 /api/oauth/github，这将会把用户重定向到 github。

 
 
 
    
  
  
  
  1. func githubOAuthStart(w http.ResponseWriter, r *http.Request) {
    2. 
  
  
  
  2.  state, err := gonanoid.Nanoid()
    3. 
  
  
  
  3.  if err != nil {
    4. 
  
  
  
  4.  respondError(w, fmt.Errorf("could not generte state: %v", err))
    5. 
  
  
  
  5.  return
    6. 
  
  
  
  6.  }
    7. 
  
  
  
  7.  
    8. 
  
  
  
  8.  stateCookieValue, err := cookieSigner.Encode("state", state)
    9. 
  
  
  
  9.  if err != nil {
    10. 
  
  
  
  10.  respondError(w, fmt.Errorf("could not encode state cookie: %v", err))
    11. 
  
  
  
  11.  return
    12. 
  
  
  
  12.  }
    13. 
  
  
  
  13.  
    14. 
  
  
  
  14.  http.SetCookie(w, &http.Cookie{
    15. 
  
  
  
  15.  Name: "state",
    16. 
  
  
  
  16.  Value: stateCookieValue,
    17. 
  
  
  
  17.  Path: "/api/oauth/github",
    18. 
  
  
  
  18.  HttpOnly: true,
    19. 
  
  
  
  19.  })
    20. 
  
  
  
  20.  http.Redirect(w, r, githubOAuthConfig.AuthCodeURL(state), http.StatusTemporaryRedirect)
    21. 
  
  
  
  21. }
    22.

OAuth2 使用一种机制来防止 CSRF ，因此它需要一个“状态”（state）。我们使用 Nanoid() 来创建一个随机字符串，并用这个字符串作为状态。我们也把它保存为一个 cookie。

OAuth 回调

一旦用户授权我们访问他的个人信息，他将会被重定向到这个端点。这个 URL 的查询字符串上将会包含状态（state）和授权码（code）： /api/oauth/github/callback?state=&code=。

 
 
 
    
  
  
  
  1. const jwtLifetime = time.Hour * 24 * 14
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. type GithubUser struct {
    4. 
  
  
  
  4.  ID int `json:"id"`
    5. 
  
  
  
  5.  Login string `json:"login"`
    6. 
  
  
  
  6.  AvatarURL *string `json:"avatar_url,omitempty"`
    7. 
  
  
  
  7. }
    8. 
  
  
  
  8.  
    9. 
  
  
  
  9. type User struct {
    10. 
  
  
  
  10.  ID string `json:"id"`
    11. 
  
  
  
  11.  Username string `json:"username"`
    12. 
  
  
  
  12.  AvatarURL *string `json:"avatarUrl"`
    13. 
  
  
  
  13. }
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15. func githubOAuthCallback(w http.ResponseWriter, r *http.Request) {
    16. 
  
  
  
  16.  stateCookie, err := r.Cookie("state")
    17. 
  
  
  
  17.  if err != nil {
    18. 
  
  
  
  18.  http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
    19. 
  
  
  
  19.  return
    20. 
  
  
  
  20.  }
    21. 
  
  
  
  21.  
    22. 
  
  
  
  22.  http.SetCookie(w, &http.Cookie{
    23. 
  
  
  
  23.  Name: "state",
    24. 
  
  
  
  24.  Value: "",
    25. 
  
  
  
  25.  MaxAge: -1,
    26. 
  
  
  
  26.  HttpOnly: true,
    27. 
  
  
  
  27.  })
    28. 
  
  
  
  28.  
    29. 
  
  
  
  29.  var state string
    30. 
  
  
  
  30.  if err = cookieSigner.Decode("state", stateCookie.Value, &state); err != nil {
    31. 
  
  
  
  31.  http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
    32. 
  
  
  
  32.  return
    33. 
  
  
  
  33.  }
    34. 
  
  
  
  34.  
    35. 
  
  
  
  35.  q := r.URL.Query()
    36. 
  
  
  
  36.  
    37. 
  
  
  
  37.  if state != q.Get("state") {
    38. 
  
  
  
  38.  http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
    39. 
  
  
  
  39.  return
    40. 
  
  
  
  40.  }
    41. 
  
  
  
  41.  
    42. 
  
  
  
  42.  ctx := r.Context()
    43. 
  
  
  
  43.  
    44. 
  
  
  
  44.  t, err := githubOAuthConfig.Exchange(ctx, q.Get("code"))
    45. 
  
  
  
  45.  if err != nil {
    46. 
  
  
  
  46.  respondError(w, fmt.Errorf("could not fetch github token: %v", err))
    47. 
  
  
  
  47.  return
    48. 
  
  
  
  48.  }
    49. 
  
  
  
  49.  
    50. 
  
  
  
  50.  client := githubOAuthConfig.Client(ctx, t)
    51. 
  
  
  
  51.  resp, err := client.Get("https://api.github.com/user")
    52. 
  
  
  
  52.  if err != nil {
    53. 
  
  
  
  53.  respondError(w, fmt.Errorf("could not fetch github user: %v", err))
    54. 
  
  
  
  54.  return
    55. 
  
  
  
  55.  }
    56. 
  
  
  
  56.  
    57. 
  
  
  
  57.  var githubUser GithubUser
    58. 
  
  
  
  58.  if err = json.NewDecoder(resp.Body).Decode(&githubUser); err != nil {
    59. 
  
  
  
  59.  respondError(w, fmt.Errorf("could not decode github user: %v", err))
    60. 
  
  
  
  60.  return
    61. 
  
  
  
  61.  }
    62. 
  
  
  
  62.  defer resp.Body.Close()
    63. 
  
  
  
  63.  
    64. 
  
  
  
  64.  tx, err := db.BeginTx(ctx, nil)
    65. 
  
  
  
  65.  if err != nil {
    66. 
  
  
  
  66.  respondError(w, fmt.Errorf("could not begin tx: %v", err))
    67. 
  
  
  
  67.  return
    68. 
  
  
  
  68.  }
    69. 
  
  
  
  69.  
    70. 
  
  
  
  70.  var user User
    71. 
  
  
  
  71.  if err = tx.QueryRowContext(ctx, `
    72. 
  
  
  
  72.  SELECT id, username, avatar_url FROM users WHERE github_id = $1
    73. 
  
  
  
  73.  `, githubUser.ID).Scan(&user.ID, &user.Username, &user.AvatarURL); err == sql.ErrNoRows {
    74. 
  
  
  
  74.  if err = tx.QueryRowContext(ctx, `
    75. 
  
  
  
  75.  INSERT INTO users (username, avatar_url, github_id) VALUES ($1, $2, $3)
    76. 
  
  
  
  76.  RETURNING id
    77. 
  
  
  
  77.  `, githubUser.Login, githubUser.AvatarURL, githubUser.ID).Scan(&user.ID); err != nil {
    78. 
  
  
  
  78.  respondError(w, fmt.Errorf("could not insert user: %v", err))
    79. 
  
  
  
  79.  return
    80. 
  
  
  
  80.  }
    81. 
  
  
  
  81.  user.Username = githubUser.Login
    82. 
  
  
  
  82.  user.AvatarURL = githubUser.AvatarURL
    83. 
  
  
  
  83.  } else if err != nil {
    84. 
  
  
  
  84.  respondError(w, fmt.Errorf("could not query user by github ID: %v", err))
    85. 
  
  
  
  85.  return
    86. 
  
  
  
  86.  }
    87. 
  
  
  
  87.  
    88. 
  
  
  
  88.  if err = tx.Commit(); err != nil {
    89. 
  
  
  
  89.  respondError(w, fmt.Errorf("could not commit to finish github oauth: %v", err))
    90. 
  
  
  
  90.  return
    91. 
  
  
  
  91.  }
    92. 
  
  
  
  92.  
    93. 
  
  
  
  93.  exp := time.Now().Add(jwtLifetime)
    94. 
  
  
  
  94.  token, err := jwtSigner.Encode(jwt.Claims{
    95. 
  
  
  
  95.  Subject: user.ID,
    96. 
  
  
  
  96.  Expiration: json.Number(strconv.FormatInt(exp.Unix(), 10)),
    97. 
  
  
  
  97.  })
    98. 
  
  
  
  98.  if err != nil {
    99. 
  
  
  
  99.  respondError(w, fmt.Errorf("could not create token: %v", err))
    100. 
  
  
  
  100.  return
    101. 
  
  
  
  101.  }
    102. 
  
  
  
  102.  
    103. 
  
  
  
  103.  expiresAt, _ := exp.MarshalText()
    104. 
  
  
  
  104.  
    105. 
  
  
  
  105.  data := make(url.Values)
    106. 
  
  
  
  106.  data.Set("token", string(token))
    107. 
  
  
  
  107.  data.Set("expires_at", string(expiresAt))
    108. 
  
  
  
  108.  
    109. 
  
  
  
  109.  http.Redirect(w, r, "/callback?"+data.Encode(), http.StatusTemporaryRedirect)
    110. 
  
  
  
  110. }
    111.

首先，我们会尝试使用之前保存的状态对 cookie 进行解码。并将其与查询字符串中的状态进行比较。如果它们不匹配，我们会返回一个 418 I'm teapot（未知来源）错误。

接着，我们使用授权码生成一个令牌。这个令牌被用于创建 HTTP 客户端来向 GitHub API 发出请求。所以最终我们会向 https://api.github.com/user 发送一个 GET 请求。这个端点将会以 JSON 格式向我们提供当前经过身份验证的用户信息。我们将会解码这些内容，一并获取用户的 ID、登录名（用户名）和头像 URL。

然后我们将会尝试在数据库上找到具有该 GitHub ID 的用户。如果没有找到，就使用该数据创建一个新的。

之后，对于新创建的用户，我们会发出一个将用户 ID 作为主题（Subject）的 JSON 网络令牌，并使用该令牌重定向到前端，查询字符串中一并包含该令牌的到期日（Expiration）。

这一 Web 应用也会被用在其他帖子，但是重定向的链接会是 /callback?token=&expires_at=。在那里，我们将会利用 JavaScript 从 URL 中获取令牌和到期日，并通过 Authorization 标头中的令牌以 Bearer token_here 的形式对 /api/auth_user 进行 GET 请求，来获取已认证的身份用户并将其保存到 localStorage。

Guard 中间件

为了获取当前已经过身份验证的用户，我们设计了 Guard 中间件。这是因为在接下来的文章中，我们会有很多需要进行身份认证的端点，而中间件将会允许我们共享这一功能。

 
 
 
    
  
  
  
  1. type ContextKey struct {
    2. 
  
  
  
  2.  Name string
    3. 
  
  
  
  3. }
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5. var keyAuthUserID = ContextKey{"auth_user_id"}
    6. 
  
  
  
  6.  
    7. 
  
  
  
  7. func guard(handler http.HandlerFunc) http.HandlerFunc {
    8. 
  
  
  
  8.  return func(w http.ResponseWriter, r *http.Request) {
    9. 
  
  
  
  9.  var token string
    10. 
  
  
  
  10.  if a := r.Header.Get("Authorization"); strings.HasPrefix(a, "Bearer ") {
    11. 
  
  
  
  11.  token = a[7:]
    12. 
  
  
  
  12.  } else if t := r.URL.Query().Get("token"); t != "" {
    13. 
  
  
  
  13.  token = t
    14. 
  
  
  
  14.  } else {
    15. 
  
  
  
  15.  http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
    16. 
  
  
  
  16.  return
    17. 
  
  
  
  17.  }
    18. 
  
  
  
  18.  
    19. 
  
  
  
  19.  var claims jwt.Claims
    20. 
  
  
  
  20.  if err := jwtSigner.Decode([]byte(token), &claims); err != nil {
    21. 
  
  
  
  21.  http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
    22. 
  
  
  
  22.  return
    23. 
  
  
  
  23.  }
    24. 
  
  
  
  24.  
    25. 
  
  
  
  25.  ctx := r.Context()
    26. 
  
  
  
  26.  ctx = context.WithValue(ctx, keyAuthUserID, claims.Subject)
    27. 
  
  
  
  27.  
    28. 
  
  
  
  28.  handler(w, r.WithContext(ctx))
    29. 
  
  
  
  29.  }
    30. 
  
  
  
  30. }
    31.

首先，我们尝试从 Authorization 标头或者是 URL 查询字符串中的 token 字段中读取令牌。如果没有找到，我们需要返回 401 Unauthorized（未授权）错误。然后我们将会对令牌中的申明进行解码，并使用该主题作为当前已经过身份验证的用户 ID。

现在，我们可以用这一中间件来封装任何需要授权的 http.handlerFunc，并且在处理函数的上下文中保有已经过身份验证的用户 ID。

 
 
 
    
  
  
  
  1. var guarded = guard(func(w http.ResponseWriter, r *http.Request) {
    2. 
  
  
  
  2.  authUserID := r.Context().Value(keyAuthUserID).(string)
    3. 
  
  
  
  3. })
    4.

获取认证用户

 
 
 
    
  
  
  
  1. func getAuthUser(w http.ResponseWriter, r *http.Request) {
    2. 
  
  
  
  2.  ctx := r.Context()
    3. 
  
  
  
  3.  authUserID := ctx.Value(keyAuthUserID).(string)
    4. 
  
  
  
  4.  
    5. 
  
  
  
  5.  var user User
    6. 
  
  
  
  6.  if err := db.QueryRowContext(ctx, `
    7. 
  
  
  
  7.  SELECT username, avatar_url FROM users WHERE id = $1
    8. 
  
  
  
  8.  `, authUserID).Scan(&user.Username, &user.AvatarURL); err == sql.ErrNoRows {
    9. 
  
  
  
  9.  http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
    10. 
  
  
  
  10.  return
    11. 
  
  
  
  11.  } else if err != nil {
    12. 
  
  
  
  12.  respondError(w, fmt.Errorf("could not query auth user: %v", err))
    13. 
  
  
  
  13.  return
    14. 
  
  
  
  14.  }
    15. 
  
  
  
  15.  
    16. 
  
  
  
  16.  user.ID = authUserID
    17. 
  
  
  
  17.  
    18. 
  
  
  
  18.  respond(w, user, http.StatusOK)
    19. 
  
  
  
  19. }
    20.

我们使用 Guard 中间件来获取当前经过身份认证的用户 ID 并查询数据库。

这一部分涵盖了后端的 OAuth 流程。在下一篇帖子中，我们将会看到如何开始与其他用户的对话。

  • 源代码

当前名称：构建一个即时消息应用（二）：OAuth
网页路径：http://www.shufengxianlan.com/qtweb/news10/79760.html

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

广告

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

猜你还喜欢下面的内容

面包屑导航知识

分类信息网

java虚拟主机　　 　成都网站设计　　 　云主机　　 　绵阳梓潼做网站　　 　成都微信小程序开发　　 　达州网站制作　　 　成都网站制作　　 　成都康明斯发电机　　 　四川成都网站建设　　 　高端网站策划　　 　发光字制作　　 　眉山网站建设　　 　成都棕数机房　　 　二枢服务器托管　　 　成都网站建设　　 　bgp多线机房托管　　 　Android开发　　 　网站建设方案　　 　胜锦安防科技　　 　成都移动托管