基于gin框架的web服务器搭建

环境和安装（请看上一篇）

本来选的lrsi（好像是这个）框架，结果被环境的翻墙劝退
gin框架作为轻量级的web框架也很nice，下面开始搭建自己的一个简易的web服务器。
为了统一协议，方便开发，我这里采用的后端接口均为CGI协议的格式。
为了实现先后端分离，后端只提供数据源已经一些基本逻辑，采用的请求格式都为json字符串。

基本功能的添加

1.日志模块

安装好gin框架之后的目录结构：

在工程目录gin_test下创建自己的控制器层controller，为了层次清晰再建一个system的文件夹，里面包含基本的logger.go
logger.go使用模块logrus 这里有个教程不错 https://zhuanlan.zhihu.com/p/78263242
自己的网站很简单，我这里只用到了将日志追加到文件啦，代码如下:

package system

import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/sirupsen/logrus"
"os"
"path"
"time"
)

func Logger() *logrus.Logger {
	now := time.Now()
	logFilePath := ""
	if dir, err := os.Getwd(); err == nil {
		logFilePath = dir + "/logs/"
	}
	if err := os.MkdirAll(logFilePath, 0777); err != nil {
		fmt.Println(err.Error())
	}
	logFileName := now.Format("2006-01-02") + ".log"
	//日志文件
	fileName := path.Join(logFilePath, logFileName)
	if _, err := os.Stat(fileName); err != nil {
		if _, err := os.Create(fileName); err != nil {
			fmt.Println(err.Error())
		}
	}
	//写入文件
	src, err := os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
	if err != nil {
		fmt.Println("err", err)
	}

	//实例化
	logger := logrus.New()

	//设置输出
	logger.Out = src

	//设置日志级别
	logger.SetLevel(logrus.DebugLevel)

	//设置日志格式
	logger.SetFormatter(&logrus.TextFormatter{
		TimestampFormat: "2006-01-02 15:04:05",
	})
	return logger
}

func LoggerToFile() gin.HandlerFunc {
	logger := Logger()
	return func(c *gin.Context) {
		// 开始时间
		startTime := time.Now()

		// 处理请求
		c.Next()

		// 结束时间
		endTime := time.Now()

		// 执行时间
		latencyTime := endTime.Sub(startTime)

		// 请求方式
		reqMethod := c.Request.Method

		// 请求路由
		reqUri := c.Request.RequestURI

		// 状态码
		statusCode := c.Writer.Status()

		// 请求IP
		clientIP := c.ClientIP()

		//日志格式
		logger.Infof("| %3d | %13v | %15s | %s | %s |",
			statusCode,
			latencyTime,
			clientIP,
			reqMethod,
			reqUri,
		)
	}
}

2.路由模块

basic.go是一个简单的路由映射，我是在逻辑层controller下面建了一个基础结构将接受的请求包（字符串）
basic.go负责将传来的字符传转换成函数运行，因为刚也说了是CGI协议，发送的是post请求。请求的格式利用curl包的话是(这里要注意，包最外层的字符串一定要用双引号，因为go中单引号不会被解析为字符串)：
curl “http://127.0.0.1:8080/ewew/wqwq” -d"{\ "interfaceName\ ":\ "UserLogin\ ",\ "data\ ":\ "dasda\ “}” -H"Content-Type:application/json"
直接上代码：

package controller

import (
	"encoding/json"
	"fmt"
	"github.com/gin_test/controller/user"
	"github.com/gin_test/system"
	"github.com/sirupsen/logrus"
	"reflect"
)

//将输入的json数组参数转换成参数

type RequestParam struct {
	timeStamp     interface{}
	version       interface{}
	interfaceName interface{}
	data          interface{}
}

//一个简单的路由映射，负责将传来的字符传转换成函数运行
type ControllerMapsType map[string]reflect.Value

var ControllerMaps ControllerMapsType

