Go on Yison's Blog

何以服务熔断及负载均衡

Sun, 29 Aug 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第10章内容过程中，动手做的小实验，涉及 Hystrix 相关知识，仅供参考。

服务熔断机制

三种状态

┌─────────────────────────────────────────────────────────────┐
│ 熔断器状态机 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ 失败率超过阈值 ┌──────────┐ │
│ │ CLOSED │ ───────────────────────▶│ OPEN │ │
│ │ 关闭 │ │ 打开 │ │
│ └──────────┘ └────┬─────┘ │
│ ▲ │ │
│ │ │ 超时后 │
│ │ 检测成功 │ 半开 │
│ │ ▼ │
│ │ ┌──────────┐ │
│ └──────────────────────────────│HALF-OPEN │ │
│ 恢复关闭 │ 半开 │ │
│ └──────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

状态	说明
Closed（关闭）	正常状态，请求正常通过；失败达到阈值时切换到 Open
Open（打开）	熔断状态，所有请求直接失败，快速返回
Half-Open（半开）	尝试恢复状态，放行部分请求；成功则关闭，失败则重新打开

Hystrix 配置参数

参数	默认值	说明
`sleepWindow`	5000ms	熔断打开后多久尝试半开
`requestVolumeThreshold`	20	熔断器打开的最小请求数
`errorPercentThreshold`	50%	错误百分比阈值
`maxConcurrentRequests`	10	最大并发请求数

负载均衡算法

常见算法

算法	说明	适用场景
随机	随机选择服务实例	请求较少、无状态服务
轮询（Round Robin）	依次选择每个实例	请求均匀、实例性能相近
加权轮询	按权重比例分配请求	实例性能不均
Hash	根据请求特征 Hash	会话保持、缓存友好
一致性 Hash	环状 Hash 分布	分布式缓存
最小连接数	选择连接数最少的	长连接服务

一致性 Hash 原理

 ┌─────────────┐
 │ 节点 A │◀── Hash(A)
 ┌───────────│ 192.168.1.1│
 │ └─────────────┘
 │ ▲
 │ │ 顺时针找
 Hash环 │ 最近的节点
 │ │
 ▼ │
┌───────────────┐ │
│ 节点 C │───────────┘
│ 192.168.1.3 │◀── Hash(C)
└───────────────┘
 ▲
 │
 │
┌───────────────┐
│ 节点 B │
│ 192.168.1.2 │◀── Hash(B)
└───────────────┘

Hystrix Go 使用

安装

go get github.com/afex/hystrix-go/hystrix

基本用法

package main

import (
 "fmt"
 "time"
 
 "github.com/afex/hystrix-go/hystrix"
)

func main() {
 // 配置 Command
 hystrix.ConfigureCommand("my_command", hystrix.CommandConfig{
 Timeout: 1000, // 超时时间 ms
 MaxConcurrentRequests: 10, // 最大并发数
 SleepWindow: 5000, // 熔断后尝试恢复的时间
 RequestVolumeThreshold: 20, // 熔断器打开的最小请求数
 ErrorPercentThreshold: 50, // 错误百分比阈值
 })
 
 // 使用熔断器执行
 err := hystrix.Do("my_command", func() error {
 // 这里是实际要执行的业务逻辑
 return callService()
 }, func(err error) error {
 // 这里是降级处理
 fmt.Println("服务调用失败，执行降级逻辑")
 return fallback()
 })
 
 if err != nil {
 fmt.Println("请求失败:", err)
 }
}

func callService() error {
 // 模拟服务调用
 time.Sleep(100 * time.Millisecond)
 return nil
}

func fallback() error {
 // 降级逻辑
 fmt.Println("执行降级返回")
 return nil
}

异步调用

// 返回 chan
resultChan := make(chan string, 1)
errorChan := hystrix.Go("my_command", func() error {
 // 异步执行
 go func() {
 result, _ := callServiceAsync()
 resultChan <- result
 }()
 return nil
}, nil)

// 等待结果
select {
case result := <-resultChan:
 fmt.Println("结果:", result)
case <-time.After(time.Second * 5):
 fmt.Println("超时")
}

监控

import "github.com/afex/hystrix-go/hystrix/metric_collector"

func init() {
 // 开启监控
 hystrix.RegisterReporter("console", &HystrixConsoleReporter{})
}

完整示例：微服务调用

服务端（string-service）

// service/main.go
package main

import (
 "flag"
 "fmt"
 "log"
 "net/http"
 "time"
)

var port = flag.Int("port", 10086, "service port")

func main() {
 flag.Parse()
 
 http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
 msg := r.URL.Query().Get("msg")
 fmt.Printf("收到请求: %s\n", msg)
 time.Sleep(time.Millisecond * 100)
 w.Write([]byte("响应: " + msg))
 })
 
 log.Printf("服务启动，端口: %d", *port)
 log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", *port), nil))
}

客户端（带熔断）

// client/main.go
package main

import (
 "flag"
 "fmt"
 "io/ioutil"
 "log"
 "net/http"
 "strings"
 "time"
 
 "github.com/afex/hystrix-go/hystrix"
)

var (
 servicePort = flag.Int("port", 10086, "service port")
 serviceHost = flag.String("host", "localhost", "service host")
)

func main() {
 flag.Parse()
 
 // 配置熔断器
 hystrix.ConfigureCommand("string_service", hystrix.CommandConfig{
 Timeout: 1000,
 MaxConcurrentRequests: 10,
 SleepWindow: 5000,
 RequestVolumeThreshold: 5,
 ErrorPercentThreshold: 40,
 })
 
 // 模拟多次请求
 for i := 0; i < 20; i++ {
 err := hystrix.Do("string_service", func() error {
 return callService(fmt.Sprintf("请求 %d", i))
 }, func(err error) error {
 fmt.Printf("降级处理: %v\n", err)
 return nil
 })
 
 if err != nil {
 fmt.Printf("第 %d 次请求失败: %v\n", i, err)
 }
 
 time.Sleep(200 * time.Millisecond)
 }
}

func callService(msg string) error {
 url := fmt.Sprintf("http://%s:%d/echo?msg=%s", 
 *serviceHost, *servicePort, strings.TrimSpace(msg))
 
 resp, err := http.Get(url)
 if err != nil {
 return err
 }
 defer resp.Body.Close()
 
 body, _ := ioutil.ReadAll(resp.Body)
 log.Printf("响应: %s", string(body))
 return nil
}

运行示例

# 1. 启动 Consul（服务发现）
consul agent -dev

# 2. 启动多个服务实例
go run service/main.go -port 10086
go run service/main.go -port 10089

# 3. 启动客户端
go run client/main.go

# 4. 人为制造失败（例如停掉下游服务）观察熔断打开与降级日志，再恢复服务确认 Half-Open 恢复

熔断与负载均衡往往一起出现：负载均衡决定请求打到哪台实例，熔断在实例不健康时快速失败并触发降级，避免线程与连接池被拖垮。结合服务发现（Consul / K8s Endpoints）可在实例上下线时自动更新负载均衡目标。

跟我一起玩微服务网关

Thu, 26 Aug 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第9章内容过程中，动手做的小实验，涉及 Consul、go-kit、Kong、JWT、Zipkin 相关知识。

微服务网关概述

┌─────────────────────────────────────────────────────────────┐
│ 微服务网关架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ API Gateway │ │
│ ├──────────────────────────────────────────────────────┤ │
│ │ 路由转发 │ 负载均衡 │ 限流熔断 │ 认证鉴权 │ 监控日志 │ │
│ └──────────────────────────────────────────────────────┘ │
│ │ │
│ ┌──────────┬───────────┼───────────┬──────────┐ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌─────────┐┌─────────┐┌─────────┐┌─────────┐┌─────────┐ │
│ │User Svc ││Order Svc││Product ││Payment ││Search │ │
│ │ ││ ││Service ││Service ││Service │ │
│ └─────────┘└─────────┘└─────────┘└─────────┘└─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

网关核心功能

功能	说明
路由转发	根据请求路径转发到后端服务
负载均衡	多实例流量分发
限流熔断	保护后端服务
认证鉴权	JWT/Session 验证
监控日志	请求追踪和日志记录

简易网关 Go 实现

项目结构

gateway/
├── main.go # 主程序
├── proxy.go # 反向代理
├── discovery.go # 服务发现
├── limiter.go # 限流器
├── circuitbreaker.go # 熔断器
└── auth.go # 认证中间件

主程序

// gateway/main.go
package main

import (
 "flag"
 "fmt"
 "log"
 "math/rand"
 "net/http"
 "net/http/httputil"
 "os"
 "os/signal"
 "strings"
 "syscall"
 "time"
 
 "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
)

func main() {
 // 解析命令行参数
 var (
 consulHost = flag.String("consul.host", "127.0.0.1", "consul server host")
 consulPort = flag.String("consul.port", "8500", "consul server port")
 gatewayPort = flag.String("gateway.port", "9090", "gateway port")
 )
 flag.Parse()
 
 // 创建日志组件
 var logger log.Logger
 {
 logger = log.NewLogfmtLogger(os.Stderr)
 logger = log.With(logger, "ts", log.DefaultTimestampUTC)
 logger = log.With(logger, "caller", log.DefaultCaller)
 }
 
 // 创建 Consul 客户端
 consulConfig := api.DefaultConfig()
 consulConfig.Address = fmt.Sprintf("http://%s:%s", *consulHost, *consulPort)
 consulClient, err := api.NewClient(consulConfig)
 if err != nil {
 logger.Log("err", err)
 os.Exit(1)
 }
 
 // 创建处理器
 discovery := NewDiscovery(consulClient, logger)
 handler := NewProxyHandler(discovery, logger)
 
 // 创建 HTTP 服务器
 server := &http.Server{
 Addr: fmt.Sprintf(":%s", *gatewayPort),
 Handler: handler,
 }
 
 // 启动服务器
 go func() {
 logger.Log("gateway", "starting", "port", *gatewayPort)
 if err := server.ListenAndServe(); err != nil {
 logger.Log("gateway", "exit", "err", err)
 }
 }()
 
 // 优雅退出
 ch := make(chan os.Signal, 1)
 signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
 logger.Log("signal", <-ch)
 
 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 
 if err := server.Shutdown(ctx); err != nil {
 logger.Log("shutdown", err)
 }
}

服务发现

// gateway/discovery.go
package main

import (
 "context"
 "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
 "math/rand"
)

type Discovery struct {
 client consul.Client
 logger log.Logger
}

func NewDiscovery(client consul.Client, logger log.Logger) *Discovery {
 return &Discovery{
 client: client,
 logger: logger,
 }
}

