MTP20_IF/main.go

package main

import (
	"context"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"mtp2_if/account"
	"mtp2_if/config"
	"mtp2_if/db"
	"mtp2_if/goods"
	"mtp2_if/logger"
	"mtp2_if/protocol"
	"mtp2_if/rediscli"
	"mtp2_if/token"

	"github.com/DeanThompson/ginpprof"
	"github.com/gin-gonic/gin"
	"github.com/golang/protobuf/proto"
	_ "github.com/mattn/go-oci8"
)

func main() {
	// 初始化配置
	err := config.SerCfg.Init("config/config.xml")
	if err != nil {
		println("read config file failed:", err)
		return
	}

	// 初始化日志组件
	err = logger.Init(config.SerCfg.GetLogSetting())
	if err != nil {
		println("init logger failed:", err)
		return
	}

	// 初始化数据库引擎
	err = db.InitDbEngine()
	if err != nil {
		logger.GetLogger().Errorf("init db engine failed:", err.Error())
		return
	}
	defer db.Close()

	// 初始化Redis客户端
	err = rediscli.InitRedisCli()
	if err != nil {
		logger.GetLogger().Errorf("init redis client failed:", err.Error())
		return
	}
	defer rediscli.CloseReidsClient()

	// proto测试
	TestProto()

	// 初始化token校验
	token.Init()

	if config.SerCfg.GetDebugMode() {
		gin.SetMode(gin.DebugMode)
	} else {
		gin.SetMode(gin.ReleaseMode)
	}

	r := gin.New()

	// 设置日志中间件
	r.Use(ginLoggerMiddleware())

	// 设置奔溃中间件
	r.Use(ginRecoveryMiddleware())

	// 路由分组
	gr := r.Group("/goods")
	gropt := gr.Group("/goodsopt")
	{
		gropt.POST("/QueryGoods", goods.QueryGoods)
		gropt.POST("/GetGoods", goods.GetGoods)
	}
	ar := r.Group("/account")
	aropt := ar.Group("/accountopt")
	{
		aropt.POST("/GetAccount", account.GetAccount)
	}

	timeout := 15 * time.Second

	// doubg模式启用pprof
	if config.SerCfg.GetDebugMode() {
		dm := r.Group("/debug/pprof")
		ginpprof.WrapGroup(dm)
		timeout = 60 * time.Second
	}

	// 声明web服务
	webser := &http.Server{
		Handler:      r,
		Addr:         config.SerCfg.GetWebListenAddr(),
		WriteTimeout: timeout,
		ReadTimeout:  timeout,
	}

	cxt, cancel := context.WithCancel(context.Background())
	defer cancel()

	// 启动服务
	c := make(chan struct{}, 1)
	go func() {
		defer close(c)
		if err := webser.ListenAndServe(); err != nil {
			logger.GetLogger().Errorf("Start service failed[%s].", err.Error())
			c <- struct{}{}
		}
	}()

	// 信号控制
	s := make(chan os.Signal, 1)
	signal.Notify(s, syscall.SIGINT, syscall.SIGTERM)
	select {
	case <-s:
		logger.GetLogger().Debug("Shutdown service...")
		timeCxt, tCancel := context.WithTimeout(cxt, 5*time.Second)
		defer tCancel()

		if err = webser.Shutdown(timeCxt); err != nil {
			logger.GetLogger().Errorf("Shutdown service failed: %s", err.Error())
		}
	case <-c:

	}

	signal.Stop(s)
	defer close(s)
	logger.GetLogger().Debug("Service stopped")

	//listenaddr := config.SerCfg.GetWebListenAddr()
	//r.Run(listenaddr)
}

func ginLoggerMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		c.Next()
		end := time.Now()
		latency := end.Sub(start)
		path := c.Request.URL.RequestURI()
		clientip := c.ClientIP()
		method := c.Request.Method
		statuscode := c.Writer.Status()
		logger.GetLogger().Infof("|%3d|%13v|%15s|%s %s",
			statuscode,
			latency,
			clientip,
			method,
			path)
	}
}

func ginRecoveryMiddleware() gin.HandlerFunc {
	return gin.RecoveryWithWriter(logger.GetLogWriter())
}

func TestProto() {
	s1 := &protocol.Student{} //第一个学生信息
	s1.Name = "jz01"
	s1.Age = 23
	s1.Address = "cq"
	s1.Cn = protocol.ClassName_class2 //枚举类型赋值
	ss := &protocol.Students{}
	ss.Person = append(ss.Person, s1) //将第一个学生信息添加到Students对应的切片中
	s2 := &protocol.Student{}         //第二个学生信息
	s2.Name = "jz02"
	s2.Age = 25
	s2.Address = "cd"
	s2.Cn = protocol.ClassName_class3
	ss.Person = append(ss.Person, s2) //将第二个学生信息添加到Students对应的切片中
	ss.School = "cqu"
	fmt.Println("Students信息为：", ss)

	// Marshal takes a protocol buffer message
	// and encodes it into the wire format, returning the data.
	buffer, _ := proto.Marshal(ss)
	fmt.Println("序列化之后的信息为：", buffer)
	// 	Use UnmarshalMerge to preserve and append to existing data.
	data := &protocol.Students{}
	proto.Unmarshal(buffer, data)
	fmt.Println("反序列化之后的信息为：", data)

	msg := &protocol.TestMessage{}
	msg.Name = "HU.XINYU"
	msg.Age = 40
	msg.Address = "123456"
	fmt.Println("信息为：", msg)

	buffer, _ = proto.Marshal(msg)
	fmt.Println("序列化之后的信息为：", buffer)

	msg1 := &protocol.TestMessage{}
	proto.Unmarshal(buffer, msg1)
	fmt.Println("反序列化之后的信息为：", msg1)
}