ir a notas de trabajo (espacio de trabajo de varios módulos)

1. ir a notas de trabajo (espacio de trabajo de varios módulos)

1.1 ¿Qué es ir a trabajar?

go 1.18 introduce genéricos funcionales (Generics), así como espacios de trabajo de múltiples módulos (Workspaces) y fuzzing (Fuzzing).

El espacio de trabajo de múltiples módulos de Go facilita a los desarrolladores trabajar en varios módulos al mismo tiempo, como por ejemplo:

• Conveniente para la depuración de código dependiente (puntos de interrupción, modificaciones de código) y solución de errores de código dependiente
• Facilita el desarrollo paralelo y la depuración de múltiples almacenes/módulos al mismo tiempo.

1.2 ir a trabajar admite comandos

• Normalmente, se recomienda no enviar go.workarchivos a git ya que se utiliza principalmente para el desarrollo de código local;
• $GOPATHSe recomienda ejecutar bajo la ruta : para generar go.workarchivos
• go work initInicializar el archivo del espacio de trabajo, utilizado para generar go.workel archivo del espacio de trabajo

Inicialice y escriba uno nuevo go.worken la ruta actual. Puede especificar los módulos de código que deben agregarse.
Ejemplo: go work init ./helloagregue el almacén local hello al espacio de trabajo.
El almacén hello debe ser un almacén de gestión de dependencias go mod ( ./hello/go.model archivo debe existir )

• go work use agrega nuevos módulos al espacio de trabajo

Ejemplo de comando:

go work use ./example 添加一个模块到工作区
go work use ./example ./example1 添加多个模块到工作区
go work use -r ./example 递归 ./example 目录到当前工作区
删除命令使用 go work edit -dropuse=./example 功能

• go work editpara editar go.workarchivos

Puede usar editel comando para editar el archivo y editarlo manualmente go.work, el efecto es el mismo, ejemplo:

go work edit -fmt go.work 重新格式化 go.work 文件
go work edit -replace=github.com/link1st/example=./example go.work 替换代码模块
go work edit -dropreplace=github.com/link1st/example 删除替换代码模块
go work edit -use=./example go.work 添加新的模块到工作区
go work edit -dropuse=./example go.work 从工作区中删除模块

• go work syncSincronizar la lista de compilación de un espacio de trabajo con los módulos del espacio de trabajo

• go env GOWORK

Verifique las variables de entorno y verifique la ruta del archivo del espacio de trabajo actual para verificar si el archivo del espacio de trabajo está configurado correctamente. Si go.workno se encuentra la ruta, puede usar GOWORKespecificar

> go env GOWORK
$GOPATH/src/link1st/link1st/workspaces/go.work

1.3 Estructura del archivo go.work

• La estructura del archivo es similar a la estructura del archivo go.mod. Admite el número de versión de Go, el espacio de trabajo especificado y el almacén que debe reemplazarse. Ejemplo de estructura de archivo:

go 1.18

use (
    ./hello
    ./example
)

replace (
    github.com/link1st/example => ./example1
)

1.4 use especifica el directorio del módulo a usar

• Puede usar go work use hello para agregar módulos, o puede modificar manualmente el espacio de trabajo de go.work para agregar nuevos módulos. La ruta del módulo se agrega al espacio de trabajo. Al compilar, el código local en uso se usará automáticamente para la compilación del código. y los reemplazos funcionan de manera similar.

# 单模块结构
use ./hello

# 多模块结构
use (
    ./hello
    ./example
)

1.5 reemplaza reemplaza la dirección del almacén dependiente

• El comando de reemplazo es el mismo que el comando go.mod y se usa para reemplazar la dirección del almacén del que depende el proyecto. Cabe señalar que reemplazar y usar no pueden especificar la misma ruta local al mismo tiempo.

同时指定报错信息:
go: módulo de espacio de trabajo http://github.com/link1st/example se reemplaza en todas las versiones del archivo go.work. Para solucionarlo, elimine el reemplazo del archivo go.work o especifique la versión en la que reemplazará el módulo.

• Ejemplo de error

Especifique la misma ruta local en uso y reemplácela al mismo tiempo

ir 1.18

use (
    ./hello
    ./example
)

replace (
    github.com/link1st/example => ./example
)

1.6 La prioridad del archivo go.work es mayor que la definida en go.mod

• Cuando utilice las funciones de reemplazo go.work y go.mod al mismo tiempo, especifique diferentes rutas de almacén de código respectivamente. La prioridad de go.work es mayor que la definida en go.mod.

Reemplace la definición en go.mod con el ejemplo del almacén local

replace (
    github.com/link1st/example => ./example1
)

Reemplace la definición en go.work con el ejemplo de almacén local1

