2024-12-10

2024-12-10 ~ 2024-12-10

Go

参考：https://www.jianshu.com/p/7c4fb2c3c66e

Go语言版本

1

go version go1.20 windows/amd64

sync.map 则是一种并发安全的 map，在 Go 1.9 引入

1 特点

Map 类型针对两种常见用例进行了优化：

····

2024-08-15

go实现发送邮件的功能

2024-08-15 ~ 2024-08-15

Go

当然，下面是一个用 Go 语言发送电子邮件的详细示例。我们将使用 gomail 包来实现邮件发送功能。这里的示例展示了如何配置邮件客户端，创建邮件，并发送邮件。

1. 安装 `gomail` 包

首先，我们需要安装 gomail 包。打开终端并运行以下命令：

····

2024-08-15

用户激活模块实现

2024-08-15 ~ 2024-08-15

Go

好的，以下是一个完整的方案，包括数据库设计、GORM 模型、用户注册和激活功能的实现，以及通过邮件发送激活码的过程。

GORM 模型

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160


package main

import (
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "net/smtp"
    "time"

    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

// 定义User模型
type User struct {
    ID             uint      `gorm:"primaryKey"`
    Username       string    `gorm:"unique"`
    Email          string    `gorm:"unique"`
    Password       string
    SubscriptionID uint
    Subscription   Subscription
    IsActive       bool
    CreatedAt      time.Time
}

// 定义Subscription模型
type Subscription struct {
    ID        uint   `gorm:"primaryKey"`
    Name      string
    CreatedAt time.Time
}

// 定义Resource模型
type Resource struct {
    ID           uint   `gorm:"primaryKey"`
    Name         string
    ResourceType string
    CreatedAt    time.Time
}

// 定义UserResource模型
type UserResource struct {
    ID        uint `gorm:"primaryKey"`
    UserID    uint
    ResourceID uint
    CreatedAt time.Time
}

// 定义Activation模型
type Activation struct {
    ID             uint   `gorm:"primaryKey"`
    UserID         uint
    ActivationCode string `gorm:"size:9"`
    CreatedAt      time.Time
}

// 生成9位激活码
func generateActivationCode() (string, error) {
    b := make([]byte, 6) // 6 bytes * 4/3 = 8 characters
    _, err := rand.Read(b)
    if err != nil {
        return "", err
    }
    return base64.StdEncoding.EncodeToString(b)[:9], nil
}

// 发送激活邮件
func sendActivationEmail(user *User, code string) error {
    from := "your-email@example.com"
    pass := "your-email-password"
    to := user.Email
    activationLink := fmt.Sprintf("http://your-domain.com/activate?code=%s", code)

    msg := fmt.Sprintf("To: %s\r\n"+
        "Subject: Please activate your account\r\n"+
        "\r\n"+
        "Click the following link to activate your account:\r\n"+
        "%s\r\n", to, activationLink)

    return smtp.SendMail("smtp.example.com:587",
        smtp.PlainAuth("", from, pass, "smtp.example.com"),
        from, []string{to}, []byte(msg))
}

func main() {
    dsn := "host=localhost user=gorm dbname=gorm password=gorm sslmode=disable"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic("failed to connect database")
    }

    // 自动迁移表结构
    db.AutoMigrate(&User{}, &Subscription{}, &Resource{}, &UserResource{}, &Activation{})

    // 用户注册示例
    activationCode, err := generateActivationCode()
    if err != nil {
        panic("failed to generate activation code")
    }

    user := User{
        Username:       "test_user",
        Email:          "test_user@example.com",
        Password:       "password", // 在实际应用中应加密存储密码
        SubscriptionID: 1,           // 假设已经有一个 Subscription
    }
    db.Create(&user)

    activation := Activation{
        UserID:         user.ID,
        ActivationCode: activationCode,
    }
    db.Create(&activation)

    // 发送激活邮件
    if err := sendActivationEmail(&user, activationCode); err != nil {
        panic("failed to send activation email")
    }

    fmt.Println("User registered, awaiting activation...")
}

