Prólogo
Go se ha escrito recientemente durante un período de tiempo debido al proyecto. Comparado con Java, la sintaxis es simple y tiene algo de azúcar sintáctico como Python, lo que hace que la gente grite "realmente fragante".
Pero en esta etapa, relativamente hablando, he escrito más en Python, y ocasionalmente tengo que volver atrás y escribir algo de Java; naturalmente, no estoy familiarizado con Go.
Por eso, es conveniente realizar un pequeño proyecto el fin de semana para profundizar algo en la experiencia. Así que pensé en un gadget de blog escrito en Java antes.
En ese momento, se prohibió vincular una gran cantidad de imágenes en Weibo Tubed, lo que provocó que muchas imágenes en blogs personales no estuvieran disponibles para su visualización. Esta herramienta puede hacer una copia de seguridad de las imágenes del artículo en el local y también puede reemplazar directamente las imágenes por otras imágenes.
Personalmente, lo he estado usando todo el tiempo, y generalmente uso herramientas como iPic para cargar imágenes en Weibo Tubed (principalmente conveniente + gratis) cuando se usan palabras en clave. Después de escribir, use esta herramienta para cambiar a una base de imágenes de pago como SM.MS con un solo clic , y la imagen se respaldará en el disco local al mismo tiempo.
El efecto de usar Go para reescribir como herramienta cli es el siguiente:
3 min.gif
Qué habilidades hay que dominar La
razón por la que elegí esta herramienta para reescribirla con Go; una es que la función es relativamente simple, pero también puede aprovechar algunas de las características de Go, como IO de red, sincronización de corrutinas, etc.
Al mismo tiempo, después de modificarlo a una herramienta de línea de comandos, ¿se siente más geek?
Antes de comenzar, introduzcamos algunos puntos de conocimiento para los usuarios de Java que no están familiarizados con Go:
- Usar y administrar paquetes de dependencia de terceros (go mod)
- El uso de corrutinas.
- Embalaje multiplataforma.
Comencemos con la operación específica.Creo que incluso los amigos que no han estado en contacto con Go pueden comenzar rápidamente a implementar una pequeña herramienta después de leerla.
Usar y administrar dependencias de terceros
- Si no ha instalado Go, consulte el sitio web oficial para instalarlo usted mismo.
Primero, permítanme presentarles la administración de dependencias de Go. Después de la versión 1.11, se ha incluido el módulo oficial de administración de dependencias, por lo que se recomienda encarecidamente en la última versión actual 1.15.
Su propósito y función son similares a maven en Java y pip en Python, pero es mucho más simple de usar que maven.
De acuerdo con su referencia de uso, debe ejecutar go mod init en el directorio del proyecto para inicializar un archivo go.mod. Por supuesto, si está utilizando un IDE como GoLang, creará automáticamente una estructura de directorio para nosotros al crear un nuevo proyecto. Por supuesto También incluya el archivo go.mod.
En este archivo presentamos los paquetes de terceros que necesitamos:
module btb
go 1.15
require (
github.com/cheggaaa/pb/v3 v3.0.5
github.com/fatih/color v1.10.0
github.com/urfave/cli/v2 v2.3.0
)Usé tres paquetes aquí, a saber:
- pb: barra de progreso, utilizada para generar una barra de progreso en la consola.
- color: se utiliza para generar texto en diferentes colores en la consola.
- cli: kit de desarrollo de herramientas de línea de comandos.
import (
"btb / constants"
"btb / service"
"github.com/urfave/cli/v2"
"log"
"os"
)
func main () {
var model string
downloadPath: = constants.DownloadPath
markdownPath: = constants.MarkdownPath
app: = & cli.App {
Flags: [] cli.Flag {
& cli.StringFlag {
Nombre: "modelo",
Uso: "modo operativo; r: reemplazar, b: copia de seguridad",
Texto predeterminado: "b",
Alias: [] cadena {"m"},
Obligatorio: verdadero,
Destino: & modelo,
},
& cli.StringFlag {
Nombre: "ruta de descarga",
Uso: "La ruta donde se almacena la imagen",
Alias: [] cadena {"dp" },
Destino: & downloadPath,
Obligatorio: verdadero,
Valor: constants.DownloadPath,
},
& cli.StringFlag {
Nombre: "markdown-path",
Uso: "La ruta donde se almacena el archivo de markdown",
Alias: [] cadena {" mp "},
Destino: & markdownPath,
Requerido: verdadero,
Valor: constants.MarkdownPath,
},
},
Acción: func (c * cli.Context) error {
service.DownLoadPic (markdownPath, downloadPath)
return nil
},
Nombre: "btb",
Uso: "Ayuda a respaldar y reemplazar las imágenes de tu blog",
}
err: = app.Run (os.Args)
if err! = nil {
log.Fatal (err)
}
}
代码非常简单，无非就是使用了 cli 所提供的 api 创建了几个命令，将用户输入的 -dp、-mp 参数映射到 downloadPath、markdownPath 变量中。
之后便利用这两个数据扫描所有的图片，以及将图片下载到对应的目录中。
更多使用指南可以直接参考官方文档。
可以看到部分语法与 Java 完全不同，比如：
* 申明变量时类型是放在后边，先定义变量名称；方法参数类似。
* 类型推导，可以不指定变量类型（新版本的 Java 也支持）
* 方法支持同时返回多个值，这点非常好用。
* 公共、私用函数利用首字母大小写来区分。
* 还有其他的就不一一列举了。
**协程**
紧接着命令执行处调用了 service.DownLoadPic(markdownPath, downloadPath) 处理业务逻辑。
这里包含的文件扫描、图片下载之类的代码就不分析了；官方 SDK 写的很清楚，也比较简单。
重点看看 Go 里的 goroutime 也就是协程。
我这里使用的场景是每扫描到一个文件就利用一个协程去解析和下载图片，从而可以提高整体的运行效率。
func DownLoadPic (markdownPath, cadena de downloadPath) {
wg: = sync.WaitGroup {}
allFile, err: = util.GetAllFile (markdownPath)
wg.Add (len (* allFile))
if err! = nil {
log.Fatal ("error de lectura de archivo")
}
para _, filePath: = range * allFile {
go func (filePath string) {
allLine, err: = util.ReadFileLine (filePath)
if err! = nil {
log.Fatal (err)
}
availableImgs: = util.MatchAvailableImg (allLine)
bar: = pb.ProgressBarTemplate (constants.PbTmpl ) .Start (len (* availableImgs))
bar.Set ("fileName", filePath).
SetWidth (120)
for _, url: = range availableImgs {
if err! = nil {
log.Fatal (err)
}
err: = util.DownloadFile (url, genFullFileName (downloadPath, filePath, & url))
if err! = nil {
log.Fatal ( err)
}
bar.Increment ()
}
bar.Finish ()
wg.Done ()
} (filePath)
}
wg.Wait ()
color.Green ("Manejo exitoso de [% v] archivos. \ n", len (* allFile))
if err! = nil {
log.Fatal (err)
}
}
就代码使用层面看起来是不是要比 Java 简洁许多，我们不用像 Java 那样需要维护一个 executorService，也不需要考虑这个线程池的大小，一切都交给 Go 自己去调度。
使用时只需要在调用函数之前加上 go 关键字，只不过这里是一个匿名函数。
而且由于 goroutime 非常轻量，与 Java 中的 thread 相比占用非常少的内存，所以我们也不需要精准的控制创建数量。
不过这里也用到了一个和 Java 非常类似的东西：WaitGroup。
它的用法与作用都与 Java 中的 CountDownLatch 非常相似；主要用于等待所有的 goroutime 执行完毕，在这里自然是等待所有的图片都下载完毕然后退出程序。
使用起来主要分为三步：
* 创建和初始化 goruntime 的数量：wg.Add(len(number)
* 每当一个 goruntime 执行完毕调用 wg.Done() 让计数减一。
* 最终调用 wg.Wait() 等待WaitGroup 的数量减为0。
对于协程 Go 推荐使用 chanel 来互相通信，这点今后有机会再讨论。
**打包**
核心逻辑也就这么多，下面来讲讲打包与运行；这点和 Java 的区别就比较大了。
众所周知，Java 有一句名言：write once run anywhere
这是因为有了 JVM 虚拟机，所以我们不管代码最终运行于哪个平台都只需要打出一个包；但 Go 没有虚拟机它是怎么做到在个各平台运行呢。
简单来说 Go 可以针对不同平台打包出不同的二进制文件，这个文件包含了所有运行所需要的依赖，甚至都不需要在目标平台安装 Go 环境。
* 虽说 Java 最终只需要打一个包，但也得在各个平台安装兼容的 Java 运行环境。
我在这里编写了一个 Makefile 用于执行打包：make release
Nombre binario
BINARY = btb
GOBUILD = go build -ldflags "-s -w" -o $ {BINARY}
GOCLEAN = go clean
RMTARGZ = rm -rf * .gz
VERSION = 0.0.1
lanzamiento:
Limpiar
$ (GOCLEAN)
$ (RMTARGZ)
Construir para mac
CGO_ENABLED = 0 GOOS = darwin GOARCH = amd64 $ (GOBUILD)
tar czvf $ {BINARY} -mac64 - $ {VERSION} .tar.gz ./${BINARY}
Construir para brazo
$ (GOCLEAN)
CGO_ENABLED = 0 GOOS = linux GOARCH = arm64 $ (GOBUILD)
tar czvf $ {BINARY} -arm64 - $ {VERSION} .tar.gz ./${BINARY}
Construir para linux
$ (GOCLEAN)
CGO_ENABLED = 0 GOOS = linux GOARCH = amd64 $ (GOBUILD)
tar czvf $ {BINARY} -linux64 - $ {VERSION} .tar.gz ./${BINARY}
Construye para ganar
$ (GOCLEAN)
CGO_ENABLED = 0 GOOS = windows GOARCH = amd64 $ (GOBUILD) .exe
tar czvf $ {BINARY} -win64 - $ {VERSION} .tar.gz ./${BINARY}.exe
$ (GOCLEAN)
可以看到我们只需要在 go build 之前指定系统变量即可打出不同平台的包，比如我们为 Linux 系统的 arm64 架构打包文件：
CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build main.go -o btb
便可以直接在目标平台执行 ./btb 运行程序。
**总结**
本文所有代码都已上传 Github: https://github.com/crossoverJie/btb
感兴趣的也可以直接运行安装脚本体验。
curl -fsSL https://raw.githubusercontent.com/crossoverJie/btb/master/install.sh | bash
目前这个版本只实现了图片下载备份，后续会完善图床替换及其他功能。
这段时间接触 Go 之后给我的感触颇深，对于年纪 25 岁的 Java 来说，Go 确实是后生可畏，更气人的是还赶上了云原生这个浪潮，就更惹不起了。
一些以前看来不那么重要的小毛病也被重点放大，比如启动慢、占用内存多、语法啰嗦等；不过我依然对这位赏饭吃的祖师爷保持期待，从新版本的 Java 可以看出也在积极改变，更不用说它还有无人撼动的庞大生态。