feat: 添加微服务模板基础架构

- 创建基于 CloudWego Hertz 的 Go 微服务脚手架
- 集成 Nacos 服务注册/发现功能
- 添加 gRPC 客户端支持
- 实现环境变量配置管理 (.env.example)
- 添加 HTTP 中间件 (Recovery, AccessLog, CORS)
- 配置 Gitea CI/CD 构建部署流程

BREAKING CHANGE: 项目结构调整，从简单的 API 服务升级为完整的微服务架构

utils/httplog/redis_tracer.go

@@ -0,0 +1,285 @@
+package httplog
+
+import (
+	"context"
+	"encoding/json"
+	"os"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/cloudwego/hertz/pkg/app"
+	"github.com/cloudwego/hertz/pkg/common/tracer/stats"
+	"github.com/go-redis/redis/v8"
+)
+
+type AccessEvent struct {
+	Timestamp       string `json:"@timestamp"`
+	TsMs            int64  `json:"ts_ms"`
+	Service         string `json:"service,omitempty"`
+	Instance        string `json:"instance,omitempty"`
+	Method          string `json:"method"`
+	Host            string `json:"host,omitempty"`
+	Path            string `json:"path"`
+	UserID          uint   `json:"user_id,omitempty"`
+	Body            string `json:"body,omitempty"`
+	Query           string `json:"query,omitempty"`
+	Result          string `json:"result,omitempty"`
+	ResultTruncated bool   `json:"result_truncated,omitempty"`
+	RequestURI      string `json:"request_uri,omitempty"`
+	Route           string `json:"route,omitempty"`
+	Status          int    `json:"status"`
+	CostMs          int64  `json:"cost_ms"`
+	RecvBytes       int    `json:"recv_bytes"`
+	SendBytes       int    `json:"send_bytes"`
+	RemoteAddr      string `json:"remote_addr,omitempty"`
+	ClientIP        string `json:"client_ip,omitempty"`
+	UserAgent       string `json:"ua,omitempty"`
+	Referer         string `json:"referer,omitempty"`
+	RequestID       string `json:"request_id,omitempty"`
+	Error           string `json:"error,omitempty"`
+	Panicked        bool   `json:"panicked"`
+	PanicValue      string `json:"panic_value"`
+}
+
+// UserIDExtractor 从请求上下文中提取用户 ID 的函数签名。
+// 不同项目可根据自身认证方式实现此函数。
+type UserIDExtractor func(c *app.RequestContext) uint
+
+type RedisListWriter struct {
+	rdb           *redis.Client
+	key           string
+	ch            chan []byte
+	flushInterval time.Duration
+	maxBatch      int
+
+	ctx    context.Context
+	cancel context.CancelFunc
+	wg     sync.WaitGroup
+
+	dropped uint64
+}
+
+func NewRedisListWriter(rdb *redis.Client, key string, queueSize int, maxBatch int, flushInterval time.Duration) *RedisListWriter {
+	ctx, cancel := context.WithCancel(context.Background())
+	w := &RedisListWriter{
+		rdb:           rdb,
+		key:           key,
+		ch:            make(chan []byte, queueSize),
+		flushInterval: flushInterval,
+		maxBatch:      maxBatch,
+		ctx:           ctx,
+		cancel:        cancel,
+	}
+	w.wg.Add(1)
+	go w.loop()
+	return w
+}
+
+func (w *RedisListWriter) Enqueue(b []byte) {
+	select {
+	case w.ch <- b:
+	default:
+		atomic.AddUint64(&w.dropped, 1)
+	}
+}
+
+func (w *RedisListWriter) Dropped() uint64 { return atomic.LoadUint64(&w.dropped) }
+
+func (w *RedisListWriter) Close(ctx context.Context) error {
+	w.cancel()
+	done := make(chan struct{})
+	go func() {
+		w.wg.Wait()
+		close(done)
+	}()
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case <-done:
+		return nil
+	}
+}
+
+func (w *RedisListWriter) loop() {
+	defer w.wg.Done()
+
+	ticker := time.NewTicker(w.flushInterval)
+	defer ticker.Stop()
+
+	flush := func(buf [][]byte) {
+		if len(buf) == 0 {
+			return
+		}
+		args := make([]interface{}, 0, len(buf))
+		for _, b := range buf {
+			args = append(args, string(b))
+		}
+		cctx, cancel := context.WithTimeout(w.ctx, 2*time.Second)
+		_ = w.rdb.RPush(cctx, w.key, args...).Err()
+		cancel()
+	}
+
+	var buf [][]byte
+	for {
+		select {
+		case <-w.ctx.Done():
+			flush(buf)
+			return
+		case b := <-w.ch:
+			buf = append(buf, b)
+			if len(buf) >= w.maxBatch {
+				flush(buf)
+				buf = buf[:0]
+			}
+		case <-ticker.C:
+			flush(buf)
+			buf = buf[:0]
+		}
+	}
+}
+
+type TracerOption func(*RedisAccessLogTracer)
+
+// WithUserIDExtractor 设置自定义的用户 ID 提取函数
+func WithUserIDExtractor(fn UserIDExtractor) TracerOption {
+	return func(t *RedisAccessLogTracer) {
+		t.userIDFn = fn
+	}
+}
+
+// WithSkipPrefix 设置需要跳过日志记录的路径前缀（如 /health, /metrics）
+func WithSkipPrefix(prefix string) TracerOption {
+	return func(t *RedisAccessLogTracer) {
+		t.skipPrefix = prefix
+	}
+}
+
+// WithMaxResponseBody 设置响应体采集的最大字节数
+func WithMaxResponseBody(n int) TracerOption {
+	return func(t *RedisAccessLogTracer) {
+		t.maxRespBody = n
+	}
+}
+
+type RedisAccessLogTracer struct {
+	writer      *RedisListWriter
+	service     string
+	instance    string
+	skipPrefix  string
+	maxRespBody int
+	userIDFn    UserIDExtractor
+}
+
+func NewRedisAccessLogTracer(rdb *redis.Client, redisKey string, service string, opts ...TracerOption) *RedisAccessLogTracer {
+	host, _ := os.Hostname()
+	t := &RedisAccessLogTracer{
+		writer:      NewRedisListWriter(rdb, redisKey, 8192, 512, 200*time.Millisecond),
+		service:     service,
+		instance:    host,
+		maxRespBody: 2048,
+	}
+	for _, opt := range opts {
+		opt(t)
+	}
+	return t
+}
+
+func (t *RedisAccessLogTracer) Start(ctx context.Context, _ *app.RequestContext) context.Context {
+	return ctx
+}
+
+func (t *RedisAccessLogTracer) Finish(_ context.Context, c *app.RequestContext) {
+	if t.skipPrefix != "" {
+		p := string(c.Request.URI().PathOriginal())
+		if len(p) >= len(t.skipPrefix) && p[:len(t.skipPrefix)] == t.skipPrefix {
+			return
+		}
+	}
+
+	ti := c.GetTraceInfo()
+	st := ti.Stats()
+
+	var cost time.Duration
+	if rpcStart := st.GetEvent(stats.HTTPStart); rpcStart != nil {
+		if rpcFinish := st.GetEvent(stats.HTTPFinish); rpcFinish != nil {
+			cost = rpcFinish.Time().Sub(rpcStart.Time())
+		}
+	}
+
+	now := time.Now().UTC()
+	req := &c.Request
+	uri := req.URI()
+
+	remoteAddr := ""
+	if ra := c.RemoteAddr(); ra != nil {
+		remoteAddr = ra.String()
+	}
+
+	errStr := ""
+	if st.Error() != nil {
+		errStr = st.Error().Error()
+	}
+	panicked, panicVal := st.Panicked()
+	panicStr := ""
+	if panicVal != nil {
+		panicStr = anyToString(panicVal)
+	}
+
+	ev := AccessEvent{
+		Timestamp:  now.Format(time.RFC3339Nano),
+		TsMs:       now.UnixMilli(),
+		Service:    t.service,
+		Instance:   t.instance,
+		Method:     string(req.Method()),
+		Host:       string(req.Host()),
+		Path:       string(uri.PathOriginal()),
+		Query:      string(uri.QueryString()),
+		RequestURI: string(uri.RequestURI()),
+		Status:     c.Response.StatusCode(),
+		CostMs:     cost.Milliseconds(),
+		RecvBytes:  st.RecvSize(),
+		SendBytes:  st.SendSize(),
+		RemoteAddr: remoteAddr,
+		ClientIP:   c.ClientIP(),
+		UserAgent:  string(req.Header.UserAgent()),
+		Referer:    string(req.Header.Peek("Referer")),
+		RequestID:  string(req.Header.Peek("X-Request-Id")),
+		Error:      errStr,
+		Panicked:   panicked,
+		PanicValue: panicStr,
+	}
+
+	if t.userIDFn != nil {
+		ev.UserID = t.userIDFn(c)
+	}
+
+	if formJSON, ok, _ := FormBodyToJSONWithFilePlaceholder(c); ok {
+		ev.Body = string(formJSON)
+	}
+
+	if respBody, ok, trunc := ResponseBodySnippet(c, t.maxRespBody); ok {
+		ev.Result = respBody
+		ev.ResultTruncated = trunc
+	}
+
+	b, err := json.Marshal(ev)
+	if err != nil {
+		return
+	}
+	t.writer.Enqueue(b)
+}
+
+func (t *RedisAccessLogTracer) Close(ctx context.Context) error {
+	return t.writer.Close(ctx)
+}
+
+func anyToString(v interface{}) string {
+	switch x := v.(type) {
+	case string:
+		return x
+	default:
+		b, _ := json.Marshal(x)
+		return string(b)
+	}
+}