// GetService 获取服务实例
func (d *Discovery) GetService(ctx context.Context, serviceName string) (*api.ServiceEntry, error) {
 entries, _, err := d.client.Health().Service(serviceName, "", true, nil)
 if err != nil {
 return nil, err
 }
 
 if len(entries) == 0 {
 return nil, fmt.Errorf("no available instances for %s", serviceName)
 }
 
 // 负载均衡：随机选择
 index := rand.Intn(len(entries))
 return &entries[index], nil
}

// GetServices 获取所有服务实例
func (d *Discovery) GetServices(ctx context.Context, serviceName string) ([]*api.ServiceEntry, error) {
 entries, _, err := d.client.Health().Service(serviceName, "", true, nil)
 if err != nil {
 return nil, err
 }
 return entries, nil
}

反向代理

// gateway/proxy.go
package main

import (
 "context"
 "fmt"
 "github.com/go-kit/kit/log"
 "net/http"
 "net/http/httputil"
 "strings"
)

type ProxyHandler struct {
 discovery *Discovery
 logger log.Logger
}

func NewProxyHandler(discovery *Discovery, logger log.Logger) *ProxyHandler {
 return &ProxyHandler{
 discovery: discovery,
 logger: logger,
 }
}

func (h *ProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // 解析请求路径：/service-name/path
 path := r.URL.Path
 parts := strings.SplitN(path, "/", 3)
 if len(parts) < 3 {
 http.Error(w, "invalid path", http.StatusBadRequest)
 return
 }
 
 serviceName := parts[1]
 targetPath := "/" + parts[2]
 
 // 获取服务实例
 instance, err := h.discovery.GetService(r.Context(), serviceName)
 if err != nil {
 h.logger.Log("service", serviceName, "err", err)
 http.Error(w, "service unavailable", http.StatusServiceUnavailable)
 return
 }
 
 // 构建代理请求
 targetURL := fmt.Sprintf("http://%s:%d%s", 
 instance.Service.Address, 
 instance.Service.Port, 
 targetPath)
 
 proxyReq, err := http.NewRequest(r.Method, targetURL, r.Body)
 if err != nil {
 http.Error(w, "proxy error", http.StatusInternalServerError)
 return
 }
 
 // 复制请求头
 for key, values := range r.Header {
 for _, value := range values {
 proxyReq.Header.Add(key, value)
 }
 }
 
 // 执行代理
 client := &http.Client{}
 resp, err := client.Do(proxyReq)
 if err != nil {
 h.logger.Log("proxy", err)
 http.Error(w, "proxy error", http.StatusBadGateway)
 return
 }
 defer resp.Body.Close()
 
 // 复制响应
 for key, values := range resp.Header {
 for _, value := range values {
 w.Header().Add(key, value)
 }
 }
 w.WriteHeader(resp.StatusCode)
 w.Write([]byte(fmt.Sprintf("Proxy to: %s", targetURL)))
}

// 反向代理实现
func newSingleHostReverseProxy(target string) *httputil.ReverseProxy {
 return httputil.NewSingleHostReverseProxy(target)
}

Kong 网关

Kong 简介

Kong 是一个云原生、可扩展、统一 API 层（API Gateway）。

Docker 部署

下面给出「单机演示」的常见步骤：创建网络 → 启动数据库 → （按所用 Kong 镜像文档执行）数据库迁移 → 启动 Kong。具体镜像名与启动参数请以你选用的 Kong 发行版 README 为准，不同主版本 CLI 与环境变量略有差异。

docker network create kong-net

docker run -d --name kong-db \
 --network kong-net \
 -p 5432:5432 \
 -e POSTGRES_USER=kong \
 -e POSTGRES_PASSWORD=kong \
 -e POSTGRES_DB=kong \
 postgres:13

# 数据库就绪后，在同一网络内执行 kong migrations bootstrap（命令随镜像而异），再启动 kong 网关与管理端口。
# 典型端口：8000（代理）、8443（HTTPS）、8001（Admin API）。正式环境请改用编排模板并开启 TLS / RBAC。

本地体验也可使用 Kong Ingress Controller（Kubernetes）或云端托管网关服务；本节重点在于：网关前面负责 TLS、路由、插件（鉴权、限流、熔断），后面的微服务仍可沿用前文自定义代理或 Istio Linkerd 等服务网格。

小结

网关层把「路由、观测、防护」收口在一处：开发阶段可用 Nginx / 手写反向代理入门，业务量上升后再引入 Kong / APISIX / Envoy 等平台化能力。

GO与Websocket

Sun, 25 Jul 2021 00:00:00 +0000

本文介绍 WebSocket 协议的原理，以及如何使用 Go 语言实现 WebSocket 实时通信功能。

解决什么问题

WebSocket 是 HTML5 下一种新的协议。它实现了浏览器与服务器全双工通信，能更好的节省服务器资源和带宽并达到实时通讯的目的。

WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

现在，很多网站为了实现推送技术，所用的技术都是 Ajax 轮询。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出 HTTP 请求，然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向服务器发出请求，然而 HTTP 请求可能包含较长的头部，其中真正有效的数据可能只是很小的一部分，显然这样会浪费很多的带宽等资源。

HTML5 定义的 WebSocket 协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。

WebSocket 与 TCP、HTTP 的关系

WebSocket 与 HTTP 协议一样都是基于 TCP 的，所以他们都是可靠的协议。WebSocket 和 HTTP 协议一样都属于应用层的协议，WebSocket 在建立握手连接时，数据是通过 HTTP 协议传输的，但是在建立连接之后，真正的数据传输阶段是不需要 HTTP 协议参与的。

┌─────────────────────────────────────────────────────────┐
│ 应用层 │
│ ┌─────────────┐ ┌─────────────┐ │
│ │ HTTP │ │ WebSocket │ │
│ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │
│ ┌──────▼──────┐ ┌──────▼──────┐ │
│ │ TLS/SSL │ │ TLS │ │
│ └──────┬──────┘ └──────┬──────┘ │
│ │ │ │
│ ┌──────▼────────────────────────────▼──────┐ │
│ │ TCP │ │
│ └─────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

分层架构

┌────────────────────────────────────────┐
│ WebSocket 协议 │
│ ├── 握手层（HTTP Upgrade） │
│ ├── 帧解析层（Frame Parsing） │
│ └── 数据传输层（Message Handling） │
├────────────────────────────────────────┤
│ Go 标准库 / Gorilla │
│ ├── gorilla/websocket │
│ └── golang.org/x/net/websocket │
└────────────────────────────────────────┘

了解 Socket 原理

WebSocket 握手过程

客户端发送握手请求

GET /ws HTTP/1.1
Host: localhost:8080
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

服务器响应握手

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

握手完成后开始双向通信

Go 中使用 gorilla/websocket

package main

import (
 "fmt"
 "log"
 "net/http"
 "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
 ReadBufferSize: 1024,
 WriteBufferSize: 1024,
 CheckOrigin: func(r *http.Request) bool {
 return true // 生产环境应做 origin 检查
 },
}

func wsHandler(w http.ResponseWriter, r *http.Request) {
 // 升级 HTTP 连接为 WebSocket
 conn, err := upgrader.Upgrade(w, r, nil)
 if err != nil {
 log.Println("upgrade failed:", err)
 return
 }
 defer conn.Close()

 // 读取消息
 for {
 messageType, msg, err := conn.ReadMessage()
 if err != nil {
 log.Println("read failed:", err)
 break
 }
 log.Printf("received: %s", msg)

 // 发送消息
 err = conn.WriteMessage(messageType, msg)
 if err != nil {
 log.Println("write failed:", err)
 break
 }
 }
}

func main() {
 http.HandleFunc("/ws", wsHandler)
 fmt.Println("WebSocket server started at :8080")
 log.Fatal(http.ListenAndServe(":8080", nil))
}

最基本的 Demo

前端代码

<!DOCTYPE html>
<html>
<head>
 <title>WebSocket Demo</title>
</head>
<body>
 <h2>WebSocket Client</h2>
 <input type="text" id="message" placeholder="输入消息">
 <button onclick="sendMessage()">发送</button>
 <div id="output"></div>

 <script>
 const ws = new WebSocket("ws://localhost:8080/ws");

 ws.onopen = () => {
 console.log("Connected to WebSocket");
 addMessage("已连接服务器");
 };

 ws.onmessage = (event) => {
 addMessage("收到: " + event.data);
 };

 ws.onclose = () => {
 addMessage("连接已关闭");
 };

 function sendMessage() {
 const msg = document.getElementById("message").value;
 ws.send(msg);
 addMessage("发送: " + msg);
 }

 function addMessage(msg) {
 document.getElementById("output").innerHTML += 
 "<p>" + msg + "</p>";
 }
 </script>
</body>
</html>

运行步骤

# 1. 安装依赖
go get github.com/gorilla/websocket

# 2. 运行服务器
go run server.go

# 3. 浏览器打开 index.html

功能升级你需要了解的

1. 心跳机制

保持连接活跃，防止被中间设备断开：

// 心跳 Ping-Pong
type Hub struct {
 clients map[*websocket.Conn]bool
 broadcast chan []byte
 register chan *websocket.Conn
 unregister chan *websocket.Conn
}

func (h *Hub) readPump(conn *websocket.Conn) {
 defer func() {
 h.unregister <- conn
 conn.Close()
 }()
 
 conn.SetReadDeadline(time.Now().Add(60 * time.Second))
 conn.SetPongHandler(func(string) error {
 conn.SetReadDeadline(time.Now().Add(60 * time.Second))
 return nil
 })
 
 for {
 _, msg, err := conn.ReadMessage()
 if err != nil {
 break
 }
 h.broadcast <- msg
 }
}

func (h *Hub) writePump(conn *websocket.Conn) {
 ticker := time.NewTicker(30 * time.Second)
 defer func() {
 ticker.Stop()
 conn.Close()
 }()
 
 for {
 select {
 case <-ticker.C:
 conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
 if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
 return
 }
 }
 }
}

2. 断线重连

function connect() {
 ws = new WebSocket("ws://localhost:8080/ws");
 
 ws.onclose = () => {
 console.log("Connection closed, reconnecting...");
 setTimeout(connect, 3000); // 3秒后重连
 };
}

3. 消息类型

// 文本消息
websocket.TextMessage

// 二进制消息
websocket.BinaryMessage

// Ping 消息
websocket.PingMessage

// Pong 消息
websocket.PongMessage

// 关闭消息
websocket.CloseMessage

总结

WebSocket 实现了真正的全双工通信
基于 HTTP 握手协议建立连接
Go 语言通过 gorilla/websocket 库可以轻松实现 WebSocket 服务
生产环境需要考虑：心跳机制、断线重连、安全认证等

参考资料

微服务配置中心小实验

Sun, 25 Jul 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第8章内容过程中，动手做的小实验，涉及 Spring Cloud Config 和 YAML 相关知识。

配置中心概念

