x

初始化项目

1
2
3
4
5
mkdir echo-practice
cd echo-practice

go mod init echo-practice
go get github.com/labstack/echo/v4

连接postgresql和redis

1
2
3
if databaseURL == "" {
	databaseURL = "postgres://postgres:Lyx88888888.@@localhost:5432/postgres?sslmode=disable"
}

echo负责路由和接口，pg用pgxpool连接池，redis用go-redis客户端，然后把连接对象注入到handler里面

Redis 存的是临时状态，比如匹配队列、在线用户、房间临时状态。

安装依赖

1
2
3
4
5
go mod init echo-demo

go get github.com/labstack/echo/v5
go get github.com/jackc/pgx/v5/pgxpool
go get github.com/redis/go-redis/v9

拉取失败，在当前powershell里面临时改代理环境变量

1
2
3
4
5
6
$env:GOPROXY="https://goproxy.cn,direct"
go env GOPROXY
go clean -modcache
go get github.com/jackc/pgx/v5/pgxpool@latest
go get github.com/go-redis/redis/v8
go mod tidy

测试和连接redis

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
var ctx = context.Background()

func main() {
	rdb := redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       0,
	})

	//ping测试链接
	pong, err := rdb.Ping(ctx).Result()
	fmt.Println(pong, err)

	//设置键值对
	err = rdb.Set(ctx, "name", "fangfang", 0).Err()
	if err != nil {
		fmt.Println(err)
	}

	//获取键值对
	val, err := rdb.Get(ctx, "name").Result()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(val)
}
1
2
PONG <nil>
fangfang

连接postgresql

1
var db *sql.DB
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
-- =========================================
-- 1. PostgreSQL 扩展
-- =========================================
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";


-- =========================================
-- 2. 用户表
-- =========================================
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),

    username VARCHAR(50) NOT NULL UNIQUE,
    password_hash TEXT NOT NULL,

    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);

COMMENT ON TABLE users IS '用户表，存储注册用户信息';
COMMENT ON COLUMN users.id IS '用户唯一标识，使用 UUID，便于后期分布式扩展';
COMMENT ON COLUMN users.username IS '用户名，必须唯一';
COMMENT ON COLUMN users.password_hash IS 'bcrypt 加密后的密码';


-- =========================================
-- 3. 单词表
-- =========================================
CREATE TABLE words (
    id BIGSERIAL PRIMARY KEY,

    word VARCHAR(100) NOT NULL,
    level VARCHAR(20) NOT NULL DEFAULT 'CET6',

    meaning TEXT,
    phonetic VARCHAR(100),

    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),

    CONSTRAINT uk_words_word_level UNIQUE (word, level)
);

COMMENT ON TABLE words IS '单词库表，存储题目中的目标单词';
COMMENT ON COLUMN words.word IS '单词本身，例如 abandon';
COMMENT ON COLUMN words.level IS '单词等级，例如 CET4、CET6、IELTS、TOEFL';
COMMENT ON COLUMN words.meaning IS '中文释义，可选';
COMMENT ON COLUMN words.phonetic IS '音标，可选';

CREATE INDEX idx_words_level ON words(level);


-- =========================================
-- 4. 近义词 / 选项表
-- =========================================
CREATE TABLE synonyms (
    id BIGSERIAL PRIMARY KEY,

    word_id BIGINT NOT NULL REFERENCES words(id) ON DELETE CASCADE,

    synonym VARCHAR(100) NOT NULL,
    is_correct BOOLEAN NOT NULL DEFAULT FALSE,

    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),

    CONSTRAINT uk_synonyms_word_synonym UNIQUE (word_id, synonym)
);

COMMENT ON TABLE synonyms IS '近义词与干扰项表，用于生成答题选项';
COMMENT ON COLUMN synonyms.word_id IS '所属单词 ID';
COMMENT ON COLUMN synonyms.synonym IS '近义词或干扰项';
COMMENT ON COLUMN synonyms.is_correct IS '是否为该单词的正确近义词';

