Summary on GzzhM

[webook-tidy] Gin & 基本路由

Fri, 17 Jul 2026 00:00:00 +0000

Gin 入门

Gin-Engine

在 Gin 中, 一个 Web 服务器被抽象成为 Engine

Engine 承担了路由器注册、接入 middleware 的核心职责

func main() {
    server := gin.Default()
}

type Engine struct {
	// ... 
    RouterGroup
	// ...
}

Gin-Context

Gin 封装的上下文, 其中 Request 和 Writer 负责处理请求和返回相应

type Context struct {
    writermem responseWriter
    Request   *http.Request
    Writer    ResponseWriter
    
    Params   Params
    handlers HandlersChain
// ..
}

对于 GET 的参数我们使用 query 进行获取参数

`1`	`code := ctx.Query("code")`

对于 POST 的参数我们使用 Bind 进行获取参数

	type Req struct {
		Code  string `json:"code"`
		Phone string `json:"phone"`
	}
	var req Req
	if err := ctx.Bind(&req); err != nil {

Gin 路由注册

在 Engine 的 RouterGroup 支持注册 Restful 的接口

// ... 
func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodPost, relativePath, handlers)
}

// GET is a shortcut for router.Handle("GET", path, handlers).
func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodGet, relativePath, handlers)
}

// DELETE is a shortcut for router.Handle("DELETE", path, handlers).
func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodDelete, relativePath, handlers)
}
// ...

基本路由

跨域请求

前端端口是 localhost:3000 请求到了后端 localhost:8080

对于域名和端口任意一个不同都是跨域请求

跨域请求问题是浏览器那边进行控制的

每次浏览器请求前，会提前发送一个 Option 的方法访问 allow-origins,allow-headers,allow-method

如果不在允许范围内就会失败

中间件

对于请求发送到实际业务逻辑。前后插入的额外处理即是 middleware

也就是 AOP编程。

最常见的 AOP 就是

beforeHook()
do()
afterHook()

限流start --> 熔断start --> handler --> 熔断end --> 限流end

Gin 插件支持使用 Use 进行中间件的注册

func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
group.Handlers = append(group.Handlers, middleware...)
return group.returnObj()
}

面试

什么是 Gin 的 middleware ？能用来解决什么问题？
什么是跨域问题，怎么解决？
跨域问题需要设置哪些头部？

最后

设计并实现一个 Gin插件库

使用 middleware 机制实现 Gin 插件库支持

Web 治理 ：熔断限流降级
可观测性 : 包括日志、metrics、tracing
身份认证与鉴权 :

[webook-tidy] Gorm & 用户基本功能 & docker

Fri, 17 Jul 2026 00:00:00 +0000

Gorm

Orm (Object Relational Mapping) : 对象关系映射。 Orm框架提供不需要关注实体对象与数据库之间的操作关系

Docker Compose

docker compose 启动 mysql8

基本语法 :

services : 服务列表
image : 镜像
command : 启动命令 (启动命令行参数)
volumes : 挂载文件
ports : 端口映射关系

version: '3.7'
services:
  mysql8:
    image: mysql:8.0.29
    command: --default-authentication-plugin=mysql_native_password
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: root
    volumes:
      - ./script/mysql/:/docker-entrypoint-initdb.d/
    ports:
      - "13316:3306"

基础命令 :

dokcer compose up : 初始化 dokcer-compose 并且懂 docker compose down : 删除 docker-compose 里面创建的容器

项目结构

Service : 代表领域服务完整的业务的处理过程

Repository : 按照 DDD 的说法是代表领域对象的存储，可以认为是存储数据的抽象

Dao : 代表数据库操作

domain : 代表领域对象

├── domain
│   ├── user.go
├── repository
│   ├── cache

│   ├── dao

│   └── user.go
├── service

这里简单提一下 :

我们公司项目的调用逻辑是 :

每一层都有自己相同的 user , 从这里看

htv2-db 操作代表 dao
exgv2 层代表 domain (和 db 弱关联，但是算是底层数据)
cefiacc 即是 Repository
ec代表 service 封装给其他组进行调用

`1`	`ec --> cefiacc --> exgv2 --> htv2(db)`

一些疑问

为什么有了 repository 之后还要有 dao ?
- repository 是一个整体抽象，本质上可以考虑用 ES或者是Mysql或者是 mongoDB 并不代表数据库

HTTP

无状态协议 HTTP

HTTP 是无状态协议，对于连续发送的两次请求, HTTP 并不知道两次都是同一个人发的

只能引入 cookie 和 session 进行记录

浏览器存储一些数据到本地，这些数据就是 Cookie

因为 Cokkie 是放在浏览器本地的，所以很不安全

一些关键配置 :

Domain : cookie 可以用在什么域名下
Path : cookie 可以用在什么路径下
Max-age 和 Expires : 过期时间
Secure : 只用于 HTTPS 协议

func SetCookie(w http.ResponseWriter, r *http.Request) {

 cookie := http.Cookie{
  Name:     "access_token", 
  MaxAge:   3600,       
  Path:     "/",        
  HttpOnly: true,       
  Secure:   true,     
 }

 // send cookie via header
 http.SetCookie(w, &cookie)
 fmt.Fprintln(w, "Cookie has been set!")
}

Session

由于 Cookie 本身不安全的特性，所以大部分我们不把一些关键信息放在 Cookie

关键数据我们希望放在后端，这个存储的东西就是 session

	sess := sessions.Default(ctx)
	sess.Set("userId", user.Id)
	sess.Options(sessions.Options{
		MaxAge: 20,
	})
	sess.Save()

个人理解 :

session也离不开本地化存储，大部分都是放在 cookie中如果禁用了cookie也会考虑放在header或者是query中
使用session无非是把敏感信息的相关校验放在了后端

面试

什么是 cookie 什么是 session ?
cookie 和 Session 比起来有什么缺点
Session ID 可以放在哪里？
用户密码加密算法选取有什么注意事项
怎么做登陆校验

后续

增强扩展 GORM 功能

为 GORM 提供可观测性的插件实现
为 GORM 提供读写分离插件
为 GORM 提供 BeforeFind 功能
为 GORM 提供辅助方法

[webook-tidy] Session & JWT & Security

Fri, 17 Jul 2026 00:00:00 +0000

场景问题

刷新登陆状态

对于一个设置了 10分钟过期时间的 session，我们应该如何采用刷新策略才能够保证用户在用着用着就要重新登陆

用户每次访问，我们都刷新
- 性能差，对 Redis 之类的影响很大。小公司看不出来，但是如果是 10w or 100w用户级别
快要过期了我在刷新，例如 10分钟过期，用户9分钟过来访问的时候刷新
- 如果用户第9分钟没有过来那就寄了

因此只能考虑使用 固定时间间隔刷新,比如每分钟内的第一次访问我们都刷新

即

在sesssion中维护一个 updateAt 的参数
然后在 middleware 中进行更新

JWT

JWT (Json WEB Token) : 很常见的一种机制，主要用于身份认证

基本原理就是通过加密生成一个 token ,每次访问都带上这个token

组成部分 :