┌─────────────────────────────────────────────────────────────┐
│ 配置中心架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ │
│ │ 配置中心 │ │
│ │ Config Server│◀──── Git/SVN/Nacos │
│ └──────┬───────┘ │
│ │ │
│ │ 拉取/推送 │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ 微服务集群 │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐│ │
│ │ │Service A│ │Service B│ │Service C││ │
│ │ └─────────┘ └─────────┘ └─────────┘│ │
│ └─────────────────────────────────────────┘ │
│ │
│ 特性： │
│ • 配置集中管理 │
│ • 配置热更新 │
│ • 环境隔离（dev/staging/prod） │
│ • 版本控制 │
│ │
└─────────────────────────────────────────────────────────────┘

Spring Cloud Config 简介

Spring Cloud Config 为分布式系统的外部配置提供了服务端和客户端支持。

核心特性

特性	说明
配置集中管理	所有配置存储在 Git 仓库
环境隔离	dev、test、prod 环境分离
配置加密	支持敏感配置加密存储
动态刷新	无需重启即可更新配置
高可用	支持集群部署

准备 Spring Boot 环境

macOS 安装

# 使用 Homebrew 安装
brew tap spring-io/tap
brew install spring-boot

# 或安装 Spring CLI
brew install springboot

快速开始

创建 app.groovy：

@RestController
class ThisWillActuallyRun {
 @RequestMapping("/")
 String home() {
 "Hello World!"
 }
}

运行：

spring run app.groovy

创建配置中心服务端

项目结构

config-server/
├── pom.xml
├── src/main/java/com/example/configserver/
│ └── ConfigServerApplication.java
└── config/
 └── application.yml

Maven 依赖 (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 
 <parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.5.2</version>
 </parent>
 
 <dependencies>
 <!-- Spring Cloud Config Server -->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-config-server</artifactId>
 </dependency>
 
 <!-- Eureka 服务发现（可选）-->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
 </dependency>
 </dependencies>
 
 <dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>2020.0.2</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
 </dependencyManagement>
</project>

启动类

@SpringBootApplication
@EnableConfigServer
public class ConfigServerApplication {
 public static void main(String[] args) {
 SpringApplication.run(ConfigServerApplication.class, args);
 }
}

配置文件

# application.yml
server:
 port: 8888

spring:
 application:
 name: config-server
 cloud:
 config:
 server:
 git:
 uri: https://github.com/your-org/config-repo
 search-paths: config/{application}
 username: your-github-username
 default-label: main

配置仓库结构

config-repo/
├── config/
│ ├── user-service/
│ │ ├── application.yml # 默认配置
│ │ ├── application-dev.yml # 开发环境
│ │ ├── application-test.yml # 测试环境
│ │ └── application-prod.yml # 生产环境
│ └── order-service/
│ └── application.yml
└── README.md

示例配置

# user-service/application.yml
server:
 port: ${PORT:8080}

spring:
 application:
 name: user-service
 datasource:
 url: jdbc:mysql://localhost:3306/user_db
 username: root
 password: ${DB_PASSWORD}
 redis:
 host: ${REDIS_HOST:localhost}
 port: ${REDIS_PORT:6379}

# 用户服务配置
user:
 cache:
 ttl: 3600
 max-size: 1000
 rate-limit:
 qps: 100

# user-service/application-dev.yml
spring:
 datasource:
 url: jdbc:mysql://localhost:3306/user_db_dev
 password: dev_password
 redis:
 host: localhost

user:
 rate-limit:
 qps: 10 # 开发环境限流放宽

Go 客户端接入

安装依赖

go get github.com/spf13/viper
go get github.com/go-laoji/go-config

Viper 配置

// config/config.go
package config

import (
 "fmt"
 "github.com/spf13/viper"
)

type Config struct {
 App AppConfig `mapstructure:"app"`
 Database DatabaseConfig `mapstructure:"database"`
 Redis RedisConfig `mapstructure:"redis"`
 User UserConfig `mapstructure:"user"`
}

type AppConfig struct {
 Name string `mapstructure:"name"`
 Port int `mapstructure:"port"`
}

type DatabaseConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Username string `mapstructure:"username"`
 Password string `mapstructure:"password"`
 Name string `mapstructure:"name"`
}

type RedisConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Password string `mapstructure:"password"`
 DB int `mapstructure:"db"`
}

type UserConfig struct {
 Cache CacheConfig `mapstructure:"cache"`
 RateLimit RateLimitConfig `mapstructure:"rate-limit"`
}

type CacheConfig struct {
 TTL int `mapstructure:"ttl"`
 MaxSize int `mapstructure:"max-size"`
}

type RateLimitConfig struct {
 QPS int `mapstructure:"qps"`
}

var GlobalConfig *Config

func LoadConfig(configServer, appName, profile string) (*Config, error) {
 v := viper.New()
 
 // 设置配置中心地址
 configURL := fmt.Sprintf("http://%s/%s/%s", configServer, appName, profile)
 v.SetConfigType("yaml")
 
 // 从配置中心获取配置
 if err := v.SafeGetConfigFile(configURL); err != nil {
 // 尝试直接读取
 v.SetConfigFile(fmt.Sprintf("config/%s.yml", profile))
 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }
 }
 
 var cfg Config
 if err := v.Unmarshal(&cfg); err != nil {
 return nil, err
 }
 
 GlobalConfig = &cfg
 return &cfg, nil
}

// 本地配置（备用）
func LoadLocalConfig() (*Config, error) {
 v := viper.New()
 
 v.SetConfigName("config")
 v.SetConfigType("yaml")
 v.AddConfigPath("./config")
 
 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }
 
 var cfg Config
 if err := v.Unmarshal(&cfg); err != nil {
 return nil, err
 }
 
 GlobalConfig = &cfg
 return &cfg, nil
}

若配置中心不可用，LoadLocalConfig() 可作为本地开发与灾备兜底；关键是保证 profile、密钥与 环境变量注入 在流水线与运行时一致。

微服务注册发现小实验

Tue, 20 Jul 2021 00:00:00 +0000

本文是个人在学习书籍《Go 语言高并发与微服务实战》第6章内容过程中，动手做的小实验，涉及 Consul 和 go-kit 相关知识。

Consul 简介

┌─────────────────────────────────────────────────────────────┐
│ Consul 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Consul │ │ Consul │ │ Consul │ │
│ │ Server │ │ Server │ │ Server │ │
│ │ (Leader)│ │(Follow) │ │(Follow) │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ └───────────┴───────────┘ │
│ │ │
│ ┌─────────┴─────────┐ │
│ │ │ │
│ ┌────▼────┐ ┌────▼────┐ │
│ │ Consul │ │ Consul │ │
│ │ Agent │ │ Agent │ │
│ │ (Node1) │ │ (Node2) │ │
│ └────┬────┘ └────┬────┘ │
│ │ │ │
│ ┌────▼────┐ ┌────▼────┐ │
│ │ Service │ │ Service │ │
│ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘

安装 Consul

下载安装

# macOS
brew install consul

# Linux
curl -fsSL https://apt.releases.hashicorp.com/gpg | sudo apt-key add -
sudo apt-add-repository "deb [arch=amd64] https://apt.releases.hashicorp.com $(lsb_release -cs) main"
sudo apt-get update && sudo apt-get install consul

# Docker
docker run -d --name=consul consul agent -dev -client=0.0.0.0

验证安装

consul --version
# Consul v1.10.0

Consul 基本操作

单机启动

# 开发模式启动
consul agent -dev

# 访问 UI
# http://127.0.0.1:8500/ui

集群启动

# 机器 1：主节点
consul agent -server \n -bootstrap-expect=1 \n -data-dir=/tmp/consul \n -node=consul-server-1 \n -bind=10.0.0.52 \n -ui

# 机器 2：加入集群
consul agent \n -data-dir=/tmp/consul \n -node=consul-server-2 \n -bind=10.0.0.53

# 在机器 2 执行加入
consul join 10.0.0.52

注册服务

# 注册服务（通过 HTTP API）
curl -X PUT -d '{
 "ID": "user-service-1",
 "Name": "user-service",
 "Tags": ["v1", "go"],
 "Address": "127.0.0.1",
 "Port": 8080,
 "Check": {
 "HTTP": "http://127.0.0.1:8080/health",
 "Interval": "10s",
 "Timeout": "5s"
 }
}' http://127.0.0.1:8500/v1/agent/service/register

# 注销服务
curl -X PUT http://127.0.0.1:8500/v1/agent/service/deregister/user-service-1

服务发现

# 查找服务
curl http://127.0.0.1:8500/v1/catalog/service/user-service

# DNS 查询
# user-service.service.consul

# 健康检查
curl http://127.0.0.1:8500/v1/health/service/user-service?passing=true

Go 微服务注册发现

项目结构

consul-demo/
├── main.go # 主程序
├── user/ # 用户服务
│ └── user.go
├── discovery/ # 服务发现封装
│ └── consul.go
└── go.mod

安装依赖

go get github.com/go-kit/kit/sd/consul
go get github.com/hashicorp/consul

Consul 客户端封装

// discovery/consul.go
package discovery

import (
 "fmt"
 "time"
 
 "github.com/go-kit/kit/sd"
 "github.com/go-kit/kit/sd/consul"
 "github.com/go-kit/kit/sd/lazy"
 "github.com/go-kit/kit/endpoint"
 "github.com/hashicorp/consul/api"
)

type Client struct {
 client consul.Client
 instancer *consul.Instancer
}

func NewConsulClient(consulAddr string) (*Client, error) {
 // 创建 Consul 客户端
 config := api.DefaultConfig()
 config.Address = consulAddr
 
 consulClient, err := api.NewClient(config)
 if err != nil {
 return nil, err
 }
 
 // 创建服务注册实例化工具
 client, err := consul.NewClient(consulClient)
 if err != nil {
 return nil, err
 }
 
 return &Client{client: client}, nil
}

// 注册服务
func (c *Client) Register(serviceName, serviceID string, addr string, port int) error {
 // 健康检查
 check := api.AgentServiceCheck{
 HTTP: fmt.Sprintf("http://%s:%d/health", addr, port),
 Interval: "10s",
 Timeout: "5s",
 Notes: "Health check for " + serviceName,
 }
 
 // 服务注册信息
 registration := api.AgentServiceRegistration{
 ID: serviceID,
 Name: serviceName,
 Tags: []string{"v1"},
 Address: addr,
 Port: port,
 EnableTagOverride: false,
 Check: &check,
 }
 
 return c.client.Register(&registration)
}

// 注销服务
func (c *Client) Deregister(serviceName, serviceID string) error {
 return c.client.Deregister(&api.AgentServiceRegistration{
 ID: serviceID,
 Name: serviceName,
 })
}

// 创建服务实例化工具
func (c *Client) GetInstancer(serviceName string) sd.Instancer {
 return consul.NewInstancer(c.client, nil, serviceName, []string{}, true)
}