replace (
    github.com/link1st/example => ./example1
)

• Al crear el código, se utiliza el código del almacén de ejemplo 1 especificado por go.work y go.work tiene mayor prioridad.

1.7 Cómo utilizar

• En Go 1.18, go run y go build utilizarán la función de espacio de trabajo de forma predeterminada. GOWORK también puede especificar la ubicación del archivo go.work.

export GOWORK="~/go/src/test/go.18/workspace/go.work"

1.8 Cómo deshabilitar un espacio de trabajo

• Ir a la variable global GOWORK está desactivado para desactivar la función del espacio de trabajo.

exportar GOWORK=apagado

1.9 Demostración del proceso de desarrollo

• Demuestra cómo utilizar la función de espacio de trabajo de varios módulos. En la era actual en la que prevalecen los microservicios, una persona mantendrá varios almacenes de códigos y, en muchos casos, se desarrollan varios almacenes simultáneamente.

• Supongamos que ahora estamos desarrollando el almacén de hello. La función implementada es invertir la cadena de entrada y generarla. La función de inversión de cadena se basa en la implementación del almacén público de http://github.com/link1st/example (en lo sucesivo, denominado colectivamente como ejemplo)

• Crear un nuevo proyecto de saludo

mkdir hello
cd hello
# 代码仓库启动 go mod 依赖管理, 生成 go.mod 文件
go mod init github.com/link1st/link1st/workspaces/hello
# 下载依赖包
go get github.com/link1st/example
# 编写 main 文件
vim main.go

• código principal.go

// Package main main 文件, go 多模块工作区演示代码
// 实现将输入的字符串反转输出并输出
package main

import (
    "flag"
    "fmt"

    "github.com/link1st/example/stringutil"
)

var (
    str = ""
)

func init() {
    
    
    flag.StringVar(&str, "str", str, "输入字符")
    flag.Parse()
}

func main() {
    
    
    if str == "" {
    
    
        fmt.Println("示例: go run main.go -str hello")
        fmt.Println("str 参数必填")
        flag.Usage()
        return
    }

    // 调用公共仓库, 进行字符串反转
    str = stringutil.Reversal(str)
    // 输出反转后的字符串
    fmt.Println(str)
    return
}

• Ejecute el código y ejecute main.go -str “hello world” o ejecute github.com/link1st/link1st/workspaces/hello -str “hello world”. Puede ver que se genera la cadena invertida de hola mundo.

> go run main.go -str "hello world"
dlrow olleh

• En este punto, la función inicial se ha completado, pero los cambios posteriores en los requisitos requieren no solo generar la cadena invertida, sino también poner la cadena en mayúsculas. Luego necesitamos agregar y desarrollar la función de poner en mayúsculas la cadena en el almacén de ejemplo.

# 回到工作根目录, 将 common 代码下载到本地进行添加新的功能
# 下载依赖的 example 包
git clone [email protected]:link1st/example.git
# 在 example 包中添加 字符串大学的功能

• El código vim ejemplo/stringutil/to_upper.go es el siguiente

// Package stringutil stringutil
package stringutil

import (
    "unicode"
)

// ToUpper 将字符串进行大写
func ToUpper(s string) string {
    
    
    r := []rune(s)
    for i := range r {
    
    
        r[i] = unicode.ToUpper(r[i])
    }
    return string(r)
}

• Dado que el código aún se está depurando localmente y no se ha enviado al repositorio de git, en este momento debe utilizar la función de espacio de trabajo de múltiples módulos de Go.

• Ingrese al directorio raíz del proyecto e inicialice el módulo que estamos desarrollando ahora

# 初始化 go.work 文件
go work init  ./hello ./example
# 查看 go.work 文件内容
cat go.work

• La estructura del archivo es la siguiente.

go 1.18

use (
    ./example
    ./hello
)

• Volviendo al proyecto hola, vim main.go agrega la función de poner cadenas en mayúsculas.

func main() {
    
    
    ...

    // 调用公共仓库, 进行字符串反转
    str = stringutil.Reversal(str)
    // 增加字符大写的功能
    str = stringutil.ToUpper(str)
    // 输出反转后的字符串
    fmt.Println(str)

    ...
}

• Ejecutar código

Se puede ver que se genera la cadena invertida y en mayúsculas. La función en mayúsculas es solo local y no se envía a git. De esta manera, podemos desarrollar dos módulos en paralelo al mismo tiempo.

go run main.go -str "hello world"
DLROW OLLEH

• En este punto, el código de demostración se ha completado.

1.10 Resumen

• El uso de la función del espacio de trabajo de múltiples módulos de Go nos permite cambiar fácilmente el trabajo entre múltiples módulos y es más adaptable al desarrollo de la arquitectura de microservicios moderna.