utils/httplog/request.go

@@ -0,0 +1,132 @@
+package httplog
+
+import (
+	"encoding/json"
+	"mime"
+	"strings"
+
+	"github.com/cloudwego/hertz/pkg/app"
+)
+
+var sensitiveKeys = []string{"password", "secret", "token", "key", "passwd"}
+
+const redactedValue = "[REDACTED]"
+
+// desensitization：只对第一层 key 做脱敏，不递归
+func desensitization(data map[string]any) ([]byte, error) {
+	out := make(map[string]any, len(data))
+
+	for k, v := range data {
+		if isSensitiveKey(k) {
+			out[k] = redactedValue
+		} else {
+			out[k] = v
+		}
+	}
+	return json.Marshal(out)
+}
+
+// 大小写不敏感、包含式匹配
+func isSensitiveKey(key string) bool {
+	k := strings.ToLower(key)
+	for _, s := range sensitiveKeys {
+		if strings.Contains(k, s) {
+			return true
+		}
+	}
+	return false
+}
+
+// FormBodyToJSONWithFilePlaceholder ：
+// - 普通表单：完整转 JSON
+// - multipart 文件字段：不取任何文件信息，只输出 "[file]" 或 ["[file]", ...]
+func FormBodyToJSONWithFilePlaceholder(c *app.RequestContext) (jsonBytes []byte, ok bool, err error) {
+	ct := string(c.Request.Header.ContentType())
+	mediaType, _, _ := mime.ParseMediaType(ct)
+	mediaType = strings.ToLower(mediaType)
+
+	out := make(map[string]any)
+
+	switch mediaType {
+	case "application/x-www-form-urlencoded":
+		args := c.PostArgs()
+		args.VisitAll(func(k, v []byte) {
+			key := string(k)
+			// 同名 key 多次出现时，转成数组
+			if old, exists := out[key]; exists {
+				switch x := old.(type) {
+				case string:
+					out[key] = []string{x, string(v)}
+				case []string:
+					out[key] = append(x, string(v))
+				default:
+					out[key] = string(v)
+				}
+			} else {
+				out[key] = string(v)
+			}
+		})
+		b, e := desensitization(out)
+		return b, true, e
+
+	case "multipart/form-data":
+		form, e := c.MultipartForm()
+		if e != nil {
+			return nil, false, e
+		}
+
+		// 普通字段
+		for k, vv := range form.Value {
+			if len(vv) == 1 {
+				out[k] = vv[0]
+			} else {
+				out[k] = vv
+			}
+		}
+
+		// 文件字段：只做占位，不读取任何文件信息
+		for k, files := range form.File {
+			if len(files) <= 1 {
+				out[k] = "[file]"
+			} else {
+				arr := make([]string, 0, len(files))
+				for range files {
+					arr = append(arr, "[file]")
+				}
+				out[k] = arr
+			}
+		}
+
+		b, e2 := desensitization(out)
+		return b, true, e2
+
+	default:
+		// 不是表单就不处理
+		return nil, false, nil
+	}
+}
+
+// ResponseBodySnippet ：获取响应内容
+func ResponseBodySnippet(c *app.RequestContext, maxBytes int) (body string, ok bool, truncated bool) {
+	b := c.Response.Body()
+	if len(b) == 0 {
+		return "", false, false
+	}
+
+	// 只采集“看起来像文本/JSON”的响应，其他（图片/zip等）直接跳过
+	ct := strings.ToLower(string(c.Response.Header.ContentType()))
+	if ct != "" && !(strings.HasPrefix(ct, "text/") ||
+		strings.Contains(ct, "application/json") ||
+		strings.Contains(ct, "application/xml") ||
+		strings.Contains(ct, "application/javascript")) {
+		return "", false, false
+	}
+
+	if maxBytes > 0 && len(b) > maxBytes {
+		b = b[:maxBytes]
+		truncated = true
+	}
+
+	body = string(b)
+	return body, true, truncated
+}

