铃仙的个人博客

视频转图片序列

Mon, 18 May 2026 00:00:00 GMT

常常在轻量级场景下使用

流程:

AI生成视频
      ↓
导出MP4
      ↓
ffmpeg拆帧
      ↓
438张WebP
      ↓
JSON描述播放规则
      ↓
网页播放

FFmpeg 拆帧

假设有一个视频：

video.mp4

拆成 PNG

ffmpeg -i video.mp4 frames/frame_%04d.png

输出：

frames/
├── frame_0001.png
├── frame_0002.png
├── frame_0003.png
...

拆成 WebP（更适合网页）

ffmpeg -i video.mp4 frames/frame_%04d.webp

输出：

frames/
├── frame_0001.webp
├── frame_0002.webp
├── frame_0003.webp
...

指定帧率

例如原视频 60 FPS，但只想导出 30 FPS：

ffmpeg -i video.mp4 -vf fps=30 frames/frame_%04d.webp

从第 0 帧开始命名

默认是：

frame_0001.webp

如果你的播放器要求：

frame_0000.webp

可以：

ffmpeg -i video.mp4 -start_number 0 frames/frame_%04d.webp

得到：

frame_0000.webp
frame_0001.webp
frame_0002.webp
...

同时提取音频

提取音频：

ffmpeg -i video.mp4 -vn -c:a copy audio.m4a

参数含义：

-vn：不要视频
-c:a copy：直接复制音频流，不重新编码

示例

mkdir -p frames

ffmpeg -i video.mp4 \
-vf fps=30 \
-start_number 0 \
-qscale:v 80 \
frames/frame_%04d.webp

再提取音频：

ffmpeg -i video.mp4 -vn -c:a copy audio.m4a

资源包结构：

naiwa/
├── config.json
├── audio.m4a
└── frames/
    ├── frame_0000.webp
    ├── frame_0001.webp
    ├── ...
    └── frame_0437.webp

搭建博客后端过程中的笔记

Fri, 18 Jul 2025 00:00:00 GMT

博客

数据库:主从配置，读写分离搜索：es