CREATE INDEX idx_synonyms_word_id ON synonyms(word_id);
CREATE INDEX idx_synonyms_word_correct ON synonyms(word_id, is_correct);
CREATE INDEX idx_synonyms_correct ON synonyms(is_correct);
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
-- =========================================
-- 5. 对战记录表
-- =========================================
CREATE TABLE battle_records (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),

    player1_id UUID NOT NULL REFERENCES users(id),
    player2_id UUID NOT NULL REFERENCES users(id),

    winner_id UUID REFERENCES users(id),

    p1_score INT NOT NULL DEFAULT 0,
    p2_score INT NOT NULL DEFAULT 0,

    status VARCHAR(20) NOT NULL DEFAULT 'PLAYING',
    end_reason VARCHAR(30),

    started_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
    ended_at TIMESTAMPTZ,

    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),

    CONSTRAINT chk_battle_players_different
        CHECK (player1_id <> player2_id),

    CONSTRAINT chk_battle_status
        CHECK (status IN ('PLAYING', 'FINISHED', 'ABORTED')),

    CONSTRAINT chk_battle_winner
        CHECK (
            winner_id IS NULL
            OR winner_id = player1_id
            OR winner_id = player2_id
        ),

    CONSTRAINT chk_battle_scores
        CHECK (p1_score >= 0 AND p2_score >= 0)
);

COMMENT ON TABLE battle_records IS '对战总记录表，保存一局比赛的整体结果';
COMMENT ON COLUMN battle_records.player1_id IS '玩家1 ID';
COMMENT ON COLUMN battle_records.player2_id IS '玩家2 ID';
COMMENT ON COLUMN battle_records.winner_id IS '胜者 ID，平局或异常结束时可以为空';
COMMENT ON COLUMN battle_records.p1_score IS '玩家1最终得分';
COMMENT ON COLUMN battle_records.p2_score IS '玩家2最终得分';
COMMENT ON COLUMN battle_records.status IS '对战状态：PLAYING、FINISHED、ABORTED';
COMMENT ON COLUMN battle_records.end_reason IS '结束原因，例如 NORMAL、DISCONNECT、TIMEOUT、SURRENDER';

CREATE INDEX idx_battle_player1 ON battle_records(player1_id);
CREATE INDEX idx_battle_player2 ON battle_records(player2_id);
CREATE INDEX idx_battle_winner ON battle_records(winner_id);
CREATE INDEX idx_battle_started_at ON battle_records(started_at DESC);
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
-- =========================================
-- 6. 对战轮次表
-- =========================================
CREATE TABLE battle_rounds (
    id BIGSERIAL PRIMARY KEY,

    battle_id UUID NOT NULL REFERENCES battle_records(id) ON DELETE CASCADE,

    round_no SMALLINT NOT NULL,

    word_id BIGINT REFERENCES words(id),


    options TEXT[] NOT NULL,
    correct_index SMALLINT NOT NULL,
    correct_synonym VARCHAR(100) NOT NULL,

    started_at TIMESTAMPTZ,
    ended_at TIMESTAMPTZ,

    CONSTRAINT uk_battle_round UNIQUE (battle_id, round_no),

    CONSTRAINT chk_round_no
        CHECK (round_no >= 1),

    CONSTRAINT chk_correct_index
        CHECK (correct_index BETWEEN 0 AND 3),

    CONSTRAINT chk_options_count
        CHECK (array_length(options, 1) = 4)
);

COMMENT ON TABLE battle_rounds IS '对战轮次表，保存每一轮题目快照';
COMMENT ON COLUMN battle_rounds.battle_id IS '所属对战 ID';
COMMENT ON COLUMN battle_rounds.round_no IS '第几轮，从 1 开始';
COMMENT ON COLUMN battle_rounds.word_id IS '题目对应的单词 ID';
COMMENT ON COLUMN battle_rounds.question_word IS '题目单词快照';
COMMENT ON COLUMN battle_rounds.options IS '四个选项快照';
COMMENT ON COLUMN battle_rounds.correct_index IS '正确选项下标，范围 0-3';
COMMENT ON COLUMN battle_rounds.correct_synonym IS '正确近义词快照';