// 激活用户
func activateUser(w http.ResponseWriter, r *http.Request) {
    activationCode := r.URL.Query().Get("code")
    if activationCode == "" {
        http.Error(w, "Missing activation code", http.StatusBadRequest)
        return
    }

    dsn := "host=localhost user=gorm dbname=gorm password=gorm sslmode=disable"
    db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        http.Error(w, "Database connection error", http.StatusInternalServerError)
        return
    }

    var activation Activation
    if err := db.Where("activation_code = ?", activationCode).First(&activation).Error; err != nil {
        http.Error(w, "Invalid activation code", http.StatusBadRequest)
        return
    }

    var user User
    db.First(&user, activation.UserID)

    // 更新用户激活状态
    user.IsActive = true
    db.Save(&user)

    // 删除激活记录
    db.Delete(&activation)

    w.Write([]byte("Account activated successfully!"))
}

func main() {
    http.HandleFunc("/activate", activateUser)
    http.ListenAndServe(":8080", nil)
}

数据库设计

users 表

1
2
3
4
5
6
7
8
9


CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    username VARCHAR(255) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password VARCHAR(255) NOT NULL,
    subscription_id INT REFERENCES subscriptions(id),
    is_active BOOLEAN DEFAULT FALSE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

subscriptions 表

1
2
3
4
5