Header : JWT 的元数据
Payload : 数据内容
Signature : 签名

基本流程如下 :

使用 NewWithClaims 设定指定的算法
并且传入对应的 userCliams

func (j *jwtHandler) setJWTToken(ctx *gin.Context, uid int64) error {
    userClaims := UserClaims{
    RegisteredClaims: jwt.RegisteredClaims{
    ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Minute * 30)),
    },
    UserId:     uid,
    UserAgents: ctx.Request.UserAgent(),
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, userClaims)
    tokenStr, err := token.SignedString([]byte("secret"))
	
	ctx.Header("x-jwt-token", tokenStr)
//. ..
}

校验方通过同样的 sign-method 和 secret 校验是否正确

JWT 的优缺点

和 Session 比起来优点 :

不依赖第三方存储
适合用于分布式环境
提高性能

缺点 :

对加密依赖非常大
最好不要在 JWT 中存储敏感信息

保护系统

如果有一个人，使用脚本进行大量的发送注册、登陆请求，系统负载会提高所以这时候需要考虑保护系统

最简单的一个办法就是 限流

限流

如何在登陆之前确定限流

我应该怎么认定是哪个用户发送了什么请求？
我应该怎么确定我限流的阈值时多少？

限流对象

IP 是最容易获取的限流方式之一

其中更好的选择还有 MAC 地址 以及 CPU序列号 但是在 web端很难获取

APP端端话可以考虑设备序列号

不过 IP 并不能实际意义上代表一个人，因为两个人可以共用一个 ip 但是这已经是较好的一个选择了

限流阈值

限流阈值时通过 压测 得到的。例如 压测 了整个系统，发现最多只能撑住每秒 1000个请求，那么阈值就是 1000

安全

不管是 JWT 还是 Session 一旦被攻击者拿到关键的 JWT 或 SSid 攻击者就会假冒你

HTTPS 可以有效的阻止攻击者拿到你的 JWT 或者是 ssid

但是如果你电脑中了病毒，那 HTTPS 也无能为力

最好的解决办法是做一个二次校验，即增加 发邮件, 发短信 的形式进行控制

或者是增加一些额信息例如 HTTP 的User-Agent头部，或者是手机硬件信息

面试

刷新 Session 过期时间的几种可行的办法
增强登陆的安全性
- 怎么保护 session id ? 主要还是开启 HTTPS 协议，把 cookie 的 Secure 和 HttpOnly 设置为 true
- 怎么做到在 Session id 或者是 JWT token 泄漏之后保护住用户？要在登陆的时候记录一下登陆的附加信息，例如 user-Agent 在登陆校验的时候统一校验
如何保护 Web 服务？针对 IP 限流、整个集群限

后续

支持 Gin 的限流插件 :

单机限流 :

令牌桶限流
漏桶限流
滑动窗口限流
固定窗口算法

分布式限流 :

基于 Redis 限流
给予 Redis 的 IP 限流

[webook-tidy] Golang 基础语法

Tue, 14 Jul 2026 00:00:00 +0000

函数式编程

Golang 支持定义方法作为变量即 myFunc = func(){}, myFunc() 的形式

同样方法也可以作为返回值

func Say() func(name string) string {
    return func(name string)string {
        return "hello," + name
    }
}

闭包

closure ：方法+它绑定的上下文

组成如下 :

方法
运行时上下文 : 即 name 变量

func Closure(name string) func() string {
	return func() string {
		return "hello " + name
	}
}

闭包如果使用不当会造成内存泄漏, 因为外层 Func 的name变量被直接使用传递出去了。如果一个对象被闭包引用，他是不会被垃圾回收的

不定参数

Golang 支持不定参数传递即,使用...进行，不定参数可以当作切片进行使用

1
2
3

func hanlder(name string ,alias ...string) {
    println(alias[0])
}

其中 Option模式 大量应用了不定参数

Defer

Golang 允许你从方法返回前一刻执行一段逻辑

Defer 的运行逻辑类似于栈即 后进先出

func Defer() {
    defer func() {
        println("第一个defer")
    }()
    defer func() {
        println("第二个defer")
    }()
}

输出如下

1
2

第二个 defer 
第一个 defer

问题

defer 有一个 catch 的机制，主要考 for 中的内容，如果是通过闭包传递或者是通过拷贝变量进行copy 他会catch到当前值而不是最后值

func DeferClosureLoopV1() {
	println()
	for i := 0; i < 10; i++ {
		defer func() {
			print(i)
			print(" ")
		}()
	}
}

// 预计是 10,10,10,10 拿到的是最后一个

func DeferClosureLoopV2() {
	println()
	for i := 0; i < 10; i++ {
		defer func(val int) {
			print(val)
			print(" ")
		}(i)
	}
}

// 预计是 1,2,3... 10
// 实际是 9,8 ,7 ,6 ,5,4,3,2,1

func DeferClosureLoopV3() {
	println()
	for i := 0; i < 10; i++ {
		j := i
		defer func() {
			print(j)
			print(" ")
		}()
	}
}

// 预计是 10，10，10 ？
// 实际上是 9,8,7,6,5,4,3,2,1

基本数据结构

切片

语法 []type ,数组的话是 [int]type

初始化方式 :

`1`	`s1 := []int{1,2,3} //创建了一个 3个亚孙的切片`

1
2

s1 := make([]int,3,4) // 初始化 3个元素，这时候访问 s1[0] = 0 
s2 := make([]int,4) // 创建一个 4个元素的切片， 这时候访问 s1[0] panic

推荐使用 s1 := make([]type,0,cap) 的方式进行创建

子切片

切片可以通过 [start:end] 的形式获取子切片，其中范围是 左闭右开 的

内存共享问题 :

在没有发生扩容的情况下，子切片和切片是共享一个数组的
即如果子切改变了一个数，那么原本的切片也会改变

map

初始化方法

1
2
3

m1 := map[string]string {
    "key": "value"
}

对于 for k,v := range map 来说，每次结果都是不一样的

接口 & 结构体

接口是 一组行为的抽象

type name interface{}

结构体

1
2
3

type a struct {

}

衍生类型

如果我们想使用第三方库，但是又没办法修改代码，又想扩展这个库的结构体，我们会使用到这个

衍生类型只共享字段并不共享实现的方法

即 typeB 拥有的方法 , typeA并不能够调用

`1`	`type typeA typeB`

类型别名

不同于衍生类型，可以说是一个别名类型本质上是没有变的

`1`	`type typeA = typeB`

泛型

对于下面这个例子，其中 T 就是泛型可以是任意类型

1
2

type List[T any] interface {
}

泛型语法

对于 Number 来说就是一个泛型约束

func Sum[T Number](vals ...T) T {
	var res T
	for _, val := range vals {
		res += val
	}
	return res
}

type Number interface {
	int | int64
}

面试重点

[✅] 什么是闭包？闭包有什么缺陷
[✅] 什么情况下会栈溢出
- 自己循环调用自己
[✅] 什么是不定参数？调用方法的时候不定参数可以传入 0个值吗？方法内部怎么使用不定参数？
- 函数参数以 … 方式进行传递就是不定参数
- 0值预计是个nil ,会自动初始化
- 和切片一样使用即可

