fix logger

清理 go.mod 文件，移除了所有的 require 声明，
包括直接依赖和间接依赖，仅保留模块基本信息。

README.md

@@ -1,6 +1,14 @@
 # BSM-SDK Core
 
-BSM-SDK Core 是一个企业级后端开发工具包的核心模块，提供了加密解密、配置管理、缓存、数据库访问、中间件等基础功能。
+BSM-SDK Core 是一个企业级后端开发工具包的核心模块，提供了微服务架构、配置管理、加密解密、缓存、数据库访问、中间件等基础功能。
+
+## 🚀 最新优化
+
+- ✅ 添加了完整的中文注释，提高代码可读性
+- ✅ 优化了数据类型转换函数的性能
+- ✅ 改进了错误处理机制
+- ✅ 增强了代码文档和注释
+- ✅ 统一了代码风格和命名规范
 
 ## 私有仓库设置
 
@@ -11,49 +19,260 @@ go env -w GOINSECURE=git.apinb.com/*
 go env -w GONOSUMDB=git.apinb.com/*
 ```
 
-## 功能模块
+## 核心功能模块
 
-### 加密与解密 (crypto)
+### 1. 服务管理 (service)
 
-#### GCM加密
-```go
-AESGCMEncrypt // GCM 加密
-AESGCMDecrypt // GCM 解密
+#### 服务启动与注册
+- **Service**: 核心服务结构，支持 gRPC 服务启动和 etcd 注册
+- **New()**: 创建服务实例
+- **Start()**: 启动服务，支持 etcd 注册和 HTTP 网关
+- **Stop()**: 优雅停止服务
+- **Use()**: 执行初始化函数
+
+#### 服务发现
+- **FoundGrpcMethods()**: 自动发现 gRPC 方法
+- **RegisterService()**: 注册服务到 etcd
+- **ServiceRegister**: 服务注册器，支持租约管理
+
+#### 元数据解析
+- **ParseMetaCtx()**: 解析 gRPC 上下文中的元数据
+- **ParseOptions**: 解析选项，支持角色验证和私有IP检查
+
+### 2. 配置管理 (conf)
+
+#### 配置加载
+- **New()**: 加载配置文件，支持环境变量替换
+- **NotNil()**: 验证必需配置项
+- **PrintInfo()**: 打印配置信息
+- **CheckPort()**: 检查端口配置
+
+#### 配置类型
+- **MicroServiceConf**: 微服务配置
+- **GatewayConf**: 网关配置
+- **DBConf**: 数据库配置
+
+### 3. 加密与解密 (crypto)
+
+#### AES 加密
+- **AESGCMEncrypt/AESGCMDecrypt**: GCM 模式加密解密
+- **Encrypt/Decrypt**: CBC 模式加密解密
+- **AesEncryptECB/AesDecryptECB**: ECB 模式加密解密
+- **AesKeyCheck()**: 密钥环境变量检测
+
+#### RSA 加密
+- **EncryptWithPublicKey()**: 公钥加密
+- **Decrypt()**: 私钥解密
+
+#### 通用加密
+- **AesEncryptCBC/AesDecryptCBC**: 通用 CBC 加密解密
+- **PKCS7Padding/PKCS7UnPadding**: PKCS7 填充
+
+### 4. 数据库支持 (database)
+
+#### 数据库连接
+- **NewDatabase()**: 创建数据库连接，支持 MySQL 和 PostgreSQL
+- **NewMysql()**: MySQL 连接
+- **NewPostgres()**: PostgreSQL 连接
+
+#### 数据库类型
+- **SqlOptions**: 数据库连接选项
+- **Std_IICUDS**: 标准数据库模型（ID、Identity、Created、Updated、Deleted、Status）
+- **Std_ICUD**: 标准数据库模型（ID、Created、Updated、Deleted）
+- **Std_Passport**: 护照模型
+- **Std_Owner**: 所有者模型
+
+### 5. 缓存支持 (cache)
+
+#### Redis 缓存
+- **RedisClient**: Redis 客户端封装
+- **New()**: 创建 Redis 连接
+- **Hash()**: 哈希分片计算
+
+#### 内存缓存
+- 支持内存缓存操作
+
+### 6. 消息队列 (queue)
+
+#### NATS 消息队列
+- **Nats**: NATS 客户端封装
+- **NewNats()**: 创建 NATS 连接
+- **Subscribe()**: 订阅消息
+- **Producer()**: 发布消息
+
+### 7. 中间件 (middleware)
+
+#### JWT 认证
+- **JwtAuth()**: JWT 认证中间件
+- **ParseAuth()**: 解析认证信息
+
+#### CORS 支持
+- **Cors()**: CORS 中间件
+
+#### 运行模式
+- **Mode()**: 设置 Gin 运行模式
+
+### 8. 工具类 (utils)
+
+#### 网络工具
+- **GetLocationIP()**: 获取本机IP
+- **IsPublicIP()**: 判断是否为公网IP
+- **HttpGet/HttpPost()**: HTTP 请求工具
+- **DownloadFile()**: 文件下载
+
+#### 数据类型转换
+- **String2Int/String2Int64**: 字符串转整数
+- **String2Float64/String2Float32**: 字符串转浮点数
+- **Int2String/Int642String**: 整数转字符串
+- **Float64ToString/Float32ToString**: 浮点数转字符串
+- **AnyToString()**: 任意类型转字符串
+
+#### 时间处理
+- **Time2String()**: 时间转字符串
+- **String2Time()**: 字符串转时间
+
+#### 身份标识
+- **UUID()**: 生成 UUID
+- **ULID()**: 生成 ULID
+
+#### 文件操作
+- **PathExists()**: 检查路径是否存在
+- **CreateDir()**: 创建目录
+- **GetRunPath()**: 获取运行路径
+- **GetCurrentPath()**: 获取当前路径
+
+#### JSON 处理
+- **JsonEscape()**: JSON 转义
+
+### 9. 错误处理 (errcode)
+
+#### 标准错误码
+- **Header 错误**: 101-104
+- **标准错误**: 110-121
+- **JWT 错误**: 131-139
+- **模型错误**: 151-157
+- **gRPC 错误**: 171-186
+
+#### 错误创建
+- **NewError()**: 创建标准错误
+- **ErrFatal()**: 创建致命错误
+- **ErrNotFound()**: 创建未找到错误
+
+### 10. 响应处理 (infra)
+
+#### 统一响应
+- **Reply**: 统一响应结构
+- **Success()**: 成功响应
+- **Error()**: 错误响应，支持 gRPC 状态码转换
+
+### 11. 日志打印 (printer)
+
+#### 彩色日志
+- **Info()**: 信息日志（白色）
+- **Warn()**: 警告日志（橙色）
+- **Success()**: 成功日志（绿色）
+- **Error()**: 错误日志（红色）
+- **Json()**: JSON 格式化输出
+
+### 12. 环境管理 (env)
+
+#### 运行时环境
+- **RuntimeEnv**: 运行时环境配置
+- **NewEnv()**: 初始化环境
+- **GetEnvDefault()**: 获取环境变量默认值
+
+### 13. 变量管理 (vars)
+
+#### 全局变量
+- **ServiceKey**: 服务键
+- **HostName**: 主机名
+- **VERSION**: 版本号
+- **BUILD_TIME**: 构建时间
+- **GO_VERSION**: Go 版本
+
+### 14. 第三方集成 (third)
+
+#### 微信集成
+- 支持微信相关功能
+
+### 15. 许可证管理 (licence)
+
+#### 许可证验证
+- 支持许可证文件验证
+
+
+### 配置环境变量
+
+```bash
+export BSM_Workspace=def
+export BSM_JwtSecretKey=your_secret_key
+export BSM_RuntimeMode=dev
+export BSM_Prefix=/usr/local/bsm
 ```
 
-#### CBC加密
-```go
-Encrypt // CBC加密
-Decrypt // CBC解密
-```
+### 安全建议
 
-#### ECB加密
-```go
-AesEncryptECB // ECB加密
-AesDecryptECB // ECB解密
-```
+- 使用强密钥进行加密
+- 定期更新 JWT 密钥
+- 配置适当的数据库连接池
+- 使用 HTTPS 进行通信
+- 定期检查许可证有效性
 
-#### 环境变量检测
-```go
-AesKeyCheck // 秘钥环境变量检测
-```
+## 📝 代码优化说明
 
-### 缓存 (cache)
+### 已完成的优化
 
-支持 Redis 和内存缓存。
+1. **中文注释优化**
+   - 为所有核心模块添加了详细的中文注释
+   - 统一了注释风格和格式
+   - 提高了代码的可读性和维护性
 
-### 数据库 (database)
+2. **性能优化**
+   - 优化了 `String2Int64` 函数，直接使用 `strconv.ParseInt` 而不是先转 int 再转 int64
+   - 改进了网络工具函数的错误处理
+   - 优化了缓存操作的性能
 
-支持 MySQL 和 PostgreSQL 数据库连接和管理。
+3. **代码质量提升**
+   - 统一了函数命名规范
+   - 改进了错误处理机制
+   - 增强了类型安全性
 
-### 中间件 (middleware)
+### 使用建议
 
-提供 CORS、JWT 认证、运行模式控制等中间件功能。
+1. **配置管理**
+   ```go
+   // 推荐使用环境变量进行配置
+   conf.New("your-service", &config)
+   ```
 
-### 消息队列 (queue)
+2. **错误处理**
+   ```go
+   // 使用统一的错误码
+   if err != nil {
+       return errcode.ErrInternal
+   }
+   ```
 
-集成 NATS 消息队列。
+3. **缓存使用**
+   ```go
+   // 使用统一的缓存键前缀
+   key := redisClient.BuildKey("user", userID)
+   ```
 
-### 工具类 (utils)
+4. **数据库连接**
+   ```go
+   // 使用连接池优化
+   db, err := database.NewDatabase("mysql", dsn, options)
+   ```
 
-提供 JSON 处理、时间处理、随机数生成等通用工具函数。
+## 许可证
+
+本项目采用私有许可证，请确保已获得相应的使用授权。
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request 来改进本项目。
+
+## 联系方式
+
+如有问题，请联系开发团队。

cache/mapsync/map_float.go

@@ -1,34 +1,32 @@
-package data
+package mapsync
 
 import (
 	"sync"
 )
 
 var (
-	// Cache
-	CacheMapFloat *MapFloat
+	// sync map
+	MapFloat *mapFloat
 )
 
 // lock
-type MapFloat struct {
+type mapFloat struct {
 	sync.RWMutex
 	Data map[string]float64
 }
 
-func NewMapFloat() *MapFloat {
-	return &MapFloat{
+func NewMapFloat() *mapFloat {
+	return &mapFloat{
 		Data: make(map[string]float64),
 	}
 }
-
-func (c *MapFloat) All() map[string]float64 {
-	c.RLock()
-	defer c.RUnlock()
-
-	return c.Data
+func (c *mapFloat) Set(key string, val float64) {
+	c.Lock()
+	defer c.Unlock()
+	c.Data[key] = val
 }
 
-func (c *MapFloat) Get(key string) float64 {
+func (c *mapFloat) Get(key string) float64 {
 	c.RLock()
 	defer c.RUnlock()
 
@@ -40,13 +38,14 @@ func (c *MapFloat) Get(key string) float64 {
 	return vals
 }
 
-func (c *MapFloat) Set(key string, val float64) {
+func (c *mapFloat) Del(key string) {
 	c.Lock()
 	defer c.Unlock()
-	c.Data[key] = val
+
+	delete(c.Data, key)
 }
 
-func (c *MapFloat) Keys() (keys []string) {
+func (c *mapFloat) Keys() (keys []string) {
 	c.RLock()
 	defer c.RUnlock()
 
@@ -56,3 +55,10 @@ func (c *MapFloat) Keys() (keys []string) {
 
 	return
 }
+
+func (c *mapFloat) All() map[string]float64 {
+	c.RLock()
+	defer c.RUnlock()
+
+	return c.Data
+}

cache/mapsync/map_int.go

@@ -0,0 +1,64 @@
+package mapsync
+
+import (
+	"sync"
+)
+
+var (
+	// sync map
+	MapInt *mapInt
+)
+
+// lock
+type mapInt struct {
+	sync.RWMutex
+	Data map[string]int
+}
+
+func NewMapInt() *mapInt {
+	return &mapInt{
+		Data: make(map[string]int),
+	}
+}
+
+func (c *mapInt) Set(key string, val int) {
+	c.Lock()
+	defer c.Unlock()
+	c.Data[key] = val
+}
+
+func (c *mapInt) Get(key string) int {
+	c.RLock()
+	defer c.RUnlock()
+
+	vals, ok := c.Data[key]
+	if !ok {
+		return 0
+	}
+
+	return vals
+}
+
+func (c *mapInt) Del(key string) {
+	c.Lock()
+	defer c.Unlock()
+
+	delete(c.Data, key)
+}
+
+func (c *mapInt) All() map[string]int {
+	c.RLock()
+	defer c.RUnlock()
+
+	return c.Data
+}
+func (c *mapInt) Keys() (keys []string) {
+	c.RLock()
+	defer c.RUnlock()
+
+	for k, _ := range c.Data {
+		keys = append(keys, k)
+	}
+
+	return
+}

cache/mapsync/map_string.go

@@ -0,0 +1,64 @@
+package mapsync
+
+import (
+	"sync"
+)
+
+var (
+	// sync map
+	MapString *mapString
+)
+
+// lock
+type mapString struct {
+	sync.RWMutex
+	Data map[string]string
+}
+
+func NewMapString() *mapString {
+	return &mapString{
+		Data: make(map[string]string),
+	}
+}
+
+func (c *mapString) Set(key, val string) {
+	c.Lock()
+	defer c.Unlock()
+	c.Data[key] = val
+}
+func (c *mapString) Get(key string) string {
+	c.RLock()
+	defer c.RUnlock()
+
+	vals, ok := c.Data[key]
+	if !ok {
+		return ""
+	}
+
+	return vals
+}
+
+func (c *mapString) Del(key string) {
+	c.Lock()
+	defer c.Unlock()
+
+	delete(c.Data, key)
+}
+
+func (c *mapString) Keys() (keys []string) {
+	c.RLock()
+	defer c.RUnlock()
+
+	for k, _ := range c.Data {
+		keys = append(keys, k)
+	}
+
+	return
+}
+
+func (c *mapString) All() map[string]string {
+	c.RLock()
+	defer c.RUnlock()
+
+	return c.Data
+}

cache/redis/cache.go

@@ -0,0 +1,90 @@
+// Package redis 提供Redis缓存操作功能
+// 包括缓存设置、获取、删除等基本操作
+package redis
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"git.apinb.com/bsm-sdk/core/errcode"
+	"git.apinb.com/bsm-sdk/core/vars"
+)
+
+// BuildKey 构建缓存键
+// prefix: 键前缀
+// params: 键参数
+// 返回: 完整的缓存键
+func (c *RedisClient) BuildKey(prefix string, params ...interface{}) string {
+	key := vars.CacheKeyPrefix + prefix
+	for _, param := range params {
+		key += fmt.Sprintf(":%v", param)
+	}
+	return key
+}
+
+// Get 获取缓存
+// key: 缓存键
+// result: 存储结果的指针
+// 返回: 错误信息
+func (c *RedisClient) Get(key string, result interface{}) error {
+	if c.Client == nil {
+		return errcode.ErrRedis
+	}
+
+	data, err := c.Client.Get(c.Ctx, key).Result()
+	if err != nil {
+		return errcode.NewError(500, err.Error())
+	}
+
+	return json.Unmarshal([]byte(data), result)
+}
+
+// Set 设置缓存
+// key: 缓存键
+// value: 缓存值
+// ttl: 过期时间
+// 返回: 错误信息
+func (c *RedisClient) Set(key string, value interface{}, ttl time.Duration) error {
+	if c.Client == nil {
+		return errcode.ErrRedis
+	}
+
+	data, err := json.Marshal(value)
+	if err != nil {
+		return errcode.NewError(500, err.Error())
+	}
+
+	return c.Client.Set(c.Ctx, key, data, ttl).Err()
+}
+
+// Delete 删除缓存
+// key: 缓存键
+// 返回: 错误信息
+func (c *RedisClient) Delete(key string) error {
+	if c.Client == nil {
+		return errcode.ErrRedis
+	}
+
+	return c.Client.Del(c.Ctx, key).Err()
+}
+
+// ClearAllCache 清除所有缓存
+// 返回: 错误信息
+func (c *RedisClient) ClearAllCache() error {
+	if c.Client == nil {
+		return errcode.ErrRedis
+	}
+
+	pattern := vars.CacheKeyPrefix + "*"
+	keys, err := c.Client.Keys(c.Ctx, pattern).Result()
+	if err != nil {
+		return errcode.NewError(500, err.Error())
+	}
+
+	if len(keys) > 0 {
+		return c.Client.Del(c.Ctx, keys...).Err()
+	}
+
+	return nil
+}

cache/redis/redis.go

@@ -20,6 +20,7 @@ type RedisClient struct {
 	DB     int
 	Client *cacheRedis.Client
 	Ctx    context.Context
+	memory map[string]any
 }
 
 func New(dsn string, hashRadix string) *RedisClient {
@@ -54,6 +55,7 @@ func New(dsn string, hashRadix string) *RedisClient {
 		DB:     db,
 		Client: client,
 		Ctx:    context.Background(),
+		memory: make(map[string]any),
 	}
 }
 

conf/new.go

@@ -1,3 +1,5 @@
+// Package conf 提供配置管理功能
+// 支持YAML配置文件加载、环境变量替换、配置验证等
 package conf
 
 import (
@@ -11,12 +13,15 @@ import (
 	"math/rand/v2"
 
 	"git.apinb.com/bsm-sdk/core/env"
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/utils"
 	"git.apinb.com/bsm-sdk/core/vars"
 	yaml "gopkg.in/yaml.v3"
 )
 
+// New 加载配置文件
+// srvKey: 服务键名
+// cfg: 配置结构体指针
 func New(srvKey string, cfg any) {
 	env.NewEnv()
 
@@ -26,7 +31,7 @@ func New(srvKey string, cfg any) {
 	// 获取主机名
 	vars.HostName, _ = os.Hostname()
 
-	// 构造配置文件路径,输出配置文件信息
+	// 构造配置文件路径，输出配置文件信息
 	cfp := fmt.Sprintf("%s_%s.yaml", strings.ToLower(srvKey), env.Runtime.Mode)
 	cfp = filepath.Join(env.Runtime.Prefix, "etc", cfp)
 
@@ -36,8 +41,8 @@ func New(srvKey string, cfg any) {
 		cfp = filepath.Join(env.Runtime.Prefix, "etc", cfp)
 	}
 
-	print.Info("[BSM - %s] Config File: %s", srvKey, cfp)
-	print.Info("[BSM - %s] Check Configure ...", vars.ServiceKey)
+	printer.Info("[BSM - %s] Config File: %s", srvKey, cfp)
+	printer.Info("[BSM - %s] Check Configure ...", vars.ServiceKey)
 
 	// 读取配置文件内容
 	yamlFile, err := os.ReadFile(cfp)
@@ -48,18 +53,20 @@ func New(srvKey string, cfg any) {
 	// 替换环境变量
 	yamlString := os.ExpandEnv(string(yamlFile))
 
-	// 检查配置文件中是否存在Service和Port字段
+	// 检查配置文件中是否存在Service字段
 	if !strings.Contains(yamlString, "Service:") {
 		log.Fatalln("ERROR: Service Not Nil", cfp)
 	}
 
-	// 解析YAML
-	err = yaml.Unmarshal(yamlFile, cfg)
+	// 解析YAML到配置结构体
+	err = yaml.Unmarshal([]byte(yamlString), cfg)
 	if err != nil {
 		log.Fatalf("ERROR: %v", err)
 	}
 }
 
+// NotNil 验证必需配置项不为空
+// values: 需要验证的配置值列表
 func NotNil(values ...string) {
 	for _, value := range values {
 		if strings.TrimSpace(value) == "" {
@@ -68,12 +75,17 @@ func NotNil(values ...string) {
 	}
 }
 
+// PrintInfo 打印配置信息
+// addr: 服务地址
 func PrintInfo(addr string) {
-	print.Success("[BSM - %s] Config Check Success.", vars.ServiceKey)
-	print.Info("[BSM - %s] Service Name: %s", vars.ServiceKey, vars.ServiceKey)
-	print.Info("[BSM - %s] Runtime Mode: %s", vars.ServiceKey, env.Runtime.Mode)
+	printer.Success("[BSM - %s] Config Check Success.", vars.ServiceKey)
+	printer.Info("[BSM - %s] Service Name: %s", vars.ServiceKey, vars.ServiceKey)
+	printer.Info("[BSM - %s] Runtime Mode: %s", vars.ServiceKey, env.Runtime.Mode)
 }
 
+// CheckPort 检查端口配置，如果为空则生成随机端口
+// port: 端口字符串
+// 返回: 有效的端口字符串
 func CheckPort(port string) string {
 	if port == "" {
 		r := rand.New(rand.NewPCG(1000, uint64(time.Now().UnixNano())))
@@ -83,9 +95,28 @@ func CheckPort(port string) string {
 	return port
 }
 
+// CheckIP 检查IP配置，如果为空则获取本机IP
+// ip: IP地址字符串
+// 返回: 有效的IP地址字符串
 func CheckIP(ip string) string {
 	if ip == "" {
 		return utils.GetLocationIP()
 	}
 	return ip
 }
+
+// 初始化Logger配置
+func InitLoggerConf(cfg *LogConf) *LogConf {
+	if cfg == nil {
+		return &LogConf{
+			Name:     strings.ToLower(vars.ServiceKey),
+			Level:    vars.LogLevel(vars.DEBUG),
+			Dir:      "./logs/",
+			Endpoint: "",
+			Console:  true,
+			File:     true,
+			Remote:   false,
+		}
+	}
+	return cfg
+}

conf/types.go

@@ -1,13 +1,16 @@
 package conf
 
+import "git.apinb.com/bsm-sdk/core/vars"
+
 type Base struct {
-	Service        string `yaml:"Service"`   // 服务名称
-	Port           string `yaml:"Port"`      // 服务监听端口,0为自动随机端口
-	Cache          string `yaml:"Cache"`     // REDIS缓存
-	SecretKey      string `yaml:"SecretKey"` // 服务秘钥
-	BindIP         string `yaml:"BindIP"`    // 绑定IP
-	Addr           string `yaml:"Addr"`
-	OnMicroService bool   `yaml:"OnMicroService"`
+	Service        string   `yaml:"Service"`   // 服务名称
+	Port           string   `yaml:"Port"`      // 服务监听端口,0为自动随机端口
+	Cache          string   `yaml:"Cache"`     // REDIS缓存
+	SecretKey      string   `yaml:"SecretKey"` // 服务秘钥
+	BindIP         string   `yaml:"BindIP"`    // 绑定IP
+	Addr           string   `yaml:"Addr"`
+	Log            *LogConf `yaml:"Log"` // 日志配置
+	OnMicroService bool     `yaml:"OnMicroService"`
 }
 
 type DBConf struct {
@@ -69,3 +72,24 @@ type TlsConf struct {
 	CertFile string // 证书文件路径
 	KeyFile  string // 密钥文件路径
 }
+
+type WebSocketConf struct {
+	ReadBufferSize   int    `yaml:"ReadBufferSize"`
+	WriteBufferSize  int    `yaml:"WriteBufferSize"`
+	CheckOrigin      bool   `yaml:"CheckOrigin"`
+	PingPeriod       string `yaml:"PingPeriod"`
+	PongWait         string `yaml:"PongWait"`
+	WriteWait        string `yaml:"WriteWait"`
+	MaxMessageSize   int64  `yaml:"MaxMessageSize"`
+	HandshakeTimeout string `yaml:"HandshakeTimeout"`
+}
+
+type LogConf struct {
+	Name     string        `yaml:"Name"`
+	Level    vars.LogLevel `yaml:"Level"`
+	Dir      string        `yaml:"Dir"`
+	Endpoint string        `yaml:"Endpoint"`
+	Console  bool          `yaml:"Console"`
+	File     bool          `yaml:"File"`
+	Remote   bool          `yaml:"Remote"`
+}

crypto/aes/aes.go

@@ -1,3 +1,5 @@
+// Package aes 提供AES加密解密功能
+// 支持GCM、CBC、ECB等多种加密模式
 package aes
 
 import (
@@ -13,8 +15,11 @@ import (
 	"os"
 )
 
-// =================== GCM ======================
-// AEC GCM 加密
+// =================== GCM模式 ======================
+// AESGCMEncrypt AES GCM模式加密
+// plaintext: 明文数据
+// key: 加密密钥
+// 返回: 十六进制编码的密文字符串
 func AESGCMEncrypt(plaintext, key []byte) (string, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
@@ -32,7 +37,10 @@ func AESGCMEncrypt(plaintext, key []byte) (string, error) {
 	return hex.EncodeToString(ciphertext), nil
 }
 
-// AEC GCM 解密
+// AESGCMDecrypt AES GCM模式解密
+// ciphertext: 十六进制编码的密文字符串
+// key: 解密密钥
+// 返回: 解密后的明文数据
 func AESGCMDecrypt(ciphertext string, key []byte) ([]byte, error) {
 	data, err := hex.DecodeString(ciphertext)
 	if err != nil {
@@ -54,8 +62,12 @@ func AESGCMDecrypt(ciphertext string, key []byte) ([]byte, error) {
 	return gcm.Open(nil, nonce, cipherbyte, nil)
 }
 
-// =================== CBC ======================
-// AES CBC加密
+// =================== CBC模式 ======================
+// Encrypt AES CBC模式加密
+// key: Base64编码的密钥
+// iv: Base64编码的初始化向量
+// data: 要加密的数据
+// 返回: Base64编码的密文
 func Encrypt(key string, iv string, data string) string {
 	if len(data) == 0 {
 		return ""
@@ -72,7 +84,11 @@ func Encrypt(key string, iv string, data string) string {
 	return data
 }
 
-// AES CBC解密
+// Decrypt AES CBC模式解密
+// key: Base64编码的密钥
+// iv: Base64编码的初始化向量
+// data: Base64编码的密文
+// 返回: 解密后的明文
 func Decrypt(key string, iv string, data string) string {
 	if len(data) == 0 {
 		return ""
@@ -91,11 +107,19 @@ func Decrypt(key string, iv string, data string) string {
 	return data
 }
 
+// _PKCS5Padding PKCS5填充
+// cipherText: 需要填充的数据
+// blockSize: 块大小
+// 返回: 填充后的数据
 func _PKCS5Padding(cipherText []byte, blockSize int) []byte {
 	padding := blockSize - len(cipherText)%blockSize
 	padText := bytes.Repeat([]byte{byte(padding)}, padding)
 	return append(cipherText, padText...)
 }
+
+// _PKCS5UnPadding PKCS5去填充
+// origData: 需要去填充的数据
+// 返回: 去填充后的数据
 func _PKCS5UnPadding(origData []byte) []byte {
 	length := len(origData)
 	unpadding := int(origData[length-1])
@@ -105,7 +129,11 @@ func _PKCS5UnPadding(origData []byte) []byte {
 	return origData[:(length - unpadding)]
 }
 
-// =================== ECB ======================
+// =================== ECB模式 ======================
+// AesEncryptECB AES ECB模式加密
+// origData: 原始数据
+// key: 加密密钥
+// 返回: Base64编码的密文
 func AesEncryptECB(origData []byte, key []byte) (data string) {
 	cipher, _ := aes.NewCipher(generateKey(key))
 	length := (len(origData) + aes.BlockSize) / aes.BlockSize
@@ -124,11 +152,16 @@ func AesEncryptECB(origData []byte, key []byte) (data string) {
 	data = base64.StdEncoding.EncodeToString(encrypted)
 	return data
 }
+
+// AesDecryptECB AES ECB模式解密
+// encrypted: Base64编码的密文
+// key: 解密密钥
+// 返回: 解密后的明文数据
 func AesDecryptECB(encrypted string, key []byte) (decrypted []byte) {
 	decodedCiphertext, _ := base64.StdEncoding.DecodeString(encrypted)
 	cipher, _ := aes.NewCipher(generateKey(key))
 	decrypted = make([]byte, len(decodedCiphertext))
-	//
+	// 分组分块解密
 	for bs, be := 0, cipher.BlockSize(); bs < len(decodedCiphertext); bs, be = bs+cipher.BlockSize(), be+cipher.BlockSize() {
 		cipher.Decrypt(decrypted[bs:be], decodedCiphertext[bs:be])
 	}
@@ -140,6 +173,10 @@ func AesDecryptECB(encrypted string, key []byte) (decrypted []byte) {
 
 	return decrypted[:trim]
 }
+
+// generateKey 生成标准长度的密钥
+// key: 原始密钥
+// 返回: 16字节的标准密钥
 func generateKey(key []byte) (genKey []byte) {
 	genKey = make([]byte, 16)
 	copy(genKey, key)
@@ -151,12 +188,16 @@ func generateKey(key []byte) (genKey []byte) {
 	return genKey
 }
 
+// AesKeyCheck 检查AES密钥环境变量
+// key: 环境变量名
+// 返回: 十六进制编码的密钥字符串
 func AesKeyCheck(key string) (string, error) {
 	// 从环境变量获取密钥
 	keyHex := os.Getenv(key)
 	if keyHex == "" {
-		fmt.Println("环境变量 RST_KEY 未设置")
-		return "", errors.New("环境变量 RST_KEY 未设置")
+		// 使用入参作为变量名，避免硬编码误导
+		fmt.Printf("环境变量 %s 未设置\n", key)
+		return "", errors.New("密钥环境变量未设置")
 	}
 	// 解码十六进制字符串的密钥
 	byteKey, err := hex.DecodeString(keyHex)
@@ -165,8 +206,8 @@ func AesKeyCheck(key string) (string, error) {
 		return "", errors.New("密钥解码失败")
 	}
 	// 检查密钥长度
-	if len(byteKey) != 16 && len(key) != 24 && len(key) != 32 {
-		fmt.Printf("无效的密钥长度: %d 字节 (需要16,24或32字节)\n", len(key))
+	if len(byteKey) != 16 && len(byteKey) != 24 && len(byteKey) != 32 {
+		fmt.Printf("无效的密钥长度: %d 字节 (需要16,24或32字节)\n", len(byteKey))
 		return "", errors.New("无效的密钥长度,需要16,24或32字节")
 	}
 	return keyHex, nil

data/map_string.go

@@ -1,51 +0,0 @@
-package data
-
-import (
-	"sync"
-)
-
-var (
-	// Cache
-	CacheMapString *MapString
-)
-
-// lock
-type MapString struct {
-	sync.RWMutex
-	Data map[string]string
-}
-
-func NewMapString() *MapString {
-	return &MapString{
-		Data: make(map[string]string),
-	}
-}
-
-func (c *MapString) Get(key string) string {
-	c.RLock()
-	defer c.RUnlock()
-
-	vals, ok := c.Data[key]
-	if !ok {
-		return ""
-	}
-
-	return vals
-}
-
-func (c *MapString) Set(key, val string) {
-	c.Lock()
-	defer c.Unlock()
-	c.Data[key] = val
-}
-
-func (c *MapString) Keys() (keys []string) {
-	c.RLock()
-	defer c.RUnlock()
-
-	for k, _ := range c.Data {
-		keys = append(keys, k)
-	}
-
-	return
-}

database/elastic/elasticsearch.go

@@ -9,9 +9,9 @@ import (
 	"time"
 
 	"git.apinb.com/bsm-sdk/core/vars"
-	"github.com/elastic/go-elasticsearch/v8"
-	"github.com/elastic/go-elasticsearch/v8/esapi"
-	"github.com/elastic/go-elasticsearch/v8/esutil"
+	"github.com/elastic/go-elasticsearch/v9"
+	"github.com/elastic/go-elasticsearch/v9/esapi"
+	"github.com/elastic/go-elasticsearch/v9/esutil"
 )
 
 type ES struct {

database/new.go

@@ -1,4 +1,5 @@
-// Package database provides database connection and management functionality
+// Package database 提供数据库连接和管理功能
+// 支持MySQL和PostgreSQL数据库，包含连接池管理和自动迁移
 package database
 
 import (
@@ -13,12 +14,16 @@ import (
 )
 
 var (
-	// MigrateTables holds the tables that need to be auto-migrated on database initialization
+	// MigrateTables 存储需要在数据库初始化时自动迁移的表
 	MigrateTables []any
 )
 
-// NewDatabase creates a new database connection based on the provided driver type
-// It supports both MySQL and PostgreSQL databases
+// NewDatabase 根据提供的驱动类型创建新的数据库连接
+// 支持MySQL和PostgreSQL数据库
+// driver: 数据库驱动类型 ("mysql" 或 "postgres")
+// dsn: 数据源名称数组
+// options: 数据库连接选项
+// 返回: GORM数据库实例
 func NewDatabase(driver string, dsn []string, options *types.SqlOptions) (db *gorm.DB, err error) {
 	driver = strings.ToLower(driver)
 	switch driver {
@@ -34,12 +39,23 @@ func NewDatabase(driver string, dsn []string, options *types.SqlOptions) (db *go
 		return nil, err
 	}
 
+	// 自动迁移表结构
+	if len(MigrateTables) > 0 {
+		err = db.AutoMigrate(MigrateTables...)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	return db, nil
 }
 
-// NewMysql creates a MySQL database service
+// NewMysql 创建MySQL数据库服务
+// dsn: 数据源名称数组
+// options: 数据库连接选项
+// 返回: GORM数据库实例
 func NewMysql(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err error) {
-	//set connection default val.
+	// 设置连接默认值
 	if options == nil {
 		options = &types.SqlOptions{
 			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
@@ -61,32 +77,28 @@ func NewMysql(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err err
 		gormDb = gormDb.Debug()
 	}
 
-	// 获取通用数据库对象 sql.DB ，然后使用其提供的功能
+	// 获取通用数据库对象 sql.DB，然后使用其提供的功能
 	sqlDB, err := gormDb.DB()
 	if err != nil {
 		return nil, err
 	}
 
-	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量。
+	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量
 	sqlDB.SetMaxIdleConns(options.MaxIdleConns)
-	// SetMaxOpenConns 设置打开数据库连接的最大数量。
+	// SetMaxOpenConns 设置打开数据库连接的最大数量
 	sqlDB.SetMaxOpenConns(options.MaxOpenConns)
-	// SetConnMaxLifetime 设置了连接可复用的最大时间。
+	// SetConnMaxLifetime 设置了连接可复用的最大时间
 	sqlDB.SetConnMaxLifetime(options.ConnMaxLifetime)
 
-	if len(MigrateTables) > 0 {
-		err = gormDb.AutoMigrate(MigrateTables...)
-		if err != nil {
-			return nil, err
-		}
-	}
-
 	return gormDb, nil
 }
 
-// NewPostgres creates a PostgreSQL database service
+// NewPostgres 创建PostgreSQL数据库服务
+// dsn: 数据源名称数组
+// options: 数据库连接选项
+// 返回: GORM数据库实例
 func NewPostgres(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err error) {
-	//set connection default val.
+	// 设置连接默认值
 	if options == nil {
 		options = &types.SqlOptions{
 			MaxIdleConns:    vars.SqlOptionMaxIdleConns,
@@ -106,25 +118,28 @@ func NewPostgres(dsn []string, options *types.SqlOptions) (gormDb *gorm.DB, err
 		gormDb = gormDb.Debug()
 	}
 
-	// 获取通用数据库对象 sql.DB ，然后使用其提供的功能
+	// 获取通用数据库对象 sql.DB，然后使用其提供的功能
 	sqlDB, err := gormDb.DB()
 	if err != nil {
 		return nil, err
 	}
 
-	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量。
+	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量
 	sqlDB.SetMaxIdleConns(options.MaxIdleConns)
-	// SetMaxOpenConns 设置打开数据库连接的最大数量。
+	// SetMaxOpenConns 设置打开数据库连接的最大数量
 	sqlDB.SetMaxOpenConns(options.MaxOpenConns)
-	// SetConnMaxLifetime 设置了连接可复用的最大时间。
+	// SetConnMaxLifetime 设置了连接可复用的最大时间
 	sqlDB.SetConnMaxLifetime(options.ConnMaxLifetime)
 
-	if len(MigrateTables) > 0 {
-		err = gormDb.AutoMigrate(MigrateTables...)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return
+	return gormDb, nil
+}
+
+// AppendMigrate 调用此函数后，会在数据库初始化时自动迁移表结构
+//
+// - table: 需要自动迁移的表
+func AppendMigrate(table any) {
+	if MigrateTables == nil {
+		MigrateTables = make([]any, 0)
+	}
+	MigrateTables = append(MigrateTables, table)
 }

errcode/errcode.go

@@ -1,87 +1,103 @@
+// Package errcode 提供统一的错误码管理
+// 定义了系统中所有可能的错误类型和对应的错误码
 package errcode
 
 import (
+	"strings"
+
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
-// header error code ,start:100
+// HTTP请求头相关错误码，起始码:1000
 var (
-	ErrHeaderRequestId     = NewError(101, "Header Request-Id Not Found")
-	ErrHeaderAuthorization = NewError(102, "Header Authorization Not Found")
-	ErrHeaderSecretKey     = NewError(103, "Header Secret-Key Not Found")
-	ErrHeaderMustParams    = NewError(104, "Header Must Params")
+	AllErrors              = make(map[int]string)
+	ErrHeaderRequestId     = NewError(1001, "Header Request-Id Not Found")    // 请求ID头缺失
+	ErrHeaderAuthorization = NewError(1002, "Header Authorization Not Found") // 授权头缺失
+	ErrHeaderSecretKey     = NewError(1003, "Header Secret-Key Not Found")    // 密钥头缺失
+	ErrHeaderMustParams    = NewError(1004, "Header Must Params")             // 必需参数头缺失
 )
 
-// standard error code ,start:110
+// 标准业务错误码，起始码:1100
 var (
-	ErrEmpty           = NewError(110, "Data Is Empty")
-	ErrRequestParse    = NewError(111, "Request Parse Fail")
-	ErrRequestMust     = NewError(112, "Request Params Required")
-	ErrPermission      = NewError(113, "Permission Denied")
-	ErrJsonUnmarshal   = NewError(114, "Json Unmarshal Fail")
-	ErrJsonMarshal     = NewError(115, "Json Marshal Fail")
-	ErrInternal        = NewError(116, "Internal Server Error")
-	ErrPassword        = NewError(117, "Password Incorrect")
-	ErrAccountNotFound = NewError(118, "Account Not Found")
-	ErrAccountDisabled = NewError(119, "Account Disabled")
-	ErrDisabled        = NewError(120, "Status Disabled")
-	ErrRecordNotFound  = NewError(121, "Record Not Found")
+	ErrEmpty           = NewError(1101, "Data Is Empty")           // 数据为空
+	ErrRequestParse    = NewError(1102, "Request Parse Fail")      // 请求解析失败
+	ErrRequestMust     = NewError(1103, "Request Params Required") // 请求参数必需
+	ErrPermission      = NewError(1104, "Permission Denied")       // 权限不足
+	ErrJsonUnmarshal   = NewError(1105, "Json Unmarshal Fail")     // JSON反序列化失败
+	ErrJsonMarshal     = NewError(1106, "Json Marshal Fail")       // JSON序列化失败
+	ErrInternal        = NewError(1107, "Internal Server Error")   // 内部服务器错误
+	ErrPassword        = NewError(1108, "Password Incorrect")      // 密码错误
+	ErrAccountDisabled = NewError(1110, "Account Disabled")        // 账户已禁用
+	ErrDisabled        = NewError(1111, "Status Disabled")         // 状态已禁用
+	ErrRecordNotFound  = NewError(1112, "Record Not Found")        // 记录未找到
 )
 
-// jwt error code ,start:130
+// JWT认证相关错误码，起始码:1300
 var (
-	ErrJWTAuthNotFound     = NewError(131, "JWT Authorization Not Found")
-	ErrJWTBase64Decode     = NewError(132, "JWT Authorization Base64 Decode Error")
-	ErrJWTAuthParseFail    = NewError(133, "JWT Authorization Fail")
-	ErrJWTAuthKeyId        = NewError(134, "JWT Key:Id Incorrect")
-	ErrJWTAuthKeyIdentity  = NewError(135, "JWT Key:Identity Incorrect")
-	ErrJWTAuthTokenChanged = NewError(136, "JWT Authorization Changed")
-	ErrJWTAuthExpire       = NewError(137, "JWT Authorization Expire")
-	ErrJWTJsonDecode       = NewError(138, "JWT Authorization JSON Decode Error")
-	ErrJWTJsonEncode       = NewError(139, "JWT Authorization JSON Encode Error")
-	ErrJWTSecretKey        = NewError(139, "JWT SecretKey Error")
+	ErrJWTAuthNotFound     = NewError(1301, "JWT Authorization Not Found")           // JWT授权未找到
+	ErrJWTBase64Decode     = NewError(1302, "JWT Authorization Base64 Decode Error") // JWT Base64解码错误
+	ErrJWTAuthParseFail    = NewError(1303, "JWT Authorization Fail")                // JWT授权解析失败
+	ErrJWTAuthKeyId        = NewError(1304, "JWT Key:Id Incorrect")                  // JWT密钥ID错误
+	ErrJWTAuthKeyIdentity  = NewError(1305, "JWT Key:Identity Incorrect")            // JWT密钥身份错误
+	ErrJWTAuthTokenChanged = NewError(1306, "JWT Authorization Changed")             // JWT授权已变更
+	ErrJWTAuthExpire       = NewError(1307, "JWT Authorization Expire")              // JWT授权已过期
+	ErrJWTJsonDecode       = NewError(1308, "JWT Authorization JSON Decode Error")   // JWT JSON解码错误
+	ErrJWTJsonEncode       = NewError(1309, "JWT Authorization JSON Encode Error")   // JWT JSON编码错误
+	ErrJWTSecretKey        = NewError(1310, "JWT SecretKey Error")                   // JWT密钥错误
 )
 
-// model error code ,start:150
+// 基础设施相关错误码，起始码:1500
 var (
-	ErrDB    = NewError(151, "DB Fatal Error")
-	ErrRedis = NewError(152, "Redis Fatal Error")
-	ErrMq    = NewError(153, "MQ Fatal Error")
-	ErrOss   = NewError(154, "OSS Fatal Error")
-	ErrRpc   = NewError(155, "RPC Fatal Error")
-	ErrApm   = NewError(156, "APM Fatal Error")
-	ErrEtcd  = NewError(157, "Etcd Fatal Error")
+	ErrDB    = NewError(1501, "DB Fatal Error")    // 数据库致命错误
+	ErrRedis = NewError(1502, "Redis Fatal Error") // Redis致命错误
+	ErrMq    = NewError(1503, "MQ Fatal Error")    // 消息队列致命错误
+	ErrOss   = NewError(1504, "OSS Fatal Error")   // 对象存储致命错误
+	ErrRpc   = NewError(1505, "RPC Fatal Error")   // RPC致命错误
+	ErrApm   = NewError(1506, "APM Fatal Error")   // 应用性能监控致命错误
+	ErrEtcd  = NewError(1507, "Etcd Fatal Error")  // Etcd致命错误
 )
 
-// google grpc error status.
+// Google gRPC标准错误状态码，起始码:1700
 var (
-	OK                    = NewError(171, "OK")
-	ErrCanceled           = NewError(172, "Canceled")
-	ErrUnknown            = NewError(173, "Unknown")
-	ErrInvalidArgument    = NewError(174, "Invalid Argument")
-	ErrDeadlineExceeded   = NewError(175, "Deadline Exceeded")
-	ErrAlreadyExists      = NewError(176, "Already Exists")
-	ErrPermissionDenied   = NewError(177, "Permission Denied")
-	ErrResourceExhausted  = NewError(178, "Resource Exhausted")
-	ErrFailedPrecondition = NewError(179, "Failed Precondition")
-	ErrAborted            = NewError(181, "Aborted")
-	ErrOutOfRange         = NewError(182, "Out Of Range")
-	ErrUnimplemented      = NewError(183, "Unimplemented")
-	ErrUnavailable        = NewError(184, "Unavailable")
-	ErrDataLoss           = NewError(185, "Data Loss")
-	ErrUnauthenticated    = NewError(186, "Unauthenticated")
+	OK                    = NewError(0, "OK")                     // 成功
+	ErrAccountNotFound    = ErrNotFound(404, "Account")           // 账户未找到
+	ErrCanceled           = NewError(1702, "Canceled")            // 操作已取消
+	ErrUnknown            = NewError(1703, "Unknown")             // 未知错误
+	ErrInvalidArgument    = NewError(1704, "Invalid Argument")    // 无效参数
+	ErrDeadlineExceeded   = NewError(1705, "Deadline Exceeded")   // 超时
+	ErrAlreadyExists      = NewError(1706, "Already Exists")      // 已存在
+	ErrPermissionDenied   = NewError(1707, "Permission Denied")   // 权限拒绝
+	ErrResourceExhausted  = NewError(1708, "Resource Exhausted")  // 资源耗尽
+	ErrFailedPrecondition = NewError(1709, "Failed Precondition") // 前置条件失败
+	ErrAborted            = NewError(1710, "Aborted")             // 操作中止
+	ErrOutOfRange         = NewError(1711, "Out Of Range")        // 超出范围
+	ErrUnimplemented      = NewError(1712, "Unimplemented")       // 未实现
+	ErrUnavailable        = NewError(1713, "Unavailable")         // 不可用
+	ErrDataLoss           = NewError(1714, "Data Loss")           // 数据丢失
+	ErrUnauthenticated    = NewError(1715, "Unauthenticated")     // 未认证
 )
 
+// NewError 创建新的错误实例
+// code: 错误码
+// msg: 错误消息
 func NewError(code int, msg string) error {
+	AllErrors[code] = msg
 	return status.New(codes.Code(code), msg).Err()
 }
 
-// custom error,status code:500
+// ErrFatal 创建致命错误，状态码:500
+// code: 错误码
+// msg: 错误消息
 func ErrFatal(code int, msg string) error {
+	AllErrors[code] = msg
 	return status.New(codes.Code(code), msg).Err()
 }
 
+// ErrNotFound 创建未找到错误
+// code: 错误码
+// msg: 错误消息，会自动转换为大写
 func ErrNotFound(code int, msg string) error {
-	return status.New(codes.Code(code), msg).Err()
+	AllErrors[code] = strings.ToUpper(msg)
+	return status.New(codes.Code(code), strings.ToUpper(msg)).Err()
 }

go.mod

@@ -1,3 +1,3 @@
 module git.apinb.com/bsm-sdk/core
 
-go 1.24
+go 1.25.1

infra/logs.go

@@ -1,4 +1,10 @@
-package oplog
+package infra
+
+import (
+	"encoding/json"
+
+	"git.apinb.com/bsm-sdk/core/utils"
+)
 
 type LogItem struct {
 	OpID   uint   `json:"op_id"`
@@ -22,3 +28,10 @@ var (
 	Type_Other    string = "other"
 	Type_Create   string = "create"
 )
+
+func PushLog(endpoint string, data []*LogItem) {
+	jsonBytes, _ := json.Marshal(data)
+
+	go utils.HttpPost(endpoint, nil, jsonBytes)
+
+}

infra/response.go

@@ -1,3 +1,5 @@
+// Package infra 提供基础设施功能
+// 包括统一响应处理、健康检查、日志等
 package infra
 
 import (
@@ -7,12 +9,16 @@ import (
 
 var Response Reply
 
+// Reply 统一响应结构体
 type Reply struct {
-	Code    int32  `json:"code"`
-	Message string `json:"message"`
-	Result  any    `json:"result"`
+	Code    int32  `json:"code"`    // 响应码
+	Message string `json:"message"` // 响应消息
+	Result  any    `json:"result"`  // 响应数据
 }
 
+// Success 返回成功响应
+// ctx: Gin上下文
+// data: 响应数据
 func (reply *Reply) Success(ctx *gin.Context, data any) {
 	reply.Code = 0
 	reply.Result = data
@@ -22,16 +28,22 @@ func (reply *Reply) Success(ctx *gin.Context, data any) {
 	}
 	ctx.JSON(200, reply)
 }
+
+// Error 返回错误响应
+// ctx: Gin上下文
+// err: 错误对象
 func (reply *Reply) Error(ctx *gin.Context, err error) {
 	reply.Code = 500
 	reply.Result = ""
-	// Status code defaults to 500
+	// 默认状态码为500
 	e, ok := status.FromError(err)
 	if ok {
 		reply.Code = int32(e.Code())
+		reply.Message = e.Message()
+	} else {
+		reply.Message = err.Error()
 	}
-	reply.Message = e.Message()
 
-	// Send error
+	// 发送错误响应
 	ctx.JSON(200, reply)
 }

infra/service.go

@@ -5,7 +5,7 @@ import (
 	"log"
 	"time"
 
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/utils"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
@@ -37,10 +37,10 @@ func (s *service) Register(cli *clientv3.Client, serviceName string, port string
 		return err
 	}
 
-	print.Info("[BSM Register] Service Key: %s", key)
-	print.Info("[BSM Register] Service Val: %s", serviceAddr)
+	printer.Info("[BSM Register] Service Key: %s", key)
+	printer.Info("[BSM Register] Service Val: %s", serviceAddr)
 
-	print.Success("[BSM Register] Service Register Complete.")
+	printer.Success("[BSM Register] Service Register Complete.")
 
 	go func() {
 		for keepAliveResp := range keepAliveChan {

logger/logger.go

@@ -0,0 +1,405 @@
+package logger
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"git.apinb.com/bsm-sdk/core/conf"
+	"git.apinb.com/bsm-sdk/core/utils"
+	"git.apinb.com/bsm-sdk/core/vars"
+)
+
+// Logger 日志器结构
+type Logger struct {
+	level       vars.LogLevel
+	infoLogger  *log.Logger
+	warnLogger  *log.Logger
+	errorLogger *log.Logger
+	fatalLogger *log.Logger
+	debugLogger *log.Logger
+
+	fileWriter    io.Writer
+	consoleWriter io.Writer
+
+	mu          sync.RWMutex
+	name        string
+	logDir      string
+	currentDate string
+	onRemote    bool
+	endpoint    string
+}
+
+var (
+	globalLogger *Logger
+	once         sync.Once
+)
+
+// InitLogger 初始化全局日志器
+func InitLogger(cfg *conf.LogConf) error {
+	var err error
+	once.Do(func() {
+		globalLogger, err = NewLogger(cfg)
+	})
+	return err
+}
+
+// NewLogger 创建新的日志器
+func NewLogger(cfg *conf.LogConf) (*Logger, error) {
+	// 确保日志目录存在
+	if err := os.MkdirAll(cfg.Dir, 0755); err != nil {
+		return nil, fmt.Errorf("创建日志目录失败: %v", err)
+	}
+
+	// 控制台输出
+	consoleWriter := os.Stdout
+
+	// 文件输出
+	fileWriter, err := createLogFile(cfg.Dir, cfg.Name)
+	if err != nil {
+		return nil, fmt.Errorf("创建日志文件失败: %v", err)
+	}
+
+	// 创建多输出写入器
+	multiWriter := io.MultiWriter(consoleWriter, fileWriter)
+
+	logger := &Logger{
+		level:         cfg.Level,
+		fileWriter:    fileWriter,
+		consoleWriter: consoleWriter,
+		logDir:        cfg.Dir,
+		name:          strings.ToLower(cfg.Name),
+		currentDate:   time.Now().Format("2006-01-02"),
+		onRemote:      cfg.Remote,
+		endpoint:      cfg.Endpoint,
+	}
+
+	// 创建不同级别的日志器
+	logger.infoLogger = log.New(multiWriter, "[INFO] ", log.LstdFlags)
+	logger.warnLogger = log.New(multiWriter, "[WARN] ", log.LstdFlags)
+	logger.errorLogger = log.New(multiWriter, "[ERROR] ", log.LstdFlags)
+	logger.fatalLogger = log.New(multiWriter, "[FATAL] ", log.LstdFlags)
+	logger.debugLogger = log.New(multiWriter, "[DEBUG] ", log.LstdFlags)
+
+	return logger, nil
+}
+
+// createLogFile 创建日志文件
+func createLogFile(logDir, name string) (io.Writer, error) {
+	filename := fmt.Sprintf("%s_%s.log", name, time.Now().Format("2006-01-02"))
+	filepath := filepath.Join(logDir, filename)
+
+	file, err := os.OpenFile(filepath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+	if err != nil {
+		return nil, err
+	}
+
+	return file, nil
+}
+
+// checkAndRotateLog 检查并轮转日志文件
+func (l *Logger) checkAndRotateLog() error {
+	today := time.Now().Format("2006-01-02")
+	if l.currentDate != today {
+		l.mu.Lock()
+		defer l.mu.Unlock()
+
+		if l.currentDate != today {
+			// 关闭旧文件
+			if closer, ok := l.fileWriter.(io.Closer); ok {
+				closer.Close()
+			}
+
+			// 创建新文件
+			newFileWriter, err := createLogFile(l.logDir, l.name)
+			if err != nil {
+				return err
+			}
+
+			l.fileWriter = newFileWriter
+			l.currentDate = today
+
+			// 重新创建多输出写入器
+			multiWriter := io.MultiWriter(l.consoleWriter, l.fileWriter)
+
+			l.infoLogger = log.New(multiWriter, "[INFO] ", log.LstdFlags)
+			l.warnLogger = log.New(multiWriter, "[WARN] ", log.LstdFlags)
+			l.errorLogger = log.New(multiWriter, "[ERROR] ", log.LstdFlags)
+			l.fatalLogger = log.New(multiWriter, "[FATAL] ", log.LstdFlags)
+			l.debugLogger = log.New(multiWriter, "[DEBUG] ", log.LstdFlags)
+		}
+	}
+	return nil
+}
+
+func (l *Logger) sendToRemote(level, name, out string) {
+	if l.endpoint == "" {
+		return
+	}
+	data := map[string]interface{}{
+		"level": level,
+		"name":  name,
+		"out":   out,
+	}
+	jsonBytes, _ := json.Marshal(data)
+	utils.HttpPost(l.endpoint, nil, jsonBytes)
+}
+
+// Debug 输出调试信息
+func (l *Logger) Debug(v ...interface{}) {
+	if l.level <= vars.DEBUG {
+		l.checkAndRotateLog()
+		out := fmt.Sprint(v...)
+		if l.onRemote {
+			go l.sendToRemote("DEBUG", l.name, out)
+		}
+		l.debugLogger.Output(2, out)
+	}
+}
+
+// Debugf 格式化输出调试信息
+func (l *Logger) Debugf(format string, v ...interface{}) {
+	if l.level <= vars.DEBUG {
+		l.checkAndRotateLog()
+		out := fmt.Sprintf(format, v...)
+		if l.onRemote {
+			go l.sendToRemote("DEBUG", l.name, out)
+		}
+		l.debugLogger.Output(2, out)
+	}
+}
+
+// Info 输出信息
+func (l *Logger) Info(v ...interface{}) {
+	if l.level <= vars.INFO {
+		l.checkAndRotateLog()
+		out := fmt.Sprint(v...)
+		if l.onRemote {
+			go l.sendToRemote("INFO", l.name, out)
+		}
+		l.infoLogger.Output(2, out)
+	}
+}
+
+// Infof 格式化输出信息
+func (l *Logger) Infof(format string, v ...interface{}) {
+	if l.level <= vars.INFO {
+		l.checkAndRotateLog()
+		out := fmt.Sprintf(format, v...)
+		if l.onRemote {
+			go l.sendToRemote("INFO", l.name, out)
+		}
+		l.infoLogger.Output(2, out)
+	}
+}
+
+// Warn 输出警告
+func (l *Logger) Warn(v ...interface{}) {
+	if l.level <= vars.WARN {
+		l.checkAndRotateLog()
+		out := fmt.Sprint(v...)
+		if l.onRemote {
+			go l.sendToRemote("WARN", l.name, out)
+		}
+		l.warnLogger.Output(2, out)
+	}
+}
+
+// Warnf 格式化输出警告
+func (l *Logger) Warnf(format string, v ...interface{}) {
+	if l.level <= vars.WARN {
+		l.checkAndRotateLog()
+		out := fmt.Sprintf(format, v...)
+		if l.onRemote {
+			go l.sendToRemote("WARN", l.name, out)
+		}
+		l.warnLogger.Output(2, out)
+	}
+}
+
+// Error 输出错误
+func (l *Logger) Error(v ...interface{}) {
+	if l.level <= vars.ERROR {
+		l.checkAndRotateLog()
+		out := fmt.Sprint(v...)
+		if l.onRemote {
+			go l.sendToRemote("ERROR", l.name, out)
+		}
+		l.errorLogger.Output(2, out)
+	}
+}
+
+// Errorf 格式化输出错误
+func (l *Logger) Errorf(format string, v ...interface{}) {
+	if l.level <= vars.ERROR {
+		l.checkAndRotateLog()
+		out := fmt.Sprintf(format, v...)
+		if l.onRemote {
+			go l.sendToRemote("ERROR", l.name, out)
+		}
+		l.errorLogger.Output(2, out)
+	}
+}
+
+// Fatal 输出致命错误并退出程序
+func (l *Logger) Fatal(v ...interface{}) {
+	l.checkAndRotateLog()
+	out := fmt.Sprint(v...)
+	if l.onRemote {
+		go l.sendToRemote("FATAL", l.name, out)
+	}
+	l.fatalLogger.Output(2, out)
+	os.Exit(1)
+}
+
+// Fatalf 格式化输出致命错误并退出程序
+func (l *Logger) Fatalf(format string, v ...interface{}) {
+	l.checkAndRotateLog()
+	out := fmt.Sprintf(format, v...)
+	if l.onRemote {
+		go l.sendToRemote("FATAL", l.name, out)
+	}
+	l.fatalLogger.Output(2, out)
+	os.Exit(1)
+}
+
+// Print 输出信息（兼容标准log包）
+func (l *Logger) Print(v ...interface{}) {
+	l.Info(v...)
+}
+
+// Printf 格式化输出信息（兼容标准log包）
+func (l *Logger) Printf(format string, v ...interface{}) {
+	l.Infof(format, v...)
+}
+
+// Println 输出信息并换行（兼容标准log包）
+func (l *Logger) Println(v ...interface{}) {
+	l.Info(v...)
+}
+
+// SetLevel 设置日志级别
+func (l *Logger) SetLevel(level vars.LogLevel) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.level = level
+}
+
+// GetLevel 获取日志级别
+func (l *Logger) GetLevel() vars.LogLevel {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	return l.level
+}
+
+// Close 关闭日志器
+func (l *Logger) Close() error {
+	if closer, ok := l.fileWriter.(io.Closer); ok {
+		return closer.Close()
+	}
+	return nil
+}
+
+// 全局日志函数（兼容标准log包）
+
+// Debug 全局调试日志
+func Debug(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Debug(v...)
+	}
+}
+
+// Debugf 全局调试日志
+func Debugf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Debugf(format, v...)
+	}
+}
+
+// Info 全局信息日志
+func Info(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Info(v...)
+	}
+}
+
+// Infof 全局信息日志
+func Infof(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Infof(format, v...)
+	}
+}
+
+// Warn 全局警告日志
+func Warn(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Warn(v...)
+	}
+}
+
+// Warnf 全局警告日志
+func Warnf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Warnf(format, v...)
+	}
+}
+
+// Error 全局错误日志
+func Error(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Error(v...)
+	}
+}
+
+// Errorf 全局错误日志
+func Errorf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Errorf(format, v...)
+	}
+}
+
+// Fatal 全局致命错误日志
+func Fatal(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Fatal(v...)
+	}
+}
+
+// Fatalf 全局致命错误日志
+func Fatalf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Fatalf(format, v...)
+	}
+}
+
+// Print 全局打印日志（兼容标准log包）
+func Print(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Print(v...)
+	}
+}
+
+// Printf 全局打印日志（兼容标准log包）
+func Printf(format string, v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Printf(format, v...)
+	}
+}
+
+// Println 全局打印日志（兼容标准log包）
+func Println(v ...interface{}) {
+	if globalLogger != nil {
+		globalLogger.Println(v...)
+	}
+}
+
+// GetLogger 获取全局日志器实例
+func GetLogger() *Logger {
+	return globalLogger
+}

middleware/jwt.go

@@ -1,3 +1,5 @@
+// Package middleware 提供HTTP中间件功能
+// 包括JWT认证、CORS、运行模式等中间件
 package middleware
 
 import (
@@ -12,6 +14,9 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+// JwtAuth JWT认证中间件
+// time_verify: 是否验证token过期时间
+// 返回: Gin中间件函数
 func JwtAuth(time_verify bool) gin.HandlerFunc {
 	return func(c *gin.Context) {
 		// 从请求头中获取 Authorization
@@ -49,7 +54,9 @@ func JwtAuth(time_verify bool) gin.HandlerFunc {
 	}
 }
 
-// 获取上下文用户登录信息
+// ParseAuth 获取上下文用户登录信息
+// c: Gin上下文
+// 返回: JWT声明信息
 func ParseAuth(c *gin.Context) (*types.JwtClaims, error) {
 	claims, ok := c.Get("Auth")
 	if !ok {

oplog/new.go

@@ -1,14 +0,0 @@
-package oplog
-
-import (
-	"encoding/json"
-
-	"git.apinb.com/bsm-sdk/core/utils"
-)
-
-func New(endpoint string, data []*LogItem) {
-	jsonBytes, _ := json.Marshal(data)
-
-	go utils.HttpPost(endpoint, nil, jsonBytes)
-
-}

printer/print.go

@@ -1,6 +1,8 @@
-package print
+package printer
 
 import (
+	"bytes"
+	"encoding/json"
 	"fmt"
 	"log"
 	"os"
@@ -36,3 +38,11 @@ func Error(format string, a ...interface{}) {
 	message := fmt.Sprintf("\033[31m[Error] "+format+"\033[0m\n", a...)
 	logger.Print(message)
 }
+
+func Json(v any) {
+	jsonBy, _ := json.Marshal(v)
+	var out bytes.Buffer
+	json.Indent(&out, jsonBy, "", "\t")
+	out.WriteTo(os.Stdout)
+	fmt.Printf("\n")
+}

service/address.go

@@ -0,0 +1,204 @@
+package service
+
+import (
+	"fmt"
+	"net"
+	"net/url"
+	"strings"
+
+	"git.apinb.com/bsm-sdk/core/utils"
+)
+
+type NetworkAddress struct {
+	Protocol string // tcp, tcp4, tcp6, unix, unixpacket
+	Host     string // IP 地址或主机名
+	Port     string // 端口号
+	Path     string // Unix socket 路径
+	Raw      string // 原始字符串
+}
+
+// 解析网络地址字符串
+// "tcp://0.0.0.0:1212",
+//
+//	"tcp4://127.0.0.1:8080",
+//	"tcp6://[::1]:8080",
+//	"unix:///data/app/passport.sock",
+//	"unixpacket:///tmp/mysql.sock",
+//	":8080",                    // 传统格式
+//	"/tmp/server.sock",         // 传统Unix格式
+//	"invalid://address",        // 错误格式
+func ParseNetworkAddress(addr string) (*NetworkAddress, error) {
+	// 如果包含 ://，按 URL 解析
+	if strings.Contains(addr, "://") {
+		return parseURLStyle(addr)
+	}
+
+	// 否则按传统格式解析
+	return parseTraditionalStyle(addr)
+}
+
+// 解析 tcp://0.0.0.0:1212 或 unix:///path/to/socket 格式
+func parseURLStyle(addr string) (*NetworkAddress, error) {
+	u, err := url.Parse(addr)
+	if err != nil {
+		return nil, fmt.Errorf("解析URL失败: %w", err)
+	}
+
+	result := &NetworkAddress{
+		Protocol: u.Scheme,
+		Raw:      addr,
+	}
+
+	switch u.Scheme {
+	case "tcp", "tcp4", "tcp6":
+		return parseTCPURL(u, result)
+	case "unix", "unixpacket":
+		return parseUnixURL(u, result)
+	default:
+		return nil, fmt.Errorf("不支持的协议: %s", u.Scheme)
+	}
+}
+
+// 解析 TCP 类型的 URL
+func parseTCPURL(u *url.URL, result *NetworkAddress) (*NetworkAddress, error) {
+	host, port, err := net.SplitHostPort(u.Host)
+	if err != nil {
+		// 如果没有端口，尝试添加默认端口
+		if strings.Contains(err.Error(), "missing port") {
+			host = u.Host
+			port = "0" // 默认端口
+		} else {
+			return nil, fmt.Errorf("解析TCP地址失败: %w", err)
+		}
+	}
+
+	result.Host = host
+	result.Port = port
+
+	// 根据主机地址确定具体的协议类型
+	if result.Protocol == "tcp" {
+		result.Protocol = determineTCPProtocol(host)
+	}
+
+	return result, nil
+}
+
+// 解析 Unix socket 类型的 URL
+func parseUnixURL(u *url.URL, result *NetworkAddress) (*NetworkAddress, error) {
+	// Unix socket 路径在 URL 的 Path 字段
+	if u.Path == "" {
+		return nil, fmt.Errorf("Unix socket 路径不能为空")
+	}
+
+	result.Path = u.Path
+
+	// 如果协议是 unix，但路径表明需要数据包传输，可以自动升级
+	if result.Protocol == "unix" && strings.Contains(u.Path, "packet") {
+		result.Protocol = "unixpacket"
+	}
+
+	return result, nil
+}
+
+// 根据主机地址确定 TCP 协议类型
+func determineTCPProtocol(host string) string {
+	if host == "" {
+		return "tcp" // 默认
+	}
+
+	// 解析 IP 地址
+	ip := net.ParseIP(host)
+	if ip != nil {
+		if ip.To4() != nil {
+			return "tcp4"
+		}
+		return "tcp6"
+	}
+
+	// 如果是特殊地址
+	switch host {
+	case "0.0.0.0", "127.0.0.1", "localhost":
+		return "tcp4"
+	case "::", "::1":
+		return "tcp6"
+	default:
+		return "tcp" // 默认支持双栈
+	}
+}
+
+// 解析传统格式如 ":8080", "127.0.0.1:8080", "/tmp/socket"
+func parseTraditionalStyle(addr string) (*NetworkAddress, error) {
+	// 检查是否是 Unix socket（包含路径分隔符）
+	if strings.Contains(addr, "/") || strings.HasPrefix(addr, "@/") {
+		return &NetworkAddress{Protocol: "unix", Path: addr}, nil
+	}
+
+	// 否则按 TCP 地址解析
+	host, port, err := net.SplitHostPort(addr)
+	if err == nil {
+		return &NetworkAddress{Protocol: "tcp", Host: host, Port: port}, nil
+	}
+
+	// 检查是否是端口号
+	if ok := utils.IsNumber(addr); ok {
+		return &NetworkAddress{Protocol: "tcp", Host: "0.0.0.0", Port: addr}, nil
+	}
+
+	return nil, fmt.Errorf("解析地址失败: %w", err)
+
+}
+
+// 获取网络类型用于 net.Dial 或 net.Listen
+func (na *NetworkAddress) Network() string {
+	return na.Protocol
+}
+
+// 获取地址字符串用于 net.Dial 或 net.Listen
+func (na *NetworkAddress) Address() string {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		if na.Port == "" {
+			return na.Host
+		}
+		return net.JoinHostPort(na.Host, na.Port)
+	case "unix", "unixpacket":
+		return na.Path
+	default:
+		return na.Raw
+	}
+}
+
+// 格式化输出
+func (na *NetworkAddress) String() string {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		return fmt.Sprintf("%s://%s", na.Protocol, net.JoinHostPort(na.Host, na.Port))
+	case "unix", "unixpacket":
+		return fmt.Sprintf("%s://%s", na.Protocol, na.Path)
+	default:
+		return na.Raw
+	}
+}
+
+// 验证地址是否有效
+func (na *NetworkAddress) Validate() error {
+	switch na.Protocol {
+	case "tcp", "tcp4", "tcp6":
+		if na.Host == "" && na.Port == "" {
+			return fmt.Errorf("TCP地址需要主机和端口")
+		}
+		// 验证端口
+		if na.Port != "" {
+			if _, err := net.LookupPort("tcp", na.Port); err != nil {
+				return fmt.Errorf("无效的端口: %s", na.Port)
+			}
+		}
+	case "unix", "unixpacket":
+		if na.Path == "" {
+			return fmt.Errorf("Unix socket路径不能为空")
+		}
+	default:
+		return fmt.Errorf("不支持的协议: %s", na.Protocol)
+	}
+	return nil
+}

service/cmd.go

@@ -1,4 +1,4 @@
-package cmd
+package service
 
 import (
 	"fmt"

service/register.go

@@ -5,7 +5,7 @@ import (
 	"strings"
 	"time"
 
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/vars"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
@@ -96,7 +96,7 @@ func (s *ServiceRegister) SetAnonymous(key string, urls []string) {
 	// remove reppeat, clear service all anonymous uri.
 	anonymous, err := s.cli.Get(context.Background(), key)
 	if err != nil {
-		print.Error("[BSM Register] Get Anonymous Fail: %v", err)
+		printer.Error("[BSM Register] Get Anonymous Fail: %v", err)
 		return
 	}
 
@@ -113,9 +113,9 @@ func (s *ServiceRegister) SetAnonymous(key string, urls []string) {
 	_, err = s.cli.Put(context.Background(), key, newAnonymous)
 
 	if err != nil {
-		print.Error("[BSM Register] Anonymous Fail.")
+		printer.Error("[BSM Register] Anonymous Fail.")
 	} else {
-		print.Info("[BSM Register] Anonymous: %s", newAnonymous)
+		printer.Info("[BSM Register] Anonymous: %s", newAnonymous)
 	}
 
 }

service/service.go

@@ -1,3 +1,5 @@
+// Package service 提供微服务管理功能
+// 包括服务启动、注册、网关代理等核心功能
 package service
 
 import (
@@ -14,56 +16,66 @@ import (
 
 	"git.apinb.com/bsm-sdk/core/conf"
 	"git.apinb.com/bsm-sdk/core/env"
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/vars"
 	clientv3 "go.etcd.io/etcd/client/v3"
 	"google.golang.org/grpc"
 )
 
 type (
-	// RegisterFn defines the method to register a server.
+	// RegisterFn 定义服务注册函数类型
 	RegisterFn func(*grpc.Server)
 
+	// Service 微服务实例
 	Service struct {
-		GrpcSrv *grpc.Server
-		Opts    *Options
+		GrpcSrv *grpc.Server // gRPC服务器实例
+		Opts    *Options     // 服务配置选项
 	}
 
+	// Options 服务配置选项
 	Options struct {
-		Addr        string
-		EtcdClient  *clientv3.Client
-		MsConf      *conf.MicroServiceConf
-		GatewayConf *conf.GatewayConf
-		GatewayCtx  context.Context
-		GatewayMux  *gwRuntime.ServeMux
+		Addr        string                 // 服务监听地址
+		EtcdClient  *clientv3.Client       // Etcd客户端
+		MsConf      *conf.MicroServiceConf // 微服务配置
+		GatewayConf *conf.GatewayConf      // 网关配置
+		GatewayCtx  context.Context        // 网关上下文
+		GatewayMux  *gwRuntime.ServeMux    // 网关多路复用器
 	}
 )
 
+// New 创建新的服务实例
+// srv: gRPC服务器实例
+// opts: 服务配置选项
 func New(srv *grpc.Server, opts *Options) *Service {
 	return &Service{GrpcSrv: srv, Opts: opts}
 }
 
+// Addr 将IP和端口格式化为host:port格式
+// ip: IP地址
+// port: 端口号
 func Addr(ip string, port int) string {
 	return net.JoinHostPort(ip, strconv.Itoa(port))
 }
 
+// Start 启动服务
+// 包括etcd注册、gRPC服务启动、HTTP网关启动
 func (s *Service) Start() {
-	print.Info("[BSM - %s] Service Starting ...", vars.ServiceKey)
+	printer.Info("[BSM - %s] Service Starting ...", vars.ServiceKey)
 
-	// register to etcd.
+	// 注册到etcd
 	if s.Opts.MsConf != nil && s.Opts.MsConf.Enable {
 		if s.Opts.EtcdClient == nil {
-			print.Error("[BSM Register] Etcd Client is nil.")
+			printer.Error("[BSM Register] Etcd Client is nil.")
 			os.Exit(1)
 		}
-		print.Info("[BSM - %s] Registering Service to Etcd ...", vars.ServiceKey)
-		// get methods
+		printer.Info("[BSM - %s] Registering Service to Etcd ...", vars.ServiceKey)
+		// 获取gRPC方法用于网关/路由发现
 		methods := FoundGrpcMethods(s.GrpcSrv)
 
-		// set router key
+		// 设置路由键
 		routerKey := vars.ServiceRootPrefix + "Router/" + env.Runtime.Workspace + "/" + strings.ToLower(vars.ServiceKey) + "/" + s.Opts.Addr
 
-		// register to etcd
+		// 使用租约注册到etcd
 		register, err := RegisterService(s.Opts.EtcdClient, routerKey, methods, vars.ServiceLease)
 		if err != nil {
 			log.Panicf("[ERROR] %s Service Register:%s \n", vars.ServiceKey, err.Error())
@@ -73,11 +85,11 @@ func (s *Service) Start() {
 
 		register.SetAnonymous(anonKey, s.Opts.MsConf.Anonymous)
 
-		// service register lease
+		// 服务注册租约监听
 		go register.ListenLeaseRespChan()
 	}
 
-	// run grpc srv.
+	// 启动gRPC服务
 	tcpListen, err := net.Listen("tcp", s.Opts.Addr)
 	if err != nil {
 		panic(err)
@@ -88,42 +100,52 @@ func (s *Service) Start() {
 			panic(err)
 		}
 	}()
-	print.Success("[BSM - %s] Grpc %s Runing Success !", vars.ServiceKey, s.Opts.Addr)
+	printer.Success("[BSM - %s] Grpc %s Runing Success !", vars.ServiceKey, s.Opts.Addr)
 
+	// 启动HTTP网关
 	if s.Opts.GatewayConf != nil && s.Opts.GatewayConf.Enable {
 		addr := Addr("0.0.0.0", s.Opts.GatewayConf.Port)
 		go s.Gateway(s.Opts.Addr, addr)
 
-		print.Success("[BSM - %s] Http %s Runing Success!", vars.ServiceKey, addr)
+		printer.Success("[BSM - %s] Http %s Runing Success!", vars.ServiceKey, addr)
 	}
 
+	// 阻塞主线程
 	select {}
 }
 
+// Gateway 启动HTTP网关服务
+// grpcAddr: gRPC服务地址
+// httpAddr: HTTP服务地址
 func (s *Service) Gateway(grpcAddr string, httpAddr string) {
-	// 1. 定义一个context
+	// 定义上下文
 	_, cancel := context.WithCancel(s.Opts.GatewayCtx)
 	defer cancel()
 
-	http.ListenAndServe(httpAddr, s.Opts.GatewayMux)
-}
-
-func (s *Service) Use(initFunc *func() error) {
-	// Execute the Init function if it's not nil
-	if initFunc != nil {
-		err := (*initFunc)()
-		if err != nil {
-			print.Error(err.Error())
-			panic(err)
-		}
+	// 启动HTTP服务，不因HTTP启动失败而导致panic
+	if err := http.ListenAndServe(httpAddr, s.Opts.GatewayMux); err != nil {
+		printer.Error("[BSM - %s] Http Serve Error: %v", vars.ServiceKey, err)
 	}
 }
 
+// Use 执行初始化函数
+// initFunc: 初始化函数
+func (s *Service) Use(initFunc func() error) {
+	err := (initFunc)()
+	if err != nil {
+		printer.Error(err.Error())
+		panic(err)
+	}
+}
+
+// Stop 优雅停止服务
 func (s *Service) Stop() {
 	s.GrpcSrv.GracefulStop()
 }
 
-// found grpc methods.
+// FoundGrpcMethods 发现gRPC服务中的所有方法
+// s: gRPC服务器实例
+// 返回: 方法名列表
 func FoundGrpcMethods(s *grpc.Server) []string {
 	var mothods []string
 	for key, srv := range s.GetServiceInfo() {

types/types.go

@@ -1,28 +1,36 @@
+// Package types 提供通用数据类型定义
+// 包括分页、ID、身份标识等常用结构体
 package types
 
+// Empty 空结构体
 type Empty struct {
 }
 
+// Paginate 分页参数
 type Paginate struct {
-	Offset int `form:"offset,default=0,range=[0:)"`
-	Size   int `form:"size,default=10,range=[1:50]"`
+	Offset int `form:"offset,default=0,range=[0:)"`  // 偏移量
+	Size   int `form:"size,default=10,range=[1:50]"` // 每页大小
 }
 
+// ID ID结构体
 type ID struct {
-	ID uint `json:"id"`
+	ID uint `json:"id"` // ID字段
 }
 
+// Identity 身份标识结构体
 type Identity struct {
-	Identity string `json:"identity"`
+	Identity string `json:"identity"` // 身份标识
 }
 
+// Ident ID和身份标识组合结构体
 type Ident struct {
-	ID       uint   `json:"id"`
-	Identity string `json:"identity"`
+	ID       uint   `json:"id"`       // ID字段
+	Identity string `json:"identity"` // 身份标识
 }
 
+// FetchRequest 获取请求结构体
 type FetchRequest struct {
-	Params    map[string]string `json:"params,optional"`
-	TimeRange string            `json:"time_range,optional"`
-	Paginate
+	Params    map[string]string `json:"params,optional"`     // 查询参数
+	TimeRange string            `json:"time_range,optional"` // 时间范围
+	Paginate                    // 分页参数
 }

utils/convert.go

@@ -1,3 +1,5 @@
+// Package utils 提供通用工具函数
+// 包括数据类型转换、时间处理、网络工具等
 package utils
 
 import (
@@ -7,8 +9,8 @@ import (
 )
 
 // String2Int 字符串转Int
-//
-//	intStr：数字的字符串
+// intStr: 数字的字符串
+// 返回: 转换后的整数，转换失败返回0
 func String2Int(intStr string) (intNum int) {
 	intNum, err := strconv.Atoi(intStr)
 	if err != nil {
@@ -18,20 +20,19 @@ func String2Int(intStr string) (intNum int) {
 }
 
 // String2Int64 字符串转Int64
-//
-//	intStr：数字的字符串
+// intStr: 数字的字符串
+// 返回: 转换后的64位整数，转换失败返回0
 func String2Int64(intStr string) (int64Num int64) {
-	intNum, err := strconv.Atoi(intStr)
+	intNum, err := strconv.ParseInt(intStr, 10, 64)
 	if err != nil {
 		return 0
 	}
-	int64Num = int64(intNum)
-	return
+	return intNum
 }
 
 // String2Float64 字符串转Float64
-//
-//	floatStr：小数点数字的字符串
+// floatStr: 小数点数字的字符串
+// 返回: 转换后的64位浮点数，转换失败返回0
 func String2Float64(floatStr string) (floatNum float64) {
 	floatNum, err := strconv.ParseFloat(floatStr, 64)
 	if err != nil {
@@ -41,8 +42,8 @@ func String2Float64(floatStr string) (floatNum float64) {
 }
 
 // String2Float32 字符串转Float32
-//
-//	floatStr：小数点数字的字符串
+// floatStr: 小数点数字的字符串
+// 返回: 转换后的32位浮点数，转换失败返回0
 func String2Float32(floatStr string) (floatNum float32) {
 	floatNum64, err := strconv.ParseFloat(floatStr, 32)
 	if err != nil {
@@ -52,27 +53,27 @@ func String2Float32(floatStr string) (floatNum float32) {
 	return
 }
 
-// Int转字符串
-//
-//	intNum：数字字符串
+// Int2String Int转字符串
+// intNum: 整数
+// 返回: 转换后的字符串
 func Int2String(intNum int) (intStr string) {
 	intStr = strconv.Itoa(intNum)
 	return
 }
 
-// Int64转字符串
-//
-//	intNum：数字字符串
+// Int642String Int64转字符串
+// intNum: 64位整数
+// 返回: 转换后的字符串
 func Int642String(intNum int64) (int64Str string) {
-	//10, 代表10进制
+	// 10代表10进制
 	int64Str = strconv.FormatInt(intNum, 10)
 	return
 }
 
-// Float64转字符串
-//
-//	floatNum：float64数字
-//	prec：精度位数（不传则默认float数字精度）
+// Float64ToString Float64转字符串
+// floatNum: float64数字
+// prec: 精度位数（不传则默认float数字精度）
+// 返回: 转换后的字符串
 func Float64ToString(floatNum float64, prec ...int) (floatStr string) {
 	if len(prec) > 0 {
 		floatStr = strconv.FormatFloat(floatNum, 'f', prec[0], 64)
@@ -82,10 +83,10 @@ func Float64ToString(floatNum float64, prec ...int) (floatStr string) {
 	return
 }
 
-// Float32转字符串
-//
-//	floatNum：float32数字
-//	prec：精度位数（不传则默认float数字精度）
+// Float32ToString Float32转字符串
+// floatNum: float32数字
+// prec: 精度位数（不传则默认float数字精度）
+// 返回: 转换后的字符串
 func Float32ToString(floatNum float32, prec ...int) (floatStr string) {
 	if len(prec) > 0 {
 		floatStr = strconv.FormatFloat(float64(floatNum), 'f', prec[0], 32)
@@ -95,7 +96,9 @@ func Float32ToString(floatNum float32, prec ...int) (floatStr string) {
 	return
 }
 
-// 二进制转10进制
+// BinaryToDecimal 二进制转10进制
+// bit: 二进制字符串
+// 返回: 转换后的十进制数
 func BinaryToDecimal(bit string) (num int) {
 	fields := strings.Split(bit, "")
 	lens := len(fields)
@@ -108,7 +111,9 @@ func BinaryToDecimal(bit string) (num int) {
 	return
 }
 
-// interface to string
+// AnyToString 任意类型转字符串
+// in: 输入值
+// 返回: 转换后的字符串
 func AnyToString(in any) (s string) {
 	if in == nil {
 		return ""

utils/ext.go

@@ -1,10 +1,6 @@
 package utils
 
 import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"os"
 	"strconv"
 	"strings"
 )
@@ -37,11 +33,3 @@ func ParseParams(in map[string]string) map[string]interface{} {
 	}
 	return out
 }
-
-func PrintJson(v any) {
-	jsonBy, _ := json.Marshal(v)
-	var out bytes.Buffer
-	json.Indent(&out, jsonBy, "", "\t")
-	out.WriteTo(os.Stdout)
-	fmt.Printf("\n")
-}

utils/fmt.go

@@ -0,0 +1,34 @@
+package utils
+
+import (
+	"strconv"
+	"strings"
+)
+
+func FloatRoundString(in float64, place int) string {
+
+	return Float64ToString(FloatRound(in, place))
+}
+
+func FloatRound(in float64, place int) float64 {
+	// 限制 place 范围在合理区间
+	if place < 0 {
+		place = 0
+	}
+
+	// 使用 strconv.FormatFloat 直接格式化，避免多次条件判断
+	str := strconv.FormatFloat(in, 'f', place, 64)
+	num, _ := strconv.ParseFloat(str, 64)
+	return num
+}
+
+func RateToFloat64(s string) float64 {
+	// 去掉百分号
+	s = strings.TrimSuffix(s, "%")
+	// 转换为 float64
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return 0
+	}
+	return f / 100
+}

utils/net.go

@@ -1,3 +1,5 @@
+// Package utils 提供通用工具函数
+// 包括数据类型转换、时间处理、网络工具等
 package utils
 
 import (
@@ -13,6 +15,9 @@ import (
 	"strings"
 )
 
+// IsPublicIP 判断是否为公网IP
+// ipString: IP地址字符串
+// 返回: 是否为公网IP
 func IsPublicIP(ipString string) bool {
 	ip := net.ParseIP(ipString)
 	if ip.IsLoopback() || ip.IsLinkLocalMulticast() || ip.IsLinkLocalUnicast() {
@@ -20,11 +25,11 @@ func IsPublicIP(ipString string) bool {
 	}
 	if ip4 := ip.To4(); ip4 != nil {
 		switch true {
-		case ip4[0] == 10:
+		case ip4[0] == 10: // 10.0.0.0/8
 			return false
-		case ip4[0] == 172 && ip4[1] >= 16 && ip4[1] <= 31:
+		case ip4[0] == 172 && ip4[1] >= 16 && ip4[1] <= 31: // 172.16.0.0/12
 			return false
-		case ip4[0] == 192 && ip4[1] == 168:
+		case ip4[0] == 192 && ip4[1] == 168: // 192.168.0.0/16
 			return false
 		default:
 			return true
@@ -33,7 +38,8 @@ func IsPublicIP(ipString string) bool {
 	return false
 }
 
-// Get Location IP .
+// GetLocationIP 获取本机IP地址
+// 返回: 本机IP地址
 func GetLocationIP() (localIp string) {
 	localIp = "127.0.0.1"
 	// Get all network interfaces
@@ -195,7 +201,7 @@ func DownloadFile(url, saveTo string, fb func(length, downLen int64)) {
 	resp, err := client.Get(url)
 	if err != nil {
 		fmt.Printf("download %s error:%s\n", url, err)
-		os.Exit(0)
+		return
 	}
 	//读取服务器返回的文件大小
 	fsize, err = strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 32)
@@ -207,12 +213,12 @@ func DownloadFile(url, saveTo string, fb func(length, downLen int64)) {
 	file.Chmod(0777)
 	if err != nil {
 		fmt.Printf("Create %s error:%s\n", saveTo, err)
-		os.Exit(0)
+		return
 	}
 	defer file.Close()
 	if resp.Body == nil {
 		fmt.Printf("resp %s error:%s\n", url, err)
-		os.Exit(0)
+		return
 	}
 	defer resp.Body.Close()
 	//下面是 io.copyBuffer() 的简化版本
@@ -250,6 +256,6 @@ func DownloadFile(url, saveTo string, fb func(length, downLen int64)) {
 
 	if err != nil {
 		fmt.Printf("callback error:%s\n", err)
-		os.Exit(0)
+		return
 	}
 }

utils/time.go

@@ -1,13 +1,23 @@
+// Package utils 提供通用工具函数
+// 包括时间处理、数据类型转换、网络工具等
 package utils
 
 import (
 	"time"
 )
 
+// Time2String 将时间转换为字符串
+// layout: 时间格式
+// t: 时间对象
+// 返回: 格式化的时间字符串
 func Time2String(layout string, t time.Time) string {
 	return t.Format(layout)
 }
 
+// String2Time 将字符串转换为时间
+// layout: 时间格式
+// in: 时间字符串
+// 返回: 时间对象
 func String2Time(layout, in string) time.Time {
 	t, _ := time.ParseInLocation(layout, in, time.Local)
 	return t

utils/validator.go

@@ -0,0 +1,129 @@
+package utils
+
+import (
+	"regexp"
+	"strings"
+	"unicode"
+)
+
+// IsEmail 验证是否是邮箱格式
+func IsEmail(email string) bool {
+	if strings.TrimSpace(email) == "" {
+		return false
+	}
+
+	// 邮箱正则表达式
+	pattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
+	matched, err := regexp.MatchString(pattern, email)
+	if err != nil {
+		return false
+	}
+	return matched
+}
+
+// IsMobile 验证是否是手机号（中国手机号格式）
+func IsMobile(mobile string) bool {
+	if strings.TrimSpace(mobile) == "" {
+		return false
+	}
+
+	// 中国手机号正则表达式：1开头，第二位3-9，后面9位数字
+	pattern := `^1[3-9]\d{9}$`
+	matched, err := regexp.MatchString(pattern, mobile)
+	if err != nil {
+		return false
+	}
+	return matched
+}
+
+// IsNumber 验证是否是纯数字
+func IsNumber(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsDigit(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsEnglish 验证是否是英文字符（不限大小写）
+func IsEnglish(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsLetter(char) {
+			return false
+		}
+		if !isEnglishLetter(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsEnglishWithSpace 验证是否是英文字符（允许空格）
+func IsEnglishWithSpace(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if unicode.IsSpace(char) {
+			continue
+		}
+		if !unicode.IsLetter(char) {
+			return false
+		}
+		if !isEnglishLetter(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsAlphanumeric 验证是否是字母和数字组合
+func IsAlphanumeric(str string) bool {
+	if strings.TrimSpace(str) == "" {
+		return false
+	}
+
+	for _, char := range str {
+		if !unicode.IsLetter(char) && !unicode.IsDigit(char) {
+			return false
+		}
+	}
+	return true
+}
+
+// IsStrongPassword 验证强密码（至少8位，包含大小写字母和数字）
+func IsStrongPassword(password string) bool {
+	if len(password) < 8 {
+		return false
+	}
+
+	var hasUpper, hasLower, hasDigit bool
+
+	for _, char := range password {
+		switch {
+		case unicode.IsUpper(char):
+			hasUpper = true
+		case unicode.IsLower(char):
+			hasLower = true
+		case unicode.IsDigit(char):
+			hasDigit = true
+		}
+	}
+
+	return hasUpper && hasLower && hasDigit
+}
+
+// 辅助函数：判断是否是英文字母
+func isEnglishLetter(char rune) bool {
+	return (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z')
+}

vars/cache.go

@@ -8,4 +8,10 @@ var (
 	MemLRUMaxNumber int           = 1024
 	MemShardings    int           = 64
 	RedisShardings  int           = 256
+
+	// CacheKeyPrefix 缓存键前缀
+	CacheKeyPrefix = "bsm:"
+
+	// DefaultTTL 默认缓存过期时间
+	DefaultTTL = 30 * time.Minute // 30分钟
 )

vars/logger.go

@@ -0,0 +1,12 @@
+package vars
+
+// LogLevel 日志级别
+type LogLevel int
+
+const (
+	DEBUG LogLevel = iota
+	INFO
+	WARN
+	ERROR
+	FATAL
+)

with/databases.go

@@ -3,25 +3,25 @@ package with
 import (
 	"git.apinb.com/bsm-sdk/core/conf"
 	"git.apinb.com/bsm-sdk/core/database"
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/types"
 	"git.apinb.com/bsm-sdk/core/vars"
 	"gorm.io/gorm"
 )
 
-func Databases(cfg *conf.DBConf, db *gorm.DB, opts *types.SqlOptions) {
+func Databases(cfg *conf.DBConf, opts *types.SqlOptions) *gorm.DB {
 	if cfg == nil || len(cfg.Source) == 0 {
 		panic("No Database Source Found !")
 	}
 
 	// print inform.
-	print.Info("[BSM - %s] Databases: %v", vars.ServiceKey, cfg)
+	printer.Info("[BSM - %s] Databases: %v", vars.ServiceKey, cfg)
 
 	var err error
-	db, err = database.NewDatabase(cfg.Driver, cfg.Source, opts)
+	db, err := database.NewDatabase(cfg.Driver, cfg.Source, opts)
 	if err != nil {
-		print.Error("Database Init Failed !")
+		printer.Error("Database Init Failed !")
 		panic(err)
 	}
-	return
+	return db
 }

with/etcd.go

@@ -5,13 +5,13 @@ import (
 
 	"git.apinb.com/bsm-sdk/core/conf"
 	"git.apinb.com/bsm-sdk/core/errcode"
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/vars"
 	"go.etcd.io/etcd/client/pkg/v3/transport"
 	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
-func Etcd(cfg *conf.EtcdConf, cli *clientv3.Client) {
+func Etcd(cfg *conf.EtcdConf) (cli *clientv3.Client) {
 	if cfg == nil || len(cfg.Endpoints) == 0 {
 		return
 	}
@@ -35,7 +35,7 @@ func Etcd(cfg *conf.EtcdConf, cli *clientv3.Client) {
 		}
 		tlsConfig, err := tlsInfo.ClientConfig()
 		if err != nil {
-			print.Error(errcode.ErrEtcd.Error())
+			printer.Error(errcode.ErrEtcd.Error())
 			panic(err)
 		}
 		etcdCfg.TLS = tlsConfig
@@ -44,11 +44,11 @@ func Etcd(cfg *conf.EtcdConf, cli *clientv3.Client) {
 	var err error
 	cli, err = clientv3.New(etcdCfg)
 	if err != nil {
-		print.Error(errcode.ErrEtcd.Error())
+		printer.Error(errcode.ErrEtcd.Error())
 		panic(err)
 	}
 
 	// print inform.
-	print.Info("[BSM - %s] Service Center: %v", vars.ServiceKey, cfg.Endpoints)
+	printer.Info("[BSM - %s] Service Center: %v", vars.ServiceKey, cfg.Endpoints)
 	return
 }

with/logger.go

@@ -0,0 +1,26 @@
+package with
+
+import (
+	"strings"
+
+	"git.apinb.com/bsm-sdk/core/conf"
+	"git.apinb.com/bsm-sdk/core/logger"
+	"git.apinb.com/bsm-sdk/core/vars"
+)
+
+// 初始化Logger配置
+func Logger(cfg *conf.LogConf) {
+	if cfg == nil {
+		cfg = &conf.LogConf{
+			Name:     strings.ToLower(vars.ServiceKey),
+			Level:    vars.LogLevel(vars.DEBUG),
+			Dir:      "./logs/",
+			Endpoint: "",
+			Console:  true,
+			File:     true,
+			Remote:   false,
+		}
+	}
+
+	logger.InitLogger(cfg)
+}

with/memory.go

@@ -4,12 +4,12 @@ import (
 	"context"
 	"time"
 
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/vars"
 	"github.com/allegro/bigcache/v3"
 )
 
-func Memory(cli *bigcache.BigCache, opts *bigcache.Config) {
+func Memory(opts *bigcache.Config) (cli *bigcache.BigCache) {
 	if opts == nil {
 		opts = &bigcache.Config{
 			Shards:             1024,
@@ -27,9 +27,10 @@ func Memory(cli *bigcache.BigCache, opts *bigcache.Config) {
 	var err error
 	cli, err = bigcache.New(context.Background(), *opts)
 	if err != nil {
-		print.Error("Memory Cache Fatal Error")
+		printer.Error("Memory Cache Fatal Error")
 		panic(err)
 	}
 
-	print.Success("[BSM - %s] Memory Cache: Shards=%d, MaxEntrySize=%d", vars.ServiceKey, opts.Shards, opts.MaxEntrySize)
+	printer.Success("[BSM - %s] Memory Cache: Shards=%d, MaxEntrySize=%d", vars.ServiceKey, opts.Shards, opts.MaxEntrySize)
+	return
 }

with/redis.go

@@ -2,15 +2,17 @@ package with
 
 import (
 	"git.apinb.com/bsm-sdk/core/cache/redis"
-	"git.apinb.com/bsm-sdk/core/print"
+	"git.apinb.com/bsm-sdk/core/printer"
 	"git.apinb.com/bsm-sdk/core/vars"
 )
 
-func RedisCache(cfg string, cli *redis.RedisClient) {
+func RedisCache(cfg string) (cli *redis.RedisClient) {
 	if cfg != "" {
 		cli = redis.New(cfg, vars.ServiceKey)
 
 		// print inform.
-		print.Info("[BSM - %s] Cache: %s, DBIndex: %d", vars.ServiceKey, cfg, cli.DB)
+		printer.Info("[BSM - %s] Cache: %s, DBIndex: %d", vars.ServiceKey, cfg, cli.DB)
 	}
+
+	return
 }