Realice la interacción RestFul basada en el lenguaje go

1. Descanso

1.1 Introducción a RestFul

RESTFUL (Representational State Transfer) es un estilo de diseño y método de desarrollo de aplicaciones web basado en HTTP o HTTPS, que se puede definir en formato XML o JSON. RESTFUL es adecuado para escenarios en los que los fabricantes de Internet móvil sirven como interfaces comerciales y realiza la función de llamadas OTT de terceros a los recursos de la red móvil. Los tipos de acción son agregar, cambiar y eliminar los recursos llamados.

REST tiende a diseñarse e implementarse de una manera más simple y liviana. Vale la pena señalar que REST no tiene un estándar claro, sino más bien un estilo de diseño.

1.2 Principios y Condiciones

1. REST se refiere a un conjunto de restricciones y principios arquitectónicos. Una aplicación o diseño que satisface estas restricciones y principios es RESTful

2. El principio REST más importante para las aplicaciones web es que la interacción entre el cliente y el servidor no tiene estado entre las solicitudes , es decir: 1) Cada solicitud del
   cliente al servidor debe contener la información necesaria para comprender la solicitud2 3) las solicitudes sin estado pueden ser respondidas por cualquier servidor disponible
   
   

3. En el lado del servidor, el estado y la funcionalidad de la aplicación se pueden agrupar en varios recursos

1.3 Características

1. Cada URI representa un recurso
2. El cliente usa GET, POST, PUT y DELETE para operar en los recursos del servidor: GET se usa para obtener recursos, POST se usa para crear nuevos recursos (también se puede usar para actualizar recursos), PUT se usa para actualizar recursos y ELIMINAR Se utiliza para eliminar recursos;
3. La interacción entre el cliente y el servidor no tiene estado entre solicitudes, cada solicitud del cliente al servidor debe contener la información necesaria para comprender la solicitud.

2. El paquete de ginebra en marcha

Gin es un marco web escrito en lenguaje Go. Tiene una velocidad de ejecución rápida, enrutadores agrupados, buena captura de fallas y manejo de errores, y muy buen soporte para middleware y json. En resumen, en el campo del desarrollo del lenguaje Go, es un marco web que vale la pena estudiar.La URL de código abierto: https://github.com/gin-gonic/gin

2.1 Descarga y carga el paquete de gin:

go get "https://github.com/gin-gonic/gin"
import "https://github.com/gin-gonic/gin"

2.2 Uso simple del paquete gin basado en HTTP

package main
import(
	"fmt"
	"https://github.com/gin-gonic/gin"
)
func main(){
    
    
	router := gin.Default()
	router.GET("/getConfig",func (context *gin.Context){
    
    
		context.JSON(http.StatusOK, gin.H{
    
    
			"code": http.StatusOK,
			"data": "message" 
		})
	})
	router.Run(":8080")
}

2.3 Uso simple del paquete gin basado en HTTPS

package main
import(
	"fmt"
	"https://github.com/gin-gonic/gin"
)
func LoadTls(port int) gin.HandlerFunc {
    
    
	return func(c *gin.Context) {
    
    
		middleware := secure.New(secure.Options{
    
    
			SSLRedirect: true,
			SSLHost:  "localhost:" + strconv.Itoa(port),
		})
		err := middleware.Process(c.Writer, c.Request)
		if err != nil {
    
    
			//如果出现错误，请不要继续。
			fmt.Println(err)
			return
		}
		// 继续往下处理
		c.Next()
	}
}
func main(){
    
    
	router := gin.Default()
	router.Use(LoadTls(8000))
	router.GET("/getConfig",func (context *gin.Context){
    
    
		context.JSON(http.StatusOK, gin.H{
    
    
			"code": http.StatusOK,
			"data": "message" 
		})
	})
	router.RunTLS(":8080", "server.crt","server.key")
}

3. Analice el servidor de archivos config.json

3.1 Establecer interfaz y protocolo

type ConfigParseServer struct {
    
    
}

func LoadTls(port int) gin.HandlerFunc {
    
    
	return func(c *gin.Context) {
    
    
		middleware := secure.New(secure.Options{
    
    
			SSLRedirect: true,
			SSLHost:     "localhost:" + strconv.Itoa(port),
		})
		err := middleware.Process(c.Writer, c.Request)
		if err != nil {
    
    
			//如果出现错误，请不要继续。
			fmt.Println(err)
			return
		}
		// 继续往下处理
		c.Next()
	}
}

func (*ConfigParseServer) GinHttps(isHttps bool) error {
    
    

	router := gin.Default()

	router.GET("/getConfigs/config", hello.GetAllConfigData)
	router.GET("/getConfig/server", hello.GetServerInfo)
	router.GET("/getConfig/client", hello.GetClientInfo)

	router.POST("/setServerInfo/", hello.SetServerInfo)
	router.POST("/setClientInfo/", hello.SetClientInfo)

	if isHttps {
    
    
		router.Use(LoadTls(8000))
		return router.RunTLS(":8000", "server.crt", "server.key")
	}
	return router.Run(":8080")
}

func main() {
    
    
	var configParseServer ConfigParseServer
	fmt.Printf("请输入0/1来确定是否使用https: ")
	var valve bool
	fmt.Scan(&valve)
	configParseServer.GinHttps(valve)
}

3.2 Implementar la interfaz

func GetJsonData() []byte {
    
    
	data, err := os.ReadFile("./hello/config.json")
	if err != nil {
    
    
		fmt.Println("readfile error")
	}
	return data
}

