自动建立表通过-doris

myservice/crypto_service.go

@@ -0,0 +1,156 @@
+package myservice
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"strings"
+)
+
+// CryptoService 加密服务结构体
+type CryptoService struct {
+	key    []byte
+	prefix string // 加密文本前缀，用于识别是否已加密
+}
+
+// NewCryptoService 创建加密服务
+func NewCryptoService(key string) (*CryptoService, error) {
+	keyBytes := []byte(key)
+
+	// 如果密钥长度不足，使用PBKDF2派生密钥
+	if len(keyBytes) < 32 {
+		derivedKey, err := deriveKey(keyBytes, 32)
+		if err != nil {
+			return nil, err
+		}
+		keyBytes = derivedKey
+	} else if len(keyBytes) > 32 {
+		keyBytes = keyBytes[:32] // 截取前32字节
+	}
+
+	return &CryptoService{
+		key:    keyBytes,
+		prefix: "ENC::", // 加密文本前缀
+	}, nil
+}
+
+// deriveKey 使用PBKDF2派生密钥
+func deriveKey(password []byte, keyLen int) ([]byte, error) {
+	// 这里简化实现，实际应该使用crypto/sha256和更复杂的盐
+	// 为了简单示例，使用固定盐（生产环境应该使用随机盐）
+	salt := []byte("fixed-salt-for-demo")
+
+	hash := make([]byte, keyLen)
+	for i := 0; i < keyLen; i++ {
+		if i < len(password) {
+			hash[i] = password[i] ^ salt[i%len(salt)]
+		} else {
+			hash[i] = salt[i%len(salt)]
+		}
+	}
+	return hash, nil
+}
+
+// Encrypt 加密文本
+func (cs *CryptoService) Encrypt(plaintext string) (string, error) {
+	// 如果已经是加密文本，直接返回
+	if cs.IsEncrypted(plaintext) {
+		return plaintext, nil
+	}
+
+	block, err := aes.NewCipher(cs.key)
+	if err != nil {
+		return "", fmt.Errorf("创建密码块失败: %w", err)
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", fmt.Errorf("创建GCM模式失败: %w", err)
+	}
+
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+		return "", fmt.Errorf("生成随机数失败: %w", err)
+	}
+
+	ciphertext := gcm.Seal(nonce, nonce, []byte(plaintext), nil)
+	encoded := base64.StdEncoding.EncodeToString(ciphertext)
+
+	// 添加前缀标识
+	return cs.prefix + encoded, nil
+}
+
+// Decrypt 解密文本
+func (cs *CryptoService) Decrypt(input string) (string, error) {
+	// 如果不是加密文本，直接返回原文本
+	if !cs.IsEncrypted(input) {
+		return input, nil
+	}
+
+	// 移除前缀
+	encoded := strings.TrimPrefix(input, cs.prefix)
+
+	ciphertext, err := base64.StdEncoding.DecodeString(encoded)
+	if err != nil {
+		// 如果不是有效的Base64，返回原文本
+		return input, nil
+	}
+
+	block, err := aes.NewCipher(cs.key)
+	if err != nil {
+		return "", fmt.Errorf("创建密码块失败: %w", err)
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", fmt.Errorf("创建GCM模式失败: %w", err)
+	}
+
+	if len(ciphertext) < gcm.NonceSize() {
+		return "", errors.New("密文太短")
+	}
+
+	nonce, ciphertext := ciphertext[:gcm.NonceSize()], ciphertext[gcm.NonceSize():]
+
+	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		// 如果解密失败，返回原文本（可能是格式相似但不是真正的加密文本）
+		return input, nil
+	}
+
+	return string(plaintext), nil
+}
+
+// IsEncrypted 检查文本是否已加密
+func (cs *CryptoService) IsEncrypted(text string) bool {
+	return strings.HasPrefix(text, cs.prefix)
+}
+
+// EncryptOrDecrypt 智能加密或解密
+// 如果输入是明文则加密，如果已是密文则解密
+func (cs *CryptoService) EncryptOrDecrypt(input string) (string, error) {
+	if cs.IsEncrypted(input) {
+		return cs.Decrypt(input)
+	}
+	return cs.Encrypt(input)
+}
+
+// EncryptIfNeeded 如果需要则加密
+func (cs *CryptoService) EncryptIfNeeded(input string) (string, error) {
+	if cs.IsEncrypted(input) {
+		return input, nil
+	}
+	return cs.Encrypt(input)
+}
+
+// DecryptIfNeeded 如果需要则解密
+func (cs *CryptoService) DecryptIfNeeded(input string) (string, error) {
+	if cs.IsEncrypted(input) {
+		return cs.Decrypt(input)
+	}
+	return input, nil
+}