CREATE INDEX idx_battle_rounds_battle_id ON battle_rounds(battle_id);
CREATE INDEX idx_battle_rounds_word_id ON battle_rounds(word_id);
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
-- =========================================
-- 7. 用户答题记录表
-- =========================================
CREATE TABLE battle_answers (
    id BIGSERIAL PRIMARY KEY,

    battle_id UUID NOT NULL REFERENCES battle_records(id) ON DELETE CASCADE,
    round_id BIGINT NOT NULL REFERENCES battle_rounds(id) ON DELETE CASCADE,

    user_id UUID NOT NULL REFERENCES users(id),

    choice_index SMALLINT,
    is_correct BOOLEAN NOT NULL DEFAULT FALSE,

    score_delta INT NOT NULL DEFAULT 0,

    response_ms INT,

    answered_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),

    CONSTRAINT uk_round_user_answer UNIQUE (round_id, user_id),

    CONSTRAINT chk_choice_index
        CHECK (choice_index IS NULL OR choice_index BETWEEN 0 AND 3),

    CONSTRAINT chk_response_ms
        CHECK (response_ms IS NULL OR response_ms >= 0)
);

COMMENT ON TABLE battle_answers IS '用户答题记录表，保存每位玩家每轮的作答情况';
COMMENT ON COLUMN battle_answers.choice_index IS '用户选择的选项下标，0-3；超时可为空';
COMMENT ON COLUMN battle_answers.is_correct IS '是否答对';
COMMENT ON COLUMN battle_answers.score_delta IS '本题得分变化，例如 +10、-10、0';
COMMENT ON COLUMN battle_answers.response_ms IS '用户作答耗时，单位毫秒';

CREATE INDEX idx_battle_answers_battle_id ON battle_answers(battle_id);
CREATE INDEX idx_battle_answers_round_id ON battle_answers(round_id);
CREATE INDEX idx_battle_answers_user_id ON battle_answers(user_id);

以后

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
-- =========================================
-- 8. 用户统计表
-- =========================================
CREATE TABLE user_stats (
    user_id UUID PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,

    rating INT NOT NULL DEFAULT 1000,

    battle_count INT NOT NULL DEFAULT 0,
    win_count INT NOT NULL DEFAULT 0,
    loss_count INT NOT NULL DEFAULT 0,
    draw_count INT NOT NULL DEFAULT 0,

    total_score INT NOT NULL DEFAULT 0,

    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),

    CONSTRAINT chk_user_stats_non_negative
        CHECK (
            rating >= 0
            AND battle_count >= 0
            AND win_count >= 0
            AND loss_count >= 0
            AND draw_count >= 0
        )
);

COMMENT ON TABLE user_stats IS '用户统计表，用于排行榜、胜率、积分等功能';

CREATE INDEX idx_user_stats_rating ON user_stats(rating DESC);
CREATE INDEX idx_user_stats_win_count ON user_stats(win_count DESC);

外键

链接两个表的字段，在一个表中存储的值必须匹配另一个表的主键或唯一键

1
2
REFERENCES words(id)	外键约束：word_id 的值必须是 words 表中 id 列已有的值
ON DELETE CASCADE	级联删除：当 words 表中的一行被删除时，所有引用该行的 synonyms 记录也会被自动删除

id UUID PRIMARY KEY DEFAULT uuid_generate_v4()

user表用uuid作为主键

sslmode=disable – 禁用 SSL（仅适用于本地开发，生产环境建议启用）

return &UserRepository{db: db}

???

已理解

1
2
3
4
5
6
if err != nil {                        // 1. 发生了错误
    if errors.Is(err, pgx.ErrNoRows) { // 2. 判断是否是“没有找到记录”
        return nil, nil                // 3. 是 → 返回 (nil, nil)，表示未找到但无系统错误
    }
    return nil, err                    // 4. 否 → 返回 (nil, 实际错误)，向上传递系统错误
}

ORDER BY RANDOM()：

PostgreSQL 的随机排序函数，结果顺序随机。

COALESCE(meaning, '')：

