GolangNote

Golang笔记

一个应用级别的变量(全局变量)使用示例

Permalink

一个应用级别的变量使用示例

Go: 定义main
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
type appContext struct {
  db *sql.DB
}

func (c *appContext) authHandler(next http.Handler) http.Handler {
  fn := func(w http.ResponseWriter, r *http.Request) {
    authToken := r.Header.Get("Authorization")
    user, err := getUser(c.db, authToken)

    if err != nil {
      http.Error(w, http.StatusText(401), 401)
      return
    }

    context.Set(r, "user", user)
    next.ServeHTTP(w, r)
  }

  return http.HandlerFunc(fn)
}

func (c *appContext) adminHandler(w http.ResponseWriter, r *http.Request) {
  user := context.Get(r, "user")
  // Maybe other operations on the database
  json.NewEncoder(w).Encode(user)
}

func main() {
  db := sql.Open("postgres", "...")
  appC := appContext{db}
  commonHandlers := alice.New(context.ClearHandler, loggingHandler, recoverHandler)
  http.Handle("/admin", commonHandlers.Append(appC.authHandler).ThenFunc(appC.adminHandler))
  http.Handle("/about", commonHandlers.ThenFunc(aboutHandler))
  http.Handle("/", commonHandlers.ThenFunc(indexHandler))
  http.ListenAndServe(":8080", nil)
}

参考文章

Go: 完整代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
package main

import (
    "encoding/json"
    "fmt"
    "net"
    "net/http"
    "time"

    "golang.org/x/net/context"
)

type ContextHandler interface {
    ServeHTTPContext(context.Context, http.ResponseWriter, *http.Request) error
}

type ContextHandlerFunc func(context.Context, http.ResponseWriter, *http.Request) error

func (f ContextHandlerFunc) ServeHTTPContext(ctx context.Context, w http.ResponseWriter, req *http.Request) error {
    return f(ctx, w, req)
}

type ContextAdapter struct {
    ctx     context.Context
    handler ContextHandler // to wrap func(context.Context, ResponseWriter, *Request) error
}

func (ca *ContextAdapter) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    if err := ca.handler.ServeHTTPContext(ca.ctx, w, req); err != nil {
        w.WriteHeader(http.StatusBadRequest)
        json.NewEncoder(w).Encode(map[string]string{
            "status":  "error",
            "message": err.Error(),
        })
    }
}

func NewRootContext(ts string) context.Context {
    return context.WithValue(context.Background(), appStartTSKey, ts)
}

func main() {
    rootContext := context.Background()
    mainRouter := http.NewServeMux()
    mainRouter.Handle("/", &ContextAdapter{
        ctx:     rootContext,
        handler: ContextHandlerFunc(handlerRoot),
    })
    mainRouter.Handle("/set", &ContextAdapter{
        ctx:     rootContext,
        handler: ContextHandlerFunc(handlerSet),
    })

    port := ":8080"
    fmt.Println("Serving http://localhost" + port)
    if err := http.ListenAndServe(port, mainRouter); err != nil {
        panic(err)
    }
}

func handlerRoot(ctx context.Context, w http.ResponseWriter, req *http.Request) error {
    switch req.Method {
    case "GET":
        fmt.Println("handlerRoot")
        ts, _ := getAppStartTSFromContext(ctx)
        ip, _ := getIPFromContext(ctx)
        ua, _ := getUserAgentFromContext(ctx)
        fmt.Fprintf(w, "Root = AppStartTS: %s / IP: %v / UserAgent: %s", ts, ip, ua)
        return nil

    default:
        http.Error(w, "Method Not Allowed", 405)
        return fmt.Errorf("Method Not Allowed:", req.Method)
    }
}

func handlerSet(ctx context.Context, w http.ResponseWriter, req *http.Request) error {
    switch req.Method {
    case "GET":
        fmt.Println("handlerSet")
        ts := time.Now().String()
        ip, err := getIP(req)
        if err != nil {
            return err
        }
        ua := req.UserAgent()
        ctx = setContextWithAppStartTS(ctx, ts)
        ctx = setContextWithIP(ctx, ip)
        ctx = setContextWithUserAgent(ctx, ua)
        fmt.Fprintf(w, "Set = AppStartTS: %s / IP: %v / UserAgent: %s", ts, ip, ua)
        return nil

    default:
        http.Error(w, "Method Not Allowed", 405)
        return fmt.Errorf("Method Not Allowed:", req.Method)
    }
}

type key int

const appStartTSKey key = 0

const userIPKey key = 1

const userAgentKey key = 2

func setContextWithAppStartTS(ctx context.Context, ts string) context.Context {
    return context.WithValue(ctx, appStartTSKey, ts)
}

func setContextWithIP(ctx context.Context, userIP net.IP) context.Context {
    return context.WithValue(ctx, userIPKey, userIP)
}

func setContextWithUserAgent(ctx context.Context, userAgent string) context.Context {
    return context.WithValue(ctx, userAgentKey, userAgent)
}

func getAppStartTSFromContext(ctx context.Context) (string, bool) {
    // ctx.Value returns nil if ctx has no value for the key;
    // the string type assertion returns ok=false for nil.
    ts, ok := ctx.Value(appStartTSKey).(string)
    return ts, ok
}

func getIPFromContext(ctx context.Context) (net.IP, bool) {
    userIP, ok := ctx.Value(userIPKey).(net.IP)
    return userIP, ok
}

func getUserAgentFromContext(ctx context.Context) (string, bool) {
    userAgent, ok := ctx.Value(userAgentKey).(string)
    return userAgent, ok
}

// getIP extracts the user IP address from req, if present.
// https://blog.golang.org/context/userip/userip.go
func getIP(req *http.Request) (net.IP, error) {
    ip, _, err := net.SplitHostPort(req.RemoteAddr)
    if err != nil {
        return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
    }
    userIP := net.ParseIP(ip)
    if userIP == nil {
        return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
    }
    return userIP, nil
}

本文网址: https://golangnote.com/topic/123.html 转摘请注明来源

Related articles

Golang Web 程序生产环境独立部署示例

一个 web 应用通常是跑在一个前端代理,如 Nginx 后,这样可以方便的在同一个服务器部署多个应用。这里说的独立部署是指让 go web 程序直接暴露在外面,独占 443、80 端口(俗称裸跑)。这样做除了性能有些提高外,更重要的是部署方便。...

Write a Comment to "一个应用级别的变量(全局变量)使用示例"

Submit Comment Login
Based on Golang + fastHTTP + sdb | go1.22.3 Processed in 12ms