什么是 defer ? 能解释一下 defer 的运行机制吗？
- Go 语言提供的一种延迟调用机制。它通常用于处理成对出现的操作，比如打开/关闭连接、加锁/释放锁。无论函数是正常执行结束还是发生了 panic，defer 注册的函数都会被确保执行，这能有效防止资源泄漏。

[已删除] 一个方法内部 defer 能不能超过 8个？
[待定] defer 内部能不能修改返回值? 怎么改？

数组和切片有什么区别？
- 类型与长度限制：
  - 数组是定长的，长度是其类型的一部分（[3]int 和 [4]int 是不同类型）
  - 切片是动态的，长度不属于类型的一部分（类型统称为 []T）
- 底层数据结构：
  - 数组是一段连续的内存空间，直接存储了所有的元素。
  - 切片本质上是一个引用类型（描述符），它的底层结构包含三个字段：一个指向底层数组的指针（Pointer）、切片的长度（Len）和容量（Cap）。
- 函数传参的性能开销:
  - Go 语言是值传递。如果把数组作为参数传递，会触发整个数组的深拷贝，对于大数组来说内存和 CPU 开销很大。
  - 传递切片时，只会拷贝切片头部的三个字段（指针、长度、容量），开销非常小。并且在函数内部修改切片的元素，会直接影响到底层的真实数组。
- 扩容机制：
  - 数组创建后不可扩容。切片支持使用 append 函数追加元素，当容量不足时，Go 运行时会自动分配一块更大的新内存，将旧数组的数据拷贝过去，并让切片的指针指向新数组。
切片怎么扩容？
- 在 256 以下进行双倍扩容
- 在 256 以上进行 (原容量 + 3 * 256) / 4 即 1.25倍的扩容

最后

了解函数式编程在在业务中的使用
了解内存泄漏，业务上的内存泄漏，排查方法，解决办法
了解垃圾回收的机制
了解 Option 模式
slice 的底层实现
map 的底层实现
defer 的实现原理和机制
闭包

写出一个泛型工具支持

切片的辅助方法 : 添加、删除、查找、求并集、交集、map reduce API
map 辅助方法
扩展 map 实现 : 接受任意类型的 HashMap, TreeMap, LinkedMap
List 实现 : LinkedList, ArraryList 和 SkipList
Set: 包括 HashSet 和 TreeSet, SortedSet
队列: 普通队列,优先队列
bean 操作操作辅助类 : 高性能高扩展的 bean copier机制
并发扩展工具 : 包括并发队列,并发阻塞队列,并发阻塞优先队列
协程池

闭包

Tue, 14 Jul 2026 00:00:00 +0000

基础概念

闭包 : 引用了自由变量的函数，即函数 + 引用环境

例子 :

func intSeq() func() int {

	i := 0
	return func() int {
		i++
		return i
	}
}

func main() {
	nextInt := intSeq()

	fmt.Println(nextInt())
	fmt.Println(nextInt())

	nextInt2 := intSeq()
	fmt.Println(nextInt2())
}

输出如下

1
2
3

1
2
1

我们发现，对于程序内定义的变量 i, 他被外部函数引用了。并且对于 nextInt 和 nextIn2 是两个不同的环境，他们拥有不同的 i

怎么理解这个过程 :

函数的局部变量是分配在栈上面的
但是闭包上的变量会逃逸到堆上

原理如下 :

对于一个以函数返回到形式的 Func，我们称为 FuncValue 其分配是在堆上
当我们通过其他变量进行接收的时候，会先去堆上找到该 FuncValue 的地址，由于闭包 Capture 了局部变量所以会在堆上额外分配一块地址

垃圾回收

以下是一些概念

逃逸 :

变量生命周期超出声明它的函数栈帧，编译器不得不把它放到堆上

GC回收 :

堆上对象在没人引用后，由 GC 回收；程序结束进程退出时也会一起释放

对于下面这种形式，因为 nextInt 已经输出完成了，虽然main函数没有退出，但是已经没有引用了，虽然产生了逃逸但是同样会被回收

func main(){
	nextInt := intSeq()
	fmt.Println(nextInt())
	fmt.Println(nextInt())

	nextInt2 := intSeq()
	fmt.Println(nextInt2())

	for {} // 卡住不让 main 退出
}

只有在循环内一直被引用，以及包级变量引用的时候才不会被回收。

1
2
3

for {
    _ = nextInt() // 循环里还在用 → 仍存活
}

var keep func() int // 包级变量

nextInt := intSeq()
fmt.Println(nextInt())
keep = nextInt       // 挂到全局 → 一直可达

for {}

包级变量理论上来说是和当前进程一起存活的。但是如果在引用期间，主动进行解引用同样也会被回收

var keep func() int

func main() {
	keep = intSeq()
	fmt.Println(keep())

	keep = nil        // 断掉引用
	runtime.GC()      // 演示用；生产里不必手动调

	for {}            // 之后闭包就可能已被回收
}

应用场景

隔离数据

如果不想让其他人访问该数据,例如生成一个斐波那契数列，但是不想让其他人更改其 value

func main() {
  gen := makeFibGen()
  for i := 0; i < 10; i++ {
    fmt.Println(gen())
  }
}

func makeFibGen() func() int {
  f1 := 0
  f2 := 1
  return func() int {
    f2, f1 = (f1 + f2), f2
    return f1
  }
}

封装函数和创建中间件

Go 的函数是一等公民，如果我们想要实现一个，接口在运行前后的请求耗时中间件的话

我们需要使用到闭包进行处理，因为 handleFunc 需要接受一个 FuncValue

func main() {
  http.HandleFunc("/hello", timed(hello))
  http.ListenAndServe(":3000", nil)
}

func timed(f func(http.ResponseWriter, *http.Request)) func(http.ResponseWriter, *http.Request) {
  return func(w http.ResponseWriter, r *http.Request) {
    start := time.Now()
    f(w, r)
    end := time.Now()
    fmt.Println("The request took", end.Sub(start))
  }
}

func hello(w http.ResponseWriter, r *http.Request) {
  fmt.Fprintln(w, "<h1>Hello!</h1>")
}

不过这并不会产生 OOM ，因为端口一直监听，但是堆上的逃逸只产生了一次

同理可以分析下面这两个情况，对于第一个场景，我们只产生了一个新的环境，而对于第二个场景我们每次都产生了新环境

nextInt := intSeq()
for {
	nextInt()
} 

for {
	nextInt := intSeq() // 每次新环境
	_ = nextInt
	// 若再塞进全局 cache / 切片 → 环境越堆越多 → 可能 OOM
}

sort 包

people := []string{"Alice", "Bob", "Dave"}
sort.Slice(people, func(i, j int) bool {
    return len(people[i]) < len(people[j])
} )
fmt.Println(people)

面试

什么是闭包？闭包有什么缺陷？

闭包的本质是引用了自由变量的函数，即函数+引用环境是闭包

闭包有什么缺陷 : 在我们反复使用新环境引用闭包变量的时候，会产生大量的内存逃逸从而使得CPU上涨和OOM

