使用 Go 构建 Web 服务技术栈

router := mux.NewRouter()
router.HandleFunc("/", func(resp http.ResponseWriter, req *http.Request) {
    resp.Write([]byte("ok"))
})

httpServer := &http.Server{
    Addr:    ":8080",
    Handler: router,
}

go func() {
    if err := s.HTTPServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        log.Fatalf("server error, %s\n", err)
    }
}()

router := gin.New()

router.GET("/", func(c *gin.Context) {
    c.String(http.StatusOK, "ok")
})

srv := &http.Server{
    Addr:    ":8080",
    Handler: router,
}

go func() {
    if err := server.HttpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        log.Fatalf("server failure : %s\n", err)
    }
}()

func AuthRequired() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.Request.Header.Get("X-Login-Token")
        if token != "xxx" {
            c.String(http.StatusUnauthorized, "login required")
            c.Abort() // must abort to next handler
            return
        }

        c.Set("username", "xxx")

        c.Next()
    }
}

apiv1 := r.Group("/api/v1")
apiv1.Use(AuthRequired())

package options

type ServerConfig struct {
    Host string `yaml:"host"`
    Port string `yaml:"port"`
}

func flagParse() string {
    configFile := ""
    flag.StringVar(&configFile, "config-file", "/etc/xxx-server/config.yaml", "server configure file")
    flag.Parse()

    logrus.Tracef("config file = %s", configFile)
    return configFile
}

func parseConfigFile(configFile string) (*ServerConfig, error) {
    file, err := ioutil.ReadFile(configFile)
    if err != nil {
        return nil, err
    }

    cfg := &ServerConfig{}
    err = yaml.Unmarshal(file, cfg)
    if err != nil {
        return nil, err
    }

    logrus.Tracef("parse config success, cfg=%#v", cfg)
    return cfg, nil
}

var cfg *ServerConfig

func InitServerConfig() error {
    configFile := flagParse()
    cfg_, err := parseConfigFile(configFile)
    if err != nil {
        return err
    }

    cfg = cfg_
    return nil
}

func GetCfg() *ServerConfig {
    return cfg
}

quit := make(chan os.Signal)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
logrus.Infof("recv shutdown server signal...")

func (server *APIServer) StopServer() {
    defer func() {
        // 清理其它资源
    }()

    waiting := 5 * time.Second
    ctx, cancel := context.WithTimeout(context.Background(), waiting)
    defer cancel()

    if err := server.HttpServer.Shutdown(ctx); err != nil {
        logrus.Fatalf("server shutdown failure, error=%s", err)
    }

    select {
    case <-ctx.Done():
        logrus.Infof("waiting finish, %v", waiting)
    }

    logrus.Infof("server exiting")
}

var (
    APICalledLatency = prometheus.NewSummaryVec(
        prometheus.SummaryOpts{
            Name: "metaserver_api_called_latency",
            Help: "Latency in microseconds",
        },
        []string{"api", "method", "status_code"},
    )
)

func init() {
    prometheus.MustRegister(APICalledLatency)
}

func SinceInMicroseconds(start time.Time) float64 {
    return float64(time.Since(start).Nanoseconds() / time.Microsecond.Nanoseconds())
}

func metricsExport() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        defer func() {
            cost := SinceInMicroseconds(start)
            api := c.Request.URL.Path
            method := c.Request.Method
            status := strconv.Itoa(c.Writer.Status())

            // set ignore itself in here
            if api == "/metrics" {
                return
            }

            APICalledLatency.WithLabelValues(api, method, status).Observe(cost)
            logrus.Tracef("api run time, api=%s, method=%s, status=%s, time=%f(ms)", api, method, status, cost/1000)
        }()

        c.Next()
    }
}

r.GET("/metrics", gin.WrapH(promhttp.Handler()))

func init() {
    logrus.SetFormatter(&logrus.TextFormatter{
        ForceColors:     false,
        DisableColors:   true,
        FullTimestamp:   true,
        TimestampFormat: "2006-01-02 15:04:05.000",
        CallerPrettyfier: func(frame *runtime.Frame) (function string, file string) {
            ss := strings.Split(frame.Function, ".")
            function = ss[len(ss)-1]
            file = fmt.Sprintf("%s:%d", filepath.Base(frame.File), frame.Line)
            return function, file
        },
    })
    logrus.SetOutput(os.Stdout)

    debug := os.Getenv("DEBUG") // 没有明确关闭，则默认打开
    if debug == "" || debug == "true" || debug == "1" {
        logrus.SetReportCaller(true)
        logrus.SetLevel(logrus.TraceLevel)
    } else {
        logrus.SetReportCaller(false)
        logrus.SetLevel(logrus.InfoLevel)
    }
}

ds := goqu.Insert("user").
    Cols("first_name", "last_name").
    Vals(
        goqu.Vals{"Greg", "Farley"},
        goqu.Vals{"Jimmy", "Stewart"},
        goqu.Vals{"Jeff", "Jeffers"},
    )
insertSQL, args, _ := ds.ToSQL()
fmt.Println(insertSQL, args)

INSERT INTO "user" ("first_name", "last_name") VALUES ('Greg', 'Farley'), ('Jimmy', 'Stewart'), ('Jeff', 'Jeffers') []

sql, args, err := sq.
    Insert("users").Columns("name", "age").
    Values("moe", 13).Values("larry", sq.Expr("? + 5", 12)).
    ToSql()

sql == "INSERT INTO users (name,age) VALUES (?,?),(?,? + 5)"

stooges := users.Where(sq.Eq{"username": []string{"moe", "larry", "curly", "shemp"}})
three_stooges := stooges.Limit(3)
rows, err := three_stooges.RunWith(db).Query()

rows, err := db.Query("SELECT * FROM users WHERE username IN (?,?,?,?) LIMIT 3",
    "moe", "larry", "curly", "shemp")