修改计划任务的持久化，act与kv的缓存逻辑，预防多服务器重复持久化

README.md

@@ -1,10 +1,10 @@
 # utility_go：强大的Go语言工具类库
 
 ## 一、项目概述
-`utility_go` 是一个功能丰富的Go语言工具类库，旨在帮助开发者更高效地开发Go应用程序。它提供了一系列实用的功能模块，涵盖了数据库操作、缓存处理、支付接口集成、排名算法实现等多个方面，可广泛应用于各种类型的Go项目中。
+`utility_go` 是一个功能丰富的Go语言工具类库，旨在助力开发者更高效地开发Go应用程序。它提供了一系列实用的功能模块，广泛涵盖数据库操作、缓存处理、支付接口集成、排名算法实现等多个方面，适用于各类Go项目。
 
 ## 二、安装方式
-要使用 `utility_go` 工具类库，你可以使用 `go get` 命令进行安装。请确保你的Go环境已经正确配置，并且可以访问互联网。
+要使用 `utility_go` 工具类库，可使用 `go get` 命令进行安装。请确保你的Go环境已正确配置，且可访问互联网。
 
 ### 安装命令
 ```sh
@@ -12,7 +12,7 @@ go get github.com/ayflying/utility_go
 ```
 
 ### 安装验证
-安装完成后，你可以在你的Go代码中导入 `utility_go` 相关的包，检查是否能够正常使用。例如：
+安装完成后，你可以在Go代码中导入 `utility_go` 相关的包，检查是否能够正常使用。示例如下：
 ```go
 package main
 
@@ -29,39 +29,45 @@ func main() {
 ```
 
 ## 三、项目结构
-`utility_go` 的项目结构设计清晰，各个模块分工明确，方便开发者使用和扩展。以下是项目的主要目录结构：
+`utility_go` 的项目结构设计清晰，各模块分工明确，便于开发者使用和扩展。以下是项目的主要目录结构及说明：
 
 ### 主要目录说明