闭包的优点 :

可以规避一些函数定义的接收器不允许传入的参数, 例如中间件只允许传入 Write 和Request .但是我们如果想要引用其他 Param，那么就需要定义一个 FuncValue的返回， func(otherParm) FuncValue
做数据的隔离防止一些不想让其他人访问该数据。例如 Sort

🛠️ 改进项与“满分回答”建议 (Improvements)
为了在面试中拿到 9-10 分，你可以将回答按照“定义 -> 常见应用(优点) -> 底层代价(缺陷) -> 语言特有陷阱”的逻辑来组织。

你可以参考以下改进后的表述：

1. 什么是闭包？（保持你的精准定义）
闭包的本质是函数体加上它所引用的外部环境（自由变量）的结合体。在 Go 中，当一个匿名函数引用了它外部作用域的变量时，就形成了闭包。

2. 闭包的优点（优化你的实战案例）
函数签名适配与状态保持（柯里化）：在 Web 开发中，标准库的 http.HandlerFunc 只接受 ResponseWriter 和 Request。我们可以利用闭包将外部配置（如 DB 连接池、日志记录器）封装进去，返回一个符合签名的函数。

数据封装与隔离：闭包可以用来隐藏状态，实现类似面向对象中“私有变量”的效果。比如实现一个计数器生成器，每次调用返回的函数都能修改外层的局部变量，而这个变量对全局是不可见的。同时，在使用 sort.Slice 时，闭包能直接捕获并操作外部的切片，免去了繁琐的参数传递。

3. 闭包的缺陷与坑（重点重构）
性能代价（内存逃逸与 GC 压力）：
闭包引用的外部变量，其生命周期会超越原本的函数调用栈。因此，Go 编译器会通过逃逸分析将这些变量分配到堆上，而不是栈上。如果高频创建闭包，会导致堆内存分配增多，加重 GC（垃圾回收）的负担，进而可能引发 CPU 占用率上升。

经典陷阱：循环变量捕获问题：
(重点展示你的技术深度和对 Go 版本更迭的了解)
在 Go 1.22 之前，for 循环中的迭代变量是共享同一个内存地址的。如果在循环里启动 Goroutine 并使用闭包引用该变量，往往会导致所有 Goroutine 最终打印的都是最后一个元素的值。
补充加分项：不过，自 Go 1.22 起，官方已经修改了 for 循环的语义，每次迭代都会创建一个新的变量，从而从根本上解决了这个经典的闭包陷阱。

面试官点评：如果你能在面试中流利地按照上述逻辑回答，不仅展现了你扎实的理论功底和实战经验，还顺带秀了一把底层（逃逸分析、GC）原理，以及对 Go 语言最新版本（1.22+）演进的关注。这绝对是一个一锤定音的高分回答！

其他

多协程快排的实现闭包

2026-07-12 不定时复盘

Sun, 12 Jul 2026 00:00:00 +0000

写在前头 :

最近生活没有了特别明确的目标，活着确实有点不自在

反差

离职的时候写了2-3篇文章说是已经规划好了，但是实际只是简单算了一下故事点和整合内容

实际任务编排并没有特别有规划或者是目的的进行

当然并不是说我没有做，我确实是做了，我在整理完之后就开始寻找能够平替飞书甘特图的内容

毕竟之前上班都是用的那个，每天上班无非就是打开甘特图，打开backlog 看一下要做什么昨天有什么没做的，都是安排好的

我记得我找了好久，最后使用石墨文档的甘特图，然后排了这两周的任务，但是实际排完之后第二天就没运行了

我排了两个3个任务

完成 Acwing AI Chat 项目
- 周一做完XXX模块
- 周二做完XXX模块
算法学习项目
- 周一学XXX算法
- 周二学XXX算法
Tidy 任务
- 整理个人todo
- 整理公司todo
- 整理规划这几个月发展
- 整理个人业务闪光点

但是最终没运行

我的一天

昨天因为要吃一顿散伙饭所以没有特地记录，今天的话可以说是可以好好记录一下

今天早上 10:00 左右起床的，不过9:00就起来了，昨天在玩堆叠大陆，买了2个DLC，然后熬了会夜看攻略

今天早上起来还在看大概看到了 10:00 然后起床洗漱

然后开始玩游戏玩到了中午12:30 开始吃饭，点的外卖不想自己做饭

然后吃完饭后，看了会抖音大概看到了 13:30. 然后好像就去看电视剧去了大概看了2个小时看到了 15:30

然后开始打开百度云看一个《golang训练营从0到1》总共28周，我预计是想要一天学一周的内容，这样子可以控制在一个月内学完，但是因为昨天耽搁了，所以今天在赶昨天的进度

现在还是很简单的内容今天主要学习了

项目结构
普通的登陆和注册
错误的基本处理
数据库的连接
session 和 cookie
以及密码加密什么的

都是一些大学阶段就应该掌握的内容，我现在2年后又重新掌握一遍，但是我并没有把我的commit推送，我甚至没有把这个项目当作我的仓库项目，只是放在那里

也就是说需要更新到我简历的项目目前还没有开始写

然后18:30左右开始做饭，今天正常无氧 20分钟

然后吃饭，吃完饭后洗澡，打游戏，刷抖音。大概好像就到了21:00左右了

出门跑步，跑了半个小时，最近拉肚子，跑步跑的不是很得劲，然后走了1.5公里回去，大概 22:10左右回到家

然后洗澡，再清一会游戏体力

大概到了23:00开始学习算法，学了预计半小时吧还是40分钟

学完之后补一下 commit 和 blog 然后开始写这篇随便总结的文章

下一步

下一周其实还有一些公司的活需要干，例如写交接文档，完成todo

但是我的心思已经不在公司那边了

随便写点

说实话我原本预计一天学习8小时的，这样子可以在一个半月内追完进度

但是实际今天只学习了4个小时，也就是说在buffer范围内，我需要花费 3个月的时间才行，这很显然对我来说不是很乐观

随便写点，或许明天有空会继续补内容，因为正好 0:00 了我要上床了，这是习惯

垃圾中堆找黄金

Wed, 08 Jul 2026 00:00:00 +0000

说实话没有什么比较好的思路能够一下子整理出工作中的闪光点

目前能想到的切入点

人脑回忆这两年的Backlog
从上到下扫描这两年全部的Backlog
根据产品季度目标 PO-backlog 来整理

预计采用的方案是

1+3,如果数量不够可能会使用 2进行补充

开始回忆

账户暂停

我们系统内部维护一个 Account Api 状态

包括 只读,归档,Error,交易

需要增加一个账户暂停的状态，把归档的状态下掉，为什么下掉归档忘记了，看着是从业务理解层面上下掉的

暂停的账户需要停止

资产的更新
记录的抓取

印象中是做了

在 Account 表中增加一列 boolean 表示账户是暂停还是启动
在 Collector Account Monitor 中根据账户的状态进行控制是否要进行资产更新
在 Fetch Data Monitor 中根据账户的状态进行控制是否要进行抓取记录

这里感觉不对 :

优化了一下流程

