[Artículos de código] Cree su propio marco de trabajo de golang paso a paso desde cero (3)

En el último artículo, establecemos la estructura básica de directorios del proyecto. Ahora revisemos mi pensamiento:

1. Crear un archivo de entrada;
2. Especificar configuración, directorio de registro;
3. Especifique la base de datos, la cola, el directorio del componente de caché;
4. Crear un directorio controlador para el procesamiento de datos;
5. Especifique elementos diversos como funciones públicas.

A continuación, aún completamos el código en este orden.

Archivo de entrada

func main()  {
    config.InitConfig()
    logger.InitLogger()
}

Ignorando algunos detalles de implementación por el momento, primero tenemos que inicializar la configuración y los registros. Veamos primero los registros. Elegí la biblioteca de registro de zap de Uber. ¿Veamos cómo escribir el módulo de registro?

Registro

package logger

import (
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"
    "gopkg.in/natefinch/lumberjack.v2"
)

var l *zap.Logger

func InitLogger(logPath, logLevel string) error {
    hook := lumberjack.Logger{
        Filename:   logPath,
        MaxSize:    1024,
        MaxBackups: 3,
        MaxAge:     7,
        Compress:   true,
    }
    w := zapcore.AddSync(&hook)

    var level zapcore.Level
    switch logLevel {
    case "debug":
        level = zap.DebugLevel
    case "info":
        level = zap.InfoLevel
    case "error":
        level = zap.ErrorLevel
    default:
        level = zap.DebugLevel
    }

    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    core := zapcore.NewCore(
        zapcore.NewConsoleEncoder(encoderConfig),
        w,
        level,
    )

    l = zap.New(core)

    return nil
}

func GetLogger() *zap.Logger {
    return l
}

Primero definimos una variable global de nivel de paquete l de tipo * zap.Logger, y creamos dos funciones, InitLogger y GetLogger. Debido a que zap no admite el archivo de registros, se define un gancho de leñador en InitLogger para archivar registros. Podemos ver que el método InitLogger tiene dos parámetros de entrada: logPath y logLevel. En términos generales, estos parámetros deben colocarse en el archivo de configuración, luego escribiremos la configuración.

Configuracion

Simplemente creamos un archivo config.json para almacenar la configuración:
config.json:

{
  "log_config": {
    "log_path": "{your_path}",
    "log_level": "debug"
  }
}

Luego cree la estructura correspondiente en config.go, y luego defina los métodos InitConfig y GetConfig. En el método InitConfig, leo el contenido del archivo de configuración, luego lo analizo en la estructura y manejo el error, si hay un error , Envolveré el mensaje de error en una capa para facilitar la ubicación futura del error. InitConfig tiene un parámetro de entrada, que es la ruta del archivo de configuración. Obtendré este parámetro desde la línea de comandos.
config.go:

package config

import (
    "encoding/json"
    "github.com/pkg/errors"
    "io/ioutil"
)

type LogConfig struct {
    LogPath string `json:"log_path"`
    LogLevel string `json:"log_level"`
}

type Config struct {
    LogConfig LogConfig `json:"log_config"`
} 

var conf Config

func InitConfig(configPath string) error {
    configFile, err := ioutil.ReadFile(configPath)
    if err != nil {
        err = errors.Wrap(err, "Read config file failed.")
        return err
    }
    err = json.Unmarshal(configFile, &conf)
    if err != nil {
        err = errors.Wrap(err, "Unmarshal config file failed.")
        return err
    }
    return nil
}

func GetConfig() Config {
    return conf
}

Por supuesto, tenemos más que esta configuración. También tenemos bases de datos, caché y otras configuraciones no agregadas, pero no apuradas, primero descubrimos una ruta, y la configuración posterior se puede pintar de acuerdo con la calabaza.

Ajustar archivo de entrada

Ok, la inicialización del registro y la configuración está escrita aproximadamente, regresemos y veamos el ajuste del archivo de entrada:

package main

import (
    "flag"
    "fmt"
    "github.com/TomatoMr/awesomeframework/config"
    "github.com/TomatoMr/awesomeframework/logger"
    "os"
)

func main()  {
    var configPath string
    flag.StringVar(&configPath, "config", "", "配置文件路径")
    flag.Parse()

    if configPath == "" {
        fmt.Printf("Config Path must be assigned.")
        os.Exit(1)
    }

    var err error
    err = config.InitConfig(configPath)
    if err != nil {
        fmt.Printf("Init config failed. Error is %v", err)
        os.Exit(1)
    }

    logConfig := config.GetConfig().LogConfig

    err = logger.InitLogger(logConfig.LogPath, logConfig.LogLevel)
    if err != nil {
        fmt.Printf("Init logger failed. Error is %v", err)
        os.Exit(1)
    }
    
    logger.GetLogger().Info("Init success.")
}

Ajustamos el archivo de entrada, obtuvimos la ruta del archivo de configuración desde la línea de comando, luego inicializamos la configuración y los registros, y finalmente imprimimos el resultado de la inicialización.

Probarlo

Primero, compile:

$ go build 

Luego modifique el log_path de su archivo config.json y luego especifique la ruta de su archivo de configuración en la línea de comando:

$ awesomeframework --config={$your_path}/config.json

Finalmente, eche un vistazo a la operación no es normal, el archivo de registro se imprime de la siguiente manera:

2020-01-19T20:41:57.506+0800	info	Init success.

Resumen

Hasta ahora, hemos inicializado la configuración y los registros, y luego comenzaremos a inicializar la base de datos y otros componentes. El código de hoy se puede encontrar en https://github.com/TomatoMr/awesomeframework
. Continuará ...

---

Bienvenido a prestar atención a mi número público: onepunchgo.