utils/httplog/uploader.go

@@ -0,0 +1,155 @@
+package httplog
+
+import (
+	"apiServer_service/utils/logger"
+	"apiServer_service/utils/redis_tools"
+	"bytes"
+	"context"
+	"crypto/sha1"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+)
+
+type AccessEventData struct {
+	Timestamp string `json:"@timestamp"`
+	TsMs      int64  `json:"ts_ms"`
+}
+
+var popBatchLua = redis.NewScript(`
+local key = KEYS[1]
+local n = tonumber(ARGV[1])
+local res = redis.call("LRANGE", key, 0, n-1)
+if (#res > 0) then
+  redis.call("LTRIM", key, n, -1)
+end
+return res
+`)
+
+func getenv(key, def string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return def
+}
+
+func getenvInt(key string, def int) int {
+	v := os.Getenv(key)
+	if v == "" {
+		return def
+	}
+	i, err := strconv.Atoi(v)
+	if err != nil {
+		return def
+	}
+	return i
+}
+
+func Updater(redisKey, esIndexPrefix string) {
+	if redisKey == "" {
+		redisKey = getenv("ES_REDIS_KEY", "access_log")
+	}
+
+	esBulkURL := getenv("ES_BULK_URL", "https://elasticsearch.hostidc.net/_bulk")
+	if esIndexPrefix == "" {
+		esIndexPrefix = getenv("ES_INDEX_PREFIX", "access")
+	}
+	esUser := getenv("ES_USERNAME", "")
+	esPass := getenv("ES_PASSWORD", "")
+
+	batchSize := getenvInt("ES_BATCH_SIZE", 1000)
+	pollIntervalMs := getenvInt("ES_POLL_INTERVAL_MS", 200)
+	httpTimeoutMs := getenvInt("ES_HTTP_TIMEOUT_MS", 5000)
+
+	rdb := redis_tools.ConnectRedis()
+
+	httpClient := &http.Client{Timeout: time.Duration(httpTimeoutMs) * time.Millisecond}
+	ctx := context.Background()
+
+	for {
+		items, err := popBatchLua.Run(ctx, rdb, []string{redisKey}, batchSize).StringSlice()
+		if err != nil {
+			time.Sleep(time.Second)
+			continue
+		}
+		if len(items) == 0 {
+			time.Sleep(time.Duration(pollIntervalMs) * time.Millisecond)
+			continue
+		}
+
+		body, _ := buildBulkBody(items, esIndexPrefix)
+		ok, _, err := postBulk(ctx, httpClient, esBulkURL, esUser, esPass, body)
+		if err != nil || !ok {
+			logger.Error("ESBulk", "写入失败: ", err)
+			continue
+		}
+	}
+}
+
+func buildBulkBody(items []string, indexPrefix string) ([]byte, int) {
+	var buf bytes.Buffer
+	count := 0
+
+	for _, line := range items {
+		idx := indexPrefix + "-" + time.Now().Format("2006.01.02")
+
+		var ev AccessEventData
+		if json.Unmarshal([]byte(line), &ev) == nil {
+			if ev.TsMs > 0 {
+				idx = indexPrefix + "-" + time.UnixMilli(ev.TsMs).UTC().Format("2006.01.02")
+			} else if ev.Timestamp != "" {
+				if ts, err := time.Parse(time.RFC3339Nano, ev.Timestamp); err == nil {
+					idx = indexPrefix + "-" + ts.UTC().Format("2006.01.02")
+				}
+			}
+		}
+
+		sum := sha1.Sum([]byte(line))
+		docID := hex.EncodeToString(sum[:])
+
+		meta := fmt.Sprintf(`{"index":{"_index":"%s","_id":"%s"}}`+"\n", idx, docID)
+		buf.WriteString(meta)
+		buf.WriteString(line)
+		buf.WriteByte('\n')
+		count++
+	}
+	return buf.Bytes(), count
+}
+
+func postBulk(ctx context.Context, client *http.Client, url, user, pass string, body []byte) (bool, []byte, error) {
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
+	if err != nil {
+		return false, nil, err
+	}
+	req.Header.Set("Content-Type", "application/x-ndjson")
+	if user != "" || pass != "" {
+		req.SetBasicAuth(user, pass)
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return false, nil, err
+	}
+	defer resp.Body.Close()
+
+	b, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return false, b, fmt.Errorf("bulk http status=%d", resp.StatusCode)
+	}
+
+	var out struct {
+		Errors bool `json:"errors"`
+	}
+	if json.Unmarshal(b, &out) == nil && out.Errors {
+		return false, b, fmt.Errorf("bulk response errors=true")
+	}
+
+	return true, b, nil
+}