写了一个 prompts 然后把对应任务的 pr丢给他让他分析

这次改动做了什么

通过 migration 给涉及到的3张Account数据库表增加 state 的列
处理相关下游模块的暂停程序 collector , monitory , api hook
通过 go 一个 migrateArchivedToPaused 将历史归档状态的账户改成暂停的账户

亮点 :

复杂领域模型的状态及设计，因为涉及到 子账户暂停母账户才可以暂停
跨模块一致性改造
存量数据迁移

个人想法

理了一下这个backlog，感觉并不是很惊艳，只能说涉及到的模块多，下游设计到的多，导致做的周期比较长比较大

我感觉可以把 migration 单独提出来说一下，可以去挖一下我们公司 migration 的实现

Ai总结

主导 CeFi 账户 Pause/Resume 端到端设计与实现，将原先混用的「归档」语义拆分为运行态（Normal/Paused）与 API 权限态，新增 DB 三字段并完成 v2.171 migration。实现 Prop/Sub 级联状态机、恢复前 API 复检、事务与业务日志；改造 Collector 与 Monitor 共 6+ 后台 Job，暂停账户停止资产拉取与 API 巡检；完成归档账户存量迁移及多轮生产 bugfix，保障 v2.171 稳定上线。

Async

背景

交易所接口的实时查询接口只能够查询最近3个月的数据，如果想要获取更早的数据需要透过异步接口获取

请求下载ID | 这一步一个月有次数限制，而且IP权重很高
根据请求下载ID 去请求下载链接

整理

整体思路

REST 入口（统一限流/配额/落库）
    ↓
DownloadId 工厂（exg + dataType → handler）
    ↓
Redis 队列（解耦「申请」与「轮询下载」）
    ↓
后台 Scan Job（轮询 + 下载 + 重试）
    ↓
MQ → Consumer（CSV 解析 → 标准 OTS 格式 → 入库）

亮点

Redis 队列进行接藕操作
任务每次在发版进程重新启动的时候进行Recover
状态机驱动 not_started → packaging_data → downloading → importing → succeed/failed，含 packaging_data_with_error
双层配额控制
- 进程级 : rate.Limiter 一分钟一次，防止误操作
- 账户级 : Redis 控制自然月计数
Mock 测试体系

AI一句话总结

设计并实现 CAM 加密资产管理系统历史数据异步拉取引擎（Go / Redis / PostgreSQL / MQ）：从 0 搭建 Binance/OKX/Bybit 异步导出全链路（申请 → 轮询 → 下载 → CSV 解析入库），含双层配额控制、Redis 队列解耦、PG 状态机与发版容错恢复；支撑对账与历史回溯，模块累计 100+ 次生产迭代。

Auth 升级

背景说明

我们的 Apikey 铭感信息都存放到 Auth 服务器上，之前 Auth 服务器上的 APikey_1 表数据太脏了

apikey 不是存放在prop层级的，而是母子层级都可能存在

现在想要升级 apikey_1 为 apikey_2

希望所有 apikey 都收拢到 prop层级上面

–

C交易所账户有层级结构：Prop 母账户（如 bnprop）下挂多个子账户（如 binancef、binanced）。原先每个子账户都要单独配置 API Key，运维成本高、易出错。

这套改动实现：子账户自动复用 Prop 母账户的 API 凭证，并支持复制已有 Prop 账户创建新账户，同时完成 Auth 服务从 V1 到 V2 的平滑迁移。

整理

存储层 : 新增 account_apikey_2 表

Auth Server 层 : 新增 Copy Api 的功能,暴露出copy-api的接口

Auth Client 层 : 封装 Copy 调用， V1/V2 自动切换

业务层 : CopyHelper 统一调度：读 Key、写 Key、复制账户

观测层 : 给每一个回退增加统计

核心决策设计 :

双表并存，平滑迁移
- V1（account_apikey）与 V2（account_apikey_v2）共存
- 支持 V1→V1、V2→V2、V1→V2 三种 Copy 路径
- 客户端按 Auth 版本自动路由，V1 读不到时自动 V1→V2 迁移
灰度发布
- CopyRegionControl() 控制 master 环境先上线
- 后续通过 Auth 版本检测自动切换 V2

个人想法

这个功能比较难做，涉及到的模块很多，而且更新新增删除 apikey 暴露给了很多地方，还需要做版本控制

导致改动的地方很多

Ai总结

负责设计并实现交易账户 API Key 共享能力，解决 Prop 母账户与子账户重复配置凭证的问题。新建 account_apikey_v2 存储层，提供 V1/V2 双版本 Copy API；在 tradeacc、auth_client、交易所 Sign 模块实现统一 CopyHelper，支持子账户自动复用 Prop 凭证及复制开户；设计 V1→V2 平滑迁移与降级回退，配合 Feature Toggle 灰度发布；新增 Copy 降级监控指标。涉及 5 个核心模块、1,000+ 行代码，6 天内分 4 个 PR 交付。

Trans 表优化

背景

成交表的数据有很多，一个客户一天的数据甚至就能到百万级别的了，需要优化一下存储

我们Trans表主要存储 id,business_id,account,time,detail这几个字段，之前 detail 是直接存储的交易所的原始返回

所以主要是优化这部分内容，通过压缩存储来进行优化

压缩算法和测试是运维那边来处理的（后续需要去看一下）

整理

我们存在两个结构一个是 ec.OTSTrans 供给上层业务组使用一个是 db.Trans 用于存储

新增 SlimOTSTrans，将 ec.OTSTrans 的 jsontag 改为短JSON名处理例如 a/b/c...
在 OTSTransToDB 的时候使用 Compressor 进行控制
新增 blob 和 blob_format 列用于表示是否是压缩内容以及存入压缩内容
将detail字段进行私有化控制，全部业务层统一使用 GetDetails()和SetDetails()进行访问

流程写入时：JSON → Slim 序列化 → 压缩 → 写入 blob，清空 details；读取时：按 blob_format 自动解压还原

┌─────────────────────────────────────────────────────────┐
│  Layer 1: JSON 字段瘦身 (SlimOTSTrans 短字段名)          │
├─────────────────────────────────────────────────────────┤
│  Layer 2: 二进制压缩 (xz / zstd / vanilla)               │
├─────────────────────────────────────────────────────────┤
│  Layer 3: 存储分离 (details 清空 → blob 存压缩数据)      │
└─────────────────────────────────────────────────────────┘
                          ↓
              blob_format 标识格式，统一读写入口
                          ↓
         blob_format=0 读旧 details（向后兼容）
         blob_format>0 读 blob 解压（新数据）

架构与设计

全链路存储优化：不是简单「加个 gzip」，而是从 JSON 结构、压缩算法、DB Schema、读写 API 到 20+ 下游模块的系统性改造。

向后兼容设计：blob_format 双轨读写，支持新旧数据共存，生产可渐进迁移。

零拷贝转换：SlimOTSTrans 与 OTSTrans 通过 unsafe.Pointer 转换，并用 init() 校验 struct layout，兼顾性能与安全。

Ai总结

