业务场景
业务场景是框架能力的试金石:同一套工具链落到评论盖楼、日志埋点、文档生成和商业化计费上,会逼出完全不同的取舍。这里把散落在各处的实战片段收拢到一起。
# 数据构造
# 评论区盖楼
大二的设计,用一个 List 存放当前 floor 楼层下的所有回复,to 为当前楼层的 comment 将放在这个 List 中,由此来构造树形结构
@Data
public class Comment {
int question;
long floor;
String from;
long to;
String content;
List<Comment> comments;
public void setComments(List<Comment> comments){
if(this.to != 0){
return;
}
this.comments = new ArrayList<>();
for(Comment c: comments){
if(c.getTo() == this.floor){
this.comments.add(c);
}
}
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
对应的 mapper 只有两条 SQL
@Mapper
@Repository
public interface CommentMapper {
@Select("select * from `comment` where `question`=#{question}")
List<Comment> getComments(int question);
@Insert("insert into `comment`(question, `to`, `from`, content) values(#{question}, #{to}, #{from}, #{content})")
void comment(Comment comment);
}
2
3
4
5
6
7
8
9
10
在 service 层做如下嵌套处理,把根据 questionId 从数据库查出的扁平所有评论 List 组装成树形结构,对每个 comment 都执行 setComment,set 的对象是所有当前 question 的评论,这里的时间复杂度会达到
public List<Comment> getComments(int question){
List<Comment> comments = commentMapper.getComments(question);
for(Comment c: comments){
c.setComments(comments);
}
List<Comment> res = new ArrayList<>();
for(Comment c: comments){
if(c.getTo() == 0){
res.add(c);
}
}
return res;
}
2
3
4
5
6
7
8
9
10
11
12
13
其实也还行,就是每一次都要拿所有的评论出来,如果有只拿某一层的评论的需求,就出大问题了
- 正常的盖楼,一般只会展示根楼层,在用户点击显示更多的时候,才会展开当前楼层的所有回复,参考贴吧的实现
这里 to 只记录了直接父级,如果要构造树形结构,每一次都要读出所有的评论,实现不了“只读根楼层,再读子楼层”
正确的楼层数据库设计:应设置一个 root 冗余字段,记录每个评论对应的根楼层,同时保留直接父级 to 字段用于构造树形结构
@Data
public class Comment {
int id; // 通原先的 floor
int from; // 评论者
int to; // 直接父级
int root; // 根父级
String content; // 评论内容
int question; // 所属题目
}
2
3
4
5
6
7
8
9
这样就可以了,在进入题目展示楼层时,先根据 question 和 to = 0 读出根楼层直接展示,当用户展开某一根楼层的评论时,根据 root 查出当前楼层所有评论,在业务侧构造完整的树形结构返回即可
进一步的两个高并发问题
- 热门评论排序(Hot Sort):冷热分离,一定不能在数据库 order by,而是要单独把热门评论拎出来缓存在 Redis ZSet ,用 socre 表示点赞数,直接 TopK 返回即可,非热点评论才从 DB 里拿
- 评论点赞高并发处理(Write Back):异步回写,每次点赞不直接 update 数据库,而只写 Redis,即执行简单的 INCR 操作,当 INCR 了 100 次,再批量写回数据库,频繁写 DB 是大忌
# PPT 转码
不管是这里的文档解析还是最后生成的 PPT 字符串返回,都是统一的 json 结构,这里要区分文档的两种形态,即
- 文件系统里的源文件,这一份会保持文件原有格式
- 对象存储系统中的 bdjson 文件,这里存储的是统一的 json 格式数据
用户直接上传文件,只会调用第一个服务,将文件存储在文件系统,保持原有数据格式;但如果涉及文件操作,就需要全部在 bdjson 上进行修改,例如转码、生成、美化
基础侧提供统一处理 bdjson 的接口,根据传入文档类型,返回一份新格式的 bdjson 的文档
const (
DocTypeDOCX DocType = "docx"
DocTypePPT DocType = "ppt"
DocTypePDF DocType = "pdf"
DocTypeXLSX DocType = "xlsx"
DocTypeTXT DocType = "txt"
)
func TransformBDJSON(source BDJSON, targetType DocType) (target BDJSON, err error) {
switch targetType {
case DocTypeDOCX:
return transToDocxBDJSON(source)
case DocTypePPT:
return transToPPTBDJSON(source)
case DocTypePDF:
return transToPDFBDJSON(source)
case DocTypeXLSX:
return transToXLSXBDJSON(source)
case DocTypeTXT:
return transToTXTBDJSON(source)
default:
return nil, fmt.Errorf("unsupported target type: %s", targetType)
}
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
再就是从各种文档到 bdjson 的双向转码
// 【反向转码服务】各种原始文档 → 统一 BDJSON,解析外部文件,输出标准 BDJSON
func ConvertToBDJSON(fileBytes []byte, sourceType DocType) (bdjson BDJSON, err error) {
switch sourceType {
case DocTypeDOCX:
return docxToBDJSON(fileBytes)
case DocTypePPT:
return pptToBDJSON(fileBytes)
case DocTypePDF:
return pdfToBDJSON(fileBytes)
case DocTypeXLSX:
return xlsxToBDJSON(fileBytes)
case DocTypeTXT:
return txtToBDJSON(fileBytes)
default:
return nil, fmt.Errorf("unsupported source type: %s", sourceType)
}
}
// 【正向转码服务】统一 BDJSON → 各种原始文档二进制,生成可直接落盘的文件字节流
func ConvertFromBDJSON(bdjson BDJSON, targetType DocType) (fileBytes []byte, err error) {
switch targetType {
case DocTypeDOCX:
return bdjsonToDocx(bdjson)
case DocTypePPT:
return bdjsonToPpt(bdjson)
case DocTypePDF:
return bdjsonToPdf(bdjson)
case DocTypeXLSX:
return bdjsonToXlsx(bdjson)
case DocTypeTXT:
return bdjsonToTxt(bdjson)
default:
return nil, fmt.Errorf("unsupported target type: %s", targetType)
}
}
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
对于业务侧而言,这样的转码是无感知的,在用户上传解析之前就会调用完成,至少在生 PPT 时,拿到的都会是 bdjson 结构的文件数据,LLM 只会接收这种数据,前置的解析由上述服务提供
# 文档协同编辑
通过 WebSocket 实现画布协同编辑的通信,后端根据 docID 初始化 WebSocket 房间,用户编辑后通过 WebSocket 广播同步全量变更,用户并发编辑通过 OT 算法处理
func InitCoordinationRooms(ctx context.Context, req UserRoleReq) error
初始化协同房间
- 获取文档的协作者列表
- 检查是否需要初始化房间
- 如果是首次有协作者,初始化 WebSocket 房间
- 返回初始化结果
通知协同状态变更:当用户权限变更、文档版本更新后,通过 WebSocket 广播通知所有在线协作者并更新各自前端的文档内容
type CoordinationUpdatePerms struct {
UID int `json:"uid" form:"uid"`
Perms int `json:"perms" form:"perms"` // 权限角色
Cause int `json:"cause" form:"cause"` // 变更原因
}
type NoticeCoordinationStatusParams struct {
DocID string `json:"docId" form:"docId"` // 加密后的文档ID
Updates []CoordinationUpdatePerms `json:"updates" form:"updates"`
}
func NoticeCoordinationStatus(ctx context.Context, req NoticeCoordinationStatusParams) (bool, error)
2
3
4
5
6
7
8
9
10
11
12
- 在房间建立完成后,后端其实不涉及 WebSocket 的接口了,前端会被动的接收后端 WebSocket 长连接的广播,实时同步最新的文档数据
真正的协同编辑是没有锁的,这里使用到了一种叫做 OT 的算法(Operational Transformation),类似于 git 的 diff 增量同步
- 用户的操作在进入 DB 之前先打到 OT 服务器
- 用户行为被 OT 服务器转化为原子的、结构化的操作信息,并附带版本号或时间
- 对于同一篇文档,根据这样的操作记录实现更新,如果变更位置不冲突,就自动合并,如果冲突,就接收版本号更新或时间靠后的操作记录
每次编辑文档,持久化顺序如下,均通过 NMQ 解耦
- 异步更新 BOS 内容 BDJson
- 异步更新 MySQL 元数据
- 异步更新 ES 索引数据
用户操作
↓
WebSocket 接收操作 (wkservice_wsapi服务)
↓
经过 OT 服务器进行合并、更新,输出原子操作
↓
操作转换成 BDJson 增量更新
↓
通过 WebSocket 广播更新给全量在线用户
↓
调用 /savebdjson 持久化完整内容
↓
调用 wkservice_rtcs_canvas 保存到 BOS
↓
异步推送 NMQ 信息写 DB 更新 MySQL
↓
更新 ES 文档索引
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
convutil.go:创建协同房间,其实就是调外挂的 websocket 微服务根据 docId、uid、docFrom 创建 ws 房间
func InitCoordinationRoom(ctx context.Context, req InitCoordinationRoomParams) (bool, error) {
var form = map[string]string{
"docId": req.DocID,
"uid": req.UID,
"docFrom": req.DocFrom,
}
values := url.Values{}
for k, v := range form {
values.Set(k, v)
}
ralReq := &ghttp.RalRequest{
Method: "GET",
Path: WsapiInitRoomPath,
Query: values,
}
response := &NoticeCoordinationStatusResp{}
ralResp := &ghttp.RalResponse{
Data: response,
Decoder: codec.JSONDecoder,
}
resource.LoggerService().Notice(ctx, "init coordination room ", logit.AutoField("req", req))
err := ral.RAL(ctx, WsapiServiceName, ralReq, ralResp)
if err != nil {
resource.LoggerService().Warning(ctx, "initroom ral fail", logit.Error("err", err))
return false, err
}
if response.Status.Code != 0 {
resource.LoggerService().Warning(ctx, "initroom ral code is ", logit.AutoField("req", req))
return false, err
}
return response.Data.Success, nil
}
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
savebdjson.go:持久化接口
- 先同步更新 BOS
- 再消息队列通知更新 MySQL
- 最后消息队列通知更新 ES
func (g *savebdjson) OnExecute(ctx context.Context, req ghttp.Request) (interface{}, error) {
savebdjsonServ := canvas.NewBaseService()
if savebdjsonServ == nil {
resource.LoggerService().Error(ctx, "savebdjson service is nil")
return nil, canvas_error.ErrWkInternalError
}
err := savebdjsonServ.SaveBDJson(ctx, &util.SaveCanvasBDJsonRequest{
UID: g.param.UIDStr,
DocID: g.param.DocID,
Canvas: g.param.BDJson,
Bucket: canvas.GetBucket(),
})
if err != nil {
resource.LoggerService().Error(ctx, "save bdjson failed", logit.Error("error", err))
return nil, canvas_error.ErrWkInternalError
}
if g.param.IsCreateThumb {
canvas.SendScreensshot(ctx, uint64(g.sockID), g.param.DocID, g.param.StoreID)
}
updateTime := time.Now().Unix()
// 发送下游命令号3300013
var command = map[string]interface{}{
"command_no": "3300013",
"opType": "update",
"edtDocRec": map[string]interface{}{
"uid": g.sockID,
"showDocId": g.param.DocID, // 传加密后的docID
"updateTime": updateTime,
},
"isSaveEdtDocRec": true, // 下游逻辑兼容,只入edtdoc_rec表
}
_, err = nmq.Call(ctx, servicer.DefaultMapper, command)
if err != nil {
resource.LoggerService().Warning(ctx, "send nmq failed", logit.Error("err", err), logit.AutoField("command", command))
return nil, canvas_error.ErrWkInternalError
}
nuid := uint64(g.sockID)
canvasDocPayload := canvasdoc.CanvasDocPayload{
DocID: &g.param.DocIDInt,
Title: g.param.Title,
UID: &nuid,
Product: frtocUtil.Uint8PTR(canvasmaterial.ToB),
UpdateTime: &updateTime,
IsHidden: frtocUtil.Uint8PTR(0),
}
canvasDocServiceImpl := canvasdoc.CanvasDocServiceImpl{}
err = canvasDocServiceImpl.UpdateDoc(ctx, &canvasDocPayload)
if err != nil {
resource.LoggerService().Error(ctx, "call nmq failed,UpdateDoc ES", logit.Error("error", err), logit.AutoField("canvasDocPayload", canvasDocPayload))
return nil, canvas_error.ErrWkCallNmqError
}
resp := &savebdjsonResponse{
UpdateTime: updateTime,
}
return resp, nil
}
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
底层的 SaveCanvasBDJson 函数,调用的是一个叫RtcsSaveCanvasBDJsonPath的微服务,真正的写锁在这个底层服务中实现,上层不加锁
// 保存自由画布内容
func SaveCanvasBDJson(ctx context.Context, req *SaveCanvasBDJsonRequest) error {
if req == nil {
resource.LoggerService().Error(ctx, "SaveCanvasBDJson req is nil")
return errors.New("SaveCanvasBDJson req is nil")
}
var header = http.Header{}
header.Add("Content-Type", "application/json")
header.Add("Cookie", "BDUSS="+req.BDUSS)
ralReq := &ghttp.RalPostRequest{
RalRequest: ghttp.RalRequest{
Method: "POST",
Path: RtcsSaveCanvasBDJsonPath,
Header: header,
},
PostData: req,
Encoder: codec.JSONEncoder,
}
resp := &SaveCanvasBDJsonResponse{}
ralResp := &ghttp.RalResponse{
Data: resp,
Decoder: codec.JSONDecoder,
}
if err := ral.RAL(ctx, RtcsCanvasServiceName, ralReq, ralResp); err != nil {
resource.LoggerService().Error(ctx, RtcsCanvasServiceName+"call failed", logit.Error("err", err))
return errors.New(RtcsCanvasServiceName + "call failed")
}
if ralResp.Response() != nil && ralResp.Response().Body != nil {
defer ralResp.Response().Body.Close()
}
if resp.Status.Code != 0 {
resource.LoggerService().Error(ctx, RtcsCanvasServiceName+"call failed", logit.String("errMSg", resp.Status.Msg))
return errors.New(RtcsCanvasServiceName + "call failed")
}
return nil
}
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
doc.go:消息队列更新 ES 索引函数
func (d *CanvasDocServiceImpl) UpdateDoc(ctx context.Context, req *CanvasDocPayload) (err error) {
if req == nil || req.DocID == nil || *req.DocID == 0 {
return wkerror.New(wkerror.ErrorCodeParamsError, "docid or title is empty")
}
dbBody, err := buildESDocBody(ctx, req)
if err != nil {
return wkerror.New(wkerror.ErrorCodeParamsError)
}
// 发送消息队列
err = SendNmq(ctx, UdocCommandNo, req.DocID, dbBody)
if err != nil {
return err
}
return nil
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
NMQ 是异步消息队列,发送后不等待确认,如果需要确认持久化完成,需要通过查询下游系统(MySQL / ES)来间接判定,为什么这么设计?
- 一是性能上的考虑,上层不需要同步等待
- 二是用消息队列做兜底防止下游数据丢失
NMQ 的作用
- 消息持久化到队列
- 消费者重试机制
- 支持死信队列处理失败消息
# 业务治理
# 前置风控与灰度编码
用户传入的文本、图片内容要经过一层黄赌毒的风控:例如对内部图片链接,业务侧调用风控接口进行判定,触发风控拒绝服务
imgUrlInner := getInnerUrl(ctx, oriURL)
Risk, err := basis.RunWenchainRisk(
ctx,
basis.WcRiskReq{
Channel: PCIMGRiskChannel,
Extra: basis.WcRiskReqExtra{
ImgUrls: []string{imgUrlInner},
},
},
)
//这里不检查IsRiskAbnormal,风控稳定性不阻塞业务流程
if Risk == nil || err != nil || Risk.Data.IsRiskCheck {
return nil, wkerror.New(aigc.ImgRiskError, "this img is not allowed")
}
2
3
4
5
6
7
8
9
10
11
12
13
14
下层调用的 wenchain 的风控接口是一个同步的 RPC 风控调用:调用方发起请求 → 阻塞等待 → 接收响应 → 反序列化到预分配的内存 response
risk.go: RunWenchainRisk
// RunWenchainRisk 调用文链风控接口
// https://iapi.baidu-int.com/apidoc/shared-73ece047-f989-40a5-b96e-d9a4e23d0a5a
func RunWenchainRisk(ctx context.Context, req WcRiskReq) (resp *WcRiskResp, err error) {
resource.LoggerService().Notice(ctx, "", logit.Int("aicomm_riskcom_RunWenchainRisk", 1)) // 调用信息日志统计
ralReq := &ghttp.RalPostRequest{
RalRequest: ghttp.RalRequest{
Method: "POST",
Path: WenchainRiskCheckPath,
Header: http.Header{
"content-type": {"application/json"},
},
},
PostData: req,
Encoder: codec.JSONEncoder,
}
response := &WcRiskResp{}
ralResp := &ghttp.RalResponse{
Data: response,
Decoder: codec.JSONDecoder,
}
if err := ral.RAL(ctx, WenchainRiskCheckRal, ralReq, ralResp); err != nil {
// error log
resource.LoggerService().Error(ctx, "risk_RunWenchainRisk", logit.AutoField("error", err))
return nil, wkerror.New(wkerror.ErrorCodeCallServiceError, "call wenchain risk service error")
}
rawResp := ralResp.Response()
defer rawResp.Body.Close()
if response.Errno != 0 {
resource.LoggerService().Error(ctx, "risk_RunWenchainRisk", logit.AutoField("response", response))
return nil, wkerror.New(wkerror.ErrorCodeCallServiceError, "wenchain risk service return error")
}
resource.LoggerService().Debug(ctx, "risk_RunWenchainRisk", logit.AutoField("response", response))
return response, nil
}
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
这里底层的风控是通过 SetNX 上锁的
- 为了防止什么,没太理解?最多重试 3 次,每次间隔 400ms,TTL 为 1 秒
- 同时风控列表的管理也是上锁的,防止并发导致的风控泄露
- 此外,对于敏感数据
documentID, userID, roleID均使用fcrypt加密传输
coordinationrisk.go
// 第69-78行:Redis SetNX 实现分布式锁
func GetAndAddLock(ctx context.Context, key string) {
for i := 0; i < MaxRetryNum; i++ {
riskLock, setErr := basis.GetRedisIns(ctx).SetNX(ctx, key, "true", 1*time.Second).Result()
if setErr == nil && riskLock {
break
}
time.Sleep(400 * time.Millisecond)
}
}
func ElementRisk(ctx context.Context, req ElementRiskReq) basis.RiskContent {
// 读之前加锁
key := SetRiskLockKey + req.CanvasDocId
GetAndAddLock(ctx, key)
// 确保锁会被释放
defer basis.GetRedisIns(ctx).Del(ctx, key)
// 读风控内容
object := fmt.Sprintf(bos_util.BosCanvasKeyPre+"/%s/risk/%s.%s", req.CanvasDocId, req.CanvasDocId, "txt")
riskContent := basis.GetRiskContent(ctx, object)
// 修改:根据不同元素类型操作列表,更新 riskContent.CanvasEleRiskList
if req.ElementType == ContentTypeText {
// 风控检查:调用 wenchain 的风控微服务
txtRisk, err := basis.RunWenchainRisk(
ctx,
basis.WcRiskReq{
Channel: basis.FileRiskChannel,
UserID: strconv.FormatUint(req.UID, 10),
Extra: basis.WcRiskReqExtra{
Content: req.Content,
},
},
)
resource.LoggerService().Notice(ctx, "txt risk", logit.AutoField("txtRisk", txtRisk))
if err != nil || txtRisk == nil {
return riskContent
}
// 拓展风控列表
if txtRisk.Data.IsRiskCheck {
riskContent.CanvasEleRiskList = append(riskContent.CanvasEleRiskList, req.ElementId)
// ...
} else {
riskContent.CanvasEleRiskList = basis.RemoveRiskEle(riskContent.CanvasEleRiskList, req.ElementId)
}
// 更新风控列表,写入 BOS
err = uploadRiskContent(ctx, object, riskContent)
if err != nil {
resource.LoggerService().Error(ctx, "upload risk content failed", logit.AutoField("object", object), logit.Error("error", err))
return riskContent
}
}
// ... 对于不同类型的 Element 都进行类似的 if-else 处理
// ...
return riskContent
}
// 写操作:保存风控内容至 BOS
func uploadRiskContent(ctx context.Context, object string, content basis.RiskContent) error {
textByte, err := json.Marshal(content)
if err != nil {
return err
}
_, err = modbdjson.UploadObjectBytes(ctx, bos_util.GetBucket(), object, textByte, true)
return err
}
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
硬编码灰度:ZimixFlow 硬编码的灰度,这里的 smallflow 实际上是在重新封装 param,真正的业务处理还在下层
genflow.go: Chat(ctx context.Context, w ghttp.Writer, req ghttp.Request)
// 峙一小流量
smallflow(ctx, req, ¶m)
if c.Request != nil && c.Request.URL != nil {
param.ExtraValues = c.Request.URL.Query()
}
func smallflow(ctx context.Context, req ghttp.Request, param *genflowtypes.RunReq) {
var dataExtra map[string]any
if err := json.Unmarshal(param.Extra, &dataExtra); err != nil {
resource.LoggerService().Warning(ctx, "param.Extra json Unmarshal failed", logit.String("extra", string(param.Extra)))
return
}
var smallflowV2 string
if param.Channel == "wenku_pc_genflow_v2" {
newCtx := wkcontext.WithHTTPRequest(ctx, req.HTTPRequest())
sampleList := wkcontext.GetFeedSample(newCtx).GetFeedSampleList(newCtx)
sampleLists := []string{}
for _, sample := range sampleList {
sampleLists = append(sampleLists, sample.ID)
}
smallflowV2 = strings.Join(sampleLists, "-")
} else if param.Channel == "wenku_na_genflow_v2" {
smallflowV2 = gjson.Get(string(param.Extra), "smallflow").Str
}
if len(smallflowV2) > 0 {
dataExtra["smallflow_v2"] = smallflowV2
extra, err := json.Marshal(dataExtra)
if err != nil {
resource.LoggerService().Warning(ctx, "param.Extra json Marshal failed", logit.AutoField("extra", dataExtra))
return
}
param.Extra = extra
}
}
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
# 商业化计费回调
生成文档后进行商业化计费回调,根据生成的文档 isLong 进行积分扣减,实现用户的商业化权益操作
- 实际上是一个订单状态机的设计:冻结 - 消费 - 解冻
- 状态机有一张状态流转日志表来追系统行为,这很关键
业务流程为
- 用户发送生 PPT 请求:权益检查 → 触发冻结 → 生成 PPT 任务异步执行
- 生 PPT 任务为 SSE 输出 → 返回结束帧返回 → 回调商业化接口 → 消费 / 退还 → 解冻
用户触发 AI 工具
↓
[Get] 查询 CommercialGet
├─ 调用 IsHasTicketNew() → GetAll() 查询剩余次数
└─ 判断:剩余次数 >= 使用次数?否 → 拦截,返回提示
↓
[Freeze] 预占用阶段(防止并发)
├─ 冻结 1 次权益(30 分钟)
└─ 返回冻结成功
↓
[执行 AI 生成任务] (耗时较长)
↓
├─ 成功 → [Consume] 真正扣费 + [UnFreeze] 释放预占用
└─ 失败 → [UnFreeze] 释放预占用(不扣费)
2
3
4
5
6
7
8
9
10
11
12
13
14
核心逻辑:根据用户当前行为响应,实现拦截重复消费,撤销预扣费等逻辑
doc: configcallback
tool := toolItem
useCnt := toolMap[tool.ToolName]
// g.Go(func() error {
hitActs := false
hitUsesTimes := false
// 消费权益动作
if obj.configCallbackParams.Action == ActionConsume {
// consume
err := obj.CommercialConsume(ctx, toolItem)
if err != nil {
// 请求商业化服务失败,不拦截
resource.LoggerService().Warning(ctx, "CommercialConsume error",
logit.Error("err", err))
hitUsesTimes = false
}
}
// 冻结行为
if obj.configCallbackParams.Action == ActionFreeze {
// freeze
_, err := obj.CommercialFreeze(ctx, toolItem)
if err != nil {
// 请求商业化服务失败,不拦截
resource.LoggerService().Warning(ctx, "CommercialFreeze error",
logit.Error("err", err))
hitUsesTimes = false
}
}
// 解冻行为
if obj.configCallbackParams.Action == ActionUnFreeze {
// unfreeze
_, err := obj.CommercialUnFreeze(ctx, toolItem)
if err != nil {
// 请求商业化服务失败,不拦截
resource.LoggerService().Warning(ctx, "CommercialUnFreeze error",
logit.Error("err", err))
hitUsesTimes = false
}
}
// 权益查询, 不会触发频控
if obj.configCallbackParams.Action == ActionGet {
hitUsesTimes = obj.CommercialGet(ctx, toolItem, useCnt)
}
// set ret
tl := ToolList{
ToolName: tool.ToolName,
HitActs: hitActs,
HitUsesTimes: hitUsesTimes,
TrialTimes: nil,
}
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
这里的并发是如何解决的?
- 写 DB 的 SQL 加锁,更新时通过 version 乐观锁检查,只有当前 version 匹配 DB 里的 version 字段,才允许更新,并置 version = version + 1
- 这样其余被写锁卡住的请求再进行写时,就会被 version 不匹配给拒绝服务
另外还有两个很重要的点没学到:一个是预占权益的具体实现(ZSet 预占);再一个是超时的自动解冻怎么实现,可能是?
- cron 定时任务
- redis zset 扫描
- rabbitmq 死信队列,缓冲队列和业务队列
- 时间轮算法
# 业务解耦
# AOP 转账日志解耦
数据结构
@Data
@Getter
@Setter
public class Log {
@JsonSerialize(using= ToStringSerializer.class)
private Long id;
@JsonSerialize(using=ToStringSerializer.class)
private Long uid;
private String username;
private Integer type;
private String obj;
private Integer result;
private String description;
private Integer deleted;
private Date gmtCreate;
private Date gmtModified;
}
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
mapper
@Mapper
public interface LogMapper {
List<Log> findLog();
int insertLog(Log log);
int deleteById(@Param("id") Long id);
int deleteAll();
List<Log> findLogByDate(@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")Date start, @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")Date end);
}
2
3
4
5
6
7
8
日志注解,定义了 type 和 description 参数,这里的 type 和 description 将在 saveLog 的时候 set 进 log 并写入数据库,用于说明日志
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogAnnotation {
// 操作类型 1=新增 2=删除 3=修改 4=查询 5=导入 6=导出
int type();
// 操作描述
String description();
}
2
3
4
5
6
7
8
9
10
AOP 日志切面
@Aspect
@Component
public class LogAspect {
@Resource
private LogMapper logMapper;
private final ObjectMapper objectMapper = new ObjectMapper();
// 切点:所有加了 @LogAnnotation 注解的方法
@Pointcut("@annotation(LogAnnotation)")
public void logPointCut() {}
// 成功执行后记录日志
@AfterReturning(pointcut = "logPointCut()", returning = "result")
public void logAfterReturning(JoinPoint joinPoint, Object result) {
saveLog(joinPoint, result, null);
}
// 抛异常时记录日志
@AfterThrowing(pointcut = "logPointCut()", throwing = "e")
public void logAfterThrowing(JoinPoint joinPoint, Exception e) {
saveLog(joinPoint, null, e);
}
// 保存日志
private void saveLog(JoinPoint joinPoint, Object result, Exception e) {
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
LogAnnotation logAnnotation = method.getAnnotation(LogAnnotation.class);
Log log = new Log();
// 操作类型
log.setType(logAnnotation.type());
// 描述
log.setDescription(logAnnotation.description());
// 操作人信息,直接从 UserContext 获取当前登录用户信息
Long uid = UserContext.getUserId();
String username = UserContext.getUsername();
log.setUid(uid);
log.setUsername(username);
// 操作方法
String className = joinPoint.getTarget().getClass().getName();
String methodName = method.getName();
log.setObj(className + "." + methodName);
// 结果:0=失败 1=成功
if (e != null) {
log.setResult(0);
log.setDescription(log.getDescription() + ",异常:" + e.getMessage());
} else {
log.setResult(1);
}
log.setDeleted(0);
log.setGmtCreate(new Date());
log.setGmtModified(new Date());
// 插入数据库
logMapper.insertLog(log);
// 清空 ThreadLocal,防止内存泄漏
UserContext.clear();
}
}
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
AOP 切面注入:实际使用时,直接在方法上加注解 @LogAnnotation,就会触发 saveLog 函数
@Service
public class UserService {
// 新增日志示例
@LogAnnotation(type = 1, description = "新增用户")
public void addUser(User user) {
// 业务代码
}
}
2
3
4
5
6
7
8
有一个有意思的点是,在切面中要拿取用户信息,这里通过 ThreadLocal 去拿取,定义了一个 UserContext 工具类,内置ThreadLocal<User>在同一线程传递信息
public class UserContext {
// 保存当前登录用户
private static final ThreadLocal<User> USER_THREAD_LOCAL = new ThreadLocal<>();
// 设置当前用户
public static void setUser(User user) {
USER_THREAD_LOCAL.set(user);
}
// 获取当前用户
public static User getUser() {
return USER_THREAD_LOCAL.get();
}
// 获取用户ID
public static Long getUserId() {
User user = getUser();
return user == null ? null : user.getId();
}
// 获取用户名
public static String getUsername() {
User user = getUser();
return user == null ? null : user.getUsername();
}
// 必须清除,防止内存泄漏
public static void clear() {
USER_THREAD_LOCAL.remove();
}
}
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
在上层调用时,事先把用户信息存入当前线程
@Service
public class UserService {
// 新增日志示例
@LogAnnotation(type = 1, description = "新增用户")
public void addUser(User user) {
// 业务代码
// ...
// 将用户信息存入当前线程
UserContext.setUser(user);
}
}
// 在 saveLog 中直接通过 UserContext.getUserId / getUsername 拿取
// 在使用完后,调用 UserContext.clear 清空
2
3
4
5
6
7
8
9
10
11
12
13
14
15
但实际上日志切面用的很少,不如直接用日志框架解耦,因为这里的切面解耦实际上也是一种硬编码,使用注解,侵入式很高,这里只是提供一种用法
# 消息队列解耦判题业务
设计模式
- 模板工厂模式:抽象判题流程
- 策略模式:三种策略编译执行代码
- 观察者模式:判题机作为消费者监听判题事件
例如车票排队等订单处理的设计
用户从页面查询、填写并发起一次判题请求,具体经过了如下步骤
- 从 Redis 读出题目详细信息,进入做题页面
- 用户填写表单,包含用户信息、题目信息、用户代码等内容,点击提交
- 后端收到请求,生成判题记录编号,而后将判题记录编号作为任务投递给 MQ,同时将记录编号返给前端(生产者的工作完成了)
- 判题机作为消费者,读取 MQ 消息,根据编号读数据库信息进行编译执行,并将结果与数据库比对,更新 MySQL 判题记录状态,并把记录状态以
{judge:status:记录编号, 1/2/3/4/5}的键值对形式写进 Redis - 用户点击提交后,将收到后端返回的判题编号,前端将根据判题编号不断轮询 Redis 查询判题状态,这一状态将持续 20s 左右,而后再从 MySQL 中拿取判题的详细信息
如何保证消息被成功消费?ACK 机制?重试机制?死信队列?