func MapRouters() ControllerMapsType {
	var ruTest  user.User  //注册组件

	crMap := make(ControllerMapsType, 0)
	//创建反射变量，注意这里需要传入ruTest变量的地址；
	//不传入地址就只能反射Routers静态定义的方法
	vf := reflect.ValueOf(&ruTest)
	vft := vf.Type()
	//读取方法数量
	mNum := vf.NumMethod()
	fmt.Println("NumMethod:", mNum)
	//遍历路由器的方法，并将其存入控制器映射变量中
	for i := 0; i < mNum; i++ {
		mName := vft.Method(i).Name
		fmt.Println("index:", i, " MethodName:", mName)
		crMap[mName] = vf.Method(i) //<<<
	}

	return crMap
}

func Create(req string) RequestParam {
	req_temp := RequestParam{}
	var dat map[string]interface{}

	if err := json.Unmarshal([]byte(req), &dat); err == nil {
		fmt.Println("==============输入的json str 转map=======================")
		fmt.Println(dat["timeStamp"])
		fmt.Println(dat["version"])
		fmt.Println(dat["interfaceName"])
		fmt.Println(dat["data"])
	}
	system.Logger().WithFields(logrus.Fields{
		"name": "yancy",
	}).Info("post请求的输入参数%v", dat)
	req_temp.timeStamp = dat["timeStamp"]
	req_temp.version = dat["version"]
	req_temp.interfaceName = dat["interfaceName"]
	req_temp.data = dat["data"]
	return req_temp
}

func (param * RequestParam) Get(inter string) interface{} {  //根据名称获取内容的函数
	var content interface{}
	switch inter {
	case "timeStamp":
		content = param.timeStamp
		break
	case "version":
		content = param.version
		break
	case "interfaceName":
		content = param.interfaceName
		break
	case "data":
		content = param.data
		break

	}
	return content
}
/**
请求包的格式：
curl "http://127.0.0.1:8080/ewew/wqwq" -d
"
{\"interfaceName\":\"UserLogin\"}
"
-H"Content-Type:application/json"


 */

func (param *RequestParam) BasicController() []reflect.Value{
	fun := (param.interfaceName).(string)
	controller_map := MapRouters() //建立映射去调用函数
	//创建带调用方法时需要传入的参数列表
	args := []reflect.Value{reflect.ValueOf((param.data).(string))}
	fmt.Printf("func %v res==%v\n", fun, args)
	system.Logger().WithFields(logrus.Fields{
		"name": "yancy",
	}).Info("传入的函数参数为 %v", args)
	//使用方法名字符串调用指定方法
	rst := controller_map[fun].Call(args)
	return rst
}

3.主函数

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gin_test/controller"
	"github.com/gin_test/system"
	"github.com/sirupsen/logrus"
	"io/ioutil"
	"net/http"
)

func main() {
	router := gin.Default()
	router.Use(system.LoggerToFile())

	// LoggerWithFormatter 中间件会将日志写入 gin.DefaultWriter
	// By default gin.DefaultWriter = os.Stdout
	router.POST("/:role/:action", func(c *gin.Context) {
		c.Request.ParseForm()
		data, _ := ioutil.ReadAll(c.Request.Body)
		fmt.Println(string(data))
		system.Logger().WithFields(logrus.Fields{
			"name": "yancy",
		}).Info("post请求的输入参数%v", string(data))
		req := controller.Create(string(data))
		system.Logger().WithFields(logrus.Fields{
			"name": "yancy",
		}).Info("After Create %s", req)
		rst := req.BasicController()
		c.String(http.StatusOK, "rst== %v",rst)
	})
	router.Run() // listen and serve on 0.0.0.0:8080 (for windows "localhost:8080")
}

contorller层

package user

import (
	"fmt"
)

type User struct {
	name string
	password string
}
func (u *User) UserLogin(data string) string{
	fmt.Println("data==",data)
	return "hello "+data
}

test

如图：

基本框架调通，接下来就靠自己慢慢添砖加瓦啦。
附上源码：https://download.csdn.net/download/qq_34484082/15940000
之后基本功能有了会放github