设计并实现 CAM 历史交易流水存储优化：Slim JSON 瘦身 + zstd/xz 压缩 + blob 分离存储，解决核心表存储与 I/O 瓶颈。
通过 blob_format 双轨兼容设计实现零停机迁移，重构 40+ 下游模块统一读写接口，开发 CLI 批量迁移工具并完成多环境灰度发布。

整理

Wed, 08 Jul 2026 00:00:00 +0000

我去过两个很远的地方，一个是香港的麦理浩径一个是成都的雪山

去成都雪山的时候

我买了一个 25L 的背包
提前一晚上买了一点路餐
买了运动相机
买了2个登山杖
买了速干内衣
买了抓绒内衣
买了冲锋衣冲锋裤

这些不是我自己想出来的，参考的网上的攻略

“世间上到现在所有的问题都有人有答案”

去麦里浩径补充买了一些东西

一个 48L 的背包
睡袋
帐篷
能量胶

我说这些是想表明，想要出发需要先整理，整理出发需要什么，现在有什么，我没有什么

我有什么

2年的工作经验，虽然很多都是 dirty - work 。但是也有一些值得拿出来讲的事
- 另外我leader和其他同事做的事情其实也可以拿过来让自己用
- 开发中使用 AI Cursor Skills prompts 的经验
Acwing 的算法基础课和提高课，以及之前刷过算法的经验
- https://www.acwing.com/activity/content/11/
- 虽然把之前学的算法忘的差不多了，但是实际去重温会发现比从0开始学速度更快，而且感受更不一样
一个 Java 的知识星球
- https://nageoffer.com/planet/ 我才发现竟然更新了 Agent 项目，不得不承认 Java 高性价比可以直接抄的项目有很多，路线上看的比Golang更清晰
一个 Python 的 AI Chat 课
- https://www.acwing.com/activity/content/4250/ ，体积小仅 18个课时，视频形式从0到1，到项目上线
一个 Java 的在线匹配课
- https://www.acwing.com/activity/content/1877/ 依旧是体积小，视频形式从0到1，到项目上线，我记得这个项目前端占比了10个课时左右
一个完整的 Golang 课程
- https://u.geekbang.org/subject/go3rd 总共24周，视频时长还没统计过，预计覆盖很多内容，但是视频是24年11月份的，不涉及现在 AI 相关内容
一些简单的 Go 项目
- https://geektutu.com/post/gee.html
- https://www.bilibili.com/video/BV1op4y177iS/?spm_id_from=333.1387.homepage.video_card.click&vd_source=25934349561f43f2cda2ed48ce984f9b 一套简单的Go-zero实现

我没有什么

良好的 Golang 基础，现在要问我 Golang 数据结构的实现，GC 什么的我都不清楚
良好的八股文基础，同样的计算机网络操作系统 Redis什么都忘记了
没有 Mysql 相关经验，工作用的是 Pg
没有 Kafka 、etcd、docker 的经验，工作用的 Redis stream实现的MQ
没有高并发 GRPC 等相关的经验

市场需要什么

网易 :

熟悉 Gin、Go-zero
熟悉 Restful API 设计规范
熟悉 Golang 生态的服务架构设计
熟悉中间件的使用 MySQL、Redis、Kafka、RocketMQ
具有高并发业务相关经验

游卡 :

精通 Golang 相关网络服务开发熟悉 Python
熟练掌握设计模式以及面向对象的设计模式
熟悉网络基本原理，比如 TCP/IP，HTTP 协议
熟悉 MYSQL 数据库，了解 MYSQL索引优化，查询优化，存储优化

字节 :

熟悉分布式系统设计、微服务系统设计、稳定性治理、常用中间件原理

腾讯 :

熟悉 Mysql、redis、es、mongo等存储以及常见的消息中间件
熟悉 TCP/IP 与 HTTP 等网络协议
有海量服务、高性能、分布式系统设计、开发经验者优先
AI 工程化实践 : 熟悉使用主流 Ai coding工具，有LLM接口继承，对话系统开发或Ai Agent 工程化落地经验者优先

我应该怎么做

提炼

提炼这两年 dirty work 中的（难点，怎么解决的，遇到的问题，闪光点）
AI 在项目中的使用方法
BS设计模式

重温

算法+刷题
Go语言的面试问题，深度理解
八股文

学习

Mysql
Redis
Kafka
etcd
docker
设计模式

需要

AI Agent 后端 (预计魔改一下Java的那个项目)
高并发服务（可能选择邓明的那个或者是魔改一下我实习的项目，看一下哪个ROI高点）

写在最后

我自己也看不清未来的走势，站在这个时间点我也迷茫恐惧想要逃避

但是我内心有一股劲，或者说我还年轻，我只有一双脚，能走到哪里，我也想看看

裁员之后我该何去何从

Tue, 07 Jul 2026 00:00:00 +0000

写在前头 :

周一通知的裁员，今天周二，这一周还有很多任务要做，今天可以说是这周最忙的一天

今天一整天都没怎么摸鱼，没有写算法题没有写项目。回到家也很累，今天锻炼就锻炼了15分钟

现在是 22：29 我想我应该做点什么

现状

这次被裁员了 20% ，覆巢之下，安有完卵 , 我应该算是最年轻的一个

跟我同一批的人他在做什么 :

跟我同一批的人有4个，指的是我们公司的，至于互联网上的其他人我并不清楚

清华哥，实习的时候和我对接，但是实习结束后没有选择转正而是去日本工作了
equation，目前应该是单独处理一个业务组，好像是在做最新的业务
yapeng,一开始是在行情组工作，但是后面分了一半心思去做 AI Agent了主要是对接客户成功那边

反观我而是一直在组内安分守己温水煮青蛙，我并不知道他们为什么会去接触这种新业务的，是Leader推荐还是CTO选拔，或者是自己去私聊。我是一个局外人

跟我同一批被裁的人在做什么 :

跟我同一批被裁的目前聊下来的大概有 4个，至少有4个有一些打算

sunl, 我前组的同事，在我实习转正之后跳到了风控组。我很佩服他这个决定，可以说是天时地利人和而且非常大胆

我记得我们公司春初的时候让大家填了一个表，询问是否想要留在自己组，如果不想要留在自己组最想去哪个组。但是我并不思变，依旧选择自己组

但是 sunl 是前年就转组了，没转组之前预计在我们的业务组呆了2年。可惜的是他也被裁了。我没记错他应该是去年结婚的，估计现在经济压力负担也大，他现在的目标就就是

下周就能到岗
远程高新工作

有点佩服，一直都在更新简历？不用准备？下周就能到岗

xll，一位工作了很久的同事，说是这波裁员之后都可以领退休金了，社保已经交满15年了

他现在的想法是

先玩一个月
然后复习
最后转 AI

哦另外两个没有表明意向，我也不清楚。我本来预计是想要gap半年的，但是看到老一辈的都这么卷，我感觉我也不能松懈

我的想法

我现在的想法是什么 :

从先玩再准备，改变成先准备在玩

预计一天学习 9:00 到 21:00 , 12个小时。算上buffer-time 预计是 10~12个小时