// 工厂函数创建 endpoint
func instanceFactory(serviceURL string) endpoint.Endpoint {
 return func(ctx context.Context, request interface{}) (interface{}, error) {
 // 调用远程服务
 return nil, nil
 }
}

// 创建端点订阅器
func (c *Client) GetEndpointer(serviceName string) sd.Endpointer {
 instancer := c.GetInstancer(serviceName)
 return lazy.NewEndpointer(instancer, instanceFactory, nil)
}

服务端实现

// user/server.go（演示：注册到 Consul + 提供 /health）
package main

import (
 "context"
 "encoding/json"
 "fmt"
 stdlog "log"
 "net"
 "net/http"
 "os"
 "os/signal"
 "syscall"
 "time"

 kitlog "github.com/go-kit/kit/log"
 "github.com/hashicorp/consul/api"
)

const (
 ServiceName = "user-service"
 ServicePort = 8080
)

type UserService struct{}

func (s *UserService) GetUser(ctx context.Context, id int64) (*User, error) {
 return &User{
 ID: id,
 Name: fmt.Sprintf("User-%d", id),
 Age: 20 + int(id%30),
 }, nil
}

type User struct {
 ID int64 `json:"id"`
 Name string `json:"name"`
 Age int `json:"age"`
}

func pickAdvertiseIP() string {
 addrs, err := net.InterfaceAddrs()
 if err != nil {
 return "127.0.0.1"
 }
 for _, a := range addrs {
 ipnet, ok := a.(*net.IPNet)
 if !ok || ipnet.IP.IsLoopback() {
 continue
 }
 if v4 := ipnet.IP.To4(); v4 != nil {
 return v4.String()
 }
 }
 return "127.0.0.1"
}

func main() {
 logger := kitlog.NewLogfmtLogger(os.Stderr)
 logger = kitlog.With(logger, "ts", kitlog.DefaultTimestampUTC)

 cfg := api.DefaultConfig()
 cfg.Address = "127.0.0.1:8500"

 client, err := api.NewClient(cfg)
 if err != nil {
 stdlog.Fatalf("consul client: %v", err)
 }

 addr := pickAdvertiseIP()
 serviceID := fmt.Sprintf("%s-%d", ServiceName, ServicePort)

 reg := &api.AgentServiceRegistration{
 ID: serviceID,
 Name: ServiceName,
 Address: addr,
 Port: ServicePort,
 Check: &api.AgentServiceCheck{
 HTTP: fmt.Sprintf("http://%s:%d/health", addr, ServicePort),
 Interval: "10s",
 },
 }

 if err := client.Agent().ServiceRegister(reg); err != nil {
 stdlog.Fatalf("register: %v", err)
 }

 svc := &UserService{}
 mux := http.NewServeMux()
 mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
 w.WriteHeader(http.StatusOK)
 _, _ = w.Write([]byte("ok"))
 })
 mux.HandleFunc("/user/", func(w http.ResponseWriter, r *http.Request) {
 u, err := svc.GetUser(r.Context(), 1)
 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }
 w.Header().Set("Content-Type", "application/json")
 _ = json.NewEncoder(w).Encode(u)
 })

 srv := &http.Server{
 Addr: fmt.Sprintf(":%d", ServicePort),
 Handler: mux,
 }

 go func() {
 _ = logger.Log("msg", "listening", "port", ServicePort)
 if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 stdlog.Fatal(err)
 }
 }()

 quit := make(chan os.Signal, 1)
 signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
 <-quit

 ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 defer cancel()
 _ = srv.Shutdown(ctx)
 _ = client.Agent().ServiceDeregister(serviceID)
}

进程退出前注销服务，可避免 Consul 里留下僵尸实例；生产环境还需配置正确的 健康检查 URL、ACL Token 与 多实例 ID。

GRPC一点通

Sat, 17 Jul 2021 00:00:00 +0000

gRPC 是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。带来双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特性。

什么是 gRPC

┌─────────────────────────────────────────────────────────────┐
│ gRPC 架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ Client Server │
│ │ │ │
│ │ ─────── HTTP/2 ───────────▶ │ │
│ │ Protobuf 序列化 │ │
│ │ │ │
│ │◀─────── Protobuf ───────────│ │
│ │ │ │
│ │
│ 特性： │
│ • HTTP/2 传输 │
│ • Protobuf 序列化 │
│ • 多语言支持 │
│ • 双向流 │
│ • 强类型定义 │
│ │
└─────────────────────────────────────────────────────────────┘

环境准备

安装 Protobuf 编译器

# macOS
brew install protobuf

# Linux
apt install protobuf-compiler

# Windows
# 下载 https://github.com/protocolbuffers/protobuf/releases

安装 Go 工具

# gRPC 核心库
go get -u google.golang.org/grpc

# Protobuf 插件
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# gRPC Gateway（HTTP 转 gRPC）
go install github.com/grpc-ecosystem/grpc-gateway/v2/cmd/protoc-gen-grpc-gateway@latest

# 添加到 PATH
export PATH="$PATH:$(go env GOPATH)/bin"

定义服务

创建项目

mkdir grpc-demo && cd grpc-demo
go mod init grpc-demo
mkdir helloworld

编写 Proto 文件

// helloworld/simple.proto
syntax = "proto3";

option go_package = "grpc-demo/helloworld";

package helloworld;

// Greeting 服务定义
service Greeter {
 // 简单 RPC
 rpc SayHello (HelloRequest) returns (HelloReply) {}
 
 // 服务端流式 RPC
 rpc SayHelloServerStream (HelloRequest) returns (stream HelloReply) {}
 
 // 客户端流式 RPC
 rpc SayHelloClientStream (stream HelloRequest) returns (HelloReply) {}
 
 // 双向流式 RPC
 rpc SayHelloBidirectionalStream (stream HelloRequest) returns (stream HelloReply) {}
}

// 请求消息
message HelloRequest {
 string name = 1;
 int32 age = 2;
}

// 响应消息
message HelloReply {
 string message = 1;
 string timestamp = 2;
}

生成 Go 代码

# 生成 gRPC 代码
protoc --go_out=. --go_opt=paths=source_relative \n --go-grpc_out=. --go-grpc_opt=paths=source_relative \n helloworld/simple.proto

# 查看生成的文件
ls -la helloworld/
# simple.pb.go - Protobuf 消息定义
# simple_grpc.pb.go - gRPC 服务定义

实现 gRPC 服务

// helloworld/server.go
package main

import (
 "context"
 "fmt"
 "log"
 "net"
 
 "google.golang.org/grpc"
 pb "grpc-demo/helloworld"
)

type server struct {
 pb.UnimplementedGreeterServer
}

// 简单 RPC 实现
func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
 return &pb.HelloReply{
 Message: fmt.Sprintf("Hello, %s! You are %d years old.", req.Name, req.Age),
 Timestamp: fmt.Sprintf("%d", time.Now().Unix()),
 }, nil
}

// 服务端流式 RPC 实现
func (s *server) SayHelloServerStream(req *pb.HelloRequest, stream pb.Greeter_SayHelloServerStreamServer) error {
 for i := 0; i < 5; i++ {
 msg := fmt.Sprintf("Hello %s (stream %d)", req.Name, i+1)
 if err := stream.Send(&pb.HelloReply{Message: msg}); err != nil {
 return err
 }
 time.Sleep(500 * time.Millisecond)
 }
 return nil
}

// 客户端流式 RPC 实现
func (s *server) SayHelloClientStream(stream pb.Greeter_SayHelloClientStreamServer) error {
 var names []string
 for {
 req, err := stream.Recv()
 if err == io.EOF {
 return stream.SendAndClose(&pb.HelloReply{
 Message: fmt.Sprintf("Hello %v!", names),
 })
 }
 if err != nil {
 return err
 }
 names = append(names, req.Name)
 }
}

// 双向流式 RPC 实现
func (s *server) SayHelloBidirectionalStream(stream pb.Greeter_SayHelloBidirectionalStreamServer) error {
 for {
 req, err := stream.Recv()
 if err == io.EOF {
 return nil
 }
 if err != nil {
 return err
 }
 
 msg := fmt.Sprintf("Hello %s!", req.Name)
 if err := stream.Send(&pb.HelloReply{Message: msg}); err != nil {
 return err
 }
 }
}

func main() {
 lis, err := net.Listen("tcp", ":50051")
 if err != nil {
 log.Fatalf("failed to listen: %v", err)
 }
 
 s := grpc.NewServer()
 pb.RegisterGreeterServer(s, &server{})
 
 log.Println("gRPC server started on :50051")
 if err := s.Serve(lis); err != nil {
 log.Fatalf("failed to serve: %v", err)
 }
}

实现 gRPC 客户端

// helloworld/client.go
package main

import (
 "context"
 "fmt"
 "log"
 "time"
 
 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials/insecure"
 pb "grpc-demo/helloworld"
)

func main() {
 // 连接 gRPC 服务器
 conn, err := grpc.Dial(":50051", grpc.WithTransportCredentials(insecure.NewCredentials()))
 if err != nil {
 log.Fatalf("did not connect: %v", err)
 }
 defer conn.Close()
 
 client := pb.NewGreeterClient(conn)
 
 // 调用简单 RPC
 ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 defer cancel()
 
 r, err := client.SayHello(ctx, &pb.HelloRequest{Name: "World", Age: 25})
 if err != nil {
 log.Fatalf("could not greet: %v", err)
 }
 log.Printf("Greeting: %s", r.GetMessage())
}

添加 HTTP Gateway

安装依赖

go get google.golang.org/grpc/proto

Gateway 服务

// gateway/main.go
package main

import (
 "context"
 "fmt"
 "net/http"
 
 "github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
 "google.golang.org/grpc"
 "google.golang.org/grpc/credentials/insecure"
 pb "grpc-demo/helloworld"
)

func main() {
 ctx := context.Background()
 ctx, cancel := context.WithCancel(ctx)
 defer cancel()
 
 mux := runtime.NewServeMux()
 opts := []grpc.DialOption{
 grpc.WithTransportCredentials(insecure.NewCredentials()),
 }
 
 err := pb.RegisterGreeterHandlerFromEndpoint(ctx, mux, ":50051", opts)
 if err != nil {
 log.Fatalf("failed to register gateway: %v", err)
 }
 
 http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
 mux.ServeHTTP(w, r)
 })
 
 log.Println("HTTP Gateway started on :8080")
 http.ListenAndServe(":8080", nil)
}

启动服务

# 终端 1: 启动 gRPC 服务
go run helloworld/server.go

# 终端 2: 启动 HTTP Gateway
go run gateway/main.go

# 测试 HTTP 接口
curl -X POST http://localhost:8080/helloworld.Greeter/SayHello \n -H "Content-Type: application/json" \n -d '{"name": "World", "age": 25}'