-- **`api/`**：存放与API相关的代码，包含不同模块的API接口定义，如 `admin`、`callback`、`system` 等。这些API接口用于处理各种外部请求，是项目与外部系统交互的重要入口。
+- **api/**：存放与API相关的代码，包含不同模块的API接口定义，如 `admin`、`callback`、`system` 等。这些API接口用于处理各种外部请求，是项目与外部系统交互的重要入口。
-- **`service/`**：服务层代码，包含各种业务逻辑的实现，如 `game_act.go`、`ip_2_region.go` 等。服务层负责处理具体的业务需求，将数据处理和业务逻辑封装在独立的函数或方法中，提高代码的可维护性和复用性。
+- **service/**：服务层代码，包含各种业务逻辑的实现，如 `game_act.go`、`ip_2_region.go` 等。服务层负责处理具体的业务需求，将数据处理和业务逻辑封装在独立的函数或方法中，提高代码的可维护性和复用性。
-- **`controller/`**：控制器层代码，主要用于处理HTTP请求和响应。控制器接收客户端的请求，调用相应的服务层方法进行处理，并将处理结果返回给客户端。
+- **controller/**：控制器层代码，主要用于处理HTTP请求和响应。控制器接收客户端的请求，调用相应的服务层方法进行处理，并将处理结果返回给客户端。
-- **`internal/`**：内部包，包含项目的核心业务逻辑，如 `game`、`logic`、`model` 等模块。其中，`model` 模块定义了项目中使用的数据模型，如数据库表对应的结构体；`logic` 模块实现了各种业务逻辑的处理函数。
+- **internal/**：内部包，包含项目的核心业务逻辑，如 `game`、`logic`、`model` 等模块。其中，`model` 模块定义了项目中使用的数据模型，如数据库表对应的结构体；`logic` 模块实现了各种业务逻辑的处理函数。
-- **`package/`**：包含各种功能包，提供了丰富的工具和功能，具体如下：
+- **package/**：包含各种功能包，提供了丰富的工具和功能，具体如下：
-    - **`aycache`**：缓存相关的功能包，提供了缓存操作的接口和实现，帮助开发者更方便地使用缓存技术，提高应用程序的性能。
+  - **aycache**：缓存相关的功能包，提供了缓存操作的接口和实现，帮助开发者更方便地使用缓存技术，提高应用程序的性能。
-    - **`elasticsearch`**：Elasticsearch相关的功能包，用于与Elasticsearch搜索引擎进行交互，实现数据的存储、检索和分析等功能。
+  - **elasticsearch**：Elasticsearch相关的功能包，用于与Elasticsearch搜索引擎进行交互，实现数据的存储、检索和分析等功能。
-    - **`excel`**：Excel处理相关的功能包，提供了Excel文件的读写操作接口，方便开发者处理Excel文件中的数据。
+  - **excel**：Excel处理相关的功能包，提供了Excel文件的读写操作接口，方便开发者处理Excel文件中的数据。
-    - **`pay`**：支付相关的功能包，包含了与各种支付平台的接口集成，如 `apple`（苹果支付）、`playstore`（Google Play Store支付）等，支持应用内购买等支付功能。
+  - **pay**：支付相关的功能包，包含了与各种支付平台的接口集成，如 `apple`（苹果支付）、`playstore`（Google Play Store支付）等，支持应用内购买等支付功能。
-    - **`rand`**：随机数相关的功能包，提供了生成各种随机数的函数，可用于测试、加密等场景。
+  - **rand**：随机数相关的功能包，提供了生成各种随机数的函数，可用于测试、加密等场景。
-    - **`rank`**：排名相关的功能包，实现了各种排名算法，如基于Redis的排行榜功能，可用于游戏排名、活动排名等场景。
+  - **rank**：排名相关的功能包，实现了各种排名算法，如基于Redis的排行榜功能，可用于游戏排名、活动排名等场景。
-    - **`s3`**：S3存储相关的功能包，用于与Amazon S3等云存储服务进行交互，实现文件的上传、下载、删除等操作。
+  - **s3**：S3存储相关的功能包，用于与Amazon S3等云存储服务进行交互，实现文件的上传、下载、删除等操作。
-- **`tools/`**：工具类代码，包含了一些常用的工具函数，如 `redis.go`（Redis操作相关）、`time.go`（时间处理相关）、`tools.go`（通用工具函数）等，方便开发者在项目中使用。
+- **tools/**：工具类代码，包含了一些常用的工具函数，如 `redis.go`（Redis操作相关）、`time.go`（时间处理相关）、`tools.go`（通用工具函数）等，方便开发者在项目中使用。
 
 ## 四、主要模块功能
 
-### 4.1 `pay/playstore`
+### 4.1 pay/playstore
-该模块主要用于与Google Play Store API交互，处理应用内购买相关的操作。它提供了以下主要功能：
+该模块主要用于与Google Play Store API交互，处理应用内购买相关的操作，提供以下主要功能：
-- **创建客户端**：通过 `New` 函数创建并返回一个包含访问androidpublisher API所需凭证的http客户端，方便开发者与Google Play Store API进行通信。
+- **创建客户端**：通过 `New` 函数创建并返回一个包含访问 `androidpublisher` API所需凭证的HTTP客户端，方便开发者与Google Play Store API进行通信。
-- **使用自定义客户端**：`NewWithClient` 函数允许开发者使用自定义的http客户端创建并返回一个包含访问androidpublisher API所需凭证的http客户端，增加了客户端的灵活性。
+- **使用自定义客户端**：`NewWithClient` 函数允许开发者使用自定义的HTTP客户端创建并返回一个包含访问 `androidpublisher` API所需凭证的HTTP客户端，增加了客户端的灵活性。
 - **验证签名**：`VerifySignature` 函数用于验证应用内购买的签名，确保支付信息的安全性和合法性。
 
-### 4.2 `s3`
+### 4.2 s3
-`s3` 模块主要用于与S3存储服务进行交互，提供了文件存储和管理的功能。其中，`ListBuckets` 函数可以列出S3存储桶的信息，方便开发者管理存储桶中的文件。
+`s3` 模块主要用于与S3存储服务进行交互，提供文件存储和管理的功能。其中，`ListBuckets` 函数可以列出S3存储桶的信息，方便开发者管理存储桶中的文件。
 
-### 4.3 `model`
+### 4.3 model
 `model` 模块定义了项目中使用的数据模型，这些数据模型通常与数据库表相对应，用于数据的存储和操作。例如：
-- **`GameMailMass`**：表示游戏邮件群发的数据模型，包含邮件的标题、内容、类型等信息。
+- **GameMailMass**：表示游戏邮件群发的数据模型，包含邮件的标题、内容、类型等信息。
-- **`GameBag`**：表示游戏背包的数据模型，包含用户标识、道具数据、图鉴、手势等信息。
+- **GameBag**：表示游戏背包的数据模型，包含用户标识、道具数据、图鉴、手势等信息。
-- **`MemberSave`**：（根据具体代码中的定义）可能表示用户会员信息的数据模型，用于存储用户的会员相关数据。
+- **MemberSave**：（根据具体代码中的定义）可能表示用户会员信息的数据模型，用于存储用户的会员相关数据。
+
+### 4.4 tools
+`tools` 模块提供了一系列通用工具函数，涵盖时间处理、Redis操作、道具数据处理等功能：
+- **时间处理**：`time.go` 文件中的函数可以进行时间计算，如获取本周开始时间、计算两个时间间隔天数等。
+- **Redis操作**：`redis.go` 文件中的函数可以进行Redis的扫描操作，支持批量获取大量数据。
+- **通用工具**：`tools.go` 文件中的函数提供了字符串处理、切片操作、道具数据合并等功能。
 
 ## 五、使用示例
 
@@ -115,6 +121,33 @@ func main() {
 }
 ```
 
+### 5.3 工具模块示例
+以下是一个使用 `tools` 模块处理道具数据的示例代码：
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/ayflying/utility_go/tools"
+)
+
+func main() {
+    // 字符串转道具类型
+    str := "1|10|2|20"
+    result := tools.Tools.Spilt2Item(str)
+    fmt.Println("Spilt2Item result:", result)
+
+    // 切片换道具类型
+    slice := []int64{1, 10, 2, 20}
+    res := tools.Tools.Slice2Item(slice)
+    fmt.Println("Slice2Item result:", res)
+
+    // 道具格式转map
+    list := tools.Tools.Items2Map(result)
+    fmt.Println("Items2Map result:", list)
+}
+```
+
 ## 六、注意事项
 - **自动生成文件**：项目中有部分代码文件是由GoFrame CLI工具生成并维护的，这些文件通常会标注有 `// Code generated and maintained by GoFrame CLI tool. DO NOT EDIT.` 注释。请不要手动修改这些文件，以免造成不必要的问题。
 - **版本兼容性**：在使用 `utility_go` 工具类库时，请确保你的Go语言版本与工具类库的要求版本兼容。建议使用最新的Go语言版本，以获得更好的性能和稳定性。
@@ -123,5 +156,4 @@ func main() {
 `utility_go` 工具类库会定期进行更新和维护，以修复已知的问题、添加新的功能和优化性能。你可以关注项目的GitHub仓库（https://github.com/ayflying/utility_go）获取最新的更新信息。如果你在使用过程中遇到任何问题或有任何建议，欢迎提交Issue或Pull Request。
 
 ## 八、许可证信息
-`utility_go` 工具类库遵循 MIT许可证，你可以在项目的 `LICENSE` 文件中查看详细的许可证条款。请确保在使用该工具类库时遵守相关的许可证规定。
+`utility_go` 工具类库遵循MIT许可证，你可以在项目的 `LICENSE` 文件中查看详细的许可证条款。请确保在使用该工具类库时遵守相关的许可证规定。
-```

api/pgk/v1/pgk.pb.go

@@ -1,237 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// versions:
-// 	protoc-gen-go v1.28.1
-// 	protoc        v3.20.0
-// source: pgk/v1/pgk.proto
-
-package v1
-
-import (
-	reflect "reflect"
-	sync "sync"
-
-	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
-	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
-)
-
-const (
-	// Verify that this generated code is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
-	// Verify that runtime/protoimpl is sufficiently up-to-date.
-	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
-)
-
-// 定义 NoticeType 枚举
-type NoticeType int32
-
-const (
-	NoticeType_DINGTALK NoticeType = 0
-	NoticeType_WECHAT   NoticeType = 1
-	NoticeType_EMAIL    NoticeType = 2
-	NoticeType_SMS      NoticeType = 3
-	NoticeType_VOICE    NoticeType = 4
-)
-
-// Enum value maps for NoticeType.
-var (
-	NoticeType_name = map[int32]string{
-		0: "DINGTALK",
-		1: "WECHAT",
-		2: "EMAIL",
-		3: "SMS",
-		4: "VOICE",
-	}
-	NoticeType_value = map[string]int32{
-		"DINGTALK": 0,
-		"WECHAT":   1,
-		"EMAIL":    2,
-		"SMS":      3,
-		"VOICE":    4,
-	}
-)
-
-func (x NoticeType) Enum() *NoticeType {
-	p := new(NoticeType)
-	*p = x
-	return p
-}
-
-func (x NoticeType) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (NoticeType) Descriptor() protoreflect.EnumDescriptor {
-	return file_pgk_v1_pgk_proto_enumTypes[0].Descriptor()
-}
-
-func (NoticeType) Type() protoreflect.EnumType {
-	return &file_pgk_v1_pgk_proto_enumTypes[0]
-}
-
-func (x NoticeType) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Use NoticeType.Descriptor instead.
-func (NoticeType) EnumDescriptor() ([]byte, []int) {
-	return file_pgk_v1_pgk_proto_rawDescGZIP(), []int{0}
-}
-
-// 排行榜数据
-type RankData struct {
-	state         protoimpl.MessageState
-	sizeCache     protoimpl.SizeCache
-	unknownFields protoimpl.UnknownFields
-
-	Id       int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
-	Score    int64 `protobuf:"varint,2,opt,name=score,proto3" json:"score,omitempty"`
-	Rank     int32 `protobuf:"varint,3,opt,name=rank,proto3" json:"rank,omitempty"`
-	UpdateTs int64 `protobuf:"varint,4,opt,name=update_ts,json=updateTs,proto3" json:"update_ts,omitempty"`
-}
-
-func (x *RankData) Reset() {
-	*x = RankData{}
-	if protoimpl.UnsafeEnabled {
-		mi := &file_pgk_v1_pgk_proto_msgTypes[0]
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		ms.StoreMessageInfo(mi)
-	}
-}
-
-func (x *RankData) String() string {
-	return protoimpl.X.MessageStringOf(x)
-}
-
-func (*RankData) ProtoMessage() {}
-
-func (x *RankData) ProtoReflect() protoreflect.Message {
-	mi := &file_pgk_v1_pgk_proto_msgTypes[0]
-	if protoimpl.UnsafeEnabled && x != nil {
-		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
-		if ms.LoadMessageInfo() == nil {
-			ms.StoreMessageInfo(mi)
-		}
-		return ms
-	}
-	return mi.MessageOf(x)
-}
-
-// Deprecated: Use RankData.ProtoReflect.Descriptor instead.
-func (*RankData) Descriptor() ([]byte, []int) {
-	return file_pgk_v1_pgk_proto_rawDescGZIP(), []int{0}
-}
-
-func (x *RankData) GetId() int64 {
-	if x != nil {
-		return x.Id
-	}
-	return 0
-}
-
-func (x *RankData) GetScore() int64 {
-	if x != nil {
-		return x.Score
-	}
-	return 0
-}
-
-func (x *RankData) GetRank() int32 {
-	if x != nil {
-		return x.Rank
-	}
-	return 0
-}
-
-func (x *RankData) GetUpdateTs() int64 {
-	if x != nil {
-		return x.UpdateTs
-	}
-	return 0
-}
-
-var File_pgk_v1_pgk_proto protoreflect.FileDescriptor
-
-var file_pgk_v1_pgk_proto_rawDesc = []byte{
-	0x0a, 0x10, 0x70, 0x67, 0x6b, 0x2f, 0x76, 0x31, 0x2f, 0x70, 0x67, 0x6b, 0x2e, 0x70, 0x72, 0x6f,
-	0x74, 0x6f, 0x12, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x22, 0x61, 0x0a, 0x08, 0x52,
-	0x61, 0x6e, 0x6b, 0x44, 0x61, 0x74, 0x61, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x03, 0x52, 0x02, 0x69, 0x64, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x72, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x12, 0x0a,
-	0x04, 0x72, 0x61, 0x6e, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, 0x72, 0x61, 0x6e,
-	0x6b, 0x12, 0x1b, 0x0a, 0x09, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x5f, 0x74, 0x73, 0x18, 0x04,
-	0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x75, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x73, 0x2a, 0x45,
-	0x0a, 0x0a, 0x4e, 0x6f, 0x74, 0x69, 0x63, 0x65, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0c, 0x0a, 0x08,
-	0x44, 0x49, 0x4e, 0x47, 0x54, 0x41, 0x4c, 0x4b, 0x10, 0x00, 0x12, 0x0a, 0x0a, 0x06, 0x57, 0x45,
-	0x43, 0x48, 0x41, 0x54, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x4d, 0x41, 0x49, 0x4c, 0x10,
-	0x02, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x4d, 0x53, 0x10, 0x03, 0x12, 0x09, 0x0a, 0x05, 0x56, 0x4f,
-	0x49, 0x43, 0x45, 0x10, 0x04, 0x42, 0x2b, 0x5a, 0x29, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e,
-	0x63, 0x6f, 0x6d, 0x2f, 0x61, 0x79, 0x66, 0x6c, 0x79, 0x69, 0x6e, 0x67, 0x2f, 0x75, 0x74, 0x69,
-	0x6c, 0x69, 0x74, 0x79, 0x5f, 0x67, 0x6f, 0x2f, 0x61, 0x70, 0x69, 0x2f, 0x70, 0x67, 0x6b, 0x2f,
-	0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
-}
-
-var (
-	file_pgk_v1_pgk_proto_rawDescOnce sync.Once
-	file_pgk_v1_pgk_proto_rawDescData = file_pgk_v1_pgk_proto_rawDesc
-)
-
-func file_pgk_v1_pgk_proto_rawDescGZIP() []byte {
-	file_pgk_v1_pgk_proto_rawDescOnce.Do(func() {
-		file_pgk_v1_pgk_proto_rawDescData = protoimpl.X.CompressGZIP(file_pgk_v1_pgk_proto_rawDescData)
-	})
-	return file_pgk_v1_pgk_proto_rawDescData
-}
-
-var file_pgk_v1_pgk_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_pgk_v1_pgk_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
-var file_pgk_v1_pgk_proto_goTypes = []interface{}{
-	(NoticeType)(0),  // 0: package.NoticeType
-	(*RankData)(nil), // 1: package.RankData
-}
-var file_pgk_v1_pgk_proto_depIdxs = []int32{
-	0, // [0:0] is the sub-list for method output_type
-	0, // [0:0] is the sub-list for method input_type
-	0, // [0:0] is the sub-list for extension type_name
-	0, // [0:0] is the sub-list for extension extendee
-	0, // [0:0] is the sub-list for field type_name
-}
-
-func init() { file_pgk_v1_pgk_proto_init() }
-func file_pgk_v1_pgk_proto_init() {
-	if File_pgk_v1_pgk_proto != nil {
-		return
-	}
-	if !protoimpl.UnsafeEnabled {
-		file_pgk_v1_pgk_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*RankData); i {
-			case 0:
-				return &v.state
-			case 1:
-				return &v.sizeCache
-			case 2:
-				return &v.unknownFields
-			default:
-				return nil
-			}
-		}
-	}
-	type x struct{}
-	out := protoimpl.TypeBuilder{
-		File: protoimpl.DescBuilder{
-			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
-			RawDescriptor: file_pgk_v1_pgk_proto_rawDesc,
-			NumEnums:      1,
-			NumMessages:   1,
-			NumExtensions: 0,
-			NumServices:   0,
-		},
-		GoTypes:           file_pgk_v1_pgk_proto_goTypes,
-		DependencyIndexes: file_pgk_v1_pgk_proto_depIdxs,
-		EnumInfos:         file_pgk_v1_pgk_proto_enumTypes,
-		MessageInfos:      file_pgk_v1_pgk_proto_msgTypes,
-	}.Build()
-	File_pgk_v1_pgk_proto = out.File
-	file_pgk_v1_pgk_proto_rawDesc = nil
-	file_pgk_v1_pgk_proto_goTypes = nil
-	file_pgk_v1_pgk_proto_depIdxs = nil
-}

aycache/aycache.go

@@ -1,8 +1,7 @@
 package aycache
 
 import (
-	"github.com/ayflying/utility_go/pkg/aycache/drive"
+	"github.com/ayflying/utility_go/pkg"
-	drive2 "github.com/ayflying/utility_go/pkg/aycache/drive"
 	"github.com/gogf/gf/v2/os/gcache"
 )
 
@@ -10,30 +9,7 @@ type Mod struct {
 	client *gcache.Cache
 }
 
-//func NewV1(_name ...string) *cache.Mod {
+// Deprecated:弃用，改用 pkg.Cache()
-//	return pgk.Cache
-//}
-
-// Deprecated:弃用，改用 pgk.Cache()
 func New(_name ...string) gcache.Adapter {
-
+	return pkg.Cache(_name...)
-	var cacheAdapterObj gcache.Adapter
-	var name = "cache"
-	if len(_name) > 0 {
-		name = _name[0]
-	}
-	switch name {
-	case "cache":
-		cacheAdapterObj = drive2.NewAdapterMemory()
-	case "redis":
-		cacheAdapterObj = drive2.NewAdapterRedis()
-	case "file":
-		cacheAdapterObj = drive2.NewAdapterFile("runtime/cache")
-	case "es":
-		cacheAdapterObj = drive.NewAdapterElasticsearch([]string{"http://127.0.0.1:9200"})
-	}
-
-	//var client = gcache.New()
-	//client.SetAdapter(cacheAdapterObj)
-	return cacheAdapterObj
 }

cmd/load.go

@@ -0,0 +1,32 @@
+package cmd
+
+import (
+	"github.com/ayflying/utility_go/controller/callback"
+	"github.com/gogf/gf/v2/net/ghttp"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+)
+
+func Load(s *ghttp.Server) {
+
+	//开启prometheus监控
+	s.Group("/metrics", func(group *ghttp.RouterGroup) {
+		group.Bind(
+			ghttp.WrapH(promhttp.Handler()),
+		)
+	})
+}
+
+// 注册游客方法
+func RegistrationAnonymous(group *ghttp.RouterGroup) (res []interface{}) {
+	group.Bind(
+		callback.NewV1(),
+	)
+	return
+
+}
+
+// 注册用户方法
+func RegistrationUser(group *ghttp.RouterGroup) (res []interface{}) {
+	group.Bind()
+	return
+}

cmd/make.go

@@ -26,7 +26,8 @@ var (
 		},
 		Examples: "make -m act -i 1:    创建活动1的接口与服务文件 \n" +
 			"make -m logic -n test: 	创建test的服务文件 \n" +
-			"make -m config -n test:    创建配置文件",
+			"make -m config -n test:    创建配置文件 \n" +
+			"make -m socket -n test:    创建socket文件 \n",
 		Func: func(ctx context.Context, parser *gcmd.Parser) (err error) {
 
 			//g.Dump(parser.GetOptAll(), parser.GetArgAll())
@@ -53,6 +54,12 @@ var (
 					return
 				}
 				err = this.Config(name)
+			case "socket":
+				var name = parser.GetOpt("name").String()
+				if name == "" {
+					return
+				}
+				err = this.Socket(name)
 			}
 
 			return
@@ -116,3 +123,25 @@ func (c *cMake) Config(name string) (err error) {
 
 	return
 }
+
+func (c *cMake) Socket(name string) (err error) {
+	var filePath = fmt.Sprintf("internal/socket/%s/%s_new.go", name, gstr.CaseSnake(name))
+	//生成文件不覆盖
+	if !gfile.Exists(filePath) {
+		// 生成目录文件
+		get, _ := fs.ReadFile(ConfigFiles, "make/socket")
+		fileStr := string(get)
+		fileStr = gstr.Replace(fileStr, "{name}", name)
+		err = gfile.PutContents(filePath, fileStr)
+
+		//生成方法文件
+		var filePath2 = fmt.Sprintf("internal/socket/%s/%s.go", name, gstr.CaseSnake(name))
+		get, _ = fs.ReadFile(ConfigFiles, "make/socket2")
+		fileStr = string(get)
+		fileStr = gstr.Replace(fileStr, "{name}", name)
+		fileStr = gstr.Replace(fileStr, "{func}", gstr.CaseCamel(name))
+		err = gfile.PutContents(filePath2, fileStr)
+	}
+
+	return
+}

cmd/make/socket

@@ -0,0 +1,10 @@
+package {name}
+
+type {name} struct {
+}
+
+func New() *{name} {
+	return &{name}{}
+}
+
+func init() {}

cmd/make/socket2

@@ -0,0 +1,19 @@
+package {name}
+
+import (
+	"github.com/ayflying/utility_go/pkg"
+	"github.com/ayflying/utility_go/pkg/websocket"
+	"google.golang.org/protobuf/proto"
+)
+
+func (s *{name}) {func}Handler(conn *websocket.WebsocketData, req any) (err error) {
+	var data = &v1.{func}2S{}
+	err = proto.Unmarshal(req.([]byte), data)
+
+	var res = &v1.{func}2C{}
+
+	resp, err := proto.Marshal(res)
+	pkg.Websocket().Send(000000, conn.Uid, resp)
+
+	return
+}

cmd/update.go

@@ -2,13 +2,14 @@ package cmd
 
 import (
 	"context"
-	"github.com/ayflying/utility_go/package/s3"
+	"github.com/ayflying/utility_go/pkg"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/ghttp"
 	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/os/gcmd"
 	"github.com/gogf/gf/v2/os/gctx"
 	"os"
+	"path"
 	"time"
 )
 
@@ -17,6 +18,8 @@ type serverCfg struct {
 	Address string `json:"address" dc:"服务地址"`
 	Prod    bool   `json:"prod" dc:"是否生产环境"`
 	S3      string `json:"s3" dc:"使用哪个对象储存中转"`
+	Arch    string `json:"arch" dc:"架构"`
+	System  string `json:"system" dc:"系统"`
 }
 
 type UpdateReq struct {
@@ -24,8 +27,6 @@ type UpdateReq struct {
 	FileUrl string            `json:"file_url" dc:"文件地址"`
 }
 
-var s3Mod *s3.Mod
-
 var (
 	Update = gcmd.Command{
 		Name:  "update",
@@ -36,9 +37,30 @@ var (
 			g.Log().Info(ctx, "准备上传更新文件")
 			//加载编辑配置文件
 			g.Cfg("hack").GetAdapter().(*gcfg.AdapterFile).SetFileName("hack/config.yaml")
+			//获取文件名
 			getFileName, err := g.Cfg("hack").Get(ctx, "gfcli.build.name")
 			Filename := getFileName.String()
 
+			////获取架构
+			//getArch, err := g.Cfg("hack").Get(ctx, "gfcli.build.arch")
+			//Arch := getArch.String()
+			//if Arch == "" {
+			//	Arch = "amd64"
+			//}
+			//
+			////获取操作系统
+			//getSystem, err := g.Cfg("hack").Get(ctx, "gfcli.build.system")
+			//System := getSystem.String()
+			//
+			//if System == "" {
+			//	System = "linux"
+			//}
+			//var systemName = System + "_" + Arch
+
+			//获取版本号
+			getVersion, err := g.Cfg("hack").Get(ctx, "gfcli.build.version")
+			Version := getVersion.String()
+
 			var list []*serverCfg
 			serverList := g.Cfg().MustGet(ctx, "server_list")
 			serverList.Scan(&list)
@@ -59,7 +81,9 @@ var (
 			g.Dump("需要更新的服务器", list)
 			//获取上传链接
 			var url = make(map[string]string)
-			filename := "linux_amd64/" + Filename
+			var system = make(map[string]string)
+			//filename := "linux_amd64/" + Filename
+			//filename := path.Join(Version, "linux_amd64", Filename)
 
 			client := g.Client()
 			client.SetTimeout(time.Minute)
@@ -73,14 +97,28 @@ var (
 				}
 
 				//查询当前上传地址是否存在
-				if _, ok := url[v.S3]; !ok {
+				_, ok2 := system[v.System+v.Arch]
+				if _, ok := url[v.S3]; !ok || !ok2 {
+
+					var systemName = "linux_amd64"
+					if v.Arch != "" && v.System != "" {
+						systemName = v.System + "_" + v.Arch
+					}
+					var filename = path.Join(Version, systemName, Filename)
+					g.Log().Debugf(ctx, "当前上传文件："+filename)
+
 					url[v.S3], err = UploadS3(v.S3, filename)
 					if err != nil {
 						g.Log().Error(ctx, err)
 						return
 					}
-				}
+					system[v.System+v.Arch] = filename
 
+					if err != nil {
+						g.Log().Error(ctx, err)
+						return
+					}
+				}
 				g.Log().Debugf(ctx, "准备同步服务器:%v,url=%v", v.Name, address+"/callback/update")
 				get, err := client.Post(ctx, address+"/callback/update", &UpdateReq{
 					FileUrl: url[v.S3],
@@ -107,9 +145,13 @@ var (
 func UploadS3(typ string, filename string) (res string, err error) {
 	//updateServerS3Name, _ := g.Config().Get(ctx, "update_server_s3_name")
 
-	s3Mod = s3.New(typ)
+	var s3Mod = pkg.S3(typ)
 	bucketName := s3Mod.GetCfg().BucketName
 	obj, err := os.Open(filename)
+	if err != nil {
+		return
+	}
+	defer obj.Close()
 	ff, err := obj.Stat()
 	_, err = s3Mod.PutObject(obj, filename, bucketName, ff.Size())
 	if err != nil {

drivers/db/elasticsearch/elasticsearch.go

@@ -46,7 +46,7 @@ type elastic struct {
 //}
 //
 //// getDocument 获取文档
-//func (d *Driver) GetDocument(name string, id string) (res json.RawMessage) {
+//func (d *Driver) Get(name string, id string) (res json.RawMessage) {
 //	resp, err := d.client.Get(name, id).
 //		Do(context.Background())
 //	if err != nil {

drivers/db/elasticsearch/load.go

@@ -1,6 +1,7 @@
 package elasticsearch
 
 import (
+	"github.com/ayflying/utility_go/internal/boot"
 	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/frame/g"
 )
@@ -15,16 +16,19 @@ const (
 )
 
 func init() {
-	var (
+	boot.AddFunc(func() {
-		err         error
+		var (
-		driverObj   = New()
+			err         error
-		driverNames = g.SliceStr{"es", "elasticsearch"}
+			driverObj   = New()
-	)
+			driverNames = g.SliceStr{"es", "elasticsearch"}
-	for _, driverName := range driverNames {
+		)
-		if err = gdb.Register(driverName, driverObj); err != nil {
+		for _, driverName := range driverNames {
-			panic(err)
+			if err = gdb.Register(driverName, driverObj); err != nil {
+				panic(err)
+			}
 		}
-	}
+	})
+
 }
 
 // New create and returns a driver that implements gdb.Driver, which supports operations for MySQL.

drivers/db/found/found.go

@@ -2,6 +2,7 @@ package found
 
 import (
 	"database/sql"
+	"github.com/ayflying/utility_go/internal/boot"
 	"github.com/gogf/gf/v2/database/gdb"
 	"github.com/gogf/gf/v2/frame/g"
 )
@@ -21,16 +22,18 @@ const (
 )
 
 func init() {
-	var (
+	boot.AddFunc(func() {
-		err         error
+		var (
-		driverObj   = New()
+			err         error
-		driverNames = g.SliceStr{"es", "found"}
+			driverObj   = New()
-	)
+			driverNames = g.SliceStr{"es", "found"}
-	for _, driverName := range driverNames {
+		)
-		if err = gdb.Register(driverName, driverObj); err != nil {
+		for _, driverName := range driverNames {
-			panic(err)
+			if err = gdb.Register(driverName, driverObj); err != nil {
+				panic(err)
+			}
 		}
-	}
+	})
 }
 
 // New create and returns a driver that implements gdb.Driver, which supports operations for MySQL.

go.mod

@@ -12,14 +12,14 @@ require (
 	github.com/goccy/go-json v0.10.4
 	github.com/gogf/gf/contrib/config/apollo/v2 v2.9.0
 	github.com/gogf/gf/v2 v2.9.0
-	github.com/google/uuid v1.6.0
 	github.com/gorilla/websocket v1.5.3
 	github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20241220152942-06eb5c6e8230
 	github.com/minio/minio-go/v7 v7.0.85
+	github.com/prometheus/client_golang v1.21.1
 	github.com/xuri/excelize/v2 v2.9.0
-	golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602
+	golang.org/x/oauth2 v0.24.0
 	google.golang.org/api v0.44.0
-	google.golang.org/protobuf v1.26.0
+	google.golang.org/protobuf v1.36.1
 	gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df
 )
 
@@ -27,6 +27,8 @@ require (
 	cloud.google.com/go v0.81.0 // indirect
 	github.com/360EntSecGroup-Skylar/excelize v1.4.1 // indirect
 	github.com/BurntSushi/toml v1.4.0 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
 	github.com/elastic/elastic-transport-go/v8 v8.6.1 // indirect
@@ -42,6 +44,7 @@ require (
 	github.com/go-pay/xtime v0.0.2 // indirect
 	github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
 	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/google/uuid v1.6.0 // indirect
 	github.com/googleapis/gax-go/v2 v2.0.5 // indirect
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
@@ -54,8 +57,12 @@ require (
 	github.com/minio/md5-simd v1.1.2 // indirect
 	github.com/mitchellh/mapstructure v1.4.1 // indirect
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/pelletier/go-toml v1.9.3 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.62.0 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
 	github.com/richardlehane/mscfb v1.0.4 // indirect
 	github.com/richardlehane/msoleps v1.0.4 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect

go.sum

@@ -54,9 +54,13 @@ github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmV
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/ayflying/excel2json v1.1.3 h1:Qy7HnF5aib7lIknaOqICvvZsSwAieLu6KJFeUccOISo=
 github.com/ayflying/excel2json v1.1.3/go.mod h1:aNzB271bUAuRq+P4J+S8a3NAltcghLIGR2HdM6akqFU=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
 github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
@@ -245,6 +249,8 @@ github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20241220152942-06eb5c6e8230 h1:B0oaMTAQKDZd8cwYT0qsAI7+c3KbFeBNA8GhgoBMXWw=
 github.com/lionsoul2014/ip2region/binding/golang v0.0.0-20241220152942-06eb5c6e8230/go.mod h1:C5LA5UO2ZXJrLaPLYtE1wUJMiyd/nwWaCO5cw/2pSHs=
 github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60=
@@ -279,6 +285,8 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826 h1:RWengNIwukTxcDr9M+97sNutRR1RKhG96O6jWumTTnw=
 github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826/go.mod h1:TaXosZuwdSHYgviHp1DAtfrULt5eUgsSMsZf+YrPgl8=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
@@ -289,7 +297,15 @@ github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZ
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
+github.com/prometheus/client_golang v1.21.1 h1:DOvXXTqVzvkIewV/CDPFdejpMCGeMcbGCQ8YOmu+Ibk=
+github.com/prometheus/client_golang v1.21.1/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=
+github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I=
+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 github.com/richardlehane/mscfb v1.0.4 h1:WULscsljNPConisD5hR0+OyZjwK46Pfyr6mPu5ZawpM=
 github.com/richardlehane/mscfb v1.0.4/go.mod h1:YzVpcZg9czvAuhk9T+a3avCpcFPMUWm7gK3DypaEsUk=
 github.com/richardlehane/msoleps v1.0.1/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
@@ -463,8 +479,9 @@ golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ
 golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
 golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602 h1:0Ja1LBD+yisY6RWM/BH7TJVXWsSjs2VwBSmvSX4HdBc=
 golang.org/x/oauth2 v0.0.0-20210402161424-2e8d93401602/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.24.0 h1:KTBBxWqUa0ykRPLtV69rRto9TLXcqYkeswu48x/gvNE=
+golang.org/x/oauth2 v0.24.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -694,8 +711,9 @@ google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpAD
 google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0 h1:bxAC2xTBsZGibn2RTntX0oH50xLsqy1OxA9tTL3p/lk=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
+google.golang.org/protobuf v1.36.1 h1:yBPeRvTftaleIgM3PZ/WBIZ7XM/eEYAaEyCwvyjq/gk=
+google.golang.org/protobuf v1.36.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc h1:2gGKlE2+asNV9m7xrywl36YYNnBG5ZQ0r/BOOxqPpmk=
 gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc/go.mod h1:m7x9LTH6d71AHyAX77c9yqWCCa3UKHcVEj9y7hAtKDk=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

internal/boot/boot.go

@@ -0,0 +1,35 @@
+package boot
+
+import (
+	"context"
+	v1 "github.com/ayflying/utility_go/api/system/v1"
+	"github.com/ayflying/utility_go/service"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+var (
+	ctx   = gctx.GetInitCtx()
+	_func = []func(){}
+)
+
+func Boot() (err error) {
+	err = service.SystemCron().StartCron()
+
+	//用户活动持久化
+	service.SystemCron().AddCronV2(v1.CronType_DAILY, func(ctx context.Context) error {
+		err = service.GameKv().SavesV1()
+		err = service.GameAct().Saves(ctx)
+		return err
+	})
+
+	//初始化自启动方法
+	for _, v := range _func {
+		v()
+	}
+	return nil
+}
+
+// AddFunc 注册方法，在启动时执行
+func AddFunc(f func()) {
+	_func = append(_func, f)
+}

internal/logic/gameAct/gameAct.go

@@ -1,10 +1,10 @@
 package gameAct
 
 import (
+	"context"
 	"fmt"
 	"github.com/ayflying/utility_go/internal/model/do"
 	"github.com/ayflying/utility_go/internal/model/entity"
-	"github.com/ayflying/utility_go/pgk"
 	"github.com/ayflying/utility_go/pkg"
 	service2 "github.com/ayflying/utility_go/service"
 	"github.com/ayflying/utility_go/tools"
@@ -12,6 +12,7 @@ import (
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv"
 	"strconv"
 	"strings"
 	"time"
@@ -105,16 +106,24 @@ func (s *sGameAct) Set(uid int64, actId int, data interface{}) (err error) {
 	return
 }
 
-func (s *sGameAct) Saves() (err error) {
+func (s *sGameAct) Saves(ctx context.Context) (err error) {
+	getCache, _ := pkg.Cache("redis").Get(nil, "cron:game_act")
+	//如果没有执行过，设置时间戳
+	if getCache.Int64() > 0 {
+		return
+	} else {
+		pkg.Cache("redis").Set(nil, "cron:game_act", gtime.Now().Unix(), time.Hour)
+	}
+
 	//遍历执行
 	ActList.Iterator(func(i interface{}) bool {
-		err = s.Save(i.(int))
+		err = s.Save(ctx, i.(int))
 		return true
 	})
 	return
 }
 
-func (s *sGameAct) Save(actId int) (err error) {
+func (s *sGameAct) Save(ctx context.Context, actId int) (err error) {
 
 	cacheKey := fmt.Sprintf("act:%v:*", actId)
 	//获取当前用户的key值
@@ -131,7 +140,8 @@ func (s *sGameAct) Save(actId int) (err error) {
 			result := strings.Split(cacheKey, ":")
 			actId, err = strconv.Atoi(result[1])
 			var uid int64
-			uid, err = strconv.ParseInt(result[2], 10, 64)
+			uid = gconv.Int64(result[2])
+			//uid, err = strconv.ParseInt(result[2], 10, 64)
 			if err != nil {
 				continue
 			}
@@ -148,8 +158,8 @@ func (s *sGameAct) Save(actId int) (err error) {
 			}
 
 			//如果有活跃，跳过持久化
-			if getBool, _ := pkg.Cache("redis").Contains(ctx,
+			if getBool, _ := pkg.Cache("redis").
-				fmt.Sprintf("act:update:%d", uid)); getBool {
+				Contains(ctx, fmt.Sprintf("act:update:%d", uid)); getBool {
 				continue
 			}
 
@@ -216,9 +226,28 @@ func (s *sGameAct) Save(actId int) (err error) {
 // 清空GetRedDot缓存
 func (s *sGameAct) RefreshGetRedDotCache(uid int64) {
 	cacheKey := fmt.Sprintf("gameAct:GetRedDot:%s:%d", gtime.Now().Format("d"), uid)
-	_, err := pgk.Cache("redis").Remove(gctx.New(), cacheKey)
+	_, err := pkg.Cache("redis").Remove(gctx.New(), cacheKey)
 	if err != nil {
 		g.Log().Error(ctx, err)
 		g.Dump(err)
 	}
 }
+
+func (s *sGameAct) Del(uid int64, actId int) {
+	if uid == 0 || actId == 0 {
+		g.Log().Error(ctx, "当前参数为空")
+		return
+	}
+	// 构造缓存键名
+	keyCache := fmt.Sprintf("act:%v:%v", actId, uid)
+
+	//删除活动缓存
+	g.Redis().Del(ctx, keyCache)
+
+	//删除当前活动储存
+	g.Model(Name).Where(do.GameAct{
+		Uid:   uid,
+		ActId: actId,
+	}).Delete()
+
+}

internal/logic/gameKv/gameKv.go

@@ -1,13 +1,17 @@
 package gameKv
 
 import (
+	"fmt"
+	"github.com/ayflying/utility_go/pkg"
 	"github.com/ayflying/utility_go/service"
 	"github.com/ayflying/utility_go/tools"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/os/gtime"
 	"strconv"
 	"strings"
 	"sync"
+	"time"
 )
 
 var (
@@ -25,10 +29,6 @@ func New() *sGameKv {
 
 func init() {
 	service.RegisterGameKv(New())
-
-	//支付钩子
-	//task.Task.Trigger(tasks.TaskType_PAY, service.GameKv().HookPay)
-	//task.Task.Trigger(tasks.TaskType_WARDROBE_LEVEL, service.GameKv().HookLevelRwd)
 }
 
 // SavesV1 方法
@@ -37,6 +37,14 @@ func init() {
 // @receiver s: sGameKv的实例。
 // @return err: 错误信息，如果操作成功，则为nil。
 func (s *sGameKv) SavesV1() (err error) {
+	getCache, err := pkg.Cache("redis").Get(nil, "cron:game_kv")
+	//如果没有执行过，设置时间戳
+	if getCache.Int64() > 0 {
+		return
+	} else {
+		pkg.Cache("redis").Set(nil, "cron:game_kv", gtime.Now().Unix(), time.Hour)
+	}
+
 	// 从Redis列表中获取所有用户KV索引的键
 	//keys, err := utils.RedisScan("user:kv:*")
 	err = tools.Redis.RedisScanV2("user:kv:*", func(keys []string) (err error) {
@@ -69,12 +77,17 @@ func (s *sGameKv) SavesV1() (err error) {
 			//if user.UpdatedAt.Seconds < gtime.Now().Add(consts.ActSaveTime).Unix() {
 			//	continue
 			//}
+			//如果有活跃，跳过持久化
+			if getBool, _ := pkg.Cache("redis").
+				Contains(ctx, fmt.Sprintf("act:update:%d", uid)); getBool {
+				continue
+			}
 
 			get, _ := g.Redis().Get(ctx, cacheKey)
 			var data interface{}
 			get.Scan(&data)
 			list = append(list, &ListData{
-				Uid: int64(uid),
+				Uid: uid,
 				Kv:  data,
 			})
 

internal/logic/ip2region/ip2region.go

@@ -11,7 +11,8 @@ import (
 )
 
 var (
-	ctx = gctx.New()
+	ctx  = gctx.New()
+	wait = false
 )
 
 type sIp2region struct {
@@ -19,13 +20,16 @@ type sIp2region struct {
 }
 
 func New() *sIp2region {
-	s := &sIp2region{}
+
-	s.Load()
+	return &sIp2region{}
-	return s
 }
 
 func init() {
 	service.RegisterIp2Region(New())
+
+	//boot.AddFunc(func() {
+	//	service.Ip2Region().Load()
+	//})
 }
 
 // Load 加载到内存中
@@ -34,13 +38,20 @@ func init() {
 //	@receiver s *sIp2region: sIp2region的实例。
 func (s *sIp2region) Load() {
 	var err error
-	//var dbPath = "/mnt/s3/ip2region.xdb"
-	var dbPath = "lib/ip2region.xdb"
 
+	var dbPath = "runtime/library/ip2region.xdb"
+	var url = "https://github.com/ayflying/resource/raw/refs/heads/main/attachment/ip2region.xdb"
+	if wait {
+		return
+	}
 	if gfile.IsEmpty(dbPath) {
+		wait = true
+		defer func() {
+			wait = false
+		}()
+		g.Log().Debug(ctx, "等待下载ip库文件")
 		//下载文件
-		putData, err2 := g.Client().Discovery(nil).
+		putData, err2 := g.Client().Discovery(nil).Get(ctx, url)
-			Get(ctx, "https://resource.luoe.cn/pgk/ip2region.xdb")
 		if err2 != nil {
 			return
 		}
@@ -66,6 +77,9 @@ func (s *sIp2region) Load() {
 }
 
 func (s *sIp2region) GetIp(ip string) (res []string) {
+	//初始化加载
+	s.Load()
+
 	res = make([]string, 5)
 	if s.searcher == nil {
 		return

internal/logic/systemCron/listener.go

@@ -3,10 +3,11 @@ package systemCron
 import (
 	"encoding/json"
 	"fmt"
-	v1 "github.com/ayflying/utility_go/api/pgk/v1"
+	v1 "github.com/ayflying/utility_go/api/pkg/v1"
 	"github.com/ayflying/utility_go/pkg/notice"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/gclient"
+	"github.com/gogf/gf/v2/os/gctx"
 )
 
 type Status struct {
@@ -22,10 +23,10 @@ func (s *sSystemCron) Guardian(DingTalkWebHook string) {
 		Name    string
 		Address string
 	}
-	cfg, _ := g.Cfg().Get(ctx, "serverList")
+	cfg, _ := g.Cfg().Get(gctx.New(), "serverList")
 	cfg.Scan(&list)
 	for _, v := range list {
-		get, err := g.Client().Discovery(nil).Get(ctx, v.Address+"/callback/status")
+		get, err := g.Client().Discovery(nil).Get(gctx.New(), v.Address+"/callback/status")
 
 		defer get.Close()
 		if err != nil {

internal/logic/systemCron/systemCron.go

@@ -7,53 +7,60 @@ import (
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gcron"
 	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/os/gtimer"
 	"sync"
 	"time"
 )
 
 var (
-	ctx = gctx.New()
+	//ctx       = gctx.New()
+	startTime *gtime.Time
 )
 
 // sSystemCron 结构体定义了系统定时任务的秒计时器。
 // 它包含了不同时间周期的任务，如秒、分钟、小时、天、周、月、年以及特定的工作日任务。
 type sSystemCron struct {
 	//互斥锁
-	Lock sync.Mutex
+	Lock        sync.Mutex
+	taskChan    chan func(context.Context) error
+	TaskTimeout time.Duration
 
 	// 每秒执行的任务
-	SecondlyTask []func() error
+	SecondlyTask []func(context.Context) error
 	// 每分钟执行的任务
-	MinutelyTask []func() error
+	MinutelyTask []func(context.Context) error
 	// 每小时执行的任务
-	HourlyTask []func() error
+	HourlyTask []func(context.Context) error
 	// 每天执行的任务
-	DailyTask []func() error
+	DailyTask []func(context.Context) error
 	// 每周执行的任务
-	WeeklyTask []func() error
+	WeeklyTask []func(context.Context) error
 	// 每月执行的任务
-	MonthlyTask []func() error
+	MonthlyTask []func(context.Context) error
 	// 每年执行的任务
-	YearlyTask []func() error
+	YearlyTask []func(context.Context) error
 	// 每周一执行的任务
-	MondayTask []func() error
+	MondayTask []func(context.Context) error
 	// 每周二执行的任务
-	TuesdayTask []func() error
+	TuesdayTask []func(context.Context) error
 	// 每周三执行的任务
-	WednesdayTask []func() error
+	WednesdayTask []func(context.Context) error
 	// 每周四执行的任务
-	ThursdayTask []func() error
+	ThursdayTask []func(context.Context) error
 	// 每周五执行的任务
-	FridayTask []func() error
+	FridayTask []func(context.Context) error
 	// 每周六执行的任务
-	SaturdayTask []func() error
+	SaturdayTask []func(context.Context) error
 	// 每周日执行的任务
-	SundayTask []func() error
+	SundayTask []func(context.Context) error
 }
 
 func New() *sSystemCron {
-	return &sSystemCron{}
+	return &sSystemCron{
+		taskChan:    make(chan func(context.Context) error, 2),
+		TaskTimeout: time.Minute * 30,
+	}
 }
 
 func init() {
@@ -63,13 +70,32 @@ func init() {
 // AddCron 添加一个定时任务到相应的调度列表中。
 //
 // @Description: 根据指定的类型将函数添加到不同的任务列表中，以供后续执行。
+// 确保自定义任务正确处理上下文取消信号，即可充分发挥超时打断功能。
 // @receiver s: sSystemCron的实例，代表一个调度系统。
 // @param typ: 任务的类型，决定该任务将被添加到哪个列表中。对应不同的时间间隔。
 // @param _func: 要添加的任务函数，该函数执行时应该返回一个error。
+// deprecated: 弃用，请使用 AddCronV2
 func (s *sSystemCron) AddCron(typ v1.CronType, _func func() error) {
+	//转换为带上下文的，提供打断
+	var _func2 = func(ctx context.Context) error {
+		return _func()
+	}
+	s.AddCronV2(typ, _func2)
+}
+
+// AddCronV2  添加一个定时任务到相应的调度列表中。
+//
+// @Description: 根据指定的类型将函数添加到不同的任务列表中，以供后续执行。
+// @receiver s: sSystemCron的实例，代表一个调度系统。
+// @param typ: 任务的类型，决定该任务将被添加到哪个列表中。对应不同的时间间隔。
+// @param _func: 要添加的任务函数，该函数执行时应该返回一个error。
+func (s *sSystemCron) AddCronV2(typ v1.CronType, _func func(context.Context) error) {
 	//加锁
 	s.Lock.Lock()
 	defer s.Lock.Unlock()
+	//
+	//ctx := gctx.New()
+	//newFunc := func()
 
 	switch typ {
 	case v1.CronType_SECOND:
@@ -110,140 +136,129 @@ func (s *sSystemCron) AddCron(typ v1.CronType, _func func() error) {
 //	@receiver s
 //	@return err
 func (s *sSystemCron) StartCron() (err error) {
-	g.Log().Debug(ctx, "启动计划任务定时器详情")
+	//预防重复启动
+	if startTime != nil {
+		return
+	}
+	startTime = gtime.Now()
+
+	g.Log().Debug(gctx.New(), "启动计划任务定时器详情")
 	//每秒任务
-	gtimer.SetInterval(ctx, time.Second, func(ctx context.Context) {
+	gtimer.SetInterval(gctx.New(), time.Second, func(ctx context.Context) {
 		//g.Log().Debug(ctx, "每秒定时器")
-		err = s.secondlyTask()
+		s.secondlyTask()
 	})
 
 	//每分钟任务
-	_, err = gcron.AddSingleton(ctx, "0 * * * * *", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 * * * * *", func(ctx context.Context) {
 		//g.Log().Debug(ctx, "每分钟定时器")
-		err = s.minutelyTask()
+		s.minutelyTask()
 	})
 
 	//每小时任务
-	_, err = gcron.AddSingleton(ctx, "0 0 * * * *", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 * * * *", func(ctx context.Context) {
 		g.Log().Debug(ctx, "每小时定时器")
-		err = s.hourlyTask()
+		s.hourlyTask()
 	})
 
 	//每天任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 * * *", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 * * *", func(ctx context.Context) {
 		g.Log().Debug(ctx, "每日定时器")
-		err = s.dailyTask()
+		s.dailyTask()
 	})
 
 	//每周任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 * * 1", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 * * 1", func(ctx context.Context) {
 		g.Log().Debug(ctx, "每周一定时器")
-		err = s.weeklyTask(1)
+		s.weeklyTask(1)
 	})
-	//每周二任务
+	//每周二的任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 * * 2", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 * * 2", func(ctx context.Context) {
 		g.Log().Debug(ctx, "每周二定时器")
-		err = s.weeklyTask(2)
+		s.weeklyTask(2)
 	})
 	//周三任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 * * 3", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 * * 3", func(ctx context.Context) {
 		g.Log().Debug(ctx, "周三定时器")
-		err = s.weeklyTask(3)
+		s.weeklyTask(3)
 	})
 	//周四任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 * * 4", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 * * 4", func(ctx context.Context) {
 		g.Log().Debug(ctx, "周四定时器")
-		err = s.weeklyTask(4)
+		s.weeklyTask(4)
 	})
 	//周五任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 * * 5", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 * * 5", func(ctx context.Context) {
 		g.Log().Debug(ctx, "周五定时器")
-		err = s.fridayTask()
+		s.weeklyTask(5)
 	})
 	//周六任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 * * 6", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 * * 6", func(ctx context.Context) {
 		g.Log().Debug(ctx, "周六定时器")
-		err = s.weeklyTask(6)
+		s.weeklyTask(6)
 	})
 	//周日任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 * * 0", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 * * 0", func(ctx context.Context) {
 		g.Log().Debug(ctx, "周日定时器")
-		err = s.weeklyTask(7)
+		s.weeklyTask(7)
 	})
 
 	//每月任务
-	_, err = gcron.AddSingleton(ctx, "0 0 0 1 * *", func(ctx context.Context) {
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 1 * *", func(ctx context.Context) {
 		g.Log().Debug(ctx, "每月定时器")
-		err = s.monthlyTask()
+		s.monthlyTask()
 	})
 
-	_, err = gcron.AddSingleton(ctx, "0 0 0 1 1 *", func(ctx context.Context) {
+	//每年任务
+	_, err = gcron.AddSingleton(gctx.New(), "0 0 0 1 1 *", func(ctx context.Context) {
 		g.Log().Debug(ctx, "每年定时器")
-		err = s.monthlyTask()
+		s.yearlyTask()
 	})
 
+	//统一执行方法
+	s.RunFuncChan()
 	return
 }
 
 // 每妙任务
-func (s *sSystemCron) secondlyTask() (err error) {
+func (s *sSystemCron) secondlyTask() {
 	if len(s.SecondlyTask) == 0 {
 		return
 	}
-	for _, _func := range s.SecondlyTask {
+	s.AddFuncChan(s.SecondlyTask)
-		err = _func()
-		if err != nil {
-			g.Log().Error(ctx, err)
-		}
-	}
 	return
 }
 
 // 每分钟任务
-func (s *sSystemCron) minutelyTask() (err error) {
+func (s *sSystemCron) minutelyTask() {
 	if len(s.MinutelyTask) == 0 {
 		return
 	}
-	for _, _func := range s.MinutelyTask {
+	s.AddFuncChan(s.MinutelyTask)
-		err = _func()
-		if err != nil {
-			g.Log().Error(ctx, err)
-		}
-	}
 	return
 }
 
 // 每小时任务
-func (s *sSystemCron) hourlyTask() (err error) {
+func (s *sSystemCron) hourlyTask() {
 	if len(s.HourlyTask) == 0 {
 		return
 	}
-	for _, _func := range s.HourlyTask {
+	s.AddFuncChan(s.HourlyTask)
-		err = _func()
-		if err != nil {
-			g.Log().Error(ctx, err)
-		}
-	}
 	return
 }
 
 // 每天任务
-func (s *sSystemCron) dailyTask() (err error) {
+func (s *sSystemCron) dailyTask() {
 	if len(s.DailyTask) == 0 {
 		return
 	}
-	for _, _func := range s.DailyTask {
+	s.AddFuncChan(s.DailyTask)
-		err = _func()
-		if err != nil {
-			g.Log().Error(ctx, err)
-		}
-	}
 	return
 }
 
 // 每周任务
-func (s *sSystemCron) weeklyTask(day int) (err error) {
+func (s *sSystemCron) weeklyTask(day int) {
-	var arr []func() error
+	var arr []func(context.Context) error
 	switch day {
 	case 1:
 		arr = s.MondayTask
@@ -267,39 +282,91 @@ func (s *sSystemCron) weeklyTask(day int) (err error) {
 	if len(arr) == 0 {
 		return
 	}
-	for _, _func := range arr {
+	s.AddFuncChan(arr)
-		err = _func()
-		if err != nil {
-			g.Log().Error(ctx, err)
-		}
-	}
-	return
-}
-
-// 周五任务
-func (s *sSystemCron) fridayTask() (err error) {
-	if len(s.FridayTask) == 0 {
-		return
-	}
-	for _, _func := range s.FridayTask {
-		err = _func()
-		if err != nil {
-			g.Log().Error(ctx, err)
-		}
-	}
 	return
 }
 
 // 每月任务
-func (s *sSystemCron) monthlyTask() (err error) {
+func (s *sSystemCron) monthlyTask() {
 	if len(s.MonthlyTask) == 0 {
 		return
 	}
-	for _, _func := range s.MonthlyTask {
+	s.AddFuncChan(s.MonthlyTask)
-		err = _func()
+	return
-		if err != nil {
+}
-			g.Log().Error(ctx, err)
+
+//每年任务
+func (s *sSystemCron) yearlyTask() {
+	if len(s.YearlyTask) == 0 {
+		return
+	}
+	s.AddFuncChan(s.YearlyTask)
+
+}
+
+// AddFuncChan 添加方法到通道
+func (s *sSystemCron) AddFuncChan(list []func(context.Context) error) {
+	for _, v := range list {
+		s.taskChan <- v
+	}
+}
+
+// RunFuncChan 统一执行方法
+func (s *sSystemCron) RunFuncChan() {
+	go func() {
+		for task := range s.taskChan {
+			//ctx := gctx.New()
+			func() {
+				//超时释放资源
+				ctx, cancel := context.WithTimeout(context.Background(), s.TaskTimeout)
+				defer cancel()
+
+				// 使用匿名函数包裹来捕获 panic
+				defer func() {
+					if r := recover(); r != nil {
+						g.Log().Errorf(gctx.New(), "执行函数时发生 panic: %v", r)
+					}
+				}()
+
+				done := make(chan error)
+				go func() {
+					done <- task(ctx)
+				}()
+				//err := task()
+				//if err != nil {
+				//	g.Log().Error(ctx, err)
+				//}
+				select {
+				case taskErr := <-done:
+					if taskErr != nil {
+						// 使用新上下文记录错误
+						g.Log().Error(gctx.New(), taskErr)
+					}
+				case <-ctx.Done(): // 监听上下文取消（包括超时）
+					g.Log().Errorf(gctx.New(), "task timeout:%v", ctx.Err())
+				}
+			}()
 		}
+	}()
+}
+
+// RunFunc 统一执行方法
+// deprecated: 弃用，会造成周期任务并发执行，to service.SystemCron().AddFuncChan
+func (s *sSystemCron) RunFunc(list []func() error) {
+	for _, _func := range list {
+		ctx := gctx.New()
+		func() {
+			// 使用匿名函数包裹来捕获 panic
+			defer func() {
+				if r := recover(); r != nil {
+					g.Log().Errorf(ctx, "执行函数时发生 panic: %v", r)
+				}
+			}()
+			err := _func()
+			if err != nil {
+				g.Log().Error(ctx, err)
+			}
+		}()
 	}
 	return
 }

package/excel/excel.go

@@ -111,8 +111,12 @@ func (s *Excel) RemoveComments(list []interface{}, json []string) []interface{}
 		// 遍历当前元素的每个键值对
 		for _, v3 := range v2.(g.Map) {
 			// 如果字符串中存在//则跳过不写入temp
-			if gstr.Contains(gconv.String(v3), "//") {
+			//if gstr.Contains(gconv.String(v3), "//") {
-				//delKey = append(delKey, k2)
+			//	//delKey = append(delKey, k2)
+			//	add = false
+			//	break
+			//}
+			if strings.HasPrefix(gconv.String(v3), "//") {
 				add = false
 				break
 			}

pgk/pgk.go

@@ -1,7 +1,7 @@
 package pgk
 
 import (
-	v1 "github.com/ayflying/utility_go/api/pgk/v1"
+	v1 "github.com/ayflying/utility_go/api/pkg/v1"
 	"github.com/ayflying/utility_go/pkg/aycache"
 	"github.com/ayflying/utility_go/pkg/notice"
 	"github.com/ayflying/utility_go/pkg/rank"

pgk/rank/rank.go

@@ -2,7 +2,7 @@ package rank
 
 import (
 	"fmt"
-	v1 "github.com/ayflying/utility_go/api/pgk/v1"
+	v1 "github.com/ayflying/utility_go/api/pkg/v1"
 	"time"
 
 	"github.com/gogf/gf/v2/database/gredis"

pkg/aycache/cache.go

@@ -1,21 +1,48 @@
 package aycache
 
 import (
+	v1 "github.com/ayflying/utility_go/api/system/v1"
+	"github.com/ayflying/utility_go/internal/boot"
 	"github.com/ayflying/utility_go/pkg/aycache/drive"
 	drive2 "github.com/ayflying/utility_go/pkg/aycache/drive"
+	"github.com/ayflying/utility_go/service"
 	"github.com/gogf/gf/v2/os/gcache"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
+	"math"
 )
 
+// Mod 定义缓存模块结构体，包含一个 gcache.Cache 客户端实例
 type Mod struct {
 	client *gcache.Cache
 }
 
-//func NewV1(_name ...string) *cache.Mod {
+// QPSCount 记录缓存的 QPS 计数
-//	return pgk.Cache
+var QPSCount int
-//}
+// QPS 是一个 Prometheus 指标，用于记录当前缓存的 QPS 数量
+var QPS = promauto.NewGauge(
+	prometheus.GaugeOpts{
+		Name: "Cache_QPS",
+		Help: "当前缓存QPS数量",
+	},
+)
 
+// init 函数在包被导入时执行，用于初始化定时任务以更新 QPS 指标
+func init() {
+	boot.AddFunc(func() {
+		// 初始化指标，每分钟计算一次平均 QPS 并重置计数器
+		service.SystemCron().AddCron(v1.CronType_MINUTE, func() error {
+			QPS.Set(math.Round(float64(QPSCount) / 60))
+			QPSCount = 0
+			return nil
+		})
+	})
+}
+
+// New 根据传入的名称创建不同类型的缓存适配器
+// 如果未传入名称，默认使用 "cache" 类型
+// 支持的类型包括 "cache"（内存缓存）、"redis"（Redis 缓存）、"file"（文件缓存）和 "es"（Elasticsearch 缓存）
 func New(_name ...string) gcache.Adapter {
-
 	var cacheAdapterObj gcache.Adapter
 	var name = "cache"
 	if len(_name) > 0 {
@@ -23,16 +50,23 @@ func New(_name ...string) gcache.Adapter {
 	}
 	switch name {
 	case "cache":
+		// 创建内存缓存适配器
 		cacheAdapterObj = drive2.NewAdapterMemory()
 	case "redis":
+		// 创建 Redis 缓存适配器
 		cacheAdapterObj = drive2.NewAdapterRedis()
 	case "file":
+		// 创建文件缓存适配器，指定缓存目录为 "runtime/cache"
 		cacheAdapterObj = drive2.NewAdapterFile("runtime/cache")
 	case "es":
-		cacheAdapterObj = drive.NewAdapterElasticsearch([]string{"http://127.0.0.1:9200"})
+		// 创建 Elasticsearch 缓存适配器，需要传入额外参数
+		cacheAdapterObj = drive.NewAdapterElasticsearch(_name[1])
 	}
 
 	//var client = gcache.New()
 	//client.SetAdapter(cacheAdapterObj)
+
+	// 每次创建适配器时，QPS 计数加 1
+	QPSCount++
 	return cacheAdapterObj
 }

pkg/aycache/drive/elasticsearch.go

@@ -2,23 +2,51 @@ package drive
 
 import (
 	"context"
+	"fmt"
+	"github.com/elastic/go-elasticsearch/v8"
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gcache"
+	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/util/gconv"
 	"time"
 )
 
+var (
+	adapterElasticsearchClient gcache.Adapter
+)
+
 type AdapterElasticsearch struct {
-	//FilePath string
+	client *elasticsearch.TypedClient
-	Addresses []string
+	name   string
 }
 
-func (a AdapterElasticsearch) Set(ctx context.Context, key interface{}, value interface{}, duration time.Duration) error {
+func (a AdapterElasticsearch) Set(ctx context.Context, _key interface{}, value interface{}, duration time.Duration) (err error) {
-	//TODO implement me
+	key := gconv.String(_key)
-	panic("implement me")
+	data := gconv.Map(value)
+	if duration > 0 {
+		data["delete_time"] = time.Now().Add(duration)
+	}
+	_, err = a.client.Index(a.name).Id(key).
+		Document(data).Do(ctx)
+	if err != nil {
+		fmt.Printf("indexing document failed, err:%v\n", err)
+		return
+	}
+	return
 }
 
 func (a AdapterElasticsearch) SetMap(ctx context.Context, data map[interface{}]interface{}, duration time.Duration) error {
-	//TODO implement me
+	for k, v := range data {
+		save := gconv.Map(v)
+		if duration > 0 {
+			save["delete_time"] = time.Now().Add(duration)
+		}
+		key := gconv.String(k)
+		a.client.Index(a.name).Id(key).
+			Document(save).Do(ctx)
+	}
+
 	panic("implement me")
 }
 
@@ -37,9 +65,17 @@ func (a AdapterElasticsearch) SetIfNotExistFuncLock(ctx context.Context, key int
 	panic("implement me")
 }
 
-func (a AdapterElasticsearch) Get(ctx context.Context, key interface{}) (*gvar.Var, error) {
+func (a AdapterElasticsearch) Get(ctx context.Context, key interface{}) (res *gvar.Var, err error) {
-	//TODO implement me
+	_key := gconv.String(key)
-	panic("implement me")
+	resp, err := a.client.Get(a.name, _key).
+		Do(context.Background())
+	if err != nil {
+		fmt.Printf("get document by id failed, err:%v\n", err)
+		return
+	}
+	fmt.Printf("fileds:%s\n", resp.Source_)
+	res = gvar.New(resp.Source_)
+	return
 }
 
 func (a AdapterElasticsearch) GetOrSet(ctx context.Context, key interface{}, value interface{}, duration time.Duration) (result *gvar.Var, err error) {
@@ -82,9 +118,26 @@ func (a AdapterElasticsearch) Values(ctx context.Context) (values []interface{},
 	panic("implement me")
 }
 
-func (a AdapterElasticsearch) Update(ctx context.Context, key interface{}, value interface{}) (oldValue *gvar.Var, exist bool, err error) {
+func (a AdapterElasticsearch) Update(ctx context.Context, _key interface{}, value interface{}) (oldValue *gvar.Var, exist bool, err error) {
-	//TODO implement me
+	key := gconv.String(_key)
-	panic("implement me")
+	data := gconv.Map(value)
+	oldValue, err = a.Get(ctx, key)
+	if err != nil {
+		exist = false
+	} else {
+		for k, v := range oldValue.Map() {
+			if _, ok := data[k]; !ok {
+				data[k] = v
+			}
+		}
+	}
+
+	_, err = a.client.Update(a.name, key).
+		Doc(data).Do(context.Background())
+	if err != nil {
+		return
+	}
+	return
 }
 
 func (a AdapterElasticsearch) UpdateExpire(ctx context.Context, key interface{}, duration time.Duration) (oldDuration time.Duration, err error) {
@@ -98,8 +151,15 @@ func (a AdapterElasticsearch) GetExpire(ctx context.Context, key interface{}) (t
 }
 
 func (a AdapterElasticsearch) Remove(ctx context.Context, keys ...interface{}) (lastValue *gvar.Var, err error) {
-	//TODO implement me
+	//获取keys最后一个
-	panic("implement me")
+	lastKey := keys[len(keys)-1]
+	lastValue, _ = a.Get(ctx, lastKey)
+
+	for k := range keys {
+		key := gconv.String(k)
+		a.client.Delete(a.name, key).Do(ctx)
+	}
+	return
 }
 
 func (a AdapterElasticsearch) Clear(ctx context.Context) error {
@@ -112,8 +172,17 @@ func (a AdapterElasticsearch) Close(ctx context.Context) error {
 	panic("implement me")
 }
 
-func NewAdapterElasticsearch(addresses []string) gcache.Adapter {
+func NewAdapterElasticsearch(name string) gcache.Adapter {
-	return &AdapterElasticsearch{
+
-		Addresses: addresses,
+	if adapterElasticsearchClient == nil {
+		_cfg, _ := g.Cfg().Get(gctx.New(), "elasticsearch")
+		var cfg elasticsearch.Config
+		_cfg.Scan(&cfg)
+		es, _ := elasticsearch.NewTypedClient(cfg)
+		adapterElasticsearchClient = &AdapterElasticsearch{
+			client: es,
+			name:   name,
+		}
 	}
+	return adapterElasticsearchClient
 }

pkg/aycache/drive/file.go

@@ -16,17 +16,6 @@ type AdapterFile struct {
 }
 
 func (a AdapterFile) Set(ctx context.Context, key interface{}, value interface{}, duration time.Duration) error {
-	//defer a.handleLruKey(ctx, key)
-	//expireTime := a.getInternalExpire(duration)
-	//a.data.Set(key, memoryDataItem{
-	//	a: value,
-	//	a: expireTime,
-	//})
-	//c.eventList.PushBack(&adapterMemoryEvent{
-	//	k: key,
-	//	e: expireTime,
-	//})
-
 	arr := strings.Split(":", gconv.String(key))
 	fileName := path.Join(arr...)
 	return gfile.PutBytes(fileName, gconv.Bytes(value))

pkg/aycache/drive/redis.go

@@ -19,7 +19,6 @@ func NewAdapterRedis() gcache.Adapter {
 		redisObj, _ := gredis.New(cfg)
 		//adapterRedisClient = gcache.NewAdapterRedis(g.Redis("default"))
 		adapterRedisClient = gcache.NewAdapterRedis(redisObj)
-
 		adapterRedisCache.SetAdapter(adapterRedisClient)
 	}
 	return adapterRedisCache

pkg/config/config.go

@@ -18,26 +18,40 @@ import (
 var (
 	//ApolloCfg      *apolloConfig.AppConfig
 	ApolloCfg      *apollo.Config
+	// ApolloListener 存储需要监听的 Apollo 配置项名称
 	ApolloListener []string
+	// Item2Obj 存储配置项名称和对应的加载器对象的映射
 	Item2Obj       = map[string]Load{}
 )
 
-// load接口定义了Load方法，用于加载数据
+// Load 接口定义了 Load 方法，用于加载数据
 type Load interface {
+	// Load 方法用于加载配置数据，支持传入可选的配置参数
 	Load(cfg ...string)
 }
 
+// NewV1 创建一个新的 Cfg 实例
 func NewV1() *Cfg {
 	return &Cfg{}
 }
 
+// Cfg 结构体包含配置操作的相关方法
 type Cfg struct {
+	// Lock 用于保证并发安全的互斥锁
 	Lock sync.Mutex
 }
 
+// GetDbFile 从数据库中获取指定名称的配置文件
+// 参数:
+//   name - 配置文件的名称
+// 返回值:
+//   *g.Var - 存储配置数据的变量
+//   error  - 操作过程中遇到的错误
 func (c *Cfg) GetDbFile(name string) (res *g.Var, err error) {
+	// 从数据库的 game_config 表中查询指定名称的配置数据
 	get2, err := g.Model("game_config").
 		Where("name", name).Master().Value("data")
+	// 将查询结果扫描到 res 变量中
 	err = get2.Scan(&res)
 	if res == nil {
 		res = &gvar.Var{}
@@ -45,107 +59,81 @@ func (c *Cfg) GetDbFile(name string) (res *g.Var, err error) {
 	return
 }
 
-func (c *Cfg) GetFile(filename string, obj ...Load) (jsonObj *gjson.Json, err error) {
+// GetFile 从文件系统或资源文件中加载 JSON 配置
+// 参数:
+//   filename   - 需要加载的配置文件名（不带扩展名）
+//   _pathStr   - 可选参数，指定配置文件目录路径，默认"manifest/game/"
+// 返回值:
+//   *gjson.Json - 解析后的 JSON 对象
+//   error       - 文件加载或解析过程中遇到的错误
+func (c *Cfg) GetFile(filename string, _pathStr ...string) (jsonObj *gjson.Json, err error) {
+	// 处理路径参数，使用默认路径或传入参数
 	pathStr := "manifest/game/"
+	if len(_pathStr) > 0 {
+		pathStr = _pathStr[0]
+	}
+	// 拼接完整的文件路径
 	filePath := pathStr + filename + ".json"
-	//err := gres.Load(pathStr + filename)
 
-	//载入静态资源到文件对象
+	// 载入静态资源到文件对象
 	err = gres.Load(filePath)
 	var bytes []byte
 
+	// 优先从文件系统读取，不存在时从资源文件读取
 	if gfile.IsFile(filePath) {
-		bytes = gfile.GetBytes(filePath)
+		bytes = gfile.GetBytes(filePath) // 读取物理文件内容
 	} else {
-		bytes = gres.GetContent(filePath)
+		bytes = gres.GetContent(filePath) // 从打包资源中获取内容
 	}
 
+	// 解析 JSON 内容并返回结果
 	jsonObj, err = gjson.DecodeToJson(bytes)
-	//g.Dump(filePath, jsonObj)
 	return
 }
 
-// getUrlFile 获取远程配置
+// GetUrlFile 获取远程配置
+// 参数:
+//   name - 配置文件的名称
+// 返回值:
+//   *gjson.Json - 解析后的 JSON 对象
+//   error       - 请求或解析过程中遇到的错误
 func (c *Cfg) GetUrlFile(name string) (jsonObj *gjson.Json, err error) {
+	// 拼接远程配置文件的 URL
 	urlStr := fmt.Sprintf("http://sdf.sdfs.sdf/%s.json", name)
+	// 发送 HTTP 请求获取远程配置数据
 	getUrl, err := g.Client().Discovery(nil).Get(nil, urlStr)
+	// 读取响应内容
 	bytes := getUrl.ReadAll()
+	// 解析 JSON 内容并返回结果
 	jsonObj, err = gjson.DecodeToJson(bytes)
 	return
 }
 
-// 获取阿波罗
+// GetApollo 从 Apollo 配置中心获取指定名称的配置
-//func (c *Cfg) GetApollo(name string, obj Load) (jsonObj *gjson.Json, err error) {
+// 参数:
-//	jsonObj, err = c.GetApolloV2(name, obj)
+//   name - 配置文件的名称
-//	return
+//   obj  - 实现了 Load 接口的加载器对象
-//
+// 返回值:
-//	//c.Lock.Lock()
+//   *gjson.Json - 解析后的 JSON 对象
-//	//defer c.Lock.Unlock()
+//   error       - 操作过程中遇到的错误
-//	//
-//	//Item2Obj[name+".json"] = obj
-//	//var cfg = apolloConfig.AppConfig{
-//	//	AppID:             ApolloCfg.AppID,
-//	//	Cluster:           ApolloCfg.Cluster,
-//	//	IP:                ApolloCfg.IP,
-//	//	NamespaceName:     name + ".json",
-//	//	Secret:            ApolloCfg.Secret,
-//	//	IsBackupConfig:    ApolloCfg.IsBackupConfig,
-//	//	BackupConfigPath:  ApolloCfg.BackupConfigPath,
-//	//	SyncServerTimeout: 60,
-//	//	MustStart:         true,
-//	//}
-//	////cfg.NamespaceName = name + ".json"
-//	//
-//	//client, err := agollo.StartWithConfig(func() (*apolloConfig.AppConfig, error) {
-//	//	return ApolloCfg, nil
-//	//})
-//	//if client == nil {
-//	//	return
-//	//}
-//	//var getStr string
-//	//var getApollo *storage.Config
-//	//for range 5 {
-//	//	getApollo = client.GetConfig(cfg.NamespaceName)
-//	//	if getApollo != nil {
-//	//		break
-//	//	}
-//	//	time.Sleep(time.Second * 5)
-//	//}
-//	//
-//	//if getApollo != nil {
-//	//	getStr = getApollo.GetValue("content")
-//	//	if getStr != "" {
-//	//		//写入配置
-//	//		gfile.PutContents(path.Join("manifest", "game", name+".json"), getStr)
-//	//	}
-//	//} else {
-//	//	jsonObj, err = c.GetFile(name)
-//	//}
-//	//jsonObj, err = gjson.DecodeToJson(getStr)
-//	////首次运行加入监听器
-//	//if !gstr.InArray(ApolloListener, name) {
-//	//	c2 := &CustomChangeListener{}
-//	//	client.AddChangeListener(c2)
-//	//	ApolloListener = append(ApolloListener, name)
-//	//}
-//	//return
-//}
-
 func (c *Cfg) GetApollo(name string, obj Load) (jsonObj *gjson.Json, err error) {
+	// 将配置项名称和对应的加载器对象存入映射
 	Item2Obj[name+".json"] = obj
 
-	// 接入阿波罗配置
+	// 接入 Apollo 配置
 	ApolloCfg.NamespaceName = name + ".json"
+	// 创建 Apollo 配置适配器
 	adapter, err := apollo.New(nil, *ApolloCfg)
 	if err != nil {
+		// 配置适配器创建失败，记录致命错误日志
 		g.Log().Fatalf(nil, `%+v`, err)
 	}
-	// Change the adapter of default configuration instance.
+	// 更改默认配置实例的适配器
 	g.Cfg(name).SetAdapter(adapter)
 
-	//首次运行加入监听器
+	// 首次运行加入监听器
 	if !gstr.InArray(ApolloListener, name+".json") {
-		//放置监听器
+		// 启动 Apollo 客户端
 		client, _ := agollo.StartWithConfig(func() (*apolloConfig.AppConfig, error) {
 			return &apolloConfig.AppConfig{
 				AppID:             ApolloCfg.AppID,
@@ -159,31 +147,40 @@ func (c *Cfg) GetApollo(name string, obj Load) (jsonObj *gjson.Json, err error)
 				MustStart:         ApolloCfg.MustStart,
 			}, nil
 		})
+		// 创建自定义监听器实例
 		c2 := &CustomChangeListener{}
+		// 为 Apollo 客户端添加监听器
 		client.AddChangeListener(c2)
+		// 将配置项名称添加到监听器列表
 		ApolloListener = append(ApolloListener, name+".json")
 	}
 
+	// 从配置中心获取指定配置项的值
 	cfg, err := g.Cfg(name).Get(nil, "content")
+	// 将配置值扫描到 jsonObj 中
 	cfg.Scan(&jsonObj)
 	return
 }
 
-// 阿波罗监听器
+// CustomChangeListener 是 Apollo 配置变化的自定义监听器
 type CustomChangeListener struct {
+	// wg 用于等待所有处理任务完成
 	wg sync.WaitGroup
 }
 
+// OnChange 当 Apollo 配置发生变化时触发
 func (c *CustomChangeListener) OnChange(changeEvent *storage.ChangeEvent) {
+	// 记录配置变化的日志
 	g.Log().Debugf(nil, "当前Namespace变化了：%v", changeEvent.Namespace)
+	// 获取变化的配置项名称
 	filename := changeEvent.Namespace
 	if obj, ok := Item2Obj[filename]; ok {
-		//重载配置文件
+		// 重载配置文件
 		obj.Load(changeEvent.Changes["content"].NewValue.(string))
 	}
 }
 
+// OnNewestChange 当获取到最新配置时触发，当前为空实现
 func (c *CustomChangeListener) OnNewestChange(event *storage.FullChangeEvent) {
 	//write your code here
-
 }

pkg/elasticsearch/elasticsearch.go

@@ -5,96 +5,102 @@ import (
 	"encoding/json"
 	"fmt"
 	"github.com/elastic/go-elasticsearch/v8"
+	"github.com/elastic/go-elasticsearch/v8/typedapi/core/bulk"
+	"github.com/elastic/go-elasticsearch/v8/typedapi/core/delete"
+	"github.com/elastic/go-elasticsearch/v8/typedapi/core/search"
+	"github.com/elastic/go-elasticsearch/v8/typedapi/core/update"
+	"github.com/elastic/go-elasticsearch/v8/typedapi/types"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gctx"
 )
 
 var (
 	es *elasticsearch.TypedClient
 )
 
-type elastic struct {
+type Elastic struct {
 	client *elasticsearch.TypedClient
+	name   string
 }
 
-func New(name ...string) *elastic {
+func NewV1(name string) *Elastic {
-	// ES 配置
+	var cfg elasticsearch.Config
-	cfg := elasticsearch.Config{
+	_cfg := g.Cfg().MustGetWithEnv(gctx.New(), "elasticsearch")
-		Addresses: []string{
+	_cfg.Scan(&cfg)
-			"http://ay.cname.com:9200",
-		},
-	}
 	if es == nil {
 		var err error
 		es, err = elasticsearch.NewTypedClient(cfg)
 		if err != nil {
 			fmt.Printf("elasticsearch.NewTypedClient failed, err:%v\n", err)
-			return &elastic{}
+			return &Elastic{}
 		}
 	}
-	return &elastic{
+	return &Elastic{
 		client: es,
+		name:   name,
 	}
 }
 
-// createIndex 创建索引
+//// Create 创建索引
-func (s *elastic) CreateIndex(name string) {
+//func (s *Elastic) Create(ctx context.Context) {
-	resp, err := s.client.Indices.
+//	resp, err := s.client.Indices.
-		Create(name).
+//		Create(s.name).Do(ctx)
-		Do(context.Background())
+//	if err != nil {
-	if err != nil {
+//		fmt.Printf("create index failed, err:%v\n", err)
-		fmt.Printf("create index failed, err:%v\n", err)
+//		return
-		return
+//	}
-	}
+//	fmt.Printf("index:%#v\n", resp.Index)
-	fmt.Printf("index:%#v\n", resp.Index)
+//}
-}
-
-// indexDocument 索引文档
-func (s *elastic) IndexDocument(name string, key string, data interface{}) {
 
+// Set 索引文档
+func (s *Elastic) Set(ctx context.Context, key string, data interface{}) (err error) {
 	// 添加文档
-	resp, err := s.client.Index(name).
+	_, err = s.client.Index(s.name).Id(key).Document(data).Do(ctx)
-		Id(key).
-		Document(data).
-		Do(context.Background())
-	if err != nil {
-		fmt.Printf("indexing document failed, err:%v\n", err)
-		return
-	}
-	fmt.Printf("result:%#v\n", resp.Result)
-}
-
-// getDocument 获取文档
-func (s *elastic) GetDocument(name string, id string) (res json.RawMessage) {
-	resp, err := s.client.Get(name, id).
-		Do(context.Background())
-	if err != nil {
-		fmt.Printf("get document by id failed, err:%v\n", err)
-		return
-	}
-	fmt.Printf("fileds:%s\n", resp.Source_)
-	res = resp.Source_
 	return
 }
 
-// updateDocument 更新文档
+// SetBulk 批量添加文档
-func (s *elastic) UpdateDocument(name string, key string, data interface{}) {
+func (s *Elastic) SetBulk(ctx context.Context, data []any) (err error) {
-
+	var save *bulk.Request
-	resp, err := s.client.Update(name, key).
+	save = &bulk.Request{
-		Doc(data). // 使用结构体变量更新
+		data,
-		Do(context.Background())
-	if err != nil {
-		fmt.Printf("update document failed, err:%v\n", err)
-		return
 	}
-	fmt.Printf("result:%v\n", resp.Result)
+	s.client.Bulk().Index(s.name).Request(save).Do(ctx)
+	return
 }
 
-// deleteDocument 删除 document
+// Get 获取文档
-func (s *elastic) DeleteDocument(name string, key string) {
+func (s *Elastic) Get(ctx context.Context, id string) (res json.RawMessage, err error) {
-	resp, err := s.client.Delete(name, key).
+	get, err := s.client.Get(s.name, id).Do(ctx)
-		Do(context.Background())
 	if err != nil {
-		fmt.Printf("delete document failed, err:%v\n", err)
 		return
 	}
-	fmt.Printf("result:%v\n", resp.Result)
+	res = get.Source_
+	return
+}
+
+// Update 更新文档
+func (s *Elastic) Update(ctx context.Context, key string, data interface{}) (res *update.Response, err error) {
+	res, err = s.client.Update(s.name, key).Doc(data).Do(ctx)
+	return
+}
+
+// Delete 删除 document
+func (s *Elastic) Delete(ctx context.Context, key string) (res *delete.Response, err error) {
+	res, err = s.client.Delete(s.name, key).Do(ctx)
+	if err != nil {
+		return
+	}
+	return
+}
+
+// Select 查询
+func (s *Elastic) Select(ctx context.Context, query *types.MatchAllQuery) (res *search.Response, err error) {
+	res, err = s.client.Search(). //Index("my_index").
+		Request(&search.Request{
+			Query: &types.Query{
+				MatchAll: &types.MatchAllQuery{},
+			},
+		}).Do(ctx)
+	return
 }

pkg/notice/notice.go

@@ -1,7 +1,7 @@
 package notice
 
 import (
-	v1 "github.com/ayflying/utility_go/api/pgk/v1"
+	v1 "github.com/ayflying/utility_go/api/pkg/v1"
 	"github.com/ayflying/utility_go/pkg/notice/drive"
 )
 

pkg/pkg.go

@@ -1,9 +1,10 @@
 package pkg
 
 import (
-	v1 "github.com/ayflying/utility_go/api/pgk/v1"
+	v1 "github.com/ayflying/utility_go/api/pkg/v1"
 	"github.com/ayflying/utility_go/pkg/aycache"
 	"github.com/ayflying/utility_go/pkg/config"
+	"github.com/ayflying/utility_go/pkg/elasticsearch"
 	"github.com/ayflying/utility_go/pkg/notice"
 	"github.com/ayflying/utility_go/pkg/rank"
 	"github.com/ayflying/utility_go/pkg/s3"
@@ -38,3 +39,7 @@ func Websocket() *websocket.SocketV1 {
 func Config() *config.Cfg {
 	return config.NewV1()
 }
+
+func Elastic(name string) *elasticsearch.Elastic {
+	return elasticsearch.NewV1(name)
+}

pkg/rank/rank.go

@@ -2,7 +2,7 @@ package rank
 
 import (
 	"fmt"
-	v1 "github.com/ayflying/utility_go/api/pgk/v1"
+	v1 "github.com/ayflying/utility_go/api/pkg/v1"
 	"time"
 
 	"github.com/gogf/gf/v2/database/gredis"

pkg/s3/s3.go

@@ -16,26 +16,32 @@ import (
 	"github.com/minio/minio-go/v7/pkg/credentials"
 )
 
+// ctx 全局上下文，用于在整个包中传递请求范围的数据
 var (
 	//client *minio.Client
 	ctx = gctx.New()
 )
 
+// DataType 定义了 S3 配置的数据结构，用于存储访问 S3 所需的各种信息
 type DataType struct {
-	AccessKey     string `json:"access_key"`
+	AccessKey     string `json:"access_key"` // 访问 S3 的密钥 ID
-	SecretKey     string `json:"secret_key"`
+	SecretKey     string `json:"secret_key"` // 访问 S3 的密钥
-	Address       string `json:"address"`
+	Address       string `json:"address"`    // S3 服务的地址
-	Ssl           bool   `json:"ssl"`
+	Ssl           bool   `json:"ssl"`        // 是否使用 SSL 加密连接
-	Url           string `json:"url"`
+	Url           string `json:"url"`        // S3 服务的访问 URL
-	BucketName    string `json:"bucket_name"`
+	BucketName    string `json:"bucket_name"` // 默认存储桶名称
-	BucketNameCdn string `json:"bucket_name_cdn"`
+	BucketNameCdn string `json:"bucket_name_cdn"` // CDN 存储桶名称
 }
 
+// Mod 定义了 S3 模块的结构体，包含一个 S3 客户端实例和配置信息
 type Mod struct {
-	client *minio.Client
+	client *minio.Client // Minio S3 客户端实例
-	cfg    DataType
+	cfg    DataType      // S3 配置信息
 }
 
+// New 根据配置创建一个新的 S3 模块实例
+// 如果未提供名称，则从配置中获取默认的 S3 类型
+// 配置错误时会触发 panic
 func New(_name ...string) *Mod {
 	var name string
 	if len(_name) > 0 {
@@ -52,7 +58,7 @@ func New(_name ...string) *Mod {
 	var cfg DataType
 	get.Scan(&cfg)
 
-	// 使用minio-go创建S3客户端
+	// 使用 minio-go 创建 S3 客户端
 	obj, err := minio.New(
 		cfg.Address,
 		&minio.Options{
@@ -72,183 +78,111 @@ func New(_name ...string) *Mod {
 	return mod
 }
 
-//func (s *Mod) Load() {
+// GetCfg 获取当前 S3 模块的配置信息
-//	//导入配置
-//	get, err := g.Cfg().Get(ctx, "s3.type")
-//	cfgType := get.String()
-//	if cfgType == "" {
-//		cfgType = "default"
-//	}
-//
-//	cfgData, err := g.Cfg().Get(ctx, "s3."+cfgType)
-//	if cfgData.IsEmpty() {
-//		panic("当前配置中未配置s3：" + cfgType)
-//	}
-//
-//	get, err = g.Cfg().Get(ctx, "s3."+cfgType)
-//	err = get.Scan(&Cfg)
-//
-//	// 使用minio-go创建S3客户端
-//	obj, err := minio.New(
-//		Cfg.Address,
-//		&minio.Options{
-//			Creds:  credentials.NewStaticV4(Cfg.AccessKey, Cfg.SecretKey, ""),
-//			Secure: Cfg.Ssl,
-//		},
-//	)
-//	if err != nil {
-//		log.Fatalln(err)
-//	}
-//
-//	client = obj
-//}
-//
-//func (s *Mod) S3(name string) {
-//	get, err := g.Cfg().Get(ctx, "s3."+name)
-//	if err != nil {
-//		panic(err)
-//	}
-//	get.Scan(&Cfg)
-//
-//	// 使用minio-go创建S3客户端
-//	obj, err := minio.New(
-//		Cfg.Address,
-//		&minio.Options{
-//			Creds:  credentials.NewStaticV4(Cfg.AccessKey, Cfg.SecretKey, ""),
-//			Secure: Cfg.Ssl,
-//		},
-//	)
-//	if err != nil {
-//		log.Fatalln(err)
-//	}
-//
-//	client = obj
-//
-//}
-
-// GetCfg 获取配置
 func (s *Mod) GetCfg() *DataType {
 	return &s.cfg
 }
 
-// GetFileUrl 生成指向S3存储桶中指定文件的预签名URL
+// GetFileUrl 生成指向 S3 存储桶中指定文件的预签名 URL
-//
+// 预签名 URL 可用于在有限时间内访问 S3 存储桶中的文件
-// @Description: 生成一个具有有限有效期的预签名URL，可用于访问S3存储桶中的文件。
+// 支持从缓存中获取预签名 URL，以减少重复请求
-// @receiver s: S3的实例，用于执行S3操作。
-// @param name: 要获取预签名URL的文件名。
-// @param bucketName: 文件所在的存储桶名称。
-// @return presignedURL: 生成的预签名URL，可用于访问文件。
-// @return err: 在获取预签名URL过程中遇到的任何错误。
 func (s *Mod) GetFileUrl(name string, bucketName string, _expires ...time.Duration) (presignedURL *url.URL, err error) {
-	// 设置预签名URL的有效期为1小时
+	// 设置预签名 URL 的有效期为 1 小时，可通过参数覆盖
 	expires := time.Hour * 1
 	if len(_expires) > 0 {
 		expires = _expires[0]
 	}
+	// 生成缓存键
 	cacheKey := fmt.Sprintf("s3:%v:%v", name, bucketName)
+	// 尝试从缓存中获取预签名 URL
 	get, _ := gcache.Get(ctx, cacheKey)
-	//g.Dump(get.Vars())
 	if !get.IsEmpty() {
+		// 将缓存中的值转换为 *url.URL 类型
 		err = gconv.Struct(get.Val(), &presignedURL)
-		//presignedURL =
 		return
 	}
-	//expires := time.Duration(604800)
+	// 调用 S3 客户端生成预签名 URL
-	// 调用s3().PresignedGetObject方法生成预签名URL
 	presignedURL, err = s.client.PresignedGetObject(ctx, bucketName, name, expires, nil)
+	// 将生成的预签名 URL 存入缓存
 	err = gcache.Set(ctx, cacheKey, presignedURL, expires)
 	return
 }
 
-// PutFileUrl 生成一个用于上传文件到指定bucket的预签名URL
+// PutFileUrl 生成一个用于上传文件到指定存储桶的预签名 URL
-//
+// 预签名 URL 的有效期默认为 10 分钟
-//	@Description:
-//	@receiver s
-//	@param name 文件名
-//	@param bucketName 存储桶名称
-//	@return presignedURL 预签名的URL，用于上传文件
-//	@return err 错误信息，如果在生成预签名URL时发生错误
 func (s *Mod) PutFileUrl(name string, bucketName string) (presignedURL *url.URL, err error) {
-	// 设置预签名URL的有效期
+	// 设置预签名 URL 的有效期为 10 分钟
-	//expires := time.Now().Add(time.Minute * 30).Unix() // 例如：有效期30分钟
-	//expires2 := time.Duration(expires)
 	expires := time.Minute * 10
-	// 生成预签名URL
+	// 调用 S3 客户端生成预签名 URL
 	presignedURL, err = s.client.PresignedPutObject(ctx, bucketName, name, expires)
-
 	return
 }
 
-// 获取储存桶列表
+// ListBuckets 获取当前 S3 客户端可访问的所有存储桶列表
+// 出错时返回 nil
 func (s *Mod) ListBuckets() []minio.BucketInfo {
 	buckets, err := s.client.ListBuckets(ctx)
-	//g.Dump(buckets)
 	if err != nil {
-		//fmt.Println(err)
 		return nil
 	}
 	return buckets
 }
 
-// PutObject 上传文件到指定的存储桶中。
+// PutObject 上传文件到指定的存储桶中
-//
+// 支持指定文件大小，未指定时将读取文件直到结束
-// @Description: 上传一个文件到指定的存储桶。
-// @receiver s *Mod: 表示调用此方法的Mod实例。
-// @param f io.Reader: 文件的读取器，用于读取待上传的文件内容。
-// @param name string: 待上传文件的名称。
-// @param bucketName string: 存储桶的名称。
-// @param _size ...int64: 可选参数，指定上传文件的大小。如果未提供，则默认为-1，表示读取文件直到EOF。
-// @return res minio.UploadInfo: 上传成功后返回的上传信息。
-// @return err error: 如果上传过程中出现错误，则返回错误信息。
 func (s *Mod) PutObject(f io.Reader, name string, bucketName string, _size ...int64) (res minio.UploadInfo, err error) {
-	// 初始化文件大小为-1，表示将读取文件至结束。
+	// 初始化文件大小为 -1，表示将读取文件至结束
 	var size = int64(-1)
-	// 如果提供了文件大小，则使用提供的大小值。
 	if len(_size) > 0 {
 		size = _size[0]
 	}
-
+	// 调用 S3 客户端上传文件，设置内容类型为 "application/octet-stream"
-	// 调用client的PutObject方法上传文件，并设置内容类型为"application/octet-stream"。
 	res, err = s.client.PutObject(ctx, bucketName, name, f, size, minio.PutObjectOptions{ContentType: "application/octet-stream"})
 	if err != nil {
+		// 记录上传错误日志
 		g.Log().Error(ctx, err)
 	}
 	return
 }
 
-// RemoveObject 删除文件
+// RemoveObject 从指定存储桶中删除指定名称的文件
 func (s *Mod) RemoveObject(name string, bucketName string) (err error) {
 	opts := minio.RemoveObjectOptions{
 		//GovernanceBypass: true,
 		//VersionID:        "myversionid",
 	}
+	// 调用 S3 客户端删除文件
 	err = s.client.RemoveObject(ctx, bucketName, name, opts)
 	return
 }
 
-// ListObjects 文件列表
+// ListObjects 获取指定存储桶中指定前缀的文件列表
+// 返回一个包含文件信息的通道
 func (s *Mod) ListObjects(bucketName string, prefix string) (res <-chan minio.ObjectInfo, err error) {
+	// 调用 S3 客户端获取文件列表
 	res = s.client.ListObjects(ctx, bucketName, minio.ListObjectsOptions{
 		Prefix: prefix,
 	})
 	return
 }
 
-// SetBucketPolicy 设置bucket或对象前缀的访问权限
+// SetBucketPolicy 设置指定存储桶或对象前缀的访问策略
+// 目前使用固定的策略，可根据需求修改
 func (s *Mod) SetBucketPolicy(bucketName string, prefix string) (err error) {
-
+	// 定义访问策略
 	policy := `{"Version": "2012-10-17","Statement": [{"Action": ["s3:GetObject"],"Effect": "Allow","Principal": {"AWS": ["*"]},"Resource": ["arn:aws:s3:::my-bucketname/*"],"Sid": ""}]}`
-
+	// 调用 S3 客户端设置存储桶策略
 	err = s.client.SetBucketPolicy(ctx, bucketName, policy)
 	return
 }
 
-// GetUrl 获取文件访问地址
+// GetUrl 获取文件的访问地址
+// 支持返回默认文件地址，根据 SSL 配置生成不同格式的 URL
 func (s *Mod) GetUrl(filePath string, defaultFile ...string) (url string) {
 	bucketName := s.cfg.BucketNameCdn
 	get := s.cfg.Url
 
-	//如果没有图片，返回默认的图片地址
+	// 如果没有指定文件路径，且提供了默认文件路径，则使用默认路径
 	if filePath == "" && len(defaultFile) > 0 {
 		filePath = defaultFile[0]
 	}
@@ -262,6 +196,7 @@ func (s *Mod) GetUrl(filePath string, defaultFile ...string) (url string) {
 	return
 }
 
+// GetPath 从文件访问 URL 中提取文件路径
 func (s *Mod) GetPath(url string) (filePath string) {
 	bucketName := s.cfg.BucketNameCdn
 	get := s.cfg.Url
@@ -269,21 +204,22 @@ func (s *Mod) GetPath(url string) (filePath string) {
 	return url[len(get+bucketName)+1:]
 }
 
-// 复制文件
+// CopyObject 在指定存储桶内复制文件
+// 支持指定源文件和目标文件路径
 func (s *Mod) CopyObject(bucketName string, dstStr string, srcStr string) (err error) {
-
+	// 定义目标文件选项
-	// 原始文件
 	var dst = minio.CopyDestOptions{
 		Bucket: bucketName,
 		Object: dstStr,
 	}
 
-	// 新文件
+	// 定义源文件选项
 	var src = minio.CopySrcOptions{
 		Bucket: bucketName,
 		Object: srcStr,
 	}
 
+	// 调用 S3 客户端复制文件
 	_, err = s.client.CopyObject(ctx, dst, src)
 	return
 }

pkg/websocket/registerer.go

@@ -1,16 +1,49 @@
 package websocket
 
-import "context"
+import "google.golang.org/protobuf/proto"
 
 // 定义一个处理方法的类型
-type Handler func(ctx context.Context, req any) (err error)
+type Handler func(conn *WebsocketData, req any) (err error)
+type Handler2 func(conn *WebsocketData)
+
+type HandlerMessage func(conn *WebsocketData, req any)
+
+type PbType func(cmd int32, data []byte, code int32, msg string) proto.Message
+type PbType2 func(data []byte) (int, []byte)
 
 // 路由器的处理映射
 var (
-	handlers = make(map[int]Handler)
+	handlers          = make(map[int]Handler)
+	OnConnectHandlers = make([]Handler2, 0)
+	OnCloseHandlers   = make([]Handler2, 0)
+	onMessageHandlers = make([]HandlerMessage, 0)
+	Byte2Pb           = make([]PbType, 0)
+	Pb2Bytes          = make([]PbType2, 0)
 )
 
 // 注册方法，将某个消息路由器ID和对应的处理方法关联起来
 func (s *SocketV1) RegisterRouter(cmd int, handler Handler) {
 	handlers[cmd] = handler
 }
+
+//注册方法，讲长连接登陆方法进行注册
+func (s *SocketV1) RegisterOnConnect(_func Handler2) {
+	OnConnectHandlers = append(OnConnectHandlers, _func)
+}
+
+func (s *SocketV1) RegisterOnClose(_func Handler2) {
+	OnCloseHandlers = append(OnCloseHandlers, _func)
+}
+
+//注册方法长连接消息体
+func (s *SocketV1) RegisterMessage(_func HandlerMessage) {
+	onMessageHandlers = append(onMessageHandlers, _func)
+}
+
+func (s *SocketV1) RegisterByte2Pb(_func PbType) {
+	Byte2Pb = append(Byte2Pb, _func)
+}
+
+func (s *SocketV1) RegisterPb2Byte(_func PbType2) {
+	Pb2Bytes = append(Pb2Bytes, _func)
+}

pkg/websocket/socket_new.go

@@ -2,57 +2,77 @@ package websocket
 
 import (
 	"context"
+	"fmt"
+	"github.com/ayflying/utility_go/pkg/aycache"
+	"github.com/ayflying/utility_go/tools"
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/net/ghttp"
 	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/os/glog"
-	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/guid"
-	"github.com/google/uuid"
 	"github.com/gorilla/websocket"
+	"google.golang.org/protobuf/proto"
+	"net/http"
 	"sync"
-	"github.com/gogf/gf/v2/net/ghttp"
+	"time"
 )
 
-type SocketV1 struct{}
+type SocketV1 struct {
+	Type int `json:"type"`
+}
 
 var (
 	//ctx = gctx.New()
 	//Conn map[uuid.UUID]*WebsocketData
-	lock sync.Mutex
+	lock  sync.Mutex
-
+	cache = aycache.New("redis")
-	m = gmap.New(true)
+	m     = gmap.NewHashMap(true)
 )
 
 type WebsocketData struct {
-	Ws   *websocket.Conn
+	Ws     *websocket.Conn `json:"ws" dc:"websocket连接池"`
-	Uuid uuid.UUID
+	Uuid   string          `json:"uuid" dc:"用户唯一标识"`
-	Uid  int64
+	Uid    int64           `json:"uid" dc:"用户编号"`
-	Ctx  context.Context
+	Groups []string        `json:"groups" dc:"群组"`
+	Ctx    context.Context `json:"ctx" dc:""`
+	RoomId string          `json:"roomId" dc:"房间编号"`
 }
 
 func NewV1() *SocketV1 {
-	return &SocketV1{}
+	return &SocketV1{
+		Type: 2,
+	}
 }
 
 type SocketInterface interface {
-	OnConnect(*websocket.Conn)
+	Load(serv *ghttp.Server, prefix string)
-	OnMessage(*WebsocketData, []byte, int)
+	OnConnect(ctx context.Context, conn *websocket.Conn)
-	Send(uuid.UUID, []byte) (err error)
+	OnMessage(conn *WebsocketData, req []byte, msgType int)
-	SendAll(data []byte)
+	Send(cmd int32, uid int64, req proto.Message)
-	OnClose(conn *websocket.Conn)
+	SendAll(cmd int32, req proto.Message)
+	OnClose(conn *WebsocketData)
 }
 
 func (s *SocketV1) Load(serv *ghttp.Server, prefix string) {
 	//websocket服务启动
 	serv.Group(prefix, func(group *ghttp.RouterGroup) {
-
 		var websocketCfg = websocket.Upgrader{
 			ReadBufferSize:  1024,
 			WriteBufferSize: 1024,
+			CheckOrigin: func(r *http.Request) bool {
+				// In production, you should implement proper origin checking
+				return true
+			},
+			Error: func(w http.ResponseWriter, r *http.Request, status int, reason error) {
+				g.Log().Errorf(r.Context(), "WebSocket error: %v", reason)
+			},
 		}
 		group.Bind(
 			func(r *ghttp.Request) {
 				ctx := r.Context()
+
 				ws, err := websocketCfg.Upgrade(r.Response.Writer, r.Request, nil)
 				if err != nil {
 					glog.Error(ctx, err)
@@ -72,37 +92,43 @@ func (s *SocketV1) Load(serv *ghttp.Server, prefix string) {
 //	@Description:
 //	@receiver s
 //	@param conn
-func (s *SocketV1) OnConnect(ctx context.Context, conn *websocket.Conn) {
+func (s *SocketV1) OnConnect(ctx context.Context, ws *websocket.Conn) {
-	//lock.Lock()
+	id := guid.S()
-	//defer lock.Unlock()
+	ip := ws.RemoteAddr().String()
-
+	conn := &WebsocketData{
-	defer conn.Close()
+		Uuid:   id,
-	id, _ := uuid.NewUUID()
+		Ws:     ws,
-	ip := conn.RemoteAddr().String()
+		Ctx:    ctx,
-
+		Groups: make([]string, 0),
-	data := &WebsocketData{
+		RoomId: "",
-		Uuid: id,
-		Ws:   conn,
-		Ctx:  ctx,
 	}
-	m.Set(id, data)
+	m.Set(id, conn)
 
 	//defer delete(Conn, id)
 
-	//to := fmt.Sprintf("创建连接：%v,ip=%v", id, ip)
+	to := fmt.Sprintf("创建连接：%v,ip=%v", id, ip)
+	g.Log().Debugf(ctx, to)
 	//s.Send(id, []byte(to))
 
+	//用户登录钩子执行
+	for _, connect := range OnConnectHandlers {
+		connect(conn)
+	}
+
 	for {
 		//进入当前连接线程拥堵
-		msgType, msg, err := conn.ReadMessage()
+		msgType, msg, err := ws.ReadMessage()
+		s.Type = msgType
 		if err != nil {
 			//客户端断开返回错误，断开当前连接
+			//g.Log().Error(ctx, err)
 			break
 		}
-		s.OnMessage(m.Get(id).(*WebsocketData), msg, msgType)
+		s.OnMessage(conn, msg, msgType)
 	}
 	//关闭连接触发
-	s.OnClose(id, conn)
+
+	s.OnClose(conn)
 	g.Log().Debugf(ctx, "断开连接:uuid=%v,ip=%v", id, ip)
 }
 
@@ -113,67 +139,221 @@ func (s *SocketV1) OnConnect(ctx context.Context, conn *websocket.Conn) {
 //	@param msg
 //	@param msgType
 func (s *SocketV1) OnMessage(conn *WebsocketData, req []byte, msgType int) {
-	//g.Log().Debugf(ctx, "收到消息：%v,type=%v,conn=%v", string(req), msgType, conn)
+	s.Type = 2
-	//s.Send(conn.Uuid, msg)
+	var cmd int
-	//s.SendAll(msg)
+	var msg []byte
-	msgStr := string(req)
+	//uid := conn.Uid
-	msg := msgStr[8:]
+	for _, v := range Pb2Bytes {
-	cmd := gconv.Int(msgStr[:8])
+		cmd, msg = v(req)
-	//GetRouter(cmd, conn.Uid, msg)
+	}
+	g.Log("cmd").Debugf(gctx.New(), fmt.Sprintf("from|%d|%d|%v", cmd, conn.Uid, gjson.MustEncodeString(req)))
+
+	//msgStr := string(req)
+	//cmd = gconv.Int(msgStr[:8])
+	//msg = []byte(msgStr[8:])
+
 	handler, exist := handlers[cmd]
 	if exist {
 		//匹配上路由器
-		handler(conn.Ctx, msg)
+		err := handler(conn, msg)
+		if err != nil {
+			g.Log().Error(conn.Ctx, err)
+		}
 	} else {
 		//fmt.Println("未注册的路由器ID:", cmd)
-		s.Send(conn.Uuid, []byte("未注册的协议号:"+msgStr[:8]))
+		//s.Send(20000000, conn.Uid, []byte("未注册的协议号:"+strconv.Itoa(cmd)))
-		s.OnClose(conn.Uuid, conn.Ws)
+		s.OnClose(conn)
 		return
 	}
 
 }
 
+//绑定用户编号
+func (s *SocketV1) BindUid(conn *WebsocketData, uid int64) {
+	lock.Lock()
+	defer lock.Unlock()
+
+	cacheKey := fmt.Sprintf("socket:uid:%d", uid)
+	g.Redis().Set(nil, cacheKey, conn.Uuid)
+
+	if conn.Uid == 0 {
+		conn.Uid = uid
+	}
+
+}
+
+//解绑用户
+func (s *SocketV1) UnBindUid(uid int64) {
+	lock.Lock()
+	defer lock.Unlock()
+
+	cacheKey := fmt.Sprintf("socket:uid:%d", uid)
+	g.Redis().Del(nil, cacheKey)
+}
+
+// Uid2Uuid 用户编号转uuid唯一标识
+func (s *SocketV1) Uid2Uuid(uid int64) (uuid string) {
+	cacheKey := fmt.Sprintf("socket:uid:%d", uid)
+	get, _ := g.Redis().Get(nil, cacheKey)
+	if get.IsNil() {
+		return
+	}
+
+	uuid = get.String()
+
+	//如果不在线了
+	if !m.Contains(uuid) {
+		// 解绑用户编号
+		s.UnBindUid(uid)
+		return
+	}
+
+	return
+}
+
+// SendUuid
+//
+//	@Description:
+//	@receiver s
+//	@param uid
+//	@param data
+func (s *SocketV1) SendUuid(cmd int32, uuidStr string, req proto.Message) {
+	if !m.Contains(uuidStr) {
+		return
+	}
+	//格式化数据
+	var data, err = proto.Marshal(req)
+	if err != nil {
+		g.Log().Error(gctx.New(), err)
+		return
+	}
+
+	conn := m.Get(uuidStr).(*WebsocketData)
+
+	//前置方法
+
+	for _, v := range Byte2Pb {
+		temp := v(cmd, data, 0, "")
+		data, _ = proto.Marshal(temp)
+	}
+	conn.Ws.WriteMessage(s.Type, data)
+	return
+}
+
 // Send
 //
 //	@Description:
 //	@receiver s
 //	@param uid
 //	@param data
-//	@return err
+func (s *SocketV1) Send(cmd int32, uid int64, req proto.Message) {
-func (s *SocketV1) Send(id uuid.UUID, data []byte) (err error) {
+	g.Log("cmd").Debugf(gctx.New(), fmt.Sprintf("to|%d|%d|%v", cmd, uid, gjson.MustEncodeString(req)))
-	if !m.Contains(id) {
+
+	uuid := s.Uid2Uuid(uid)
+	if uuid == "" {
 		return
 	}
-
+	s.SendUuid(cmd, uuid, req)
-	conn := m.Get(id).(*WebsocketData)
-	conn.Ws.WriteMessage(1, data)
-
 	return
 }
 
 // 批量发送
-func (s *SocketV1) SendAll(data []byte) {
+func (s *SocketV1) SendAll(cmd int32, req proto.Message) {
+	g.Log("cmd").Debugf(gctx.New(), fmt.Sprintf("all:%d|-1|%v", cmd, gjson.MustEncodeString(req)))
+
+	//格式化数据
+	var data, err = proto.Marshal(req)
+	if err != nil {
+		g.Log().Error(gctx.New(), err)
+		return
+	}
+
+	for _, v := range Byte2Pb {
+		temp := v(cmd, data, 0, "")
+		data, _ = proto.Marshal(temp)
+	}
 	m.Iterator(func(k interface{}, v interface{}) bool {
-		//fmt.Printf("%v:%v ", k, v)
 		conn := v.(*WebsocketData)
-		conn.Ws.WriteMessage(1, data)
+		conn.Ws.WriteMessage(s.Type, data)
 		return true
 	})
 }
 
+//加入群组
+func (s *SocketV1) JoinGroup(conn *WebsocketData, group string) {
+	conn.Groups = append(conn.Groups, group)
+	cacheKey := "websocket:group:" + group
+	get, _ := aycache.New("redis").Get(conn.Ctx, cacheKey)
+	var list = make(map[int64]string)
+	if !get.IsNil() {
+		get.Scan(&list)
+	}
+	list[conn.Uid] = conn.Uuid
+	cache.Set(conn.Ctx, cacheKey, list, time.Hour*24*7)
+}
+
+// 退出群组
+func (s *SocketV1) LeaveGroup(conn *WebsocketData, group string) {
+	conn.Groups = tools.RemoveSlice[string](conn.Groups, group)
+	cacheKey := "websocket:group:" + group
+	get, _ := cache.Get(conn.Ctx, cacheKey)
+	var list = make(map[int64]string)
+	if !get.IsNil() {
+		get.Scan(&list)
+	}
+	delete(list, conn.Uid)
+	cache.Set(conn.Ctx, cacheKey, list, time.Hour*24*7)
+}
+
+//群组广播
+func (s *SocketV1) SendGroup(cmd int32, group string, req proto.Message) {
+	cacheKey := "websocket:group:" + group
+	get, _ := cache.Get(gctx.New(), cacheKey)
+	var list = make(map[int64]string)
+	if !get.IsNil() {
+		get.Scan(&list)
+	}
+	for uid, v := range list {
+		if m.Contains(v) {
+			s.Send(cmd, uid, req)
+		}
+	}
+}
+
 // OnClose
 //
 //	@Description:
 //	@receiver s
 //	@param conn
-func (s *SocketV1) OnClose(id uuid.UUID, conn *websocket.Conn) {
+func (s *SocketV1) OnClose(conn *WebsocketData) {
 	// 在此处编写断开连接后的处理逻辑
-	g.Log().Debugf(gctx.New(), "WebSocket connection from %s has been closed.", conn.RemoteAddr())
+	//g.Log().Debugf(gctx.New(), "WebSocket connection from %s has been closed.", conn.RemoteAddr())
+
+	//用户登录钩子执行
+	for _, connect := range OnCloseHandlers {
+		connect(conn)
+	}
+	uid := conn.Uid
+	if uid > 0 {
+		s.UnBindUid(uid)
+		for _, v := range conn.Groups {
+			s.LeaveGroup(conn, v)
+		}
+	}
 
 	// 可能的后续操作：
 	// 1. 更新连接状态或从连接池移除
 	// 2. 发送通知或清理关联资源
 	// 3. 执行特定于业务的断开处理
-	m.Remove(id)
+	conn.Ws.Close()
-	conn.Close()
+	m.Remove(conn.Uuid)
+}
+
+// 是否在线
+func (s *SocketV1) IsOnline(uid int64) bool {
+	uuid := s.Uid2Uuid(uid)
+	if m.Contains(uuid) {
+		return true
+	}
+	return false
 }

service/game_act.go

@@ -6,6 +6,8 @@
 package service
 
 import (
+	"context"
+
 	"github.com/gogf/gf/v2/frame/g"
 )
 
@@ -29,10 +31,11 @@ type (
 		// @param data interface{}: 要存储的活动信息数据。
 		// @return err error: 返回错误信息，如果操作成功，则返回nil。
 		Set(uid int64, actId int, data interface{}) (err error)
-		Saves() (err error)
+		Saves(ctx context.Context) (err error)
-		Save(actId int) (err error)
+		Save(ctx context.Context, actId int) (err error)
 		// 清空GetRedDot缓存
 		RefreshGetRedDotCache(uid int64)
+		Del(uid int64, actId int)
 	}
 )
 

service/system_cron.go

@@ -6,6 +6,8 @@
 package service
 
 import (
+	"context"
+
 	v1 "github.com/ayflying/utility_go/api/system/v1"
 	"github.com/gogf/gf/v2/net/gclient"
 )
@@ -24,16 +26,32 @@ type (
 		// AddCron 添加一个定时任务到相应的调度列表中。
 		//
 		// @Description: 根据指定的类型将函数添加到不同的任务列表中，以供后续执行。
+		// 确保自定义任务正确处理上下文取消信号，即可充分发挥超时打断功能。
 		// @receiver s: sSystemCron的实例，代表一个调度系统。
 		// @param typ: 任务的类型，决定该任务将被添加到哪个列表中。对应不同的时间间隔。
 		// @param _func: 要添加的任务函数，该函数执行时应该返回一个error。
+		// deprecated: 弃用，请使用 AddCronV2
 		AddCron(typ v1.CronType, _func func() error)
+		// AddCronV2  添加一个定时任务到相应的调度列表中。
+		//
+		// @Description: 根据指定的类型将函数添加到不同的任务列表中，以供后续执行。
+		// @receiver s: sSystemCron的实例，代表一个调度系统。
+		// @param typ: 任务的类型，决定该任务将被添加到哪个列表中。对应不同的时间间隔。
+		// @param _func: 要添加的任务函数，该函数执行时应该返回一个error。
+		AddCronV2(typ v1.CronType, _func func(context.Context) error)
 		// StartCron 开始计划任务执行
 		//
 		//	@Description:
 		//	@receiver s
 		//	@return err
 		StartCron() (err error)
+		// AddFuncChan 添加方法到通道
+		AddFuncChan(list []func(context.Context) error)
+		// RunFuncChan 统一执行方法
+		RunFuncChan()
+		// RunFunc 统一执行方法
+		// deprecated: 弃用，会造成周期任务并发执行，to service.SystemCron().AddFuncChan
+		RunFunc(list []func() error)
 	}
 )
 

tools/random.go

@@ -1,6 +1,8 @@
 package tools
 
 import (
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/grand"
 	"math/rand"
 	"time"
 )
@@ -50,3 +52,73 @@ func (m *randMod) RandomAll(data map[int]int, n int) []int {
 	}
 	return result
 }
+
+func RandomAll[t Any](data map[t]int, n int) []t {
+	if n > len(data) {
+		n = len(data)
+	}
+	rand.Seed(time.Now().UnixNano())
+	// 复制权重映射，避免修改原始数据
+	remainingWeights := make(map[t]int)
+	for k, v := range data {
+		remainingWeights[k] = v
+	}
+	result := make([]t, 0, n)
+
+	for i := 0; i < n; i++ {
+		totalWeight := 0
+		// 计算剩余元素的总权重
+		for _, weight := range remainingWeights {
+			totalWeight += weight
+		}
+		if totalWeight == 0 {
+			break
+		}
+		// 生成一个 0 到总权重之间的随机数
+		randomNum := rand.Intn(totalWeight)
+		currentWeight := 0
+		for key, weight := range remainingWeights {
+			currentWeight += weight
+			if randomNum < currentWeight {
+				// 将选中的元素添加到结果切片中
+				result = append(result, key)
+				// 从剩余权重映射中移除选中的元素
+				delete(remainingWeights, key)
+				break
+			}
+		}
+	}
+	return result
+}
+
+// RandByArrInt 根据传入的 interface 切片中的整数值按权重随机返回一个索引
+// 参数 s: 一个包含整数的 interface 切片，切片中的每个元素代表一个权重
+// 返回值: 随机选中的元素的索引
+func (m *randMod) RandByArrInt(_s interface{}) int {
+	// 初始化总权重为 0
+	sv := 0
+	s := gconv.Ints(_s)
+
+	// 遍历切片，累加每个元素的权重
+	for i := range s {
+		sv += gconv.Int(s[i])
+	}
+	if sv < 1 {
+		return 0
+	}
+
+	// 使用 grand.Intn 生成一个 0 到总权重之间的随机数
+	r := grand.Intn(sv)
+	// 初始化当前累加的权重为 0
+	var all int
+	// 再次遍历切片，累加权重
+	for i := range s {
+		all += s[i]
+		// 如果当前累加的权重大于随机数，则返回当前索引
+		if all > r {
+			return i
+		}
+	}
+	// 如果没有找到符合条件的索引，返回 0
+	return 0
+}

tools/redis.go

@@ -14,7 +14,7 @@ type redis struct {
 }
 
 func (r *redis) Load() {
-	g.Log().Debugf(gctx.New(), "初始化工具类")
+	g.Log().Debugf(gctx.New(), "初始化redis工具类")
 	if Redis == nil {
 		Redis = &redis{}
 	}

tools/time.go

@@ -121,3 +121,10 @@ func (m *timeMod) GetDailyTimeList(time1 time.Time, time2 time.Time) (timeList [
 	}
 	return
 }
+
+// ExcelTime2Time excel时间转时间 (12/10/24 02:03转为时间)
+func (m *timeMod) ExcelTime2Time(excelTime string) time.Time {
+	layout := "1/2/06 15:04" // 月/日/年(最后两位) 小时:分钟 (24小时制)
+	timeNew, _ := time.ParseInLocation(layout, excelTime, time.Local)
+	return timeNew
+}

tools/tools.go

@@ -1,6 +1,8 @@
 package tools
 
 import (
+	"encoding/json"
+	"github.com/ayflying/utility_go/internal/boot"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gctx"
 	"github.com/gogf/gf/v2/os/gtime"
@@ -18,9 +20,9 @@ type Number interface {
 	int | int64 | int32 | int16 | uint64 | uint32 | uint16 | float32 | float64
 }
 
-//type Any interface {
+type Any interface {
-//	interface{} | string | int | int64 | int32 | int16 | uint64 | uint32 | uint16 | float32 | float64
+	string | int | int64 | int32 | int16 | uint64 | uint32 | uint16 | float32 | float64
-//}
+}
 
 type toolsInterface interface {
 	Load()
@@ -30,15 +32,17 @@ type tools struct {
 }
 
 func init() {
-	g.Log().Debugf(gctx.New(), "初始化工具类")
+	boot.AddFunc(func() {
+		g.Log().Debugf(gctx.New(), "初始化tools工具类")
 
-	names := []toolsInterface{
+		names := []toolsInterface{
-		Tools,
+			Tools,
-	}
+		}
-	for _, v := range names {
+		for _, v := range names {
-		v.Load()
+			v.Load()
-	}
+		}
 
+	})
 }
 
 func (m *tools) Load() {
@@ -124,11 +128,11 @@ func (m *tools) Items2Map(items [][]int64) (list map[int64]int64) {
 // 该函数通过遍历切片，从后向前检查每个元素，如果找到与指定值相等的元素，则将其从切片中移除。
 // 这种从后向前的遍历方法可以避免因移除元素而导致的数组重新排列带来的额外计算。
 // RemoveSlice 删除切片中的某个值
-func RemoveSlice[t Number](slice []t, value ...t) []t {
+func RemoveSlice[t Any](slice []t, value ...t) []t {
 	// 从后向前遍历切片
 	for i := len(slice) - 1; i >= 0; i-- {
 		// 检查当前元素是否等于需要移除的值
-		if InArray(slice[i], value) {
+		if InArray[t](value, slice[i]) {
 			// 如果相等，移除该元素
 			// 使用append和切片操作符来实现移除操作，将i之前和i之后的元素合并到一起
 			slice = append(slice[:i], slice[i+1:]...)
@@ -145,7 +149,7 @@ func RemoveSlice[t Number](slice []t, value ...t) []t {
 //	@param value 需要查找的值
 //	@param array 进行查找的切片
 //	@return bool 返回是否存在
-func InArray[t Number](value t, array []t) bool {
+func InArray[t Any](array []t, value t) bool {
 	for _, v := range array {
 		if v == value {
 			return true
@@ -253,3 +257,33 @@ func (m *tools) ItemsMerge(_items ...[][]int64) [][]int64 {
 	}
 	return items
 }
+
+// ProcessingMap 处理map
+// 该函数用于递归处理一个键为字符串、值为int64的map。
+// 如果键是一个JSON字符串，会尝试将其解析为一个新的map，并递归处理这个新的map。
+// 最终返回一个处理后的map，其中所有键都是非JSON字符串。
+func (m *tools) ProcessingMap(data map[string]int64) map[string]int64 {
+	// 创建一个临时map，用于存储处理后的键值对
+	var temp = make(map[string]int64)
+	// 遍历输入的map
+	for k, v := range data {
+		// 创建一个新的map，用于存储解析后的JSON数据
+		data_k := make(map[string]int64)
+		// 尝试将键解析为JSON数据
+		err := json.Unmarshal([]byte(k), &data_k)
+		// 如果解析成功
+		if err == nil {
+			// 递归处理解析后的map
+			data_kmap := m.ProcessingMap(data_k)
+			// 返回处理后的map
+			// 如果解析失败，直接将原键值对添加到临时map中
+			// 将递归处理后的结果合并到临时map中
+			for k_k, k_v := range data_kmap {
+				temp[k_k] = k_v
+			}
+		} else {
+			temp[k] = v
+		}
+	}
+	return temp
+}

utility.go

@@ -1,17 +1,11 @@
 package utility_go
 
 import (
-	_ "github.com/ayflying/utility_go/internal/logic"
-
-	"context"
-	"time"
-
-	v1 "github.com/ayflying/utility_go/api/system/v1"
-	"github.com/ayflying/utility_go/service"
-	"github.com/gogf/gf/v2/os/gctx"
-	"github.com/gogf/gf/v2/os/gtimer"
-
 	"github.com/ayflying/utility_go/config"
+	"github.com/ayflying/utility_go/internal/boot"
+	_ "github.com/ayflying/utility_go/internal/logic"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gctx"
 )
 
 var (
@@ -20,14 +14,12 @@ var (
 )
 
 func init() {
-	service.SystemCron().StartCron()
+	g.Log().Debug(ctx, "utility_go init启动完成")
+	// 初始化配置
+	var err = boot.Boot()
 
-	//用户活动持久化
+	if err != nil {
-	gtimer.SetTimeout(ctx, time.Minute, func(ctx context.Context) {
+		panic(err)
-		service.SystemCron().AddCron(v1.CronType_DAILY, func() error {
+	}
-			service.GameAct().Saves()
-			return nil
-		})
-	})
 
 }

utility_test.go

@@ -0,0 +1,66 @@
+package utility_go_test
+
+import (
+	//_ "github.com/ayflying/utility_go/internal/logic"
+
+	"github.com/ayflying/utility_go/internal/boot"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/gctx"
+	"testing"
+)
+
+var (
+	ctx = gctx.GetInitCtx()
+)
+
+func TestInit(t *testing.T) {
+	g.Log().Debug(ctx, "开始调试了")
+	// 初始化配置
+	var err = boot.Boot()
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+//
+//func TestLoadConfig(t *testing.T) {
+//
+//	tests := []struct {
+//		name     string
+//		filePath string
+//		wantErr  bool
+//	}{
+//		{
+//			name:     "valid config file",
+//			filePath: "testdata/valid_config.json",
+//			wantErr:  false,
+//		},
+//		{
+//			name:     "non-existent file",
+//			filePath: "nonexistent.json",
+//			wantErr:  true,
+//		},
+//		{
+//			name:     "invalid config format",
+//			filePath: "testdata/invalid_config.json",
+//			wantErr:  true,
+//		},
+//		{
+//			name:     "empty file path",
+//			filePath: "",
+//			wantErr:  true,
+//		},
+//	}
+//
+//	for _, tt := range tests {
+//		t.Run(tt.name, func(t *testing.T) {
+//
+//			_, err := config.Load(tt.filePath)
+//			if tt.wantErr {
+//				assert.Error(t, err)
+//			} else {
+//				assert.NoError(t, err)
+//			}
+//		})
+//	}
+//}