先准备一个月，大概是 300 ~ 360 h

预计需要完成3个项目

一个 Python 搭建的 AI Chat 项目，这个项目来自 Acwing ; https://www.acwing.com/activity/content/4250/

之前写到一半放弃了，18个课时，算上double，总共36个课时

一个 Golang 的项目，这个还没有找可能是从实习简历里面捞一个出来，或者是重新写一个。预计课时也是18左右 double 36
一个 Mit 6.824 我很可惜，我一直没有完整的思考和写过这个项目，预计课时 10 double 20
一个 Java 项目可能也来自 Acwing 或者是 Java 星球里面的 12306 抢票系统。预计课时 18 double 36

项目花费课时 36*3 + 20 = 128

期间还需要补充八股文

主要复习来自 https://xiaolincoding.com/network/ 小林coding

计算机网络 5个章节预计一个章节 10小时，总共50个小时

操作系统 10个章节预计一个章节 10小时预计100个小时

Mysql 总共8个章节预计一个章节 10小时预计 80个小时

Redis 总共8个章节预计一个章节 10小时预计 80个小时

100+160+50 = 310 h (看来欠的有点多 hh)

可能还需要准备一下 Etcd，分布式，高并发，MQ 等问题这里预计要 50个小时

总共 360h

剩下的时间还需要算上算法的内容，预计课时是 45，算上刷题和复习 double一下大概90

还有一些时间大概就是准备一下面试题什么的

总共算一下大概就是

128 + 360 + 90 = 578 大概高强度一天10个小时学习，57天大概是两个月。如果是下周一开始准备的话大概是9月14号后开始进行玩

(这里简单算一笔账，如果每天回家学习1个小时，大概需要学习578天也就是2年，但是现在只需要两个月) hh , 果然上班之后时间都不是自己的

这周因为还有工作，所以预计会在周五总结一下手上有的和手上没有的，同时决策一些方案。例如去哪里玩什么的

写在后面

我承认这个计划可能很难，我感觉也会失败，而且失败的代价或许是惨痛的，因为算上double 我可能会gap 4个月

或者说找不到好的工作。

但是我想说的是，现在没有更好的选择了不是吗

我能做到的是当下最好的选择

加油，这下真该加油了

补充一下

刚刚写完之后清了一下游戏的体力想到一些问题

如果我写 Java 项目那么就需要多准备一份 Java 八股文，预计会额外增加故事点，这可能会增加压力，但是他会带来更多选择的好处这个值得决策，而且我引入 Java 项目主要是可以多一个资料全一点的高并发项目可以抄，Golang这边目前没看到
我的时间都去哪了？假设一天正常工作8小时，其中摸鱼时间1小时，这一小时我会水群看知乎看小红书，这叫放松。那么我早上9：00起床，9：30到公司，晚上18：30下班，到睡觉0：30期间有6个小时
锻炼，炒菜，吃饭洗澡洗碗 1个小时半
游戏清体力过日常 1个小时
回家刷抖音/B站 1个小时
如果要跑步的话 1个小时

那么还剩 1个半小时，这一个半小时就是学习的一个半小时，但是我又要提前半个小时放松大脑，所以只有1个小时

这个小时就是 23：00到00：00 ，这个时间点之前我再记录日记，现在再写博客，闲暇的时候我会去水群，其他时间可能会去看直播

所以我只有工作了之后我确实只有 1个小时的休闲时间，当然如果把刷抖音/b站，游戏去掉或者说加起来控制再1个小时，那么我只会多出一个小时可是这样事情会变得很枯燥

而且之前我还在和女朋友聊天，再学习漫展修图各种各种，看来我工作的时候确实没时间学习，或者说学习是一条很长的战线

哦还有我玩游戏1个小时只是搬砖游戏的一个小时，偶尔还会去玩其他游戏占用其他时间，另外之前炒股又花了一部分时间

突然想起来史铁生的《好运设计》，以及某些政府政策导致某些人群某些地区的发展变动

我的时间被谁设计了，我的一生被谁设计了。我选择了这个行业，但是我并没有在这个行业看到希望看到的之后绝望

倘若我能拿 22 *15 总包也只有30，算一年存20w，十年才200w，可是有什么工作能够工作10年，或者说我有什么耐心有什么毅力能够在枯燥动荡日子里坚持十年

坚持十年后买房100w 买车20w 结婚20w 总共花费 140w，赡养父母 20w 总共160w 我还剩40w 这时候我还剩下什么

`1`	`逆流河这条路是看不到尽头的，只有深深的绝望`

[重磅消息] 我被裁员了！

Mon, 06 Jul 2026 00:00:00 +0000

写在前头

种一棵树的最好时间是十年前，其次是现在
我们什么都没做错，我们只是被筛选

工作历程

在这家公司大概有 3年了, 我只能说缘分让我留在了这，而且我正好也懒不向上求。

现在的我没有情绪上的特大波动，仿佛就好像认为自己本该走一样，无非早点晚点。

但是我也没什么思绪能够理清现在的表达逻辑，就简单的说一下

组内变动

从我实习到现在，我们组确切的说变动了4次
- 第一次是 DEFI & CEFI 的拆分，这是从业务属性上进行拆分
- 第二次是将 Collector Account 的组合并，负责底层调度账户的逻辑写好大概有2年了，没什么新内容。所以那个组被砍掉了，归为我们拆出来的组管
- 第三次是 数据组 合并到 CEFI 组，同样的，数据组 的大部分内容都很简单，无非就是处理数据接口 API调度以及处理旧数据，大体的框架跑安稳了几年之后没什么新东西，同时处理旧数据的内容可以直接使用SOP进行处理，并且很多东西都配置化了
- 第四次就是我们这次了, 也可以说不是变动吧我们组原先的 Leader 换人了，新招了一位 Leader 过来，新增了一些 快照处理 回溯 账户暂停 的需求。然后需求做的差不多,我们也被裁员了

我经历了 3次完整的业务组调整,见过很多人走,也见过很多人来

一位组内的实习生,因为临近春招，频繁请假,然后被裁员了，裁员的很突然，实习生嘛，没什么交接流程直接就走了
还有一些实习了很久但是没转正的，说是想要回家工作去了新疆
还有一个从腾讯微宝出来的,但是他没通过转正考核
还有一位也是腾讯出来的,但是他转正后工作了几个月就跳槽去了证券
还有一些刚团建完就被裁员的
为了出国然后辞职的

好多好多, 刚毕业那会我对很多同事都很热情,同样我也经常和他们交流。但是走的人越多,我越沉默,渐渐的我不说话

多年之前 我是这么寂寞的, 今时今日我也是这么寂寞的 ... 

寂寞又怎么样？

礁石都不说话

但是水流过去之后

礁石留下
            ---- <<江南随笔>>

自身成长

1
2

我刚买了两瓶新的盐，一瓶酱油，一瓶橄榄油,我还没来得及用，但是我要走了
            ---- 我自己

硬说我这两年没有成长是真的，甚至可以说我是退步了

我忘记了之前大学那会的算法题
我忘记了我实习时候写在简历上的项目
我忘记了我当初准备面试时候背的八股文
我失去了学习的热情
我失去了这两年的时间