四种 RPC 模式

模式	说明
Unary（一元）	客户端发起一次请求，服务端返回一次响应；最常见，类似普通 HTTP JSON。
Server streaming（服务端流）	客户端一次请求，服务端以流多次推送数据；适合大列表、订阅通知。
Client streaming（客户端流）	客户端多次写入流，服务端最终一次汇总响应；适合批量上传、日志汇总。
Bidirectional streaming（双向流）	两端可同时读写流；适合聊天、协作编辑、实时推送等对「管道」建模的场景。

选型上：能用 Unary 就不用流式；若业务本身是「按需拉取一块块数据」，优先考虑 Server streaming；必须在单连接上交织多条请求/响应时（如 HTTP/2 多路复用语义），再结合双向流评估。

小结

掌握四种模式后，阅读 .proto 里的 rpc 定义会更直观：stream 关键字出现在请求侧、响应侧或两侧，分别对应上述三种流式形态。

《Go语言编程》☞鉴赏

Thu, 03 Dec 2020 00:00:00 +0000

在读这本书之前，我已经熟悉了Go的语法，并编码实现了具体的应用。但这本书据说详细解读了Go语言的诞生背景和作者的设计初衷&理念，所以，带着好奇的心态读了这本书，顺带查缺补漏。

前言

Go语言官方自称，之所以开发Go 语言，是因为“近10年来开发程序之难让我们有点沮丧”。
这一定位暗示了Go语言希望取代C和Java的地位，成为最流行的通用开发语言。

Go希望成为互联网时代的C语言。多数系统级语言（包括Java和C#）的根本编程哲学来源于C++，将C++的面向对象进一步发扬光大。但是Go语言的设计者却有不同的看法，他们认为C++ 真的没啥好学的，值得学习的是C语言。

C语言经久不衰的根源是它足够简单。因此，Go语言也要足够简单！

如果一个特性并不对解决任何问题有显著的价值，那么Go就不提供它

并发与分布式

多核化和集群化是互联网时代的典型特征，那语言需要哪些特性来应对这些特征呢？

并发执行的“执行体”
执行体是个抽象的概念，在操作系统层面有多个概念与之对应，比如操作系统自己掌管的进程（process）、进程内的线程（thread）以及进程内的协程（coroutine，也叫轻量级线程）。

多数语言在语法层面并不直接支持协程，而通过库的方式支持的协程的功能也并不完整，比如仅仅提供协程的创建、销毁与切换等能力。如果在这样的协程中调用一个同步IO操作，比如网络通信、本地文件读写，都会阻塞其他的并发执行协程，从而无法真正达到协程本身期望达到的目标。

Go语言在语言级别支持协程，叫goroutine。Go语言标准库提供的所有系统调用（syscall）操作，当然也包括所有同步IO操作，都会出让CPU给其他goroutine，这让事情变得非常简单。我们对比一下Java和Go，近距离观摩下两者对“执行体”的支持。

为了简化，我们在样例中使用的是Java标准库中的线程，而不是协程，具体代码如下：

public class MyThread implements Runnable { 
 	String arg; 
	public MyThread(String a) { 
 		arg = a; 
 	} 
	public void run() { 
 		// ... 
 	} 
	public static void main(String[] args) { 
		new Thread(new MyThread("test")).start(); 
 		// ... 
 	}
}

相同功能的代码，在Go语言中是这样的：

func run(arg string) { 
 	// ... 
} 
func main() { 
	go run("test") 
 	... 
}

对比非常鲜明。我相信你已经明白为什么Go语言会叫Go语言了：Go语言献给这个时代最好的礼物，就是加了go这个关键字。

“执行体间的通信”
执行体间的通信包含几个方式：

执行体之间的互斥与同步
- 当执行体之间存在共享资源（一般是共享内存）时，为保证内存访问逻辑的确定性，需要对访问该共享资源的相关执行体进行互斥。当多个执行体之间的逻辑存在时序上的依赖时，也往往需要在执行体之间进行同步。
- 互斥与同步是执行体间最基础的交互方式。
- 多数语言在库层面提供了线程间的互斥与同步支持，那么协程之间的互斥与同步呢？
  - 呃，不好意思，没有。
执行体之间的消息传递
- 在并发编程模型的选择上，有两个流派，一个是共享内存模型，一个是消息传递模型。
- 多数传统语言选择了前者，少数语言选择后者，其中选择“消息传递模型”的最典型代表是Erlang语言。业界有专门的术语叫“Erlang风格的并发模型”，其主体思想是两点：一是“轻量级的进程（Erlang中‘进程’这个术语就是我们上面说的‘执行体’）”，二是“消息乃进程间通信的唯一方式”。
- Go语言推荐采用“Erlang风格的并发模型”的编程范式，尽管传统的“共享内存模型”仍然被保留，允许适度地使用。在Go语言中内置了消息队列的支持，只不过它叫通道（channel）。两个goroutine之间可以通过通道来进行交互。

软件工程

单机时代的语言可以只关心问题本身的解决，但是随着工程规模的不断扩大，软件复杂度的不断增加，软件工程也成为语言设计层面要考虑的重要课题。

多数软件需要一个团队共同去完成，在团队协作的过程中，人们需要建立统一的交互语言来降低沟通的成本。规范化体现在多个层面，如：

代码风格规范
错误处理规范
包管理
契约规范（接口）
单元测试规范
功能开发的流程规范

Go语言很可能是第一个将代码风格强制统一的语言，例如Go语言要求public的变量必须以大写字母开头，private变量则以小写字母开头，这种做法不仅免除了public、private关键字，更重要的是统一了命名风格。

另外，Go语言对{ }应该怎么写进行了强制，比如以下风格是正确的：

if expression { 
 ... 
}

但下面这个写法就是错误的：

if expression 
{ 
 ... 
}

而C和Java语言中则对花括号的位置没有任何要求。哪种更有利，这个见仁见智。但很显然的是，所有的Go代码的花括号位置肯定是非常统一的。

最有意思的其实还是 Go 语言首创的错误处理规范：

f, err := os.Open(filename) 
if err != nil { 
 	log.Println("Open file failed:", err) 
 	return 
} 
defer f.Close() 
... // 操作已经打开的f文件

defer语句的含义是不管程序是否出现异常，均在函数退出时自动执行相关代码。
Go语言的函数允许返回多个值。

大多数函数的最后一个返回值会为error类型，以在错误情况下返回详细信息。
error类型只是一个系统内置的interface，如下：

type error interface { 
 	Error() string
}

有了error类型，程序出现错误的逻辑看起来就相当统一。

在Java中，你可能这样写代码来保证资源正确释放：

try { 
 	Statement stmt = ...; 
	try { 
 		ResultSet rset = ...; 
		try { 
 			... // 正常代码
 		} 
		finally { 
 			rset.close(); 
 		} 
 	} 
	finally { 
 		stmt.close(); 
 	} 
} 
finally { 
conn.close(); 
}

完成同样的功能，相应的Go代码只需要写成这样：

conn := ... 
defer conn.Close() 
stmt := ... 
defer stmt.Close() 
rset := ... 
defer rset.Close() 
... // 正常代码

对比两段代码，Go语言处理错误的优势显而易见。当然，其实Go语言带给我们的惊喜还有很多。

编程哲学

计算机软件经历了数十年的发展，形成了多种学术流派，有面向过程编程、面向对象编程、函数式编程、面向消息编程等，这些思想究竟孰优孰劣，众说纷纭。 C语言是纯过程式的，这和它产生的历史背景有关。Java语言则是激进的面向对象主义推崇者，典型表现是它不能容忍体系里存在孤立的函数。而Go语言没有去否认任何一方，而是用批判吸收的眼光，将所有编程思想做了一次梳理，融合众家之长，但时刻警惕特性复杂化，极力维持语言特性的简洁，力求小而精。从编程范式的角度来说，Go语言是变革派，而不是改良派。对于C++、Java和C#等语言为代表的面向对象（OO）思想体系，Go语言总体来说持保守态度，有限吸收。首先，Go语言反对函数和操作符重载（overload），而C++、Java和C#都允许出现同名函数或操作符，只要它们的参数列表不同。虽然重载解决了一小部分面向对象编程（OOP）的问题，但同样给这些语言带来了极大的负担。而Go语言有着完全不同的设计哲学，既然函数重载带来了负担，并且这个特性并不对解决任何问题有显著的价值，那么Go就不提供它。其次，Go语言支持类、类成员方法、类的组合，但反对继承，反对虚函数（virtual function）和虚函数重载。确切地说，Go也提供了继承，只不过是采用了组合的文法来提供：

type Foo struct { 
 	Base 
 	... 
} 
func (foo *Foo) Bar() { 
 	... 
}

再次，Go语言也放弃了构造函数（constructor）和析构函数（destructor）。由于Go语言中没有虚函数，也就没有vptr，支持构造函数和析构函数就没有太大的价值。本着“如果一个特性并不对解决任何问题有显著的价值，那么Go就不提供它”的原则，构造函数和析构函数就这样被Go语言的作者们干掉了。在放弃了大量的OOP特性后，Go语言送上了一份非常棒的礼物：接口（interface）。你可能会说，除了C这么原始的语言外，还有什么语言没有接口呢？是的，多数语言都提供接口，但它们的接口都不同于Go语言的接口。 Go语言中的接口与其他语言最大的一点区别是它的非侵入性。在C++、Java和C#中，为了实现一个接口，你需要从该接口继承，具体代码如下：

class Foo implements IFoo { // Java文法
 	... 
} 
class Foo : public IFoo { // C++文法
 	... 
} 
IFoo* foo = new Foo; 
在Go语言中，实现类的时候无需从接口派生，具体代码如下：
type Foo struct { // Go 文法
 	... 
} 
var foo IFoo = new(Foo)

只要Foo实现了接口IFoo要求的所有方法，就实现了该接口，可以进行赋值。 Go语言的非侵入式接口，看似只是做了很小的文法调整，实则影响深远。其一，Go语言的标准库再也不需要绘制类库的继承树图。你只需要知道这个类实现了哪些方法，每个方法是啥含义就足够了。其二，不用再纠结接口需要拆得多细才合理，比如我们实现了File类，它有下面这些方法：

Read(buf []byte) (n int, err error) 
Write(buf []byte) (n int, err error) 
Seek(off int64, whence int) (pos int64, err error) 
Close() error

那么，到底是应该定义一个IFile接口，还是应该定义一系列的IReader、IWriter、 ISeeker和ICloser接口，然后让File从它们派生好呢？事实上，脱离了实际的用户场景，讨论这两个设计哪个更好并无意义。问题在于，实现File类的时候，我怎么知道外部会如何用它呢？其三，不用为了实现一个接口而专门导入一个包，而目的仅仅是引用其中的某个接口的定义。在Go语言中，只要两个接口拥有相同的方法列表，那么它们就是等同的，可以相互赋值，如对于以下两个接口，第一个接口：