`git commit feat-[content]

配置初始化

使用yaml进行配置保存

system:  
  ip:  
  port: 8080  
  env: dev # 一般用于gin的日志输出  
log:  
  app: blogx_server  
  dir: logs

日志初始化

为什么用日志库而不是标准日志

功能更强大
显示更清晰

日志格式

logs/Date/App

连接数据库

==读写分离== 插件:https://github.com/go-gorm/dbresolver 能自动识别读写操作,进行操作分发

settings.yaml

db:  
  user: root  
  password: root  
  host: 127.0.0.1  
  port: 5432  
  database: gvb_db  
  debug: false  
  source: postgres  
# 数据库配置一样，模拟多个数据库读写分离  
db1:  
  user: root  
  password: root  
  host: 127.0.0.1  
  port: 5432  
  database: gvb_db  
  debug: false  
  source: postgres

⚠️如果连接不上远程数据库 查看🛜网络的代理设置，看是否设置了sock代理，可能连接被代理拦截了，增加白名单即可

路由初始化

将api从路由里剥离出来，避免耦合

根据ip获取地理位置

经常用于社交平台通过ip地址去定位在网上冲浪都是走公网ip 哪些是内网？

192.168.0.0
172.16-32
10.。。
127.0.0.1

ip2region: "github.com/lionsoul2014/ip2region/binding/golang/xdb"

离线数据库查询，效率高，精度低或利用现有网站去发请求
精准度高，效率低

初始化ip2region

func InitIPDB() {  
    var dbPath = "init/ip2region.xdb"  
    _searcher, err := xdb.NewWithFileOnly(dbPath)  
    if err != nil {  
       logrus.Fatalf("ip地址数据库加载失败: %s\n", err)  
       return  
    }  
    //不关闭因为后面还需要用  
    //defer searcher.Close()  
    searcher = _searcher  
}

通过区间判断是否是内网

func HasLocalIPAddr(ip string) bool {  
    return HasLocalIP(net.ParseIP(ip))  
}  
  
// HasLocalIP 通过ip判断内网  
func HasLocalIP(ip net.IP) bool {  
    if ip.IsLoopback() {  
       return true  
    }  
    ip4 := ip.To4()  
    if ip4 == nil {  
       return false  
    }  
    return ip4[0] == 10 ||  
       (ip4[0] == 172 && ip4[1] >= 16 && ip[4] <= 31) ||  
       (ip4[0] == 192 && ip4[1] == 168) ||  
       (ip4[0] == 169 && ip4[1] == 254)  
}

如果不是内网，再进行查表

var searcher *xdb.Searcher  
const LOCFOMMAT = 5  
func GetIPLoc(ip string) (location string) {  
    //利用区间先快速判断是否是内网  
    if ipUtils.HasLocalIPAddr(ip) {  
       return "内网"  
    }  
    region, err := searcher.SearchByStr(ip)  
    if err != nil {  
       logrus.Warnf("错误的ip地址:[%s]", ip)  
       return "异常地址"  
    }  
    //处理addrList  
    _addrList := strings.Split(region, "|")  
    if len(_addrList) != LOCFOMMAT {  
       //出现概率目前极低  
       logrus.Warnf("异常的ip地址:[%s]", ip)  
       return "未知地址"  
    }  
 //...
 //处理格式
 //...
    return region  
}

表结构搭建

优先核心表
表的设计尽量保证后期表结构不变化
要考虑冗余字段：==字段可以多但是不能少==

日志系统

登录日志
操作日志
- 获取请求体->可以放在请求中间件里
静态路由
- r.static(),路径映射URL

JWT

jwt库 "github.com/dgrijalva/jwt-go"

定义 Claims 结构 自定义 Claims，包含用户的基本信息（如 UserID、Username、Role），并组合 jwt.StandardClaims 形成 MyClaims。

type Claims struct {  
    UserID   uint   `json:"userID"`  
    Username string `json:"username"`  
    Role     uint8  `json:"role"`  
}  
  
type MyClaims struct {  
    Claims  
    jwt.StandardClaims  
}

生成token

// GetToken 转换 token
func GetToken(claims Claims) (string, error) {  
    cla := MyClaims{  
       Claims: claims,  
       StandardClaims: jwt.StandardClaims{  
          ExpiresAt: time.Now().Add(time.Duration(global.Config.Jwt.Expire) * time.Hour).Unix(), // 过期时间  
          Issuer:    global.Config.Jwt.Issuer,                                                   // 签发人  
       },  
    }  
    //设置签名算法  
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, cla)  
    return token.SignedString([]byte(global.Config.Jwt.Secret)) // 进行签名生成对应的token  
}

解析 Token 通过 ParseToken(tokenString) 解析 JWT：

校验签名是否合法
判断是否过期、是否非法或无效
成功后返回自定义的 MyClaims

func ParseToken(tokenString string) (*MyClaims, error) {  
    if tokenString == "" {  
       //如果未登录，直接返回  
       return nil, errors.New("请登录")  
    }  
    token, err := jwt.ParseWithClaims(tokenString, &MyClaims{}, func(token *jwt.Token) (interface{}, error) {  
       return []byte(global.Config.Jwt.Secret), nil  
    })  
    if err != nil {  
       //如果出错,判断出错类型  
       if strings.Contains(err.Error(), "token is expired") {  
          return nil, errors.New("token过期")  
       }  
       if strings.Contains(err.Error(), "signature is invalid") {  
          return nil, errors.New("token无效")  
       }  
       if strings.Contains(err.Error(), "token contains an invalid") {  
          return nil, errors.New("token非法")  
       }  
       return nil, err  
    }  
    //断言确定token有效  
    if claims, ok := token.Claims.(*MyClaims); ok && token.Valid {  
       return claims, nil  
    }  
    return nil, errors.New("invalid token")  
}

拓展：双token

单token 过期时间长，安全程度低

双token包括access_token用来鉴权，refresh_token用来获取新access_token，时间可以设置为较长

jwt缺点：

不能主动失效 Redis添加黑名单

图片管理

图片上传的文件名重复问题

直接存hash

七牛云

TODO

用户管理

图片验证码库:"github.com/mojocn/base64Captcha"

存储器设置

// 根据自己需求更改验证码存储上限和过期时间  
var result = base64Captcha.NewMemoryStore(10240, 3*time.Minute)  
//或者使用默认配置 10240,10min
var result = base64Captcha.DefaultMemStore

生成器配置

// digitConfig 生成图形化数字验证码配置  
func digitConfig() *base64Captcha.DriverDigit {  
    digitType := &base64Captcha.DriverDigit{  
       Height:   50,  
       Width:    100,  
       Length:   5,  
       MaxSkew:  0.45,  
       DotCount: 80,  
    }  
    return digitType  
}

生成

// CreateCode  
// @Result id 验证码id  
// @Result bse64s 图片base64编码  
// @Result err 错误  
func CreateCode() (string, string, string, error) {  
    var driver base64Captcha.Driver  
    //纯数字验证码  
    driver = digitConfig()  
    if driver == nil {  
       logrus.Errorf("图形化数字验证码配置失败")  
    }  
    // 创建验证码并传入创建的类型的配置，以及存储的对象  
    c := base64Captcha.NewCaptcha(driver, result)  
    id, b64s, answer, err := c.Generate()  
    return id, b64s, answer, err  
}

发邮件

import (
    "log"
    "net/smtp"

    "github.com/jordan-wright/email"
)

func main() {
    e := email.NewEmail()
    //设置发送方的邮箱
    e.From = "dj <XXX@qq.com>"
    // 设置接收方的邮箱
    e.To = []string{"XXX@qq.com"}
    //设置抄送如果抄送多人逗号隔开
    e.Cc = []string{"XXX@qq.com",XXX@qq.com}
    //设置秘密抄送
    e.Bcc = []string{"XXX@qq.com"}
    //设置主题
    e.Subject = "这是主题"
    //设置文件发送的内容
    e.Text = []byte("www.topgoer.com是个不错的go语言中文文档")
    //设置服务器相关的配置
    err := e.Send("smtp.qq.com:25", smtp.PlainAuth("", "你的邮箱账号", "这块是你的授权码", "smtp.qq.com"))
    if err != nil {
        log.Fatal(err)
    }
}

setting.yaml配置

email:  
  domain: ""  # 邮件服务器 
  port: 0   # 465 开ssl 587 没有开ssl
  sendEmail: ""   
  authCode: ""  
  sendNickname: ""  
  ssl: false  
  tls: false

用户密码一定不能明文存储在数据库里

QQ登录

TODO

随便做个页面：有qq登录就行
审核

用户名+密码登录

命令行创建用户

包:"golang.org/x/crypto/ssh/terminal"

实现了密码的加密显示(" * ")

terminal.ReadPassword(int(os.Stdin.Fd()))

邮箱绑定

PostgreSQL主从配置

es配置

🔍 1. 强大的全文搜索能力

支持模糊查询、分词、匹配度排序。
能处理拼写错误、同义词等复杂搜索需求。

⚡ 2. 高性能

数据检索速度快，尤其适合处理大规模数据。
查询和写入都具备良好的延迟控制

docker-compose

  es:
    image: "elasticsearch:7.12.0"
    restart: always
    privileged: true
    environment:
      discovery.type: single-node
      ES_JAVA_OPTS: "-Xms512m -Xmx512m"
    volumes:
      - ./es/data:/usr/share/elasticsearch/data
    networks:
      blogx_network:
        ipv4_address: 10.2.0.5

修改data目录的权限#

chmod -R 0777 ./es/data

es v9笔记

Mysql同步数据到es的方式

同步双写
异步双写
数据抽取
数据订阅
canal( 选用)

PG同步es

TODO

防Xss注入

go Markdown 解析

md->html->text rune? rune 是一个内置的数据类型，用于表示 Unicode 字符（Unicode code point）。它的本质是 int32 的别名（占 4 个字节），用来处理 UTF-8 编码的字符

文章引入缓存

避免频繁访问数据库引入缓存：浏览量，点赞数等

如:点赞的时候，在缓存里面记录一个key,value，key 就是文章id，value 就是点赞数

查询文章的时候，从缓存里面查点赞数，响应的时候，实际点赞数=数据库中点赞数＋缓存中的点赞数在每天的0点进行数据同步

文章删除

管理员可以删任意的文章，如果删的是用户的，应该给用户发一个系统消息
用户只能删自己发布的文章

删文章如果是物理删除，就需要删除对应的关晚记录文章点赞，文章收藏，文章置顶，文章评论，文章浏览

定时任务

库:Cron 用于在非高峰期同步缓存数据到数据库

全局通知

方案:

管理员创建一条全局通知就给所有用户发一条系统消息(只适用于人少的情况)
用户在系统消息界面主动查询

WebSocket

websocket是socket连接和http协议的结合体，可以实现网页和服务端的长连接

不要在中间件加任何认证,认证通过查请求头去认证

go get github.com/gorilla/websocket

https://www.fengfengzhidao.com/article/htkS14sBEG4v2tWkYG4A#websocket

建立连接的时机？维护用户在线表

如果目的方在线，就建立ws连接否则直接入库

文章查询

es,降级(db)

分数->相关度

获取服务器资源占用量

包：github.com/shirou/gopsutil

莉莉丝go面试题

Mon, 30 Jun 2025 00:00:00 GMT

gc的是什么

go的gc利用多线程，使用三色标记法同步检测进行内存垃圾回收主要回收

堆上分配的对象
不再有引用的对象
临时变量
闭包捕获的变量

堆栈存的是什么

堆

动态分配的变量
闭包中捕获的变量

栈

函数参数
临时变量
函数返回地址
函数调用帧

go编译器通过逃逸分析决定变量的存放位置

为什么用redis不用本地缓存

因为本地缓存无法共享，无法拓展，无法持久化而redis高性能，可共享，可拓展，可过期，支持多种持久化方式

本地缓存性能更高，但是分布式系统对一致性和可拓展性的要求优先级更高

redis持久化机制

RDB （快照）

每隔一段时间就对数据生成一个快照，以二进制形式存储在磁盘的dump.rdb文件优点:

恢复时性能高缺点:
数据量大时可能造成卡顿
两次快照间隔中可能丢失数据

AOF （日志追加）

AOF记录每一个写命令并追加到文件末尾，恢复时进行操作重放优点:

安全性高
可读性强缺点
持久化文件比rdb大（引出 AOF重写）
重放性能没有rdb高

混合持久化

结合RDB和AOF，AOF重写时，前半部分使用rdb，后续使用AOF追加

数据一致性怎么保证

应用场景? 单机数据库，分布式系统,缓存数据库双写

事务的ACID

redo log -> 一致性 undo log -> 回滚

raft算法

leader选举,日志复制，安全性

redis，mysql双写

延迟双删
先删除数据库，再删除缓存
binlog监听（canal）

消息队列实现异步一致性

登录实现

session

服务器需要存session拓展性差

token(jwt)

无法主动过期

安全

https / 防止 Xss
OAuth2.0 / OpenID Connect：用于第三方登录（如微信、Google 登录）。
单点登录（SSO）：多个系统共享登录状态，常用 CAS 或 SAML 协议。
多因素认证（MFA）：密码 + 短信/验证码/生物识别，提升安全性。

小林计算机网络笔记

Tue, 17 Jun 2025 00:00:00 GMT

链接幂等性: 重复请求得到的结果是一样的

HTTP

缓存技术

HTTP 缓存有两种实现方式，分别是强制缓存和协商缓存。 ![[截屏2025-06-17 00.02.02.png|535x449]] 强制缓存 浏览器判断缓存没有过期就直接使用浏览器的本地缓存，主动权在浏览器 协商缓存 与服务端协商后,通过协商结果判断是否使用缓存

时间
ETag

注意，协商缓存这两个字段都需要配合强制缓存中 Cache-Control 字段来使用，只有在未能命中强制缓存的时候，才能发起带有协商缓存字段的请求。

怎么优化HTTP/1.1

避免发送HTTP请求
- 缓存
减少HTTP请求次数
- 减少重定向次数
- 合并请求
  - 比如网站小图片利用CSS Image Sprites技术合并
- 延迟发送请求
减小响应数据大小
- 无损压缩 content-encoding(gzip,brotli)
- 有损压缩 Accept: audio/*; q=0.2, audio/basic q：质量因子

HTTP 2.0

优点

头部压缩
二进制帧
并发传输
服务器主动推送缺点
队头堵塞

HTTP 3.0

美中不足的HTTP2.0 队头堵塞造成了很大的性能瓶颈，但它其实是tcp协议本身的缺陷,所以3.0改用udp协议 ![[截屏2025-07-18 15.39.39.png|426x396]]

由于tcp是字节流协议，当有包丢失时，后续的包因为序号对不上，只能卡在缓存里，无法接受，在接收方看来就是堵塞

TLS握手延迟 每次发起http请求，都要进行tcp三次握手和tls四次握手，而且由于tcp本身的“拥塞控制”特点引起的慢启动特性，产生了延迟 QUIC协议 HTTP3.0通过QUIC协议实现还有一个特点是:==QUIC实现在用户层面，相比TCP在内核层面，更加容易更新迭代==

HTTPS

S指"TLS/SSL"加密

为什么要引入HTTPS

因为http的明文传输导致了极大的安全隐患为了解决这个问题，首先想到的是对称加密，但是对称加密无法保证密钥本身传输的安全性于是引入==摘要算法和数字签名== 摘要算法和数字签名 摘要算法就是对传输内容取Hash 数字签名就是用发送者的私钥对内容进行加密，接收方用发送方公开的密钥进行解密但是这样虽然表面上传输安全，但是如果有怀有恶意的人把自己的公钥发给接收方，再用自己的私钥对伪装的内容加密，这样接收方也无法判断内容的真实性，这主要的问题就是:==如何证明发送方的身份==,于是引入权威机构来为发送方证明，这就是==数字证书== 数字证书 发送方将自己的公钥给权威机构(CA)，CA用自己的私钥对发送方公钥等内容(域名,有效期等)进行签名，加密的结果就是==数字证书==,这样接收方收到内容后可以拿证书用CA的公钥解密证书的签名，如果发现解密结果的hash和计算的的证书的hash一致，就告知接收方发送方的身份合法，由此保障传输安全

操作系统（如 Windows、macOS）、浏览器（如 Chrome、Firefox）或 HTTP 客户端（如 cURL）内置了全球受信任的 根 CA 证书列表（包含公钥）

HTTPS如何建立连接的

多了一层TLS/SSL层 TLS四次握手，利用RSA算法或者ECDHE算法交换密钥，之后就是用这个密钥进行加密的HTTP通信

TLS四次握手:

客户端发起加密通信请求，并发送一个随机数，同时发送自己使用的TLS协议版本
确认TLS版本，回发一个服务端生成的随机数,确认算法等密码套件
客户端先通过CA公钥确认数字证书的合法性，如果合法就用解密的服务器公钥加密报文，并发送一个服务器公钥加密的随机数；今后使用公钥加密的通知；以及密钥交换结束的通知
服务端收到第三个随机数，通过协商的算法进行加密，计算出本次通信的会话密钥，然后发送今后使用公钥加密的通知；以及密钥交换结束的通知

HTTPS如何保障内容的完整性

TLS记录协议把内容分成多个数据端，分别进行压缩，同时附上一个MAC值(哈希值)用来保证数据的真实性，再一起通过对称密码进行加密，并添加报头

HTTPS是绝对安全的吗

中间人攻击 例如：伪装基站截获信息转发给中间服务器，建立TLS连接后再和真正服务端建立连接，这样就能偷看数据了

但前提是客户端选择接受中间服务器的数字证书,这个证书往往能被识别出是不正确的

现代浏览器首选**ECDHE + RSA TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256

密钥交换：ECDHE（客户端与服务器协商出会话密钥）
签名验证：RSA（用于验证服务器证书或 ECDHE 参数）
安全性：支持前向保密

HTTPS性能优化

损耗在哪?

第一个环节， TLS 协议握手过程；
第二个环节，握手后的对称加密报文传输。

如何优化

硬件，软件
协议优化
- 密钥交换过程选择ECDHE而不是RSA算法(ECDHE第三次抢跑，RSA 密钥交换算法的 TLS 握手过程慢且长)
- TLS升级:RTT合并，密码套件升级(防==降级攻击==)
证书优化
- 周期请求并缓存
会话复用
- SessionID
- Session Ticket
- ==重放攻击== ->对会话密钥设定一个合理的过期时间

RPC

本质上不算协议，而是一种调用方式 RPC 有很多种实现方式，不一定非得基于 TCP 协议 早期C/S架构使用RPC而B/S架构使用HTTP，现在区分不明显，RPC常用于公司内部多个微服务直接的通信

WebSocket

服务器推送方案

HTTP不断轮询
长轮询这两种只适用于简单场景，当可能会有大量消息主动推送时，就要考虑websocket了

TCP

基本认识

如何确定TCP连接 TCP四元组可以唯一确定一个连接

源地址
源端口
目的地址
目的端口 TCP连接上限 取决于客户端的ip数和端口数但服务端的最大并发连接数肯定达不到理想值因为:1.系统限制 2.内存限制

TCP和UDP的区别

连接

TCP面向连接
UDP无连接

服务对象

TCP一对一
UDP一对一或一对多，多对多

可靠性

TCP可靠
UDP不可靠

分片

TCP在传输层分片(如大于MSS)
UDP在IP层分片(如大于MTU)

首部开销

TCP最小20字节
UDP 8字节

拥塞控制，流量控制

TCP有拥塞控制
UDP没有

传输方式

TCP基于字节流
UDP基于数据报

TCP连接建立

- 客户端 TCP 连接 TIME_WAIT 状态过多，会导致端口资源耗尽而无法建立新的连接吗？

会的，如果客户端每次都用新端口，老端口都处于TIME_WAIT状态，那可会导致端口耗尽，无法发起新连接

三次握手 ==第三次握手是可以携带数据的，前两次握手是不可以携带数据的==

如果已经建立了连接，但是客户端突然出现故障了怎么办？

TCP的保活机制

也可实现心跳机制，设置定时器，规定时间内未发起请求，定时器时间一到就释放 如果已经建立了连接，但是服务端的进程崩溃会发生什么？ 会交给内核释放资源，但同时也能完成和客户端的四次挥手

TCP 特性

重传机制

超时重传 ==时间驱动重传== 超时时间是动态变化的 快速重传 ==数据驱动重传 ![[截屏2025-07-21 10.35.09.png|484x370]]== 问题在于:重传是重传一个还是重传所有？

SACK:TCP 头部附加上已经传输的数据
D-SACK:告诉「发送方」有哪些数据被重复接收了

流量控制

滑动窗口 swnd rwnd 滑动窗口并非一成不变的，发送窗口和接收窗口存放的字节都是放在操作系统的缓冲区内的，会被操作系统调整

![[22.jpg.webp]]

那如果系统缓存和窗口大小同时减小呢？ 可能会导致丢包 为了防止这种情况发生，TCP 规定是不允许同时减少缓存又收缩窗口的

如果窗口调整ACK丢失呢?

为了解决这个问题TCP为每个连接都设置了==持续定时器==,只要有一方收到了对方的零窗口通知，就启动定时器，如果定时器超时，就会发送窗口探测 ( Window probe ) 报文,请求对方当前的窗口大小,如果连续3次都是0，可能就会发送RST关闭连接

糊涂窗口综合症

简单来说，就是窗口越缩越小，导致每次传输成本过大 ![[26.png.webp]]

解决方法: 接收方：不发送小窗口通知发送方: 避免发小数据（Nagle算法）

if 有数据要发送 {
  if 可用窗口大小 >= MSS and 可发送的数据 >= MSS {
    立刻发送MSS大小的数据 
  } else {
    if 有未确认的数据 {
      将数据放入缓存等待接收ACK 
  } else {
    立刻发送数据 
  } 
 }
}

拥塞控制

为什么要有拥塞控制？

因为流量控制只是对发送方接收方来说的，没有考虑网络状况

cwnd:拥塞窗口(swnd=min(cwnd,rwnd)) 拥塞就缩小，反正扩大

怎么知道当前网络是否出现了拥塞呢？

看有无超时重传现象

主要是四个算法:

拥塞避免
慢启动
拥塞发生
快速恢复

慢启动：当发送方每收到一个 ACK，拥塞窗口 cwnd 的大小就会加 1

慢启动的上限叫做慢启动门限ssthresh

cwnd<ssthresh:慢启动算法
cwnd>ssthresh:拥塞避免算法 ![[截屏2025-07-21 17.24.56.png]]

TCP 半连接队列和全连接队列

![[3.jpg.webp|506x506]]

ss命令：查看TCP全连接队列的使用情况

1 -l 显示正在监听（listening）的socket
2 -n 不解析服务名称
3 -t 只显示tcpsocket

netstat -s | grep overflowed 可以查看全连接队列溢出情况 如果持续不断地有连接因为 TCP 全连接队列溢出被丢弃，就应该调大 backlog 以及 somaxconn 参数。

防范SYN攻击:

增大全连接队列
开启 tcp_syncookies
减少SYN/ACK重传次数

如何优化TCP

三次握手的性能提升

客户端优化

降低超时重传次数上限 服务端优化
增大半连接队列容量
开启syncookie
开启TCP_FastOpen功能(绕过三次握手)

四次挥手的性能提升

即使 close() 被调用，内核还是会接收 ACK、发送 ACK ——只是不能再用这个 socket 做读写了

主动方

降低FIN_WAIT1状态下的重传数
复用处于TIME_WAIT状态下的连接
增大TIME_WAIT上限个数 被动方
降低FIN_WAIT状态下的重传数

存在TIME_WAIT状态的原因(默认60s)

为什么关闭同个端口的TCP马上重连会显示端口占用的原因

为了防止历史连接中的数据影响下一次同个四元组的TCP连接
保证被动关闭的一方能够正常关闭

TCP传输数据的性能提升

扩大窗口大小
扩大发送方/接收方缓冲区
调整内存范围

为什么每次TCP建立连接时，序列号都不一样呢

为了避免该四元组受到上一次连接的数据干扰

同样设计目的的还有TIME_WAIT状态

PAW机制：防止TCP包中的序列号发生绕回开启tcp_timestamp的情况下，连接双方维护一个时间戳，每收到一个包就对比看时间戳是否是递增的，不是就丢弃 什么时候SYN报文会被丢弃

如果同时开启recycle和timestamp，就会开启叫做per-host的PAW机制，这种机制不对四元组作检查，而是只对ip做检查
所以如果客户端通过NAT网关，A，B客户端显示为同一ip，而有一方的时间戳比较小，就会导致其包被认为超时而丢弃
有一方的半连接队列或全连接队列满了

服务端收到SYN请求后，内核把该连接储存到半连接队列(SYN队列)中，当完成三次握手后，再把连接从半连接队列拿出放到全连接队列中(Accept队列),等待进程取出

已建立的TCP，收到SYN会发生什么

服务端收到客户端重连发送的SYN(乱序)，会返回正常顺序的ACK，客户端发现序列号不是自己想要的，就会发送RST终止连接

如何优雅关闭一个TCP连接？

KILL（❌）
killcx 通过伪造四元组骗取正确序列号，再伪造正确序列号终止连接(主动)
tcpkill 监听，伪造正确序列号(被动)

四次挥手中收到乱序的FIN包怎么处理

会加入乱序队列，等到收到正常的数据包再检查乱序队列看是否有可用数据包，有的话才进入TIME_WAIT状态

Golang.net/http包学习记录

Mon, 07 Apr 2025 00:00:00 GMT

请求该网站，可以将请求的内容以json的形式返回 http://httpbin.org/

如何打印请求内容？

// 打印请求
dump, _ := httputil.DumpRequest(req, true)
fmt.Println(string(dump))

Example

流程：发送请求——>接收返回内容

func get() {
    r, err := http.Get("http://httpbin.org/get")
    if err != nil {
       panic(err)
    }
    //记得关闭
    defer r.Body.Close()
    content, err := io.ReadAll(r.Body)
    if err != nil {
       panic(err)
    }
    //回应内容
    fmt.Println(string(content))
}

net/http默认只封装了get和post方法，put和delete需要自己根据实现

实现方法:

NewRequest

设置Content-type

选择Client执行Do方法发送请求

接收返回内容

// put sends an HTTP PUT request to http://httpbin.org/put and prints the response.
// The function demonstrates how to make a PUT request with custom headers.
// It sets the Content-Type header but sends no body in this example.
func put() {
 // Create a new PUT request with nil body
 request, err := http.NewRequest(http.MethodPut, "http://httpbin.org/put", nil)
 if err != nil {
  panic(err) // Handle error if request creation fails
 }

 // Set the Content-Type header (though we're not sending any content in this example)
 request.Header.Set("Content-Type", "application/x-www-form-urlencoded")

 // Send the request using the default HTTP client
 r, err := http.DefaultClient.Do(request)
 if err != nil {
  panic(err) // Handle error if request fails
 }
 defer r.Body.Close() // Ensure the response body is closed when we're done

 // Read the entire response body
 content, err := io.ReadAll(r.Body)
 if err != nil {
  panic(err) // Handle error if reading response fails
 }

 // Print the response content as string
 fmt.Println(string(content))
}

Request

1. 带查询参数请求

func requestByParams() {
    req, err := http.NewRequest("GET", "http://httpbin.org/get", nil)
    if err != nil {
       panic(err)
    }
    //设置url参数
    params := make(url.Values)
    params.Set("param1", "value1")
    params.Set("param2", "value2")
    params.Add("param1", "value3")
    fmt.Println(req.Method, params)
    //编码成param1=value1&param1=value3格式
    fmt.Println(params.Encode())
    req.URL.RawQuery = params.Encode()
    r, err := http.DefaultClient.Do(req)
    if err != nil {
       panic(err)
    }
    printBody(r)
}
//请求内容 ： param1=value1&param1=value3&param2=value2

2. 定制请求头

func requestByHeaders() {
    req, err := http.NewRequest("GET", "http://httpbin.org/get", nil)
    if err != nil {
       panic(err)
    }
    //可以通过修改User-Agent简单绕过反爬
    req.Header.Set("User-Agent", "Safari")
    req.Header.Add("header1", "value1")
    req.Header.Add("header2", "value2")
    r, err := http.DefaultClient.Do(req)
    if err != nil {
       panic(err)
    }
    printBody(r)
}

Response

状态

func getStat(r *http.Response) {
    fmt.Println(r.StatusCode) //状态码  200
    fmt.Println(r.Status)     //状态信息  ok 200
}

头

func header(r *http.Response) {
    //Header是一个map，通过get的方式比通过at的方式好处:大小写忽略
    fmt.Println(r.Header.Get("content-type"))
}

编码

需要解码的主要场景

响应内容使用非UTF-8编码时
- 网页常用编码如 GBK、ISO-8859-1(西欧)、EUC-JP(日文)等
- 若不正确解码，中文字符等会显示为乱码
Content-Type头部指定了字符集
- 如 Content-Type: text/html; charset=gbk

func encoding(r *http.Response) {
    //可以通过网页的头部猜测网页的编码信息
    //引入包:golang.org/x/net/html
    bufReader := bufio.NewReader(r.Body)
    bytes, _ := bufReader.Peek(1024) //预读,不会移动reader的读取位置
    //提供content-type的原因：Content-Type 提供的上下文（如语言区域）能显著提高准确性，检测优先级高
    res, _, _ := charset.DetermineEncoding(bytes, r.Header.Get("content-type"))
    fmt.Println(res)
    //不解码结果
    //rawBody, _ := io.ReadAll(bufReader)
    //fmt.Println(string(rawBody))

    // 当编码不是UTF-8时需要解码转换
    //引入包:golang.org/x/text/transform，解码
    bodyReader := transform.NewReader(bufReader, res.NewDecoder())
    content, _ := io.ReadAll(bodyReader)
    fmt.Println(string(content))
}

Post

提交表单

func postForm() {
    //http.Post()
    data := make(url.Values)
    data.Add("name", "John Doe")
    data.Add("email", "johndoe@gmail.com")

    u := "http://httpbin.org/post"
    //相当于http.Post(u,content-type,data)里让content-type="application/x-www-form-urlencoded"的封装
    r, _ := http.PostForm(u, data)
    defer r.Body.Close()
    content, _ := io.ReadAll(r.Body)

    fmt.Println(string(content))
}

提交JSON格式内容

func postJson() {
    //http.Post()
    sourceData := struct {
       Name  string `json:"name"`
       Email string `json:"email"`
    }{"John Doe", "johndoe@gmail.com"}
    data, _ := json.Marshal(sourceData)
    u := "http://httpbin.org/post"
    r, _ := http.Post(u, "application/json", bytes.NewReader(data))
    defer r.Body.Close()
    content, _ := io.ReadAll(r.Body)

    fmt.Println(string(content))
}

提交文件

<mark style="background: #FFF3A3A6;">muiltipart</mark>实现拼接请求
multipart会随机创建一个boundary

func postFile() {
    //数据缓冲区
    body := &bytes.Buffer{}
    //创建拼接类
    writer := multipart.NewWriter(body)
    //增加字段
    _ = writer.WriteField("name", "John Doe")
    _ = writer.WriteField("email", "johndoe@gmail.com")
    //上传文件 表单名 + 文件名
    uploadFile_1, _ := writer.CreateFormFile("uploadfile_1", "test.jpg")
    file, _ := os.Open("./request.go")
    defer file.Close()
    _, err := io.Copy(uploadFile_1, file)
    if err != nil {
       return
    }
    //关闭拼接
    _ = writer.Close()
    fmt.Println(writer.FormDataContentType())
    fmt.Println(body)
    r, _ := http.Post("http://httpbin.org/post", writer.FormDataContentType(), body)
    defer r.Body.Close()
    content, _ := io.ReadAll(r.Body)
    fmt.Println(string(content))
}

Download

实现带进度条的下载

func downloadWithProcess(url, filename string) {
    r, err := http.Get(url)
    if err != nil {
       fmt.Println(err)
       return
    }
    defer func(Body io.ReadCloser) {
       err := Body.Close()
       if err != nil {
          fmt.Println(err)
       }
    }(r.Body)
    out, err := os.Create(filename)
    if err != nil {
       fmt.Println(err)
       return
    }
    defer func(out *os.File) {
       err := out.Close()
       if err != nil {
          fmt.Println(err)
       }
    }(out)
    newReader := &Reader{
       Reader: r.Body,
       Total:  r.ContentLength,
    }
    _, err = io.Copy(out, newReader)
    if err != nil {
       fmt.Println(err)
    }
    fmt.Println("\nDone")

}

// Reader 重写Reader实现进度条功能
// 本质是io.copy内部有循环调用Read，而我们重写了Read，才能实现进度条刷新
type Reader struct {
    io.Reader
    Total   int64
    Current int64
}

func (r *Reader) Read(p []byte) (n int, err error) {
    n, err = r.Reader.Read(p)
    r.Current += int64(n)
    // \r实现每次打印都回到行首
    fmt.Printf("\rDownloading: %.2f of %%100", float64(r.Current*10000/r.Total)/100)
    return
}

Redirect

DefaultClient是包内提供的一个已经设置了一些默认属性和Client变量可以如下根据需求自定义client

//默认的检查重定向实现
func defaultCheckRedirect(req *Request, via []*Request) error {
  if len(via) >= 10 {
   return errors.New("stopped after 10 redirects")
  }
  return nil
}

设置重定向上限

func redirectLimits() {
    client := &http.Client{
       CheckRedirect: func(r *http.Request, via []*http.Request) error {
          if len(via) >= 10 {
             //如果重定向次数过多
             return errors.New("stopped after 10 redirects")
          }
          return nil
       },
    }
    //重定向11次，报错
    resp, err := client.Get("https://httpbin.org/absolute-redirect/11")
    if err != nil {
       fmt.Println(err)
       return
    }
    defer resp.Body.Close()
    content, _ := io.ReadAll(resp.Body)
    fmt.Println(string(content))
}

禁止重定向

client := &http.Client{
    CheckRedirect: func(r *http.Request, via []*http.Request) error {
        return http.ErrUseLastResponse
    },
}

Cookie

![cookie示意图](截屏2025-04-19 16.28.32.png)

cookie 的分类有两种，一种是会话期 cookie，一种是持久性 cookie

手动附加Cookie

// 不用jar手动附加cookie
func redirWithCookieManual() {
    client := &http.Client{
       CheckRedirect: func(r *http.Request, via []*http.Request) error {
          //禁止重定向
          return http.ErrUseLastResponse
       },
    }
    firstReq, _ := http.NewRequest(http.MethodGet, "https://httpbin.org/cookies/set?freeform=sada&name=tie", nil)
    firstRes, _ := client.Do(firstReq)
    defer firstRes.Body.Close()
    //获得服务端返回的cookies
    //手动重定向地址
    secondReq, _ := http.NewRequest(http.MethodGet, "https://httpbin.org/cookies", nil)
    for _, cookie := range firstRes.Cookies() {
       //将cookie附加到重定向的请求中
       secondReq.AddCookie(cookie)
    }
    secondRes, _ := client.Do(secondReq)
    defer secondRes.Body.Close()
    content, _ := io.ReadAll(secondRes.Body)
    fmt.Println(string(content))
}

使用Jar自动附加Cookie

// 使用Jar附加cookie
func jarCookie() {
    jar, _ := cookiejar.New(nil)
    client := &http.Client{
       Jar: jar,
    }
    r, _ := client.Get("https://httpbin.org/cookies/set?freeform=sada&name=tie")
    defer r.Body.Close()
    _, _ = io.Copy(os.Stdout, r.Body)
}

标准库只提供了会话期cookie

Proxy

proxyUrl, _ := url.Parse("http://127.0.0.1:7897")  //代理启动的端口
t := http.Transport{
    Proxy: http.ProxyURL(proxyUrl),
}
//代理一般分两种，http代理和shadowsocks的代理,socks5
client := &http.Client{Transport: &t}
r, _ := client.Get("https://google.com")
defer r.Body.Close()
_, _ = io.Copy(os.Stdout, r.Body)

JWT快速入门

Sat, 01 Jun 2024 00:00:00 GMT

什么是jwt

Json Web Token，通过数字签名的方式，以json对象为载体，在不同的服务终端之间安全的传输信息

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.
eyJ1c2VySWQiOjEyMywidXNlcm5hbWUiOiJhbGljZSJ9.
SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

它由三部分组成：

Header（头部）：说明用的加密算法，例如 HS256
Payload（载荷）：存放用户信息，比如 userId, role, exp
Signature（签名）：用密钥签名，确保数据没被篡改格式就是： Header.Payload.Signature

使用

假设你登录成功后，服务器生成一个 JWT：

Header:
{
  "alg": "HS256",
  "typ": "JWT"
}

Payload:
{
  "userId": 123,
  "username": "alice",
  "exp": 1713207687
}

服务器用密钥生成签名，然后把整个 JWT 返回给前端，前端以后每次请求都带着它：

Authorization: Bearer <你的JWT>

服务器验证这个 Token，就知道你是谁，而且不需要查数据库。

验证签名的过程是：

用 同样的密钥 和算法（比如 HS256）
对 Header.Payload 重新生成一遍签名
看是否和原来的 <Signature> 一样如果一样，说明 token 没被篡改如果不一样，说明 token 被伪造或篡改了

注意

JWT 存在前端（通常放在 localStorage 或 cookie 中）
不能存敏感信息（JWT 是明文可解码的）
超时后需重新登录或刷新 token（配合 refresh token）