func ParseJson2Struct() *AutoGenerated {
    
    
	datafig, err := os.ReadFile("./hello/config.json")
	if err != nil {
    
    
		fmt.Println("ParseJson: os.ReadFile.....")
	}
	cfg := new(AutoGenerated)
	err = json.Unmarshal(datafig, cfg)
	if err != nil {
    
    
		fmt.Println("ParseJson: json.Unmarshal.....")
	}
	return cfg
}


func SetConfigInfo(context *gin.Context, modle string) (int, string) {
    
    
	var code int = -1
	var errorMessage string
	raw := GetJsonData()
	var configStruct AutoGenerated
	err := json.Unmarshal(raw, &configStruct)
	if err != nil {
    
    
		fmt.Println("SetConfigInfo: json.Unmarshal failed")
	}
	data, _ := io.ReadAll(context.Request.Body)
	var res map[string]interface{
    
    }
	err = json.Unmarshal(data, &res)
	if err != nil {
    
    
		fmt.Println("GetConfigInfo: json.Unmarshal failed...")
	}

	for k := range res {
    
    
		if k != modle {
    
    
			errorMessage = "Only the config of " + modle + " can be modified here"
			return code, errorMessage
		}
	}

	err = json.Unmarshal(data, &configStruct)
	if err != nil {
    
    
		Logger("Error", "json Unmarshal failed")
		errorMessage = "type of value is wrong"
		return code, errorMessage
	}

	Indata, err := json.MarshalIndent(configStruct, "", "  ")
	if err != nil {
    
    
		fmt.Println("json.MarshalIndent failed")
	}

	fp, err := os.Create("./newConfig.json")
	if err != nil {
    
    
		fmt.Println("os.Create fail...")
	}
	defer fp.Close()

	fp.Write(Indata)

	code = 0
	errorMessage = "modify success!!!"
	return code, errorMessage
}
func SetServerInfo(context *gin.Context) {
    
    
	code, reason := SetConfigInfo(context, "server")
	var newConfig AutoGenerated

	data, err := os.ReadFile("./newConfig.json")
	if err != nil {
    
    
		Logger("Error", "SetServerVersionInfo: ReadFile failed")
	}
	err = json.Unmarshal(data, &newConfig)
	if err != nil {
    
    
		Logger("Error", "SetServerVersionInfo: json Unmarshal failed")
	}

	var param interface{
    
    }

	if reason == "modify success!!!" {
    
    
		param = newConfig.Server
	} else {
    
    
		param = nil
	}

	context.JSON(http.StatusOK, gin.H{
    
    
		"code":   code,
		"reason": reason,
		"params": param,
	})
}

func SetClientInfo(context *gin.Context) {
    
    
	code, reason := SetConfigInfo(context, "client")
	var newConfig AutoGenerated

	data, err := os.ReadFile("./newConfig.json")
	if err != nil {
    
    
		Logger("Error", "SetServerVersionInfo: ReadFile failed")
	}
	err = json.Unmarshal(data, &newConfig)
	if err != nil {
    
    
		Logger("Error", "SetServerVersionInfo: json Unmarshal failed")
	}

	var param interface{
    
    }

	if reason == "modify success!!!" {
    
    
		param = newConfig.Client
	} else {
    
    
		param = nil
	}

	context.JSON(http.StatusOK, gin.H{
    
    
		"code":   code,
		"reason": reason,
		"params": param,
	})
}

func GetConfigStruct() *AutoGenerated {
    
    
	//fmt.Println(*ParseJson2Struct())
	return ParseJson2Struct()
}

func GetServerInfo(context *gin.Context) {
    
    
	context.JSON(http.StatusOK, gin.H{
    
    
		"code": http.StatusOK,
		//"reason": "get data success",
		"data": GetConfigStruct().Server,
	})
}

func GetClientInfo(context *gin.Context) {
    
    
	context.JSON(http.StatusOK, gin.H{
    
    
		"code": http.StatusOK,
		//"reason": "get data success",
		"data": GetConfigStruct().Client,
	})
}

Después de implementar el servidor, es un dolor de cabeza anidar información json para obtener la clave en el código, escriba el siguiente código

3.3 clave de búsqueda json

func getKeys(data map[string]interface{
    
    }) string {
    
    
	var j int
	var flag int
	var keyList []string
	//fmt.Println(len(data))
	for j = 0; j < 20; j++ {
    
    
		flag = 0
		for k, v := range data {
    
    
			keyList = append(keyList, k)
			switch value := v.(type) {
    
    
			case string, int, float64, uint:
				flag = -1
			case map[string]interface{
    
    }:
				data = value
				fmt.Println(data)
			}
		}
		if flag == -1 {
    
    
			break
		}
	}
	queryString := keyList[0]
	var i int
	if len(keyList) > 1 {
    
    
		queryString += "."
		for i = 1; i < len(keyList)-1; i++ {
    
    
			queryString += keyList[i]
			queryString += "."
		}
		queryString += keyList[i]
	}
	return queryString    //key的格式为key1.key2.key3...
}

//如上取到的key的格式，可以通过jmespath.Search去json中取相应的value
func getOneClassInfo(context *gin.Context, postJsondata []byte) {
    
    
	jsonData := GetJsonData()
	var totalData interface{
    
    }
	err := json.Unmarshal(jsonData, &totalData)
	if err != nil {
    
    
		fmt.Println("getServerInfo:111json.Unmarshal")
	}

	var jsonMap map[string]interface{
    
    }
	err = json.Unmarshal(postJsondata, &jsonMap)
	if err != nil {
    
    
		fmt.Println("getServerInfo:222json.Unmarshal")
	}

	path := getKeys(jsonMap)
	res, err := jmespath.Search(path, totalData)
	if err != nil {
    
    
		fmt.Println("jmespath Search failed....")
	}
	context.JSON(http.StatusOK, res)
}