webx/web_binder.go

@@ -0,0 +1,159 @@
+package webx
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"reflect"
+	"strconv"
+	"strings"
+)
+
+// invokeHandler 调用处理器函数
+func (rb *routeBuilder) invokeHandler(ctx context.Context, w http.ResponseWriter, req *http.Request) {
+	handlerType := reflect.TypeOf(rb.handler)
+	handlerValue := reflect.ValueOf(rb.handler)
+
+	// 获取参数数量
+	numIn := handlerType.NumIn()
+	args := make([]reflect.Value, numIn)
+
+	// 绑定每个参数
+	for i := 0; i < numIn; i++ {
+		paramType := handlerType.In(i)
+		args[i] = rb.bindParam(i, paramType, ctx, w, req)
+	}
+
+	// 调用处理器函数
+	results := handlerValue.Call(args)
+
+	// 处理返回值
+	rb.handleResults(results, w)
+}
+
+// bindParam 绑定单个参数
+func (rb *routeBuilder) bindParam(index int, paramType reflect.Type, ctx context.Context, w http.ResponseWriter, req *http.Request) reflect.Value {
+	// 特殊类型绑定
+	switch paramType {
+	case reflect.TypeOf((*http.ResponseWriter)(nil)).Elem():
+		return reflect.ValueOf(w)
+	case reflect.TypeOf((*http.Request)(nil)):
+		return reflect.ValueOf(req)
+	case reflect.TypeOf((*context.Context)(nil)).Elem():
+		return reflect.ValueOf(ctx)
+	}
+
+	// 基本类型 - 尝试从路径参数绑定
+	if paramType.Kind() == reflect.String || paramType.Kind() == reflect.Int || paramType.Kind() == reflect.Int64 {
+		// 尝试从路径中提取参数
+		if pathParam := extractPathParam(rb.path, req.URL.Path, index); pathParam != "" {
+			return convertToType(pathParam, paramType)
+		}
+
+		// 尝试从查询参数绑定
+		if queryParam := extractQueryParam(paramType.Name(), req); queryParam != "" {
+			return convertToType(queryParam, paramType)
+		}
+	}
+
+	// 结构体 - 从 JSON 请求体绑定
+	if paramType.Kind() == reflect.Struct || (paramType.Kind() == reflect.Ptr && paramType.Elem().Kind() == reflect.Struct) {
+		return rb.bindFromJSON(paramType, req)
+	}
+
+	// 返回零值
+	return reflect.Zero(paramType)
+}
+
+// extractPathParam 从路径提取参数
+func extractPathParam(pattern, actualPath string, index int) string {
+	patternParts := strings.Split(strings.Trim(pattern, "/"), "/")
+	actualParts := strings.Split(strings.Trim(actualPath, "/"), "/")
+
+	for i, part := range patternParts {
+		if strings.HasPrefix(part, "{") && strings.HasSuffix(part, "}") {
+			if i < len(actualParts) {
+				return actualParts[i]
+			}
+		}
+	}
+
+	// 如果路径中没有参数，尝试最后一个部分
+	if len(actualParts) > 0 {
+		return actualParts[len(actualParts)-1]
+	}
+
+	return ""
+}
+
+// extractQueryParam 从查询参数提取
+func extractQueryParam(paramName string, req *http.Request) string {
+	// 转换为小写查找
+	key := strings.ToLower(paramName)
+	return req.URL.Query().Get(key)
+}
+
+// bindFromJSON 从 JSON 绑定
+func (rb *routeBuilder) bindFromJSON(paramType reflect.Type, req *http.Request) reflect.Value {
+	var val reflect.Value
+
+	if paramType.Kind() == reflect.Ptr {
+		val = reflect.New(paramType.Elem())
+	} else {
+		val = reflect.New(paramType)
+	}
+
+	if req.Body != nil {
+		defer req.Body.Close()
+		json.NewDecoder(req.Body).Decode(val.Interface())
+	}
+
+	if paramType.Kind() == reflect.Ptr {
+		return val
+	}
+	return val.Elem()
+}
+
+// convertToType 字符串转换为指定类型
+func convertToType(str string, targetType reflect.Type) reflect.Value {
+	switch targetType.Kind() {
+	case reflect.String:
+		return reflect.ValueOf(str)
+	case reflect.Int:
+		if i, err := strconv.Atoi(str); err == nil {
+			return reflect.ValueOf(i)
+		}
+	case reflect.Int64:
+		if i, err := strconv.ParseInt(str, 10, 64); err == nil {
+			return reflect.ValueOf(i)
+		}
+	case reflect.Bool:
+		if b, err := strconv.ParseBool(str); err == nil {
+			return reflect.ValueOf(b)
+		}
+	}
+	return reflect.Zero(targetType)
+}
+
+// handleResults 处理返回值
+func (rb *routeBuilder) handleResults(results []reflect.Value, w http.ResponseWriter) {
+	if len(results) == 0 {
+		return
+	}
+
+	// 第一个返回值处理
+	firstResult := results[0].Interface()
+
+	// 如果是错误
+	if err, ok := firstResult.(error); ok {
+		w.WriteHeader(http.StatusInternalServerError)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"error": err.Error(),
+		})
+		return
+	}
+
+	// 如果是其他类型，返回 JSON
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(firstResult)
+}

