refactor(conf): optimize error handling

Author: lvan100

CODE_OF_CONDUCT.md

@@ -146,4 +146,4 @@ Appeals can be submitted via email to the maintainers.
 * 暂停或永久禁用项目访问权限
 * 向相关平台报告
 
-如对处理结果有异议，可通过电子邮件向维护者提交申诉。
+如对处理结果有异议，可通过电子邮件向维护者提交申诉。

CONTRIBUTING.md

@@ -31,37 +31,37 @@ new features. Please follow the guidelines below to contribute.
 
 2. **Maintain consistent coding style**
 
-   * Follow Go’s official style guidelines (`gofmt`, `golint`, `go vet`).
-   * Recommended: [`golangci-lint`](https://github.com/golangci/golangci-lint) for local linting.
+    * Follow Go’s official style guidelines (`gofmt`, `golint`, `go vet`).
+    * Recommended: [`golangci-lint`](https://github.com/golangci/golangci-lint) for local linting.
 
 3. **Write tests**
 
-   * All new features or bug fixes must include unit tests.
-   * Use Go’s `testing` package; test files should be named `xxx_test.go`.
-   * Example:
+    * All new features or bug fixes must include unit tests.
+    * Use Go’s `testing` package; test files should be named `xxx_test.go`.
+    * Example:
 
-     ```go
-     func TestAdd(t *testing.T) {
-         result := Add(1, 2)
-         if result != 3 {
-             t.Errorf("expected 3, got %d", result)
-         }
-     }
-     ```
+      ```go
+      func TestAdd(t *testing.T) {
+          result := Add(1, 2)
+          if result != 3 {
+              t.Errorf("expected 3, got %d", result)
+          }
+      }
+      ```
 
 4. **Update documentation**
 
-   * If your changes affect usage or APIs, update README or code comments.
+    * If your changes affect usage or APIs, update README or code comments.
 
 5. **Submit and create a Pull Request**
 
-   * Clearly describe:
+    * Clearly describe:
 
-      * **What**: What changes are made
-      * **Why**: Why the changes are needed
-      * **How**: How it was implemented
-      * **Testing**: How it was tested
-   * Link related issues if applicable.
+        * **What**: What changes are made
+        * **Why**: Why the changes are needed
+        * **How**: How it was implemented
+        * **Testing**: How it was tested
+    * Link related issues if applicable.
 
 ## Branch Naming Guidelines
 
@@ -126,37 +126,37 @@ Thank you for contributing to Go-Spring!
 
 2. **保持一致的代码风格**
 
-   * 遵循 Go 官方代码规范（使用 `gofmt`、`golint`、`go vet`）。
-   * 推荐使用 [`golangci-lint`](https://github.com/golangci/golangci-lint) 进行本地检查。
+    * 遵循 Go 官方代码规范（使用 `gofmt`、`golint`、`go vet`）。
+    * 推荐使用 [`golangci-lint`](https://github.com/golangci/golangci-lint) 进行本地检查。
 
 3. **编写测试用例**
 
-   * 所有新功能或 Bug 修复必须配备单元测试。
-   * 使用 Go 内置 `testing` 包，测试文件命名为 `xxx_test.go`。
-   * 示例：
+    * 所有新功能或 Bug 修复必须配备单元测试。
+    * 使用 Go 内置 `testing` 包，测试文件命名为 `xxx_test.go`。
+    * 示例：
 
-     ```go
-     func TestAdd(t *testing.T) {
-         result := Add(1, 2)
-         if result != 3 {
-             t.Errorf("expected 3, got %d", result)
-         }
-     }
-     ```
+      ```go
+      func TestAdd(t *testing.T) {
+          result := Add(1, 2)
+          if result != 3 {
+              t.Errorf("expected 3, got %d", result)
+          }
+      }
+      ```
 
 4. **更新文档**
 
-   * 如果变更影响使用或接口，请同步更新 README 或代码注释。
+    * 如果变更影响使用或接口，请同步更新 README 或代码注释。
 
 5. **提交并创建 Pull Request**
 
-   * 清晰说明：
+    * 清晰说明：
 
-      * **What**：本次修改的内容
-      * **Why**：修改原因
-      * **How**：实现方式
-      * **Testing**：测试情况
-   * 关联相关 Issue（如有）。
+        * **What**：本次修改的内容
+        * **Why**：修改原因
+        * **How**：实现方式
+        * **Testing**：测试情况
+    * 关联相关 Issue（如有）。
 
 ## 分支命名规范
 
@@ -185,4 +185,4 @@ Thank you for contributing to Go-Spring!
 * 可通过 GitHub Issue 提问或反馈
 * 参与项目讨论区交流
 
-感谢你为 Go-Spring 做出的贡献！
+感谢你为 Go-Spring 做出的贡献！

conf/bind.go

@@ -23,8 +23,7 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/go-spring/log"
-	"github.com/go-spring/spring-core/util"
+	"github.com/go-spring/spring-base/util"
 )
 
 var (
@@ -93,12 +92,12 @@ func (tag ParsedTag) String() string {
 func ParseTag(tag string) (ret ParsedTag, err error) {
 	j := strings.LastIndex(tag, "}")
 	if j <= 0 {
-		err = log.FormatError(ErrInvalidSyntax, "parse tag '%s' error", tag)
+		err = util.FormatError(ErrInvalidSyntax, "parse tag '%s' error", tag)
 		return
 	}
 	k := strings.Index(tag, "${")
 	if k < 0 {
-		err = log.FormatError(ErrInvalidSyntax, "parse tag '%s' error", tag)
+		err = util.FormatError(ErrInvalidSyntax, "parse tag '%s' error", tag)
 		return
 	}
 	if i := strings.LastIndex(tag, ">>"); i > j {
@@ -145,7 +144,7 @@ func (param *BindParam) BindTag(tag string, validate reflect.StructTag) error {
 			param.Tag = parsedTag
 			return nil
 		}
-		return log.FormatError(ErrInvalidSyntax, "parse tag '%s' error", tag)
+		return util.FormatError(ErrInvalidSyntax, "parse tag '%s' error", tag)
 	}
 	if parsedTag.Key == "ROOT" {
 		parsedTag.Key = ""
@@ -180,16 +179,18 @@ type Filter interface {
 func BindValue(p Properties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) (RetErr error) {
 
 	if !util.IsPropBindingTarget(t) {
-		err := errors.New("target should be value type")
-		return log.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		err := util.FormatError(nil, "target should be value type")
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	// run validation if "expr" tag is defined and no prior error
 	defer func() {
 		if RetErr == nil {
 			tag, ok := param.Validate.Lookup("expr")
 			if ok && len(tag) > 0 {
-				RetErr = validateField(tag, v.Interface())
+				if RetErr = validateField(tag, v.Interface()); RetErr != nil {
+					RetErr = util.FormatError(RetErr, "validate path=%s type=%s error", param.Path, v.Type().String())
+				}
 			}
 		}
 	}()
@@ -200,8 +201,8 @@ func BindValue(p Properties, v reflect.Value, t reflect.Type, param BindParam, f
 	case reflect.Slice:
 		return bindSlice(p, v, t, param, filter)
 	case reflect.Array:
-		err := errors.New("use slice instead of array")
-		return log.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		err := util.FormatError(nil, "use slice instead of array")
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	default: // for linter
 	}
 
@@ -216,7 +217,7 @@ func BindValue(p Properties, v reflect.Value, t reflect.Type, param BindParam, f
 	// resolve property value (with default and references)
 	val, err := resolve(p, param)
 	if err != nil {
-		return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	// try converter function first
@@ -225,7 +226,7 @@ func BindValue(p Properties, v reflect.Value, t reflect.Type, param BindParam, f
 		out := fnValue.Call([]reflect.Value{reflect.ValueOf(val)})
 		if !out[1].IsNil() {
 			err = out[1].Interface().(error)
-			return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+			return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 		}
 		v.Set(out[0])
 		return nil
@@ -239,28 +240,28 @@ func BindValue(p Properties, v reflect.Value, t reflect.Type, param BindParam, f
 			v.SetUint(u)
 			return nil
 		}
-		return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		var i int64
 		if i, err = strconv.ParseInt(val, 0, 0); err == nil {
 			v.SetInt(i)
 			return nil
 		}
-		return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	case reflect.Float32, reflect.Float64:
 		var f float64
 		if f, err = strconv.ParseFloat(val, 64); err == nil {
 			v.SetFloat(f)
 			return nil
 		}
-		return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	case reflect.Bool:
 		var b bool
 		if b, err = strconv.ParseBool(val); err == nil {
 			v.SetBool(b)
 			return nil
 		}
-		return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	default:
 		// treat everything else as string
 		v.SetString(val)
@@ -283,7 +284,7 @@ func bindSlice(p Properties, v reflect.Value, t reflect.Type, param BindParam, f
 	elemType := t.Elem()
 	p, err := getSlice(p, elemType, param)
 	if err != nil {
-		return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	slice := reflect.MakeSlice(t, 0, 0)
@@ -305,7 +306,7 @@ func bindSlice(p Properties, v reflect.Value, t reflect.Type, param BindParam, f
 			break
 		}
 		if err != nil {
-			return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+			return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 		}
 		slice = reflect.Append(slice, subValue)
 	}
@@ -336,13 +337,13 @@ func getSlice(p Properties, et reflect.Type, param BindParam) (Properties, error
 			strVal = p.Get(param.Key)
 		} else {
 			if !param.Tag.HasDef {
-				return nil, fmt.Errorf("property %q %w", param.Key, ErrNotExist)
+				return nil, util.FormatError(nil, "property %q %w", param.Key, ErrNotExist)
 			}
 			if param.Tag.Def == "" {
 				return nil, nil
 			}
 			if !util.IsPrimitiveValueType(et) && converters[et] == nil {
-				return nil, fmt.Errorf("can't find converter for %s", et.String())
+				return nil, util.FormatError(nil, "can't find converter for %s", et.String())
 			}
 			strVal = param.Tag.Def
 		}
@@ -365,10 +366,10 @@ func getSlice(p Properties, et reflect.Type, param BindParam) (Properties, error
 	} else if fn, ok := splitters[s]; ok && fn != nil {
 		// use custom splitter function
 		if arrVal, err = fn(strVal); err != nil {
-			return nil, log.FormatError(err, "split %q error", strVal)
+			return nil, util.FormatError(err, "split %q error", strVal)
 		}
 	} else {
-		return nil, fmt.Errorf("unknown splitter '%s'", s)
+		return nil, util.FormatError(nil, "unknown splitter '%s'", s)
 	}
 
 	r := New()
@@ -396,8 +397,8 @@ func getSlice(p Properties, et reflect.Type, param BindParam) (Properties, error
 func bindMap(p Properties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) error {
 
 	if param.Tag.HasDef && param.Tag.Def != "" {
-		err := errors.New("map can't have a non-empty default value")
-		return log.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		err := util.FormatError(nil, "map can't have a non-empty default value")
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	elemType := t.Elem()
@@ -416,13 +417,13 @@ func bindMap(p Properties, v reflect.Value, t reflect.Type, param BindParam, fil
 		if param.Tag.HasDef {
 			return nil
 		}
-		return fmt.Errorf("property %q %w", param.Key, ErrNotExist)
+		return util.FormatError(nil, "property %q %w", param.Key, ErrNotExist)
 	}
 
 	// fetch subkeys under the current key prefix
 	keys, err := p.SubKeys(param.Key)
 	if err != nil {
-		return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	for _, key := range keys {
@@ -464,8 +465,8 @@ func bindMap(p Properties, v reflect.Value, t reflect.Type, param BindParam, fil
 func bindStruct(p Properties, v reflect.Value, t reflect.Type, param BindParam, filter Filter) error {
 
 	if param.Tag.HasDef && param.Tag.Def != "" {
-		err := errors.New("struct can't have a non-empty default value")
-		return log.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+		err := util.FormatError(nil, "struct can't have a non-empty default value")
+		return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 	}
 
 	for i := range t.NumField() {
@@ -484,12 +485,12 @@ func bindStruct(p Properties, v reflect.Value, t reflect.Type, param BindParam,
 
 		if tag, ok := ft.Tag.Lookup("value"); ok {
 			if err := subParam.BindTag(tag, ft.Tag); err != nil {
-				return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+				return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 			}
 			if filter != nil {
 				ret, err := filter.Do(fv.Addr().Interface(), subParam)
 				if err != nil {
-					return log.WrapError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
+					return util.FormatError(err, "bind path=%s type=%s error", param.Path, v.Type().String())
 				}
 				if ret {
 					continue
@@ -531,12 +532,12 @@ func resolve(p Properties, param BindParam) (string, error) {
 		return resolveString(p, val)
 	}
 	if p.Has(param.Key) {
-		return "", fmt.Errorf("property %q isn't simple value", param.Key)
+		return "", util.FormatError(nil, "property %q isn't simple value", param.Key)
 	}
 	if param.Tag.HasDef {
 		return resolveString(p, param.Tag.Def)
 	}
-	return "", fmt.Errorf("property %q %w", param.Key, ErrNotExist)
+	return "", util.FormatError(nil, "property %q %w", param.Key, ErrNotExist)
 }
 
 // resolveString expands property references of the form ${key}
@@ -590,7 +591,7 @@ func resolveString(p Properties, s string) (string, error) {
 
 	if end < 0 {
 		err := ErrInvalidSyntax
-		return "", log.FormatError(err, "resolve string %q error", s)
+		return "", util.FormatError(err, "resolve string %q error", s)
 	}
 
 	var param BindParam
@@ -599,13 +600,13 @@ func resolveString(p Properties, s string) (string, error) {
 	// resolve the referenced property
 	resolved, err := resolve(p, param)
 	if err != nil {
-		return "", log.WrapError(err, "resolve string %q error", s)
+		return "", util.FormatError(err, "resolve string %q error", s)
 	}
 
 	// resolve the remaining part of the string
 	suffix, err := resolveString(p, s[end+1:])
 	if err != nil {
-		return "", log.WrapError(err, "resolve string %q error", s)
+		return "", util.FormatError(err, "resolve string %q error", s)
 	}
 
 	// combine: prefix + resolved + suffix