CREATE TABLE subscriptions (
    id SERIAL PRIMARY KEY,
    name VARCHAR(50) NOT NULL,   -- 'free' 或者 'vip'
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

resources 表

1
2
3
4
5
6


CREATE TABLE resources (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    resource_type VARCHAR(50) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

user_resources 表

1
2
3
4
5
6


CREATE TABLE user_resources (
    id SERIAL PRIMARY KEY,
    user_id INT REFERENCES users(id),
    resource_id INT REFERENCES resources(id),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

activations 表

1
2
3
4
5
6


CREATE TABLE activations (
    id SERIAL PRIMARY KEY,
    user_id INT REFERENCES users(id),
    activation_code VARCHAR(9) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

详细步骤

数据库设计：

····

2024-08-15

订阅模块实现

2024-08-15 ~ 2024-08-15

Go

设计一个系统，提供不同的资源访问权限给免费用户和 VIP 用户，这里将分别介绍下整体设计思路和数据库设计，并用 GORM 的方式说明。

整体设计思路

用户注册和登录模块。
资源模块，可以是文件、视频、API 调用等。
订阅模块，有免费和 VIP 两种订阅。
权限控制模块，根据用户订阅类型控制资源访问权限。

数据库设计

我们需要设计几个主要的数据表：

····

2023-12-09

Protobuf编码原理及优化技巧探讨

2023-12-09 ~ 2023-12-09

Go

https://mp.weixin.qq.com/s/hAfrPlPD2KBCWxpIuGkQTQ

全文复制保存方便自己查看。

1、Protobuf编码原理介绍

序列化算法被广泛应用于各种通信协议中，本文对序列化算法进行狭义定义：

将某个struct或class的内存数据和通信数据链路上的字节流进行互相转化的算法。

····

2023-11-20

如何真正写好Golang代码?

2023-11-20 ~ 2023-11-20

Go

从https://mp.weixin.qq.com/s/OIHqmgK4V7Y26uYoFjsCyA 复制

Golang 实现SOLID 设计原则

本章节按照设计模式中的核心设计原则介绍在Go语言中的实现。

····

2023-11-12

GMP

2023-11-12 ~ 2025-03-18

Go

非原创

好文：https://yizhi.ren/2019/06/03/goscheduler

参考：https://blog.csdn.net/xmcy001122/article/details/119392934

····

2023-09-03

go server退出

2023-09-03 ~ 2023-09-03

Go

go server以相当优雅的姿势退出（待继续完善）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94


package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"
)

type H struct{}

func (H) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	time.Sleep(5 * time.Second)
	fmt.Fprintf(w, "Hello, World!") // 向客户端发送响应
}

func initServer() *http.Server {
	s := &http.Server{
		Addr:    ":8080",
		Handler: H{},
	}
	return s
}

type Backend struct {
	Ctx context.Context
	Srv *http.Server

	CancelFunc func()
}

var onlyOneSignalHandler = make(chan struct{})
var shutdownSignals = []os.Signal{os.Interrupt, syscall.SIGTERM}
var shutdownHandler chan os.Signal

// SetupSignalContext is same as SetupSignalHandler, but a context.Context is returned.
// Only one of SetupSignalContext and SetupSignalHandler should be called, and only can
// be called once.
func (b *Backend) SetupSignalContext() context.Context {
	close(onlyOneSignalHandler) // panics when called twice

	shutdownHandler = make(chan os.Signal, 2)

	signal.Notify(shutdownHandler, shutdownSignals...)

	go func() {
		<-shutdownHandler
		b.Clean()
		<-shutdownHandler
		os.Exit(1) // second signal. Exit directly.
	}()

	return b.Ctx
}

// SetupSignalHandler registered for SIGTERM and SIGINT. A stop channel is returned
// which is closed on one of these signals. If a second signal is caught, the program
// is terminated with exit code 1.
// Only one of SetupSignalContext and SetupSignalHandler should be called, and only can
// be called once.
func (b *Backend) SetupSignalHandler() <-chan struct{} {
	return b.SetupSignalContext().Done()
}

func (b *Backend) RunAndServe(stopCh <-chan struct{}) {
	b.Srv.ListenAndServe()
	<-stopCh
	if err := b.Srv.Shutdown(b.Ctx); err != nil {
		log.Fatal("Server Shutdown:", err)
	}
	log.Printf("initServer exiting")
}

func (b *Backend) Clean() {
	fmt.Println("do some clean")
	time.Sleep(time.Second * 10)
	b.CancelFunc()
	fmt.Println("clean over")
	b.Ctx.Done()
}

func main() {
	ctx, cancel := context.WithCancel(context.Background())
	simpleBackend := Backend{
		Ctx:        ctx,
		Srv:        initServer(),
		CancelFunc: cancel,
	}
	simpleBackend.RunAndServe(simpleBackend.SetupSignalHandler())
}

2023-06-18

go_自旋锁

2023-06-18 ~ 2023-06-18

Go

CAS算法（compare and swap）

CAS算法是一种有名的无锁算法。无锁编程，即不使用锁的情况下实现多线程之间的变量同步，也就是在没有线程被阻塞的情况下实现变量的同步，所以也叫非阻塞同步（Non-blocking Synchronization）。CAS算法涉及到三个操作数:

····

2023-01-30

超时控制下执行函数

2023-01-30 ~ 2024-12-10

Go

go中实现超时控制下执行函数功能

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


func RunWithTimeout(fun func() error, timeout time.Duration) error {
	finished := make(chan struct{})
	var err error
	go func() {
		err = fun()
		finished <- struct{}{}
	}()

	select {
	case <-finished:
		return err
	case <-time.After(timeout):
		return fmt.Errorf("timeout")
	}
}

2022-11-18

gorm删除记录（删除具有级联关系的数据）

2022-11-18 ~ 2024-12-10

Go

删除具有级联关系的数据

参考：https://gorm.io/zh_CN/docs/associations.html#Association-Mode

带 Select 的删除

你可以在删除记录时通过 Select 来删除具有 has one、has many、many2many 关系的记录，例如：

····

2022-10-23

go signal处理

2022-10-23 ~ 2024-12-10

Go

Go Signal信号处理

参考: [Go Signal信号处理]((17条消息) Go Signal信号处理_无风的雨-CSDN博客_go signal)

可以先参考官方资料[go.signal](signal package - os/signal - pkg.go.dev)

····

2022-10-19

Go语言的%d,%p,%v等占位符的使用

2022-10-19 ~ 2024-12-10

Go

1.占位符分别代表了什么？

golang 的fmt 包实现了格式化I/O函数，类似于C的 printf 和 scanf。定义示例类型和变量

1
2
3
4
5


type Human struct {
	Name string
} 

var people = Human{Name:"zhangsan"}

2 普通占位符

占位符	说明	举例	输出
%v	相应值的默认格式。	Printf("%v", people)	{zhangsan}
%+v	打印结构体时，会添加字段名	Printf("%+v", people)	{Name:zhangsan}
%#v	相应值的Go语法表示	Printf("#v", people)	main.Human{Name:“zhangsan”}
%T	相应值的类型的Go语法表示	Printf("%T", people)	main.Human
%%	字面上的百分号，并非值的占位符	Printf("%%")	%

3 布尔占位符

占位符	说明	举例	输出
%t	true或false	Printf("%t", true)	true

4 整数占位符

占位符	说明	举例	输出
%b	二进制表示	Printf("%b", 5)	101
%c	相应Unicode码点锁表示的字符	Printf("%c", 0x4e2d)	中
%d	十进制表示	Printf("%d", 0x12)	18
%o	八进制表示	Printf("%d", 10)	12
%q单引号围绕的字符字面值，由Go语法安全地转义	Printf("%q", 0x4E2D)	‘中’
%x	十六进制表示，字母形式为小写 a-f	Printf("%x", 13)	d
%X	十六进制表示，字母形式为大写 A-F	Printf("%x", 13)	D
%U	Unicode格式：U+1234，等同于 “U+%04X”	Printf("%U", 0x4E2D)	U+4E2D

5 浮点数和复数的组成部分(实部和虚部)

占位符	说明	举例	输出
%b	无小数部分的，指数为二的幂的科学计数法，与 strconv.FormatFloat 的 ‘b’ 转换格式一致。例如 -123456p-78
%e	科学计数法，例如 -1234.456e+78	Printf("%e", 10.2)	1.020000e+01
%E	科学计数法，例如 -1234.456E+78	Printf("%e", 10.2)	1.020000E+01
%f	有小数点而无指数，例如 123.456	Printf("%e", 10.2)	10.200000
%g	根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出	Printf("%g", 10.20)	10.2
%G	根据情况选择 %E 或 %f 以产生更紧凑的（无末尾的0）输出	Printf("%G", 10.20+2i)	(10.2+2i)

6 字符串与字节切片

占位符	说明	举例	输出
%s	输出字符串表示（string类型或[]byte)	Printf("%s", []byte(“Go语言”))	Go语言
%q	双引号围绕的字符串，由Go语法安全地转义	Printf("%q", “Go语言”)	“Go语言”
%x	十六进制，小写字母，每字节两个字符	Printf("%x", “golang”)	676f6c616e67
%X	十六进制，大写字母，每字节两个字符	Printf("%X", “golang”)	676F6C616E67

7 指针

占位符	说明	举例	输出
%p	十六进制表示，前缀 0x	Printf("%p", &people)	0x4f57f0

8 其它标记

占位符	说明	举例	输出
+	总打印数值的正负号；对于%q（%+q）保证只输出ASCII编码的字符。	Printf("%+q", “中文”)	“\u4e2d\u6587”
-	在右侧而非左侧填充空格（左对齐该区域）
#	备用格式：为八进制添加前导 0（%#o）为十六进制添加前导 0x（%#x）或 0X（%#X），为 %p（%#p）去掉前导 0x；如果可能的话，%q（%#q）会打印原始（即反引号围绕的）字符串；如果是可打印字符，%U（%#U）会写出该字符的 Unicode 编码形式（如字符 x 会被打印成 U+0078 ‘x’）。	Printf("%#U", ‘中’)	U+4E2D
’ '	(空格)为数值中省略的正负号留出空白（% d）；以十六进制（% x, % X）打印字符串或切片时，在字节之间用空格隔开
0	填充前导的0而非空格；对于数字，这会将填充移到正负号之后

2022-10-19

互斥锁

2022-10-19 ~ 2022-10-19

Go

互斥锁

用一个互斥锁来在Go协程间安全的访问数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


package main

import (
	"fmt"
	"math/rand"
	"runtime"
	"sync"
	"sync/atomic"
	"time"
)

func main() {
	var state = make(map[int]int)
	var mutex = &sync.Mutex{}
	var ops int64 = 0
	for r := 0; r < 100; r++ {
		// 运行100个go协程来重复读取state
		go func() {
			total := 0
			for {
				key := rand.Intn(5)
				mutex.Lock()
				total += state[key]
				mutex.Unlock()
				atomic.AddInt64(&ops, 1)
				runtime.Gosched() // 为了确保这个Go协程不会在调度中饿死，我们在每次操作后明确的使用runtime.Gosched()进行释放。是自动处理的。
			}
		}()
	}
	for w := 0; w < 10; w++ { // 模拟写入操作
		go func() {
			for {
				key := rand.Intn(5)
				val := rand.Intn(100)
				mutex.Lock()
				state[key] = val
				mutex.Unlock()
				atomic.AddInt64(&ops, 1)
				runtime.Gosched()
			}
		}()
	}
	time.Sleep(time.Second)
	opsFinal := atomic.LoadInt64(&ops)
	fmt.Println("ops:", opsFinal)
	mutex.Lock() //对 state 使用一个最终的锁，显示它是如何结束的。
	fmt.Println("state:", state)
	mutex.Unlock()
}

2022-10-19

关于锁的一些注意事项

2022-10-19 ~ 2024-12-10

Go

尽量减少锁的持有时间

细化锁的粒度。通过细化锁的粒度来减少锁的持有时间以及避免在持有锁操作的时候做各种耗时的操作。
不要在持有锁的时候做 IO 操作。尽量只通过持有锁来保护 IO 操作需要的资源而不是 IO 操作本身：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16



func doSomething() {
    m.Lock()
    item := ...
    http.Get()  // 各种耗时的 IO 操作
    m.Unlock()
}

// 改为
func doSomething() {
    m.Lock()
    item := ...
    m.Unlock()

    http.Get()
}

善用 defer 来确保在函数内正确释放

通过 defer 可以确保不会遗漏释放锁操作，避免出现死锁问题，以及避免函数内非预期的 panic 导致死锁的问题不过使用 defer 的时候也要注意别因为习惯性的 defer m.Unlock() 导致无意中在持有锁的时候做了 IO 操作，出现了非预期的持有锁时间太长的问题。

····

2022-10-19

学习一下sync.Cond的用法

2022-10-19 ~ 2024-12-10

Go

使用场景：
我需要完成一项任务，但是这项任务需要满足一定条件才可以执行，否则我就等着。
那我可以怎么获取这个条件呢？一种是循环去获取，一种是条件满足的时候通知我就可以了。显然第二种效率高很多。
通知的方式的话，golang里面通知可以用channel的方式

····

2022-10-12

Go实现不同goroutine之间的阻塞

2022-10-12 ~ 2022-10-12

Go

Go 程序从 main 包的 main() 函数开始，在程序启动时，Go 程序就会为 main() 函数创建一个默认的 goroutine。

所有 goroutine 在 main() 函数结束时会一同结束。若在启用的goroutine中不使用WaitGroup的话会因为main函数已执行完，阻塞的函数与发送信号的函数会一同结束，不能真正实现阻塞的功能。

····

2022-10-12

Go的继承与重写以及结构体嵌套

2022-10-12 ~ 2022-10-12

Go

1. 首先声明两个基础结构体（其他语言的基类吧:)）

1
2
3
4
5
6
7


type Animal struct {
	Name string
}

type Old struct {
	Age int
}

并给Animal类增加一个方法Walk()

····

Go

1 特点

1. 安装 gomail 包

GORM 模型

数据库设计

users 表

subscriptions 表

resources 表

user_resources 表

activations 表

详细步骤

整体设计思路

数据库设计

1、Protobuf编码原理介绍

Golang 实现SOLID 设计原则

go server以相当优雅的姿势退出（待继续完善）

CAS算法（compare and swap）

删除具有级联关系的数据

带 Select 的删除

Go Signal信号处理

1.占位符分别代表了什么？

2 普通占位符

3 布尔占位符

4 整数占位符

5 浮点数和复数的组成部分(实部和虚部)

6 字符串与字节切片

7 指针

8 其它标记

互斥锁

尽量减少锁的持有时间

善用 defer 来确保在函数内正确释放

1. 首先声明两个基础结构体（其他语言的基类吧:)）

1. 安装 `gomail` 包