如果 meaning 字段为 NULL，则返回空字符串，避免 Go 中扫描到 nil 字符串时出错。同样处理 phonetic 字段。

go引入自建包名报错 package XXX is not in std

这个错误消息表明Go代码尝试导入一个位于项目目录之外的包，并且Go无法找到这个包。首先看了我的包名对应的路径是没有问题的。

检查配置环境变量

1
go run server\main.go

为什么winnerID是指针地址

1
2
3
4
5
6
7
8
9
func (contest *ConflictRepostiory) FinishBattle(
	environment context.Context,
	battleID uuid.UUID,
	winnerID *uuid.UUID,
	p1Score int,
	p2Score int,
	endReason string,
	) {

允许没有胜者，

sync.Once

保证某个操作在全局范围内只执行一次

1
2
3
4
5
6
7
8
9
10
11
var once sync.Once

for i := 0; i < 10; i++ {
    go func() {
        once.Do(func() {
            fmt.Println("这只打印一次")
        })
    }()
}
time.Sleep(time.Second)
// 输出只有一行 "这只打印一次"

协程

1
defer rows.Close()

延迟执行close，在当前函数返回结果前自动关闭结果集，防止连接泄露，defer保障无论返回panic还是正常都会执行关闭

持有数据库连接资源的都defer

1
for rows.Next() {

遍历结果集的每一行

1
JOIN synonyms s ON s.word_id = w.id

内联查询，on后面跟查询条件

只保留那些在 synonyms 表中至少有一条关联记录的单词。如果一个单词在 synonyms 表中没有对应的行，则这个单词不会出现在查询结果中。

1
group by w.id ,w.word

按单词的id和单词本身分组

1
having count(*) filter (where s.is_correct = true) >=1

filter语法，计算分组后四个单词里面is correct的数量，然后要求它大于等于1

1
order by

排序

1
result := make([]wordRow, 0, count)

创建一个result的切片，类型是wordRow，初始长度是0，容量是count

思路

有一个想法后先分析它是业务逻辑复杂还是主要数据库的查询

DDD

将业务逻辑作为软件的核心，通过建立与业务专家一致的“领域模型”来解决复杂业务问题。

BDD

一种敏捷开发实践，强调用自然语言描述软件的行为，从用户需求出发，让业务、开发和测试三方协作并自动验证。

ORM自动映射

对象关系映射 的一种高级功能，它能自动将数据库表结构映射到程序中的对象，并自动处理对象状态与数据库记录的同步。

首先确定

对战形式：实时，所以用到websocket

然后设计数据存储，游戏流程，前端需要展示题目，选项，用户点击选项后判断对错，更新得分，加载下一题

WebSocket 用于实时同步双方状态（得分、当前题目、谁答对等）。HTTP 用于页面加载、获取初始数据等。

没有思路就频繁切换到用户视角

用户a和b对战，一局有十轮，一轮中从word表里面取出一个单词，然后根据word id查synonyms

多行数据从数据库到业务层的转换

如果是十轮，就在查完一个单词的基础上加limit 10，把查询到的结果返回到rows里面，初始化一个result切片，长度是10，遍历rows，把每一行word id 和word扫描到wordRow里面，然后追加到result，这就实现了多行数据从数据库到业务层的转换

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
func (r *QuestionRepository) getRandomWords(ctx context.Context) ([]wordRow, error) {
	sql := `
		SELECT w.id, w.word
		FROM words w
	
		GROUP BY w.id, w.word
		
		ORDER BY RANDOM()
		LIMIT 10
	`

	rows, err := r.db.Query(ctx, sql)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	result := make([]wordRow, 0, count)

	for rows.Next() {
		var w wordRow
		if err := rows.Scan(&w.ID, &w.Word); err != nil {
			return nil, err
		}
		result = append(result, w)
	}

	if err := rows.Err(); err != nil {
		return nil, err
	}

	return result, nil
}

根据word id查synonyms

取出来的单词和单词id放在业务层的wordRow后利用它查synonym，这个场景是已知word id，求synonyms

首先确定实体

前端需要通过ws向后端发送指令，所以定义客户端到服务端的消息格式

1
2
3
4
5
type ClientMessage struct {
    Type   string `json:"type"`   // 消息类型，如 "answer"
    Round  int    `json:"round"`  // 当前第几题（防止旧消息被误判）
    Choice int    `json:"choice"` // 玩家选择的选项索引（0-3）
}

服务端需要接收用户的回答，需要确定哪个玩家在哪一回合选择什么

1
2
3
4
5
type Answer struct {
    Player int   // 玩家编号（1 或 2）
    Round  int   // 回合编号
    Choice int   // 选项索引
}

服务端需要向用户发送信息

设计函数时要分析在什么场景，做什么动作，已知什么，要返回什么

服务端在游戏中向所有用户发送信息且不影响其他操作，所以需要先复制再发送

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//  错误做法：直接使用 map
g.mu.Lock()
for _, client := range g.players {
    safeSend(client, msg)  // 发送过程可能很慢
}
g.mu.Unlock()
// 问题：发送时持有锁，阻塞其他操作（如新玩家加入）

//  正确做法：先复制再发送
g.mu.Lock()
clients := copyClients()  // 快速复制
g.mu.Unlock()
for _, client := range clients {
    safeSend(client, msg)  // 发送时不持有锁
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
Broadcast("hello")
    │
    ├─ Lock() ──────────────────────┐
    │                                │
    ├─ 复制 players map 到 slice      │ 锁内操作（快）
    │   clients = [c1, c2, c3]       │
    │                                │
    ├─ Unlock() ─────────────────────┘
    │
    ├─ for client in clients: ──────┐
    │   ├─ safeSend(c1, "hello")    │ 锁外操作（可以慢）
    │   ├─ safeSend(c2, "hello")    │ 不影响其他 goroutine
    │   └─ safeSend(c3, "hello")    │ 访问 g.players
    └────────────────────────────────┘

复制操作是写入操作，加锁保证获取某个时间点干净快照

需要定义一个游戏运行所需要的状态和依赖

用户输入需要写入泵，前端展示需要读取泵

两个用户在同一个场景需要房间

一个用户加入需要加入操作

如果前端int被访问即判断加入，通过int记录client信息，（创建客户端对象，然后读取赋值），如果两个人同时访问一个int，把先进入房间的通道关闭

什么情况下加锁

至少有两个go线程同时操作同一个变量，至少有一个是写操作

是map，go的map不是并发安全的，并发读写会panic

然后启动读写泵开始交互

ON CONFLICT (username)

冲突检测

完善注册功能

先确定数据模型struct实体，请求参数，注册响应

然后确定数据访问层，也就是repository，再确定service层，再确定handler层，最后配置路由

什么时候写defer

defer用于确保某个函数调用在当前函数返回前，无论正常返回还是返回panic，都要执行

只要获得了一个需要手动关闭或释放的资源，就在获取成功的下一行写defer释放他

常见情景有

文件操作

open后立即defer close

http响应体

get或post后立马defer close

互斥锁

mu.lock后立即defer unlock

数据库连接或事物

什么时候写err报错判断

飞书实际返回json后需要定义对应的go结构体去承接它

1
2
3
4
5
6
7
8
-- 一次性添加两个列
ALTER TABLE users 
ADD COLUMN IF NOT EXISTS feishu_open_id VARCHAR(100) UNIQUE,
ADD COLUMN IF NOT EXISTS feishu_union_id VARCHAR(100);

-- 创建索引
CREATE INDEX IF NOT EXISTS idx_users_feishu_open_id ON users(feishu_open_id);
CREATE INDEX IF NOT EXISTS idx_users_feishu_union_id ON users(feishu_union_id);
1
2
app_id 请求不合法
错误码：20028

授权链接里的 client_id / app_id 不合法、为空、写错、或者不是飞书开放平台认可的应用 ID。飞书 OAuth 获取授权码接口文档说明，授权链接需要传 client_id、redirect_uri、response_type=code、state 等参数；重定向 URL 也需要在开放平台配置通过安全校验。

ngrok内网穿透

1
ngrok http 8080

如有错误，多多指教

valine