webx/web_router.go

@@ -0,0 +1,128 @@
+package webx
+
+import (
+	"net/http"
+)
+
+// HandlerFunc 通用的处理器函数类型
+type HandlerFunc interface{}
+
+// Router 路由器
+type Router struct {
+	mux          *http.ServeMux
+	globalBefore []func(http.Handler) http.Handler
+	globalAfter  []func(http.ResponseWriter, *http.Request)
+}
+
+func NewRouter(mux *http.ServeMux) *Router {
+	return &Router{
+		mux: mux,
+	}
+}
+
+// UseBefore 在处理器前执行的中间件
+func (r *Router) UseBefore(middleware ...func(http.Handler) http.Handler) *Router {
+	r.globalBefore = append(r.globalBefore, middleware...)
+	return r
+}
+
+// UseAfter 在处理器后执行的中间件
+func (r *Router) UseAfter(middleware ...func(http.ResponseWriter, *http.Request)) *Router {
+	r.globalAfter = append(r.globalAfter, middleware...)
+	return r
+}
+
+// GET 注册 GET 请求
+func (r *Router) GET(path string, handler HandlerFunc) *routeBuilder {
+	return r.handle("GET", path, handler)
+}
+
+// POST 注册 POST 请求
+func (r *Router) POST(path string, handler HandlerFunc) *routeBuilder {
+	return r.handle("POST", path, handler)
+}
+
+// handle 内部处理方法
+func (r *Router) handle(method, path string, handler HandlerFunc) *routeBuilder {
+	return &routeBuilder{
+		router:  r,
+		method:  method,
+		path:    path,
+		handler: handler,
+	}
+}
+
+// 路由构建器
+type routeBuilder struct {
+	router      *Router
+	method      string
+	path        string
+	handler     HandlerFunc
+	before      []func(http.Handler) http.Handler
+	after       []func(http.ResponseWriter, *http.Request)
+	description string
+}
+
+// Before 添加路由前中间件
+func (rb *routeBuilder) Before(middleware ...func(http.Handler) http.Handler) *routeBuilder {
+	rb.before = append(rb.before, middleware...)
+	return rb
+}
+
+// After 添加路由后中间件
+func (rb *routeBuilder) After(middleware ...func(http.ResponseWriter, *http.Request)) *routeBuilder {
+	rb.after = append(rb.after, middleware...)
+	return rb
+}
+
+// Desc 添加描述
+func (rb *routeBuilder) Desc(desc string) *routeBuilder {
+	rb.description = desc
+	return rb
+}
+
+// Register 注册路由
+func (rb *routeBuilder) Register() {
+	// 创建最终的 HTTP 处理器
+	finalHandler := rb.createHandler()
+
+	// 应用路由级 before 中间件
+	for i := len(rb.before) - 1; i >= 0; i-- {
+		finalHandler = rb.before[i](finalHandler)
+	}
+
+	// 应用全局 before 中间件
+	for i := len(rb.router.globalBefore) - 1; i >= 0; i-- {
+		finalHandler = rb.router.globalBefore[i](finalHandler)
+	}
+
+	// 注册到 ServeMux
+	rb.router.mux.Handle(rb.path, finalHandler)
+}
+
+// 创建处理器
+func (rb *routeBuilder) createHandler() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		// 方法检查
+		if rb.method != "" && req.Method != rb.method {
+			http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+			return
+		}
+
+		// 创建上下文
+		ctx := req.Context()
+
+		// 执行处理器
+		rb.invokeHandler(ctx, w, req)
+
+		// 执行路由级 after 中间件
+		for _, after := range rb.after {
+			after(w, req)
+		}
+
+		// 执行全局 after 中间件
+		for _, after := range rb.router.globalAfter {
+			after(w, req)
+		}
+	})
+}