package one 
type ReadWriter interface { 
 	Read(buf [] byte) (n int, err error) 
 	Write(buf [] byte) (n int, err error) 
} 
第二个接口：
package two 
type IStream interface { 
 	Write(buf [] byte) (n int, err error) 
 	Read(buf [] byte) (n int, err error) 
}

这里我们定义了两个接口，一个叫one.ReadWriter，一个叫two.IStream，两者都定义了Read()和Write()方法，只是定义的次序相反。one.ReadWriter先定义了Read()再定义 Write()，而two.IStream反之。在Go语言中，这两个接口实际上并无区别，因为：

任何实现了one.ReadWriter接口的类，均实现了two.IStream；
任何one.ReadWriter接口对象可赋值给two.IStream，反之亦然；
在任何地方使用one.ReadWriter接口，与使用two.IStream并无差异。
所以在Go语言中，为了引用另一个包中的接口而导入这个包的做法是不被推荐的。因为多引用一个外部的包，就意味着更多的耦合。除了OOP外，近年出现了一些小众的编程哲学，Go语言对这些思想亦有所吸收。例如，Go 语言接受了函数式编程的一些想法，支持匿名函数与闭包。再如，Go语言接受了以Erlang语言为代表的面向消息编程思想，支持goroutine和通道，并推荐使用消息而不是共享内存来进行并发编程。总体来说，Go语言是一个非常现代化的语言，精小但非常强大。

Go语言特性

Go语言作为一门全新的静态类型开发语言，与当前的开发语言相比具备众多令人兴奋不已的新特性。

自动垃圾回收

我们可以先看下不支持垃圾回收的语言的资源管理方式，以下为一小段C语言代码：

void foo() 
{ 
 	char* p = new char[128]; 
 	... // 对p指向的内存块进行赋值
 	func1(p); // 使用内存指针
 	delete[] p; 
}

各种非预期的原因，比如由于开发者的疏忽导致最后的delete语句没有被调用，都会引发经典而恼人的内存泄露问题。
假如该函数被调用得非常频繁，那么我们观察该进程执行时，会发现该进程所占用的内存会一直疯长，直至占用所有系统内存并导致程序崩溃，而如果泄露的是系统资源的话，那么后果还会更加严重，最终很有可能导致系统崩溃。

如果使用Go语言实现，我们就完全不用考虑何时需要释放之前分配的内存的问题，系统会自动帮我们判断，并在合适的时候（比如CPU相对空闲的时候）进行自动垃圾收集工作。

更丰富的内置类型

支持几乎所有语言都支持的简单内置类型（比如整型和浮点型等）
Go语言也内置了一些比较新的语言中内置的高级类型，比如C#和Java中的数组和字符串。
除此之外，Go语言还内置了一个对于其他静态类型语言通常用库方式支持的字典类型（map）。
另外有一个新增的数据类型：数组切片（Slice）。我们可以认为数组切片是一种可动态增长的数组。

这几种数据结构基本上覆盖了绝大部分的应用场景。

函数多返回值

目前的主流语言中除Python外基本都不支持函数的多返回值功能，不是没有这类需求，可能是语言设计者没有想好该如何提供这个功能，或者认为这个功能会影响语言的美感。

Go语言革命性地在静态开发语言阵营中率先提供了多返回值功能。
这个特性让开发者可以从原来用各种比较别扭的方式返回多个值的痛苦中解脱出来，既不用再区分参数列表中哪几个用于输入，哪几个用于输出，也不用再只为了返回多个值而专门定义一个数据结构。

例如：

func getName()(firstName, middleName, lastName, nickName string){ 
	return "May", "M", "Chen", "Babe" 
}

因为返回值都已经有名字，因此各个返回值也可以用如下方式来在不同的位置进行赋值，从而提供了极大的灵活性：

func getName()(firstName, middleName, lastName, nickName string){ 
 	firstName = "May" 
 	middleName = "M" 
 	lastName = "Chen" 
 	nickName = "Babe" 
	return 
}

并不是每一个返回值都必须赋值，没有被明确赋值的返回值将保持默认的空值。而函数的调用相比C/C++语言要简化很多：

fn, mn, ln, nn := getName()

如果开发者只对该函数其中的某几个返回值感兴趣的话，也可以直接用下划线作为占位符来忽略其他不关心的返回值。下面的调用表示调用者只希望接收lastName的值，这样可以避免声明完全没用的变量：

_, _, lastName, _ := getName()

错误处理

Go语言引入了3个关键字用于标准的错误处理流程，这3个关键字分别为defer、panic和recover。

整体上而言与C++和Java等语言中的异常捕获机制相比，Go语言的错误处理机制可以大量减少代码量，让开发者也无需仅仅为了程序安全性而添加大量一层套一层的try-catch语句，这对于代码的阅读者和维护者来说也是一件很好的事情。

匿名函数和闭包

Go语言支持常规的匿名函数和闭包，比如下列代码就定义了一个名为f的匿名函数，开发者可以随意对该匿名函数变量进行传递和调用：

f := func(x, y int) int { 
	return x + y 
}

类型和接口

Go语言的类型定义非常接近于C语言中的结构（struct），甚至直接沿用了struct关键字。相比而言，Go语言并没有直接沿袭C++和Java的传统去设计一个超级复杂的类型系统，不支持继承和重载，而只是支持了最基本的类型组合功能。

巧妙的是，虽然看起来支持的功能过于简洁，细用起来你却会发现，C++和Java使用那些复杂的类型系统实现的功能在Go语言中并不会出现无法表现的情况，这反而让人反思其他语言中引入这些复杂概念的必要性。

并发编程

Go语言引入了goroutine概念，它使得并发编程变得非常简单。通过使用goroutine而不是裸用操作系统的并发机制，以及使用消息传递来共享内存而不是使用共享内存来通信，Go语言让并发编程变得更加轻盈和安全。

通过在函数调用前使用关键字go，我们即可让该函数以goroutine方式执行。goroutine是一种比线程更加轻盈、更省资源的协程。Go语言通过系统的线程来多路派遣这些函数的执行，使得每个用go关键字执行的函数可以运行成为一个单位协程。当一个协程阻塞的时候，调度器就会自动把其他协程安排到另外的线程中去执行，从而实现了程序无等待并行化运行。而且调度的开销非常小，一颗CPU调度的规模不下于每秒百万次，这使得我们能够创建大量的goroutine，从而可以很轻松地编写高并发程序，达到我们想要的目的。

下面我们用一个简单的例子来演示goroutine和channel的使用方式。这是一个并行计算的例子，由两个goroutine进行并行的累加计算，待这两个计算过程都完成后打印计算结果：

package main 

import "fmt" 

func sum(values [] int, resultChan chan int) { 
	sum := 0 
	for _, value := range values { 
		sum += value 
	} 
	resultChan <- sum // 将计算结果发送到channel中
} 

func main() { 
	values := [] int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 
	resultChan := make(chan int, 2) 
	go sum(values[:len(values)/2], resultChan) 
	go sum(values[len(values)/2:], resultChan) 
 	sum1, sum2 := <-resultChan, <-resultChan // 接收结果
 	fmt.Println("Result:", sum1, sum2, sum1 + sum2) 
}

反射

反射（reflection）是在Java语言出现后迅速流行起来的一种概念。通过反射，你可以获取对象类型的详细信息，并可动态操作对象。反射是把双刃剑，功能强大但代码可读性并不理想。若非必要，我们并不推荐使用反射。

Go语言的反射实现了反射的大部分功能，但没有像Java语言那样内置类型工厂，故而无法做到像Java那样通过类型字符串创建对象实例。在Java中，你可以读取配置并根据类型名称创建对应的类型，这是一种常见的编程手法，但在Go语言中这并不被推荐。

语言交互性

由于Go语言与C语言之间的天生联系，Go语言的设计者们自然不会忽略如何重用现有C模块的这个问题，这个功能直接被命名为Cgo。Cgo既是语言特性，同时也是一个工具的名称。

在Go代码中，可以按Cgo的特定语法混合编写C语言代码，然后Cgo工具可以将这些混合的C代码提取并生成对于C功能的调用包装代码。开发者基本上可以完全忽略这个Go语言和C语言的边界是如何跨越的。

例如：

package main 

/* 
#include <stdio.h> 
*/ 
import "C" 
import "unsafe" 

func main() { 
 	cstr := C.CString("Hello, world") 
 	C.puts(cstr) 
 	C.free(unsafe.Pointer(cstr)) 
}

常用标准库

Go标准库可以大致按其中库的功能进行以下分类，这个分类比较简单，不求准确，但求能够帮助开发者根据自己模糊的需求更快找到自己需要的包。

输入输出。
- 这个分类包括二进制以及文本格式在屏幕、键盘、文件以及其他设备上的输入输出等，比如二进制文件的读写。对应于此分类的包有bufio、fmt、io、log和flag等，其中flag用于处理命令行参数。
文本处理。
- 这个分类包括字符串和文本内容的处理，比如字符编码转换等。对应于此分类的包有encoding、bytes、strings、strconv、text、mime、unicode、regexp、index和path等。其中path用于处理路径字符串。
网络。
- 这个分类包括开发网络程序所需要的包，比如Socket编程和网站开发等。对应于此分类的包有：net、http和expvar等。
系统。
- 这个分类包含对系统功能的封装，比如对操作系统的交互以及原子性操作等。对应于此分类的包有os、syscall、sync、time和unsafe等。
数据结构与算法。
- 对应于此分类的包有math、sort、container、crypto、hash、archive、compress和image等。因为image包里提供的图像编解码都是算法，所以也归入此类。
运行时。
- 对应于此分类的包有：runtime、reflect和go等。

最后

这本书还给我们深入讲解了很多有意思的东西，只有自己用心投入去阅读和享受才能真的有所收获，其中还剖析了音乐播放器、聊天系统、网页相册等实际项目例子&核心源代码，总的来说挺不错的，有兴趣的童鞋尽管认真地去翻阅、去学习、去尝试吧。

最后，让我们引用作者的话来结束本篇鉴赏吧。

在十余年的技术生涯中，我接触过、使用过、喜爱过不同的编程语言，但总体而言，Go语
言的出现是最让我兴奋的事情。

我个人对未来10年编程语言排行榜的趋势判断如下：
❤ Java语言的份额继续下滑，并最终被C和Go语言超越；
❤ C语言将长居编程榜第二的位置，并有望在Go取代Java前重获语言榜第一的宝座；
❤ Go语言最终会取代Java，居于编程榜之首。