…

所以我可以 大大方方的承认 我失败了,我退步了

那么你说我没改变吗？

2024年

我尝试拍漫展，学习修图，并且获得了不错的作品，有一些摄影的朋友
我完整的完成了我的毕设
我一个人租房一个人换房
第一次出国
我好像就没了

2025年

我爬了一座雪山
开始陆陆续续减肥从 170 减到了 150
我买了人生第一辆公路车
人生第一次搬家
卖掉了我的摄影设备
开始玩期货，并且从 200u 赚到了 20W RMB .不得不承认这段时间回不去了
开始玩基金

2026年

开始自己做饭
开始护肤
开始护发
开始锻炼, 从 150 减到了 140
开始跑步
开始价值投资
开始玩股票

我尝试了很多很多，同时也浪费了很多很多

我知道主要让我赚钱的是工作, 但是我并没有在上面进行努力

补充

在这3年值得提几句的点真不多，我刚得到 优秀员工 下一秒就被裁了，从任务上看

实习期间 :

那时候 AI还没火，我单独写了一个异步调度任务的需求一整个完整的需求

从异步调度 API
存入数据库状态，发送给MQ
MQ轮询消费
处理数据
数据入库，状态更新

正式期间 :

优化数据库存储

这个说实话方案是我 Leader 出的，我只是负责实行而已

Auth 服务器迁移

这个比较难描述，我们单独把敏感的API信息放到了一个 Auth 服务器上面，但是我们之前 V1 版本维护的不好。所以我们做了 V2 升级

好像就没有了，一时半会没想起来后面第二篇整理的时候在想吧

后期规划和安排

我原本是想着

去尼泊尔学一趟英语顺便走一趟尼泊尔徒步
然后去埃及学滑雪
去菲律宾潜水
最后去趟日本旅行

但是我发现如果我这么玩下来可能要半年了，到时候我会脱节吗 我不知道，我是否又能做到在旅行的时候学习呢

然后下午的时候想了一下发现我思路错误了

我应该先学习然后再投简历和面试的时候出去玩

这次预计 gap 3个月，因为赔偿hi N+1 正好 3个月

预计是 2个月准备 +1个月游玩

期间的安排还没定过，预计是

先洗一遍简历的项目
然后背八股文和一些中间件
期间看情况有没有时间学第二语言

我感觉这几个月会很忙

当然还有一些其他问题

整理工作的经验
社保要不要自己交，断交，以及失业金的领取
要不要换个房子租，去海边租

一些感悟

其实我很早就能猜到我们组要裁员的，大概是3个月前，我们组就没什么需求了

但是那时候我还没有开始，因为第一出差第二端午 51 假期规划出游

直到最近一个月才开始重新刷算法题，但是当我开始我才发现我开始晚了

裁员的事其实上周，CTO就找leader聊过了，但是名单是这周才出。

从 CTO 的角度来看，CTO只能看到一个人有没有写bug，他的薪资是多少，他的产出是多少

我可以认为是我们组产出是第二高的，或者是第一
bug的话因为AI的出现很少有了

CTO 同样还需要参考 产品经理 和 Leader 的建议

Leader 从可替代性，涉及模块出发，我确实会走。因为我自己拥有的模块业务属性不高，而且可替代性很强。我相当于是一个工具，只是被用，而不是在培养
从产品经理的角度来看，自从有了AI的加持，对于一个需求能不能做，合不合适做，这个问题就变的微乎其微了，所以我的护城河也没了

其他

写累了明天再写吧，写这么点东西竟然写了我一个小时

[blog] 当前使用体验

Thu, 11 Jun 2026 00:00:00 +0000

我的初心

Q : 为什么之前我要写这个博客

我创建 Blog 这个项目的初心是打算日常记录以及学习记录分享

可是从毕业以及工作之后越来越没有学习的心思了

工作内容变动
恋爱的琐事
副业的变动
牛熊转换 …

各种内容充斥在生活里面，让我开始摆烂

项目的扎手点

目前这个项目的设计逻辑是

使用者在 IDEA 编辑对应的 Markdown 文件
- 如果你要发布一个文章你需要创建一个 package 指的是手动的右键点击创建 package
- 然后插入一个 title 图片如果没有图片的话会很丑
- 还需要手动填写文件的日期 date
- 手动填写 slug
- 手动填写 categories
在本地运行 hugo server 进行确认
提交 & push 然后等 action 同步最后才上线
如果需要编辑和更新文章的话那同样麻烦

一些吐槽

而且我的并不打算把我的文章广为流传，因为确实没有什么内容，不值得推广，如果我真想要分享不如去知乎上面分享

另外 Markdown 的缺点，你并不能手动的拖动调整图片的大小这是我很烦的一点

后来我尝试了 Notion 和 Obsidian

Obsidian 可以说是本地化的 Markdown 文件，同样处理图片很麻烦

Notion 的话对我来说很好用，但是他没有标签也不能自定义展示，我没在用 Blog 的时候大部分时间都在用 Notion

另外 Notion 必须联网这点很不好，而且 notion 自家的代理太烂了，时长卡顿

经历了很多内容最后还是打算捡起来这个项目，就想尝试能不能做好，先慢慢做下去吧

另外 Notion 预计只能记录一些生活化相关的内容，偏学习或者是技术的内容，我感觉记录在上面不太专业，而且也不可以定制化展示

后续想法

想要考虑做成动态页面，这样子可以在前端直接发布文章，也可以自动的打标签，可以防止一开始创建文件的繁琐步骤
- 但是这样成本预计就上来了，现在使用 git-page 部署的，只能部署静态网页，边走边看了
或者是简单的版本，可以考虑写几个 scripts ，用于自动创建 page，这个看着是效益最高的

Summary on GzzhM

[webook-tidy] Gin & 基本路由

Gin 入门

Gin-Engine

Gin-Context

Gin 路由注册

基本路由

跨域请求

中间件

面试

最后

[webook-tidy] Gorm & 用户基本功能 & docker

Gorm

Docker Compose

项目结构

一些疑问

HTTP

无状态协议 HTTP

Cookie

Session

面试

后续

[webook-tidy] Session & JWT & Security

场景问题

刷新登陆状态

JWT

JWT 的优缺点

保护系统

限流

限流对象

限流阈值

安全

面试

后续

[webook-tidy] Golang 基础语法

函数式编程

闭包

不定参数

Defer

问题

基本数据结构

切片

子切片

map

接口 & 结构体

衍生类型

类型别名

泛型

面试重点

最后

闭包

基础概念

垃圾回收

应用场景

隔离数据

封装函数 和 创建中间件

sort 包

面试

什么是闭包 ？ 闭包有什么缺陷？

其他

2026-07-12 不定时复盘

反差

我的一天

下一步

随便写点

垃圾中堆找黄金

开始回忆

账户暂停

个人想法

Ai总结

Async

背景

整理

AI一句话总结

Auth 升级

背景说明

整理

个人想法

Ai总结

Trans 表优化

封装函数和创建中间件

什么是闭包？闭包有什么缺陷？