webx/web_service.go

@@ -0,0 +1,261 @@
+package webx
+
+import (
+	"encoding/json"
+	"net/http"
+	"reflect"
+	"strings"
+)
+
+// WebService 路由服务
+type WebService struct {
+	router *http.ServeMux
+}
+
+// NewWebService 创建WebService
+func NewWebService(router *http.ServeMux) *WebService {
+	return &WebService{router: router}
+}
+
+// RouteBuilder 路由构建器
+type RouteBuilder struct {
+	method      string
+	path        string
+	handlerFunc reflect.Value
+	paramNames  []string
+	paramTypes  []reflect.Type
+	middlewares []func(http.Handler) http.Handler
+	router      *http.ServeMux
+}
+
+// GET 注册GET请求
+func (ws *WebService) GET(path string, handler interface{}) *RouteBuilder {
+	return ws.handle("GET", path, handler)
+}
+
+// POST 注册POST请求
+func (ws *WebService) POST(path string, handler interface{}) *RouteBuilder {
+	return ws.handle("POST", path, handler)
+}
+
+// PUT 注册PUT请求
+func (ws *WebService) PUT(path string, handler interface{}) *RouteBuilder {
+	return ws.handle("PUT", path, handler)
+}
+
+// DELETE 注册DELETE请求
+func (ws *WebService) DELETE(path string, handler interface{}) *RouteBuilder {
+	return ws.handle("DELETE", path, handler)
+}
+
+// handle 统一处理方法
+func (ws *WebService) handle(method, path string, handler interface{}) *RouteBuilder {
+	// 解析路径参数名
+	paramNames := extractPathParams(path)
+
+	// 获取处理器函数信息
+	handlerValue := reflect.ValueOf(handler)
+	handlerType := handlerValue.Type()
+
+	// 验证处理器函数
+	if handlerType.Kind() != reflect.Func {
+		panic("handler must be a function")
+	}
+
+	// 获取参数类型
+	paramTypes := make([]reflect.Type, handlerType.NumIn())
+	for i := 0; i < handlerType.NumIn(); i++ {
+		paramTypes[i] = handlerType.In(i)
+	}
+
+	// 验证返回值
+	if handlerType.NumOut() != 2 {
+		panic("handler must return exactly 2 values: (T, error)")
+	}
+
+	return &RouteBuilder{
+		method:      method,
+		path:        path,
+		handlerFunc: handlerValue,
+		paramNames:  paramNames,
+		paramTypes:  paramTypes,
+		router:      ws.router,
+	}
+}
+
+// Use 添加中间件
+func (rb *RouteBuilder) Use(middleware ...func(http.Handler) http.Handler) *RouteBuilder {
+	rb.middlewares = append(rb.middlewares, middleware...)
+	return rb
+}
+
+// Register 注册路由
+func (rb *RouteBuilder) Register() {
+	// 创建适配器
+	adapter := &handlerAdapter{
+		method:      rb.method,
+		pathPattern: rb.path,
+		paramNames:  rb.paramNames,
+		paramTypes:  rb.paramTypes,
+		handlerFunc: rb.handlerFunc,
+	}
+
+	// 应用中间件
+	var handler http.Handler = adapter
+	for i := len(rb.middlewares) - 1; i >= 0; i-- {
+		handler = rb.middlewares[i](handler)
+	}
+
+	// 注册到路由器
+	rb.router.Handle(rb.path, handler)
+}
+
+// handlerAdapter 处理器适配器
+type handlerAdapter struct {
+	method      string
+	pathPattern string
+	paramNames  []string
+	paramTypes  []reflect.Type
+	handlerFunc reflect.Value
+}
+
+func (ha *handlerAdapter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// 只处理指定方法的请求
+	if r.Method != ha.method {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+
+	// 1. 解析路径参数
+	pathParams := ha.parsePathParams(r.URL.Path)
+
+	// 2. 构建函数参数
+	args := ha.buildArgs(r, pathParams)
+	if args == nil {
+		http.Error(w, "Invalid parameters", http.StatusBadRequest)
+		return
+	}
+
+	// 3. 调用处理器函数
+	results := ha.handlerFunc.Call(args)
+
+	// 4. 处理返回结果
+	ha.handleResponse(w, results)
+}
+
+// parsePathParams 解析路径参数
+func (ha *handlerAdapter) parsePathParams(requestPath string) map[string]string {
+	params := make(map[string]string)
+
+	// 简单实现：按/分割，然后匹配
+	patternParts := strings.Split(ha.pathPattern, "/")
+	requestParts := strings.Split(requestPath, "/")
+
+	if len(patternParts) != len(requestParts) {
+		return params
+	}
+
+	for i, patternPart := range patternParts {
+		if strings.HasPrefix(patternPart, "{") && strings.HasSuffix(patternPart, "}") {
+			paramName := patternPart[1 : len(patternPart)-1]
+			params[paramName] = requestParts[i]
+		}
+	}
+
+	return params
+}
+
+// buildArgs 构建函数参数
+func (ha *handlerAdapter) buildArgs(r *http.Request, pathParams map[string]string) []reflect.Value {
+	args := make([]reflect.Value, len(ha.paramTypes))
+
+	// 参数索引
+	pathParamIndex := 0
+
+	for i, paramType := range ha.paramTypes {
+		// 情况1：路径参数（必须是string类型）
+		if pathParamIndex < len(ha.paramNames) && paramType.Kind() == reflect.String {
+			paramName := ha.paramNames[pathParamIndex]
+			if value, ok := pathParams[paramName]; ok {
+				args[i] = reflect.ValueOf(value)
+				pathParamIndex++
+				continue
+			}
+		}
+
+		// 情况2：Body参数（POST/PUT等请求的结构体）
+		if r.Method == "POST" || r.Method == "PUT" || r.Method == "PATCH" {
+			// 检查是否是结构体类型
+			if paramType.Kind() == reflect.Struct ||
+				(paramType.Kind() == reflect.Ptr && paramType.Elem().Kind() == reflect.Struct) {
+				bodyParam, err := ha.parseBody(r, paramType)
+				if err != nil {
+					return nil
+				}
+				args[i] = bodyParam
+				continue
+			}
+		}
+
+		// 无法处理的参数类型
+		return nil
+	}
+
+	return args
+}
+
+// parseBody 解析请求体
+func (ha *handlerAdapter) parseBody(r *http.Request, paramType reflect.Type) (reflect.Value, error) {
+	// 创建参数实例
+	var paramValue reflect.Value
+	if paramType.Kind() == reflect.Ptr {
+		paramValue = reflect.New(paramType.Elem())
+	} else {
+		paramValue = reflect.New(paramType)
+	}
+
+	// 解析JSON
+	if err := json.NewDecoder(r.Body).Decode(paramValue.Interface()); err != nil {
+		return reflect.Value{}, err
+	}
+
+	// 如果是非指针类型，需要解引用
+	if paramType.Kind() != reflect.Ptr {
+		paramValue = paramValue.Elem()
+	}
+
+	return paramValue, nil
+}
+
+// handleResponse 处理响应
+func (ha *handlerAdapter) handleResponse(w http.ResponseWriter, results []reflect.Value) {
+	// 第一个返回值是数据
+	data := results[0].Interface()
+
+	// 第二个返回值是error
+	errVal := results[1].Interface()
+	if errVal != nil {
+		err := errVal.(error)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// 返回JSON响应
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(data)
+}
+
+// extractPathParams 从路径中提取参数名
+func extractPathParams(path string) []string {
+	var params []string
+	parts := strings.Split(path, "/")
+
+	for _, part := range parts {
+		if strings.HasPrefix(part, "{") && strings.HasSuffix(part, "}") {
+			paramName := part[1 : len(part)-1]
+			params = append(params, paramName)
+		}
+	}
+
+	return params
+}