由七牛云存储团队编著的这本书将尽可能展现出Go语言的迷人魅力。希望本书能够让更多
人理解这门语言，热爱这门语言，让这门优秀的语言能够落到实处，把程序员从以往繁杂的语言
细节中解放出来，集中精力开发更加优秀的系统软件。

许式伟
2012年3月7日

关于我

name: yison.li
github: https://github.com/yisonli

Go依赖管理工具

Sat, 09 May 2020 00:00:00 +0000

最早的时候，Go 所依赖的所有第三方库都放在 GOPATH 目录下。随着 Go 语言的发展，从 v1.5 开始引入 vendor 模式。本文介绍两个 Golang 官方依赖管理工具。

依赖管理演进

┌─────────────────────────────────────────────────────────────┐
│ Go 依赖管理演进 │
├─────────────────────────────────────────────────────────────┤
│ │
│ GOPATH 时代 ──▶ Vendor 时代 ──▶ dep 时代 ──▶ go mod 时代 │
│ (2012) (2014) (2017) (2018) │
│ │
└─────────────────────────────────────────────────────────────┘

dep（已过时）

⚠️ 提示：dep 已停止维护，建议使用 go modules。

安装

# macOS
brew install dep

# Linux
curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh

# Windows
go get -u github.com/golang/dep/cmd/dep

常用命令

命令	说明
`dep init`	初始化项目，生成 Gopkg.toml 和 Gopkg.lock
`dep status`	查看依赖状态
`dep ensure`	确保依赖已安装
`dep ensure -add`	添加新依赖
`dep ensure -update`	更新依赖版本
`dep check`	检查导入是否同步

使用示例

# 初始化项目
dep init

# 添加依赖
dep ensure -add github.com/spf13/viper

# 更新所有依赖
dep ensure -update

# 查看状态
dep status

配置文件

# Gopkg.toml
[[constraint]]
 name = "github.com/spf13/viper"
 version = "^1.6.0"

[[constraint]]
 name = "github.com/go-sql-driver/mysql"
 version = "^1.5.0"

go modules（推荐）

go modules 是 Go 1.11 引入的官方依赖管理方案，现在已是主流。

核心概念

概念	说明
Module	相关 Go 包的集合，是版本控制的单元
go.mod	模块定义文件，记录依赖关系
go.sum	依赖校验文件，确保构建一致性
GOPROXY	依赖代理服务器，加速下载

启用方式

# Go 1.11+ 默认启用
export GO111MODULE=on # 显式启用
export GO111MODULE=off # 禁用（使用 GOPATH）
export GO111MODULE=auto # 自动检测（默认）

常用命令

命令	说明
`go mod init`	初始化模块，生成 go.mod
`go mod tidy`	整理依赖（添加缺失，移除未用）
`go mod download`	下载依赖到本地缓存
`go mod vendor`	将依赖复制到 vendor 目录
`go mod graph`	打印依赖图
`go mod verify`	验证依赖是否正确
`go mod why`	解释为什么需要某依赖

初始化项目

# 在项目目录执行
go mod init github.com/username/project

# 或指定模块名
go mod init mymodule

go.mod 示例

module github.com/username/project

go 1.21

require (
 github.com/gin-gonic/gin v1.9.1
 github.com/go-sql-driver/mysql v1.7.1
 github.com/spf13/viper v1.16.0
)

require (
 github.com/bytedance/sonic v1.9.1 // indirect
 github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
 github.com/gabriel-vasile/mimetype v1.4.2 // indirect
)

go.sum 示例

github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YIdfeAwnHoK0S2RThAQPz7AH81q6Us=
github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=

完整使用流程

1. 创建新项目

# 创建项目目录
mkdir myproject && cd myproject

# 初始化模块
go mod init github.com/username/myproject

# 创建主文件
cat > main.go << 'EOF'
package main

import (
 "fmt"
 "github.com/gin-gonic/gin"
)

func main() {
 r := gin.Default()
 r.GET("/ping", func(c *gin.Context) {
 c.JSON(200, gin.H{"message": "pong"})
 })
 r.Run()
}
EOF

# 下载依赖并整理
go mod tidy

2. 添加依赖

# 方式一：go get
go get github.com/spf13/viper

# 指定版本
go get github.com/spf13/viper@v1.16.0

# 最新版本
go get github.com/spf13/viper@latest

# 指定分支
go get github.com/spf13/viper@master

# 指定 commit
go get github.com/spf13/viper@e3861e3

# 方式二：直接编辑 go.mod
echo 'github.com/redis/go-redis/v9 v9.0.0' >> go.mod
go mod tidy

3. 升级/降级依赖

# 升级到最新版本
go get -u github.com/gin-gonic/gin

# 升级到指定版本
go get github.com/gin-gonic/gin@v1.9.0

# 清理未使用的依赖
go mod tidy

4. 使用 vendor

# 将依赖复制到 vendor 目录
go mod vendor

# 查看 vendor 内容
ls vendor/

# 使用 vendor 构建
go build -mod=vendor

代理配置

设置 GOPROXY

# 阿里云代理（推荐国内使用）
go env -w GOPROXY=https://mirrors.aliyun.com/goproxy/,direct

# 官方代理
go env -w GOPROXY=https://proxy.golang.org,direct

# 七牛云
go env -w GOPROXY=https://goproxy.cn,direct

# 多个代理（逗号分隔）
go env -w GOPROXY=https://goproxy.cn,https://proxy.golang.org,direct

代理参数

参数	说明
`direct`	直连源站
`off`	禁用代理
`=https://proxy.golang.org`	官方代理

私有模块

设置 GONOSUMDB

# 跳过校验的域名
go env -w GONOSUMDB="gitlab.com/mycompany/*"

设置 GOPRIVATE

# 私有模块不走代理
go env -w GOPRIVATE="gitlab.com/mycompany,github.com/myteam"

配置 netrc

# ~/.netrc
machine github.com
login your-username
password your-token

常见问题

Q: 依赖下载失败

# 清理缓存
go clean -modcache

# 设置国内镜像
go env -w GOPROXY=https://goproxy.cn,direct

Q: go.mod 和 go.sum 不同步

go mod tidy

Q: vendor 和 mod 冲突

# 删除 vendor，使用 go mod
rm -rf vendor
go mod tidy

Q: 循环导入

# 检查依赖图
go mod graph | grep ":"

最佳实践

始终使用 go mod tidy 保持依赖整洁
使用 vendor 确保构建可重复
使用国内镜像 加速下载
定期升级依赖 获取安全补丁
提交 go.sum 锁校验和到版本库，CI 使用 go mod verify 防止依赖被篡改。

Go深入了解sync库的锁和信号量

Tue, 15 Oct 2019 00:00:00 +0000

sync 包提供了 Go 语言的基本同步基元，如互斥锁。除了 Once 和 WaitGroup 类型，大部分都适用于低水平程序线程，高水平的同步使用 channel 通信更好。

并发与同步

Go 并发基础

package main

import (
 "fmt"
 "time"
)

func main() {
 // 创建 goroutine
 go sayHello()
 
 // 主 goroutine 继续执行
 for i := 0; i < 5; i++ {
 fmt.Println("Main:", i)
 time.Sleep(time.Millisecond * 100)
 }
}

func sayHello() {
 for i := 0; i < 5; i++ {
 fmt.Println("Hello:", i)
 time.Sleep(time.Millisecond * 100)
 }
}

同步问题

// 竞态条件示例
var counter int

func increment() {
 counter++ // 非原子操作
}

func main() {
 // 1000 个 goroutine 同时修改 counter
 for i := 0; i < 1000; i++ {
 go increment()
 }
 time.Sleep(time.Second)
 // 预期: 1000，实际可能: 900-1000 之间
 fmt.Println(counter) // 存在竞态条件！
}

sync.Mutex 互斥锁

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type Counter struct {
 mu sync.Mutex
 count int
}

func (c *Counter) Incr() {
 c.mu.Lock()
 defer c.mu.Unlock()
 c.count++
}

func (c *Counter) Value() int {
 c.mu.Lock()
 defer c.mu.Unlock()
 return c.count
}

func main() {
 var counter Counter
 
 // 1000 个 goroutine 安全递增
 for i := 0; i < 1000; i++ {
 go counter.Incr()
 }
 
 time.Sleep(time.Second)
 fmt.Println(counter.Value()) // 输出: 1000
}

注意事项

✅ 使用 defer 确保锁一定会释放
✅ 锁的粒度要尽可能小
❌ 不要在持有锁时调用用户代码
❌ 不要忘记解锁

sync.RWMutex 读写锁

适用场景

场景	锁类型	说明
读多写少	RWMutex	多个读锁可并存
写操作	Mutex	独占访问

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type SafeMap struct {
 mu sync.RWMutex
 m map[string]int
}

func (sm *SafeMap) Set(key string, value int) {
 sm.mu.Lock()
 defer sm.mu.Unlock()
 sm.m[key] = value
}

func (sm *SafeMap) Get(key string) (int, bool) {
 sm.mu.RLock() // 读锁
 defer sm.mu.RUnlock()
 val, ok := sm.m[key]
 return val, ok
}

func main() {
 sm := SafeMap{m: make(map[string]int)}
 
 // 多个读 goroutine
 for i := 0; i < 10; i++ {
 go func(id int) {
 for j := 0; j < 100; j++ {
 sm.Set(fmt.Sprintf("key-%d", j%5), j)
 }
 }(i)
 }
 
 // 一个写 goroutine
 go func() {
 for i := 0; i < 100; i++ {
 sm.Set("write", i)
 }
 }()
 
 time.Sleep(time.Second)
 
 // 读取结果
 for i := 0; i < 5; i++ {
 fmt.Printf("key-%d: %d\n", i, sm.Get(fmt.Sprintf("key-%d", i)))
 }
}

sync.Cond 条件变量

适用场景

等待某个条件成立
线程等待/唤醒模式
生产者-消费者模型

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

type Queue struct {
 mu sync.Mutex
 cond *sync.Cond
 items []int
 max int
}

func NewQueue(max int) *Queue {
 q := &Queue{
 items: make([]int, 0, max),
 max: max,
 }
 q.cond = sync.NewCond(&q.mu)
 return q
}

func (q *Queue) Put(item int) {
 q.mu.Lock()
 defer q.mu.Unlock()
 
 // 队列满，等待
 for len(q.items) >= q.max {
 q.cond.Wait() // 解锁并等待
 }
 
 q.items = append(q.items, item)
 fmt.Printf("Put: %d, Queue: %v\n", item, q.items)
 
 // 唤醒一个等待的消费者
 q.cond.Signal()
}

func (q *Queue) Get() int {
 q.mu.Lock()
 defer q.mu.Unlock()
 
 // 队列空，等待
 for len(q.items) == 0 {
 q.cond.Wait()
 }
 
 item := q.items[0]
 q.items = q.items[1:]
 fmt.Printf("Get: %d, Queue: %v\n", item, q.items)
 
 // 唤醒一个等待的生产者
 q.cond.Signal()
 
 return item
}

func main() {
 q := NewQueue(3)
 
 // 生产者
 go func() {
 for i := 0; i < 10; i++ {
 q.Put(i)
 time.Sleep(100 * time.Millisecond)
 }
 }()
 
 // 消费者
 go func() {
 for i := 0; i < 10; i++ {
 q.Get()
 time.Sleep(150 * time.Millisecond)
 }
 }()
 
 time.Sleep(3 * time.Second)
}

Broadcast vs Signal

方法	说明
`Signal()`	唤醒一个等待的 goroutine
`Broadcast()`	唤醒所有等待的 goroutine

sync.WaitGroup 等待组

基本用法

package main

import (
 "fmt"
 "sync"
 "time"
)

func main() {
 var wg sync.WaitGroup
 
 // 添加 3 个任务
 wg.Add(3)
 
 for i := 0; i < 3; i++ {
 go func(id int) {
 defer wg.Done() // 完成后计数减 1
 fmt.Printf("Task %d started\n", id)
 time.Sleep(time.Second)
 fmt.Printf("Task %d completed\n", id)
 }(i)
 }
 
 // 等待所有任务完成
 wg.Wait()
 fmt.Println("All tasks completed!")
}

常见模式

// 1. 并行爬虫
func crawlUrls(urls []string) []string {
 var wg sync.WaitGroup
 results := make(chan string, len(urls))
 
 for _, url := range urls {
 wg.Add(1)
 go func(u string) {
 defer wg.Done()
 if body, err := fetch(u); err == nil {
 results <- body
 }
 }(url)
 }
 
 // 等待完成并关闭通道
 go func() {
 wg.Wait()
 close(results)
 }()
 
 var bodies []string
 for body := range results {
 bodies = append(bodies, body)
 }
 return bodies
}

// 2. 错误处理
type Task struct {
 ID int
 URL string
 Err error
}

func processTasks(tasks []Task) []Task {
 var wg sync.WaitGroup
 for i := range tasks {
 wg.Add(1)
 go func(idx int) {
 defer wg.Done()
 tasks[idx].Err = process(tasks[idx].URL)
 }(i)
 }
 wg.Wait()
 return tasks
}

sync.Once 一次性执行

基本用法

package main

import (
 "fmt"
 "sync"
)

type Config struct {
 Data string
}

var (
 config *Config
 once sync.Once
)

func getConfig() *Config {
 once.Do(func() {
 fmt.Println("Loading config...")
 config = &Config{
 Data: "loaded-once",
 }
 })
 return config
}

func main() {
 c1 := getConfig()
 c2 := getConfig()
 fmt.Println(c1 == c2, c1.Data) // true, 同一实例
}

注意事项

once.Do 内的函数若 panic，仍视为「已执行」，再次调用不会重试；需要在内部自行 recover 或保证可恢复。
不要在 once.Do 里再嵌套依赖同一 Once 的死锁路径。

Go应用的灵活配置Viper

Thu, 10 Oct 2019 00:00:00 +0000

Viper 是一个完整的 Go 应用程序配置解决方案，它可以处理所有类型的配置需求和格式。

Viper 功能特性

功能	说明
多格式支持	Yaml、Json、TOML、HCL、ENV、Java Properties
多来源读取	文件、环境变量、命令行参数、远程配置
热加载	支持监听配置文件变化自动重载
类型转换	自动转换配置值为 Go 类型
远程配置	支持从 etcd、Consul、NATS 等读取配置
默认值	支持设置默认值

安装

go get -u github.com/spf13/viper

基础用法

config.yaml 配置文件

app:
 name: "my-app"
 version: "1.0.0"
 port: 8080

database:
 host: "localhost"
 port: 3306
 username: "root"
 password: "secret"
 name: "test_db"

redis:
 host: "127.0.0.1"
 port: 6379
 password: ""
 db: 0

information:
 list:
 - "One"
 - "Two"
 - "Three"
 lucky_number: 7

timestamp: "2019-10-10 14:15:16"
author: "Yisonli"

初始化配置

package main

import (
 "fmt"
 "github.com/spf13/viper"
)

func main() {
 // 创建 Viper 实例
 v := viper.New()

 // 设置配置文件名（不含扩展名）
 v.SetConfigName("config")

 // 添加配置文件搜索路径
 v.AddConfigPath("./config/")
 v.AddConfigPath("$HOME/.app/")
 v.AddConfigPath("/etc/app/")

 // 设置配置文件类型
 v.SetConfigType("yaml")

 // 读取配置
 if err := v.ReadInConfig(); err != nil {
 panic(fmt.Errorf("配置读取失败: %w", err))
 }

 // 获取配置值
 fmt.Printf("应用名称: %s\n", v.GetString("app.name"))
 fmt.Printf("数据库主机: %s\n", v.GetString("database.host"))
 fmt.Printf("列表: %v\n", v.GetStringSlice("information.list"))
}

全局 Viper 实例

var VP *viper.Viper

func AutoLoadConfig() error {
 VP = viper.New()

 // 设置配置文件名
 VP.SetConfigName("config")

 // 添加配置文件路径
 VP.AddConfigPath("./config/")

 // 设置配置文件类型
 VP.SetConfigType("yaml")

 if err := VP.ReadInConfig(); err != nil {
 return fmt.Errorf("配置读取失败: %w", err)
 }

 // 绑定环境变量
 VP.BindEnv("GOPATH")

 fmt.Printf("list: %+v, gopath: %s\n", VP.Get("information.list"), VP.Get("GOPATH"))
 return nil
}

高级用法

读取环境变量

// 自动绑定环境变量
v.AutomaticEnv()
v.SetEnvPrefix("APP") // 环境变量前缀：APP_DATABASE_HOST
v.SetEnvKeyReplacer(strings.NewReplacer(".", "_"))

// 手动绑定
v.BindEnv("database.host", "DB_HOST") // 绑定到 DB_HOST 环境变量

读取命令行参数

v.SetConfigFile("./config.yaml") // 指定配置文件路径
v.SetConfigType("yaml") // 明确配置文件类型

// 绑定 Pflags
v.BindPFlag("database.host", flag.Lookup("db-host"))

设置默认值

v := viper.New()

v.SetDefault("app.port", 8080)
v.SetDefault("database.host", "localhost")
v.SetDefault("database.port", 3306)
v.SetDefault("cache.enabled", true)

类型安全获取

// 字符串
name := v.GetString("app.name")

// 整数
port := v.GetInt("app.port")

// 布尔
enabled := v.GetBool("cache.enabled")

// 浮点数
rate := v.GetFloat64("api.rate_limit")

// 切片
list := v.GetStringSlice("information.list")

// Map
dbConfig := v.GetStringMap("database")
// dbConfig["host"], dbConfig["port"], etc.

// 嵌套获取
host := v.GetString("database.host")
listItem := v.GetString("information.list.0") // "One"

Unmarshal 到结构体

type Config struct {
 App AppConfig `mapstructure:"app"`
 Database DatabaseConfig `mapstructure:"database"`
 Redis RedisConfig `mapstructure:"redis"`
}

type AppConfig struct {
 Name string `mapstructure:"name"`
 Version string `mapstructure:"version"`
 Port int `mapstructure:"port"`
}

type DatabaseConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Username string `mapstructure:"username"`
 Password string `mapstructure:"password"`
 Name string `mapstructure:"name"`
}

type RedisConfig struct {
 Host string `mapstructure:"host"`
 Port int `mapstructure:"port"`
 Password string `mapstructure:"password"`
 DB int `mapstructure:"db"`
}

func main() {
 v := viper.New()
 v.SetConfigFile("config.yaml")
 v.SetConfigType("yaml")
 v.ReadInConfig()

 var config Config
 if err := v.Unmarshal(&config); err != nil {
 panic(err)
 }

 fmt.Printf("App: %s:%d\n", config.App.Name, config.App.Port)
 fmt.Printf("DB: %s:%d\n", config.Database.Host, config.Database.Port)
}

监听配置文件变化

v := viper.New()
v.SetConfigName("config")
v.SetConfigType("yaml")
v.ReadInConfig()

// 监听配置变化
v.WatchConfig()
v.OnConfigChange(func(e fsnotify.Event) {
 fmt.Printf("配置文件已更新: %s\n", e.Name)
 // 重新读取配置
 v.ReadInConfig()
})

远程配置

etcd 配置

import (
 "github.com/spf13/viper/remote"
 "github.com/hashicorp/vault/api"
)

func initRemoteConfig() error {
 v := viper.New()

 // 设置远程源
 err := remote.AddProvider("etcd", "http://127.0.0.1:4001", "/config.yaml")
 if err != nil {
 return err
 }

 // 或者使用 Consul
 err = remote.AddProvider("consul", "http://127.0.0.1:8500", "/config.yaml", "my-consul-token")

 // 启用远程配置
 err = v.AddRemoteProvider("etcd", "http://127.0.0.1:4001", "/config.yaml")
 v.SetConfigType("yaml")
 
 return v.ReadRemoteConfig()
}

多环境配置

// 根据环境加载不同配置
func loadConfig(env string) (*viper.Viper, error) {
 v := viper.New()

 // 基础配置
 v.SetConfigName("config")
 v.SetConfigType("yaml")
 v.AddConfigPath("./config/")

 // 环境特定配置
 if env != "" {
 v.SetConfigName("config." + env) // config.dev.yaml, config.prod.yaml
 }

 if err := v.ReadInConfig(); err != nil {
 return nil, err
 }

 return v, nil
}

// 使用
v, err := loadConfig("dev") // 加载 config.dev.yaml

最佳实践

项目结构

project/
├── config/
│ ├── config.yaml # 默认配置
│ ├── config.dev.yaml # 开发环境
│ ├── config.prod.yaml # 生产环境
│ └── config.test.yaml # 测试环境
├── config.yaml
└── main.go

环境变量配置

# .env 文件
APP_NAME=my-app
APP_ENV=production
DATABASE_HOST=localhost
DATABASE_PORT=3306

// 加载 .env 文件
go get github.com/joho/godotenv

func main() {
 // 加载 .env 文件
 godotenv.Load()

 v := viper.New()
 v.AutomaticEnv()
 
 // 或者手动映射（键名建议使用点分层级，对应 yaml 嵌套字段）
 v.BindEnv("database.host", "DATABASE_HOST")
 v.BindEnv("database.port", "DATABASE_PORT")

 // 读取：优先配置文件，再以环境变量覆盖 AutomaticEnv / BindEnv 的值
 host := v.GetString("database.host")
 _ = host
}

.env 只适合开发机本地密钥；线上请使用容器/编排注入的环境变量或密钥管理服务，BindEnv 只是把环境变量桥接到同一套键名。