Básicamente, después de obtener este marco básico, puede realizar algunos cambios que desee realizar, por ejemplo, si desea agregar un complemento de cola, puede modificarlo en el directorio correspondiente, pero quiero hacerlo más general. Este artículo iniciará un servicio websocket y cambiará el archivo de configuración a formato yaml.
Modificar configuración
Hay varias razones por las que desea cambiar la configuración de json a yaml:
- json se usa principalmente para la transmisión de información, y yaml es más adecuado para usar como formato de archivo de configuración, el propósito de ambos es diferente;
- El formato yaml se ve más claro que json;
- Puede agregar comentarios en el archivo yaml para que la configuración sea más fácil de entender.
Aquí, el paquete utilizado para analizar el archivo yaml es "gopkg.in/yaml.v2". Se pueden encontrar ejemplos en github, y se puede encontrar un enlace a este proyecto al final del artículo.
Agregue servicios websocket al marco
Espero que este proyecto pueda cubrir algunas funciones básicas tanto como sea posible, así que le agregué una interfaz websocket para ver cómo lo hice.
Como se mencionó anteriormente, la lógica de procesamiento específica de este proyecto se llevará a cabo en proceso / controlador, mientras que el nivel de interfaz se distribuye en los directorios http y rpc. Antes de agregar websocket a este marco, primero debemos saber: websocket es un protocolo, un protocolo que se actualiza en http, por lo que no escucha el puerto directamente como abrimos el servicio http antes, sino en http Abra una interfaz en el servicio, a través de la interfaz para lograr la conexión entre el servidor y el cliente, bueno, después de aclarar esto, echemos un vistazo a cómo lograr el código.
Primero, agregamos una ruta.
engine.GET("/ws", Ws)
Luego, implemente el manejador – Ws al que apunta la ruta.
func Ws(ctx *gin.Context) {
ws, err := upGrader.Upgrade(ctx.Writer, ctx.Request, nil)
if err != nil {
return
}
defer ws.Close()
for {
//读取数据
mt, message, err := ws.ReadMessage()
if err != nil {
break
}
if string(message) == "ping" {
message = []byte("pong")
}
if string(message) == "server_time" {
resp, _, _ := controller.GetServerTime()
serverTime := strconv.FormatInt(resp.ServerTime, 10)
message = []byte(serverTime)
}
//写入数据
err = ws.WriteMessage(mt, message)
if err != nil {
break
}
}
}
Tenga en cuenta que este código de oración:
ws, err := upGrader.Upgrade(ctx.Writer, ctx.Request, nil)
Como se mencionó anteriormente, websocket es un protocolo, un protocolo sobre http, por lo que "actualizamos" http. También se usa un bucle for en el código, que es muy parecido a la supervisión http. Para unificar, llamamos a controller.GetServerTime () para obtener la hora del sistema, lo que unifica la interfaz http y la interfaz ws, y la lógica de implementación real está en el controlador.
A continuación, escribimos un cliente para probar:
func TestWs(t *testing.T) {
var dialer *websocket.Dialer
conn, _, err := dialer.Dial("ws://127.0.0.1:8080/ws", nil)
if err != nil {
fmt.Println(err)
return
}
go timeWriter(conn)
for {
_, message, err := conn.ReadMessage()
if err != nil {
fmt.Println("read:", err)
return
}
fmt.Printf("received: %s\n", message)
}
}
func timeWriter(conn *websocket.Conn) {
for {
time.Sleep(time.Second * 2)
conn.WriteMessage(websocket.TextMessage, []byte(time.Now().Format("2006-01-02 15:04:05")))
conn.WriteMessage(websocket.TextMessage, []byte("ping"))
conn.WriteMessage(websocket.TextMessage, []byte("server_time"))
}
}
Hasta ahora, hemos agregado la función websocket a este marco y hemos cambiado el formato del archivo de configuración de json a yaml, que se ve más claro.
Para ver el código completo, consulte: https://github.com/TomatoMr/awesomeframework .
Bienvenido a prestar atención a mi número público: onepunchgo, déjame un mensaje.