utils/loger/log.go

@@ -1,193 +0,0 @@
-package loger
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/sirupsen/logrus"
-	"io"
-	"os"
-	"reflect"
-	"runtime"
-	"strings"
-	"time"
-)
-
-// ANSI 转义码定义颜色
-const (
-	reset        = "\033[0m"
-	red          = "\033[31m"
-	green        = "\033[32m"
-	yellow       = "\033[33m"
-	blue         = "\033[34m"
-	magenta      = "\033[35m"
-	cyan         = "\033[36m"
-	white        = "\033[97m"
-	gray         = "\033[90m"
-	brightYellow = "\033[93m"
-)
-
-// 自定义日志格式化器
-type customFormatter struct{}
-
-// Format 实现 logrus.Formatter 接口
-func (f *customFormatter) Format(entry *logrus.Entry) ([]byte, error) {
-	// 根据日志级别选择颜色
-	var levelColor string
-	switch entry.Level {
-	case logrus.DebugLevel:
-		levelColor = cyan
-	case logrus.InfoLevel:
-		levelColor = green
-	case logrus.WarnLevel:
-		levelColor = yellow
-	case logrus.ErrorLevel:
-		levelColor = red
-	case logrus.FatalLevel, logrus.PanicLevel:
-		levelColor = magenta
-	default:
-		levelColor = white
-	}
-
-	// 获取时间，格式为 yyyy/mm/dd hh:mm:ss.ms
-	timestamp := fmt.Sprintf("%s%s%s", levelColor, entry.Time.Format("01-02 15:04:05"), reset)
-
-	// 获取文件名和行号
-	_, file, line, ok := runtime.Caller(6) // 使用更高的层级
-	if !ok {
-		file = "unknown"
-		line = 0
-	}
-	if entry.Caller != nil {
-		// 获取调用者的文件名并只保留文件名部分
-		file = file[strings.LastIndex(file, "/")+1:] // 仅保留文件名
-	}
-
-	// 获取日志标题
-	title, ok := entry.Data["title"].(string)
-	if !ok {
-		title = "unknown"
-	}
-
-	// 格式化日志级别，并为其添加颜色
-	level := fmt.Sprintf("%s[%s]%s", levelColor, strings.ToUpper(entry.Level.String()), reset)
-	title = fmt.Sprintf("%s「%s」%s", levelColor, title, reset)
-
-	// 格式化输出内容
-	logMessage := fmt.Sprintf("%s %s:%d: %s >> %s %s\n",
-		timestamp,
-		file,
-		line,
-		level,
-		title,
-		entry.Message,
-	)
-
-	return []byte(logMessage), nil
-}
-
-func getLog() *logrus.Logger {
-	logLevel := os.Getenv("LOG_LEVEL")
-	logSave := os.Getenv("LOG_SAVE")
-	logSaveDir := os.Getenv("LOG_SAVE_PATH")
-	log := logrus.New()
-	switch logLevel {
-	case "debug":
-		log.SetLevel(logrus.DebugLevel)
-	case "info":
-		log.SetLevel(logrus.InfoLevel)
-	case "warn":
-		log.SetLevel(logrus.WarnLevel)
-	case "error":
-		log.SetLevel(logrus.ErrorLevel)
-	case "fatal":
-		log.SetLevel(logrus.FatalLevel)
-	}
-	// 自定义日志格式
-	log.SetFormatter(&customFormatter{})
-	// 启用调用信息的追踪，这样可以获取到文件名和行号
-	log.SetReportCaller(true)
-
-	if logSave == "true" {
-		logFileName := time.Now().Format("20060102") + ".log"
-		logSavePath := logSaveDir + "/" + logFileName
-		// 判断日志文件是否已存在
-		_, err := os.Stat(logSaveDir)
-		if os.IsNotExist(err) {
-			// 路径不存在，创建目录
-			if err := os.MkdirAll(logSaveDir, 0755); err != nil {
-				log.Error("日志文件目录创建失败")
-				return log
-			}
-		}
-		logFile, _ := os.OpenFile(logSavePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
-		multiWriter := io.MultiWriter(os.Stdout, logFile)
-		log.SetOutput(multiWriter)
-	}
-	return log
-}
-
-func toString(v interface{}) string {
-	// 使用反射检查类型
-	rv := reflect.ValueOf(v)
-
-	// 处理结构体和结构体指针
-	if rv.Kind() == reflect.Struct || (rv.Kind() == reflect.Ptr && rv.Elem().Kind() == reflect.Struct) {
-		jsonData, err := json.Marshal(v)
-		if err != nil {
-			return fmt.Sprintf("Error marshalling to JSON: %v", err)
-		}
-		return string(jsonData)
-	}
-
-	// 对于其他类型，使用 fmt.Sprintf
-	return fmt.Sprintf("%v", v)
-}
-
-// isPrintable 检查字符串是否只包含可打印字符
-func isPrintable(s string) bool {
-	for _, r := range s {
-		if r < 32 || r > 126 {
-			return false
-		}
-	}
-	return true
-}
-
-// joinToString 将多个参数转换为字符串，并拼接在一起。
-func joinToString(parts ...interface{}) string {
-	var strParts []string
-	for _, part := range parts {
-		strParts = append(strParts, toString(part))
-	}
-	return strings.Join(strParts, "")
-}
-
-func Debug(title string, content ...interface{}) {
-	getLog().WithFields(logrus.Fields{
-		"title": title,
-	}).Debug(joinToString(content))
-}
-
-func Info(title string, content ...interface{}) {
-	getLog().WithFields(logrus.Fields{
-		"title": title,
-	}).Info(joinToString(content))
-}
-
-func Warn(title string, content ...interface{}) {
-	getLog().WithFields(logrus.Fields{
-		"title": title,
-	}).Warn(joinToString(content))
-}
-
-func Error(title string, content ...interface{}) {
-	getLog().WithFields(logrus.Fields{
-		"title": title,
-	}).Error(joinToString(content))
-}
-
-func Fatal(title string, content ...interface{}) {
-	getLog().WithFields(logrus.Fields{
-		"title": title,
-	}).Fatal(joinToString(content))
-}

utils/logger/log.go

@@ -0,0 +1,171 @@
+package logger
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"reflect"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+const (
+	reset  = "\033[0m"
+	red    = "\033[31m"
+	green  = "\033[32m"
+	yellow = "\033[33m"
+	blue   = "\033[34m"
+	cyan   = "\033[36m"
+	white  = "\033[97m"
+)
+
+type colorFormatter struct{}
+
+func (f *colorFormatter) Format(entry *logrus.Entry) ([]byte, error) {
+	var levelColor string
+	switch entry.Level {
+	case logrus.DebugLevel:
+		levelColor = cyan
+	case logrus.InfoLevel:
+		levelColor = green
+	case logrus.WarnLevel:
+		levelColor = yellow
+	case logrus.ErrorLevel:
+		levelColor = red
+	case logrus.FatalLevel, logrus.PanicLevel:
+		levelColor = red
+	default:
+		levelColor = white
+	}
+
+	timestamp := fmt.Sprintf("%s%s%s", levelColor, entry.Time.Format("01-02 15:04:05"), reset)
+
+	file := "unknown"
+	line := 0
+	if entry.Caller != nil {
+		file = entry.Caller.File
+		if idx := strings.LastIndex(file, "/"); idx >= 0 {
+			file = file[idx+1:]
+		}
+		line = entry.Caller.Line
+	}
+
+	title, _ := entry.Data["title"].(string)
+	if title == "" {
+		title = "-"
+	}
+
+	level := fmt.Sprintf("%s[%s]%s", levelColor, strings.ToUpper(entry.Level.String()), reset)
+	titleStr := fmt.Sprintf("%s「%s」%s", levelColor, title, reset)
+
+	msg := fmt.Sprintf("%s %s:%d: %s >> %s %s\n",
+		timestamp, file, line, level, titleStr, entry.Message,
+	)
+	return []byte(msg), nil
+}
+
+var (
+	instance *logrus.Logger
+	once     sync.Once
+)
+
+func GetLogger() *logrus.Logger {
+	once.Do(func() {
+		instance = logrus.New()
+
+		switch strings.ToLower(os.Getenv("LOG_LEVEL")) {
+		case "debug":
+			instance.SetLevel(logrus.DebugLevel)
+		case "info":
+			instance.SetLevel(logrus.InfoLevel)
+		case "warn":
+			instance.SetLevel(logrus.WarnLevel)
+		case "error":
+			instance.SetLevel(logrus.ErrorLevel)
+		case "fatal":
+			instance.SetLevel(logrus.FatalLevel)
+		default:
+			instance.SetLevel(logrus.InfoLevel)
+		}
+
+		instance.SetFormatter(&colorFormatter{})
+		instance.SetReportCaller(true)
+
+		if os.Getenv("LOG_SAVE") == "true" {
+			logDir := os.Getenv("LOG_SAVE_PATH")
+			if logDir != "" {
+				if err := os.MkdirAll(logDir, 0755); err != nil {
+					instance.Errorf("创建日志目录失败: %v", err)
+				} else {
+					logFile := logDir + "/" + time.Now().Format("20060102") + ".log"
+					f, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+					if err == nil {
+						instance.SetOutput(io.MultiWriter(os.Stdout, f))
+					}
+				}
+			}
+		}
+	})
+	return instance
+}
+
+func callerSkip() *runtime.Frame {
+	pcs := make([]uintptr, 10)
+	n := runtime.Callers(3, pcs)
+	frames := runtime.CallersFrames(pcs[:n])
+	for {
+		frame, more := frames.Next()
+		if !strings.Contains(frame.File, "utils/logger/") {
+			return &frame
+		}
+		if !more {
+			break
+		}
+	}
+	return nil
+}
+
+func toString(v interface{}) string {
+	rv := reflect.ValueOf(v)
+	if rv.Kind() == reflect.Struct || (rv.Kind() == reflect.Ptr && rv.Elem().Kind() == reflect.Struct) {
+		data, err := json.Marshal(v)
+		if err != nil {
+			return fmt.Sprintf("%v", v)
+		}
+		return string(data)
+	}
+	return fmt.Sprintf("%v", v)
+}
+
+func joinToString(parts ...interface{}) string {
+	strs := make([]string, 0, len(parts))
+	for _, p := range parts {
+		strs = append(strs, toString(p))
+	}
+	return strings.Join(strs, " ")
+}
+
+func Debug(title string, content ...interface{}) {
+	GetLogger().WithField("title", title).Debug(joinToString(content...))
+}
+
+func Info(title string, content ...interface{}) {
+	GetLogger().WithField("title", title).Info(joinToString(content...))
+}
+
+func Warn(title string, content ...interface{}) {
+	GetLogger().WithField("title", title).Warn(joinToString(content...))
+}
+
+func Error(title string, content ...interface{}) {
+	GetLogger().WithField("title", title).Error(joinToString(content...))
+}
+
+func Fatal(title string, content ...interface{}) {
+	GetLogger().WithField("title", title).Fatal(joinToString(content...))
+}

utils/nacos/baseNacos.go

@@ -1,66 +1,87 @@
 package nacos
 
 import (
-	"github.com/nacos-group/nacos-sdk-go/v2/common/constant"
+	"errors"
 	"net"
 	"os"
 	"strconv"
 	"strings"
+	"sync"
+
+	"github.com/nacos-group/nacos-sdk-go/v2/common/constant"
 )
 
 var (
-	cc *constant.ClientConfig
-	sc []constant.ServerConfig
+	cc     *constant.ClientConfig
+	sc     []constant.ServerConfig
+	initMu sync.Once
 )
 
 func GetIP(domain string) string {
-	// 确保域名不为空
 	if domain == "" {
 		return ""
 	}
-
-	// 使用 net.LookupIP 查找域名的 IP 地址
 	ips, err := net.LookupIP(domain)
-	if err != nil {
+	if err != nil || len(ips) == 0 {
 		return ""
 	}
-
-	// 检查是否找到了 IP
-	if len(ips) == 0 {
-		return ""
-	}
-
-	// 返回第一个 IPv4 地址（如果有）
 	for _, ip := range ips {
 		if ipv4 := ip.To4(); ipv4 != nil {
 			return ipv4.String()
 		}
 	}
-
-	// 如果没有 IPv4，返回第一个 IP（可能是 IPv6）
 	return ips[0].String()
 }
 
-func InitNacosRegistryConfig() {
-	if cc != nil && sc != nil {
-		return
-	}
-	nacosHosts := strings.Split(os.Getenv("NACOS_HOSTS"), ",")
-	nacosPort, _ := strconv.Atoi(os.Getenv("NACOS_PORT"))
-	for _, host := range nacosHosts {
-		serverConfig := constant.NewServerConfig(GetIP(host), uint64(nacosPort))
-		sc = append(sc, *serverConfig)
-	}
+func InitNacosRegistryConfig() error {
+	var initErr error
+	initMu.Do(func() {
+		hostsStr := os.Getenv("NACOS_HOSTS")
+		portStr := os.Getenv("NACOS_PORT")
+		if hostsStr == "" || portStr == "" {
+			initErr = errors.New("NACOS_HOSTS 和 NACOS_PORT 必须配置")
+			return
+		}
 
-	LogDir := os.Getenv("LOG_SAVE_PATH")
-	cc = &constant.ClientConfig{
-		NamespaceId:         os.Getenv("NACOS_NAMESPACE"),
-		TimeoutMs:           5000,
-		NotLoadCacheAtStart: true,
-		LogDir:              LogDir,
-		//CacheDir:            "/tmp/nacos/cache",
-		LogLevel: "debug",
-		Username: os.Getenv("NACOS_USER"),
-		Password: os.Getenv("NACOS_PASSWORD"),
-	}
+		nacosPort, err := strconv.Atoi(portStr)
+		if err != nil {
+			initErr = errors.New("NACOS_PORT 格式错误")
+			return
+		}
+
+		nacosHosts := strings.Split(hostsStr, ",")
+		for _, host := range nacosHosts {
+			host = strings.TrimSpace(host)
+			if host == "" {
+				continue
+			}
+			ip := GetIP(host)
+			if ip == "" {
+				ip = host
+			}
+			serverConfig := constant.NewServerConfig(ip, uint64(nacosPort))
+			sc = append(sc, *serverConfig)
+		}
+
+		if len(sc) == 0 {
+			initErr = errors.New("无有效的 Nacos 服务器地址")
+			return
+		}
+
+		logDir := os.Getenv("LOG_SAVE_PATH")
+		if logDir == "" {
+			logDir = "/tmp/nacos/log"
+		}
+
+		cc = &constant.ClientConfig{
+			NamespaceId:         os.Getenv("NACOS_NAMESPACE"),
+			TimeoutMs:           5000,
+			NotLoadCacheAtStart: true,
+			LogDir:              logDir,
+			LogLevel:            "warn",
+			Username:            os.Getenv("NACOS_USER"),
+			Password:            os.Getenv("NACOS_PASSWORD"),
+		}
+	})
+	return initErr
 }

utils/nacos/configuration.go

@@ -1,14 +1,13 @@
 package nacos
 
 import (
-	"apiServer_service/utils/loger"
+	"apiServer_service/utils/logger"
 	"github.com/nacos-group/nacos-sdk-go/v2/clients"
 	"github.com/nacos-group/nacos-sdk-go/v2/clients/config_client"
 	"github.com/nacos-group/nacos-sdk-go/v2/vo"
 )
 
-// NewNacosConfigClient 创建一个 Nacos 配置服务
-func NewNacosConfigClient() (*config_client.IConfigClient, error) {
+func NewNacosConfigClient() (config_client.IConfigClient, error) {
 	InitNacosRegistryConfig()
 	cli, err := clients.NewConfigClient(
 		vo.NacosClientParam{
@@ -19,39 +18,34 @@ func NewNacosConfigClient() (*config_client.IConfigClient, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &cli, nil
+	return cli, nil
 }
 
-// AddConfig 新增配置
 func AddConfig(dataId, group, content string) error {
 	client, err := NewNacosConfigClient()
 	if err != nil {
 		return err
 	}
-	_, err = (*client).PublishConfig(vo.ConfigParam{
+	_, err = client.PublishConfig(vo.ConfigParam{
 		DataId:  dataId,
 		Group:   group,
 		Content: content,
 	})
-	if err != nil {
-		return err
-	}
-	return nil
+	return err
 }
 
-// GetConfig 获取配置
 func GetConfig(dataId, group string) string {
 	client, err := NewNacosConfigClient()
 	if err != nil {
-		loger.Error("获取配置客户端失败", err)
+		logger.Error("获取配置客户端失败", err)
 		return ""
 	}
-	content, err := (*client).GetConfig(vo.ConfigParam{
+	content, err := client.GetConfig(vo.ConfigParam{
 		DataId: dataId,
 		Group:  group,
 	})
 	if err != nil {
-		loger.Error("获取配置失败", err)
+		logger.Error("获取配置失败", err)
 		return ""
 	}
 	return content

utils/nacos/service.go

@@ -1,29 +1,39 @@
 package nacos
 
 import (
+	"errors"
+	"os"
+	"strconv"
+	"sync"
+
 	"github.com/nacos-group/nacos-sdk-go/v2/clients"
 	"github.com/nacos-group/nacos-sdk-go/v2/clients/naming_client"
 	"github.com/nacos-group/nacos-sdk-go/v2/model"
 	"github.com/nacos-group/nacos-sdk-go/v2/vo"
-	"os"
-	"strconv"
 )
 
 var (
-	cli            naming_client.INamingClient
-	groupName      string
-	ServerUriCache = make(map[string]model.Instance)
+	namingClient naming_client.INamingClient
+	namingMu     sync.Mutex
+	groupName    string
+	serviceCache sync.Map
 )
 
-// NewNacosRegistry 创建一个nacos注册中心
-func NewNacosRegistry() (*naming_client.INamingClient, error) {
-	InitNacosRegistryConfig()
-	if cli != nil {
-		return &cli, nil
+func NewNacosRegistry() (naming_client.INamingClient, error) {
+	namingMu.Lock()
+	defer namingMu.Unlock()
+
+	if namingClient != nil {
+		return namingClient, nil
 	}
+
+	if err := InitNacosRegistryConfig(); err != nil {
+		return nil, err
+	}
+
 	groupName = os.Getenv("NACOS_GROUP_NAME")
 	var err error
-	cli, err = clients.NewNamingClient(
+	namingClient, err = clients.NewNamingClient(
 		vo.NacosClientParam{
 			ClientConfig:  cc,
 			ServerConfigs: sc,
@@ -32,17 +42,21 @@ func NewNacosRegistry() (*naming_client.INamingClient, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &cli, nil
+	return namingClient, nil
 }
 
-// RegisterService 注册当前服务到nacos中
 func RegisterService() error {
 	client, err := NewNacosRegistry()
 	if err != nil {
 		return err
 	}
+
 	serviceName := os.Getenv("NACOS_SERVICE_NAME")
 	host := os.Getenv("NACOS_SERVICE_HOST")
+	if serviceName == "" || host == "" {
+		return errors.New("NACOS_SERVICE_NAME 和 NACOS_SERVICE_HOST 必须配置")
+	}
+
 	port, err := strconv.Atoi(os.Getenv("NACOS_SERVICE_PORT"))
 	if err != nil {
 		port = 8848
@@ -51,7 +65,8 @@ func RegisterService() error {
 	if err != nil {
 		weight = 10
 	}
-	_, err = (*client).RegisterInstance(vo.RegisterInstanceParam{
+
+	_, err = client.RegisterInstance(vo.RegisterInstanceParam{
 		Ip:          host,
 		Port:        uint64(port),
 		ServiceName: serviceName,
@@ -61,43 +76,50 @@ func RegisterService() error {
 		Ephemeral:   false,
 		GroupName:   groupName,
 	})
-	if err != nil {
-		return err
-	}
-	return nil
+	return err
 }
 
-// DiscoverServiceList 发现服务列表
 func DiscoverServiceList(serviceName string) ([]model.Instance, error) {
 	client, err := NewNacosRegistry()
 	if err != nil {
 		return nil, err
 	}
-	instances, err := (*client).SelectInstances(vo.SelectInstancesParam{
+	return client.SelectInstances(vo.SelectInstancesParam{
 		ServiceName: serviceName,
 		HealthyOnly: false,
 		GroupName:   groupName,
 	})
-	if err != nil {
-		return nil, err
-	}
-	return instances, nil
 }
 
-// DiscoverService 发现一个服务
 func DiscoverService(serviceName string) (model.Instance, error) {
-	ServiceCache := ServerUriCache[serviceName]
+	if cached, ok := serviceCache.Load(serviceName); ok {
+		cachedInstance := cached.(model.Instance)
+		client, err := NewNacosRegistry()
+		if err != nil {
+			return cachedInstance, err
+		}
+		instance, err := client.SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
+			ServiceName: serviceName,
+			GroupName:   groupName,
+		})
+		if err != nil {
+			return cachedInstance, err
+		}
+		serviceCache.Store(serviceName, *instance)
+		return *instance, nil
+	}
+
 	client, err := NewNacosRegistry()
 	if err != nil {
-		return ServiceCache, err
+		return model.Instance{}, err
 	}
-	instances, err := (*client).SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
+	instance, err := client.SelectOneHealthyInstance(vo.SelectOneHealthInstanceParam{
 		ServiceName: serviceName,
 		GroupName:   groupName,
 	})
 	if err != nil {
-		return ServiceCache, err
+		return model.Instance{}, err
 	}
-	ServerUriCache[serviceName] = *instances
-	return *instances, nil
+	serviceCache.Store(serviceName, *instance)
+	return *instance, nil
 }

utils/redis_tools/redis_tools.go

@@ -0,0 +1,95 @@
+package redis_tools
+
+import (
+	"apiServer_service/utils/logger"
+	"context"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/go-redis/redis/v8"
+)
+
+var (
+	client *redis.Client
+	once   sync.Once
+)
+
+func ConnectRedis() *redis.Client {
+	once.Do(func() {
+		addr := os.Getenv("REDIS_HOST")
+		if addr == "" {
+			addr = "127.0.0.1:6379"
+		}
+		password := os.Getenv("REDIS_PASSWORD")
+
+		client = redis.NewClient(&redis.Options{
+			Addr:         addr,
+			Password:     password,
+			DB:           0,
+			PoolSize:     20,
+			MinIdleConns: 5,
+			DialTimeout:  5 * time.Second,
+			ReadTimeout:  3 * time.Second,
+			WriteTimeout: 3 * time.Second,
+		})
+
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		if err := client.Ping(ctx).Err(); err != nil {
+			logger.Warn("Redis", "连接失败: ", err)
+			return
+		}
+		logger.Info("Redis", "连接成功")
+	})
+	return client
+}
+
+func GetClient() *redis.Client {
+	return ConnectRedis()
+}
+
+func Close() error {
+	if client != nil {
+		return client.Close()
+	}
+	return nil
+}
+
+// ---- List 操作 ----
+
+func AddToList(key string, value interface{}) error {
+	return GetClient().LPush(context.Background(), key, value).Err()
+}
+
+func GetListRange(key string, start, stop int64) ([]string, error) {
+	return GetClient().LRange(context.Background(), key, start, stop).Result()
+}
+
+func GetAllFromList(key string) ([]string, error) {
+	return GetListRange(key, 0, -1)
+}
+
+func RemoveFromList(key string, value interface{}) error {
+	return GetClient().LRem(context.Background(), key, 0, value).Err()
+}
+
+// ---- KV 缓存操作 ----
+
+func SetCache(key string, value interface{}, expiration time.Duration) error {
+	return GetClient().Set(context.Background(), key, value, expiration).Err()
+}
+
+func GetCache(key string) (string, error) {
+	return GetClient().Get(context.Background(), key).Result()
+}
+
+func Exists(key string) bool {
+	n, err := GetClient().Exists(context.Background(), key).Result()
+	return err == nil && n > 0
+}
+
+func Del(keys ...string) error {
+	return GetClient().Del(context.Background(), keys...).Err()
+}

utils/request/request.go

@@ -1,16 +1,14 @@
 package request
 
 import (
-	"apiServer_service/utils/loger"
+	"apiServer_service/utils/logger"
 	"fmt"
 	"github.com/cloudwego/hertz/pkg/app"
 )
 
-// BindRequestStruct 结构体参数绑定
-func BindRequestStruct(c *app.RequestContext, request interface{}) error {
-	err := c.BindAndValidate(request)
-	if err != nil {
-		loger.Debug("BindRequestStruct", fmt.Sprintf("参数错误: %v", err))
+func BindRequestStruct(c *app.RequestContext, req interface{}) error {
+	if err := c.BindAndValidate(req); err != nil {
+		logger.Debug("BindRequestStruct", fmt.Sprintf("参数错误: %v", err))
 		BadRequest(c, "参数错误")
 		return err
 	}

utils/server_cli/serverCli.go

@@ -2,21 +2,29 @@ package server_cli
 
 import (
 	"apiServer_service/proto"
-	"apiServer_service/utils/loger"
+	"apiServer_service/utils/logger"
 	"apiServer_service/utils/nacos"
 	"context"
 	"errors"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/metadata"
 	"os"
 	"strconv"
+	"sync"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/metadata"
+)
+
+var (
+	grpcConn   *grpc.ClientConn
+	grpcClient proto.ServerVisitServiceClient
+	connMu     sync.Mutex
 )
 
-// 获取 apiServer 的地址
 func getApiServer() string {
 	service, err := nacos.DiscoverService("apiServer")
 	if err != nil {
-		loger.Error("获取服务器地址失败", err)
+		logger.Error("获取服务器地址失败", err)
 		if service.Ip != "" {
 			return service.Ip + ":" + strconv.Itoa(int(service.Port))
 		}
@@ -25,42 +33,56 @@ func getApiServer() string {
 	return service.Ip + ":" + strconv.Itoa(int(service.Port))
 }
 
-// 获取 grpc 客户端
-func getGrpcClient() (*proto.ServerVisitServiceClient, error) {
+func getGrpcClient() (proto.ServerVisitServiceClient, error) {
+	connMu.Lock()
+	defer connMu.Unlock()
+
+	if grpcClient != nil && grpcConn != nil {
+		return grpcClient, nil
+	}
+
 	serverUri := getApiServer()
 	if serverUri == "" {
-		loger.Error("获取服务器地址失败")
-		return nil, errors.New("getApiServer error")
+		return nil, errors.New("无法获取 apiServer 地址")
 	}
-	conn, err := grpc.NewClient(serverUri, grpc.WithInsecure())
+
+	conn, err := grpc.NewClient(serverUri, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	if err != nil {
-		loger.Error("getGrpcClient error", err)
+		logger.Error("gRPC 连接失败", err)
 		return nil, err
 	}
 
-	c := proto.NewServerVisitServiceClient(conn)
-	return &c, nil
+	grpcConn = conn
+	grpcClient = proto.NewServerVisitServiceClient(conn)
+	return grpcClient, nil
 }
 
-// getContext 创建带有 token 的上下文
-func getContext() context.Context { // 创建带有 token 的上下文
+func getContext() context.Context {
 	token := os.Getenv("GRPC_TOKEN")
-	md := metadata.Pairs("authorization", "Bearer "+token) // 设置 authorization 头
-	ctx := metadata.NewOutgoingContext(context.Background(), md)
-	return ctx
+	md := metadata.Pairs("authorization", "Bearer "+token)
+	return metadata.NewOutgoingContext(context.Background(), md)
 }
 
-// ReportVisit 演示方法 向服务器上报访问记录
-func ReportVisit(token, note, VisitIp, OS string, point, UserId int) error {
+func ReportVisit(token, note, visitIP, osName string, point, userID int) error {
 	client, err := getGrpcClient()
 	if err != nil {
 		return err
 	}
-	recode, err := (*client).AddServerVisitRecode(getContext(), &proto.ServerVisitRequest{})
+	record, err := client.AddServerVisitRecode(getContext(), &proto.ServerVisitRequest{})
 	if err != nil {
-		loger.Error("ReportVisit error", err)
+		logger.Error("ReportVisit error", err)
 		return err
 	}
-	loger.Debug("ReportVisit", recode)
+	logger.Debug("ReportVisit", record)
 	return nil
 }
+
+func CloseGrpcConn() {
+	connMu.Lock()
+	defer connMu.Unlock()
+	if grpcConn != nil {
+		grpcConn.Close()
+		grpcConn = nil
+		grpcClient = nil
+	}
+}