update README.md

Author: lvan100

README_CN.md

@@ -5,52 +5,40 @@
     <img src="https://img.shields.io/github/go-mod/go-version/go-spring/spring-core" alt="go-version"/>
     <img src="https://img.shields.io/github/v/release/go-spring/spring-core?include_prereleases" alt="release"/>
     <img src="https://codecov.io/gh/go-spring/spring-core/branch/main/graph/badge.svg" alt="test-coverage"/>
+    <br/>
 </div>
 
+[English](README.md)
+
 **Go-Spring** 是一个功能强大、使用方便的 Go 应用开发框架，其灵感来源于 Java 生态中的 Spring 和 Spring Boot，
 它的设计目标是将 Java 世界中的优秀开发理念无缝迁移到 Go 语言中，从而提升开发效率、增强模块可复用性、提高代码可维护性。
 
 它为 Go 应用带来了类似 Spring Boot 的体验，提供自动配置、依赖注入、配置热更新、条件注入、生命周期管理、微服务支持等功能，
 力求“一站式”解决实际开发问题。同时，它又高度兼容 Go 标准库，延续了 Go 一贯的简洁与高性能，特别适合构建现代 Go 微服务系统。
 
-### 🌟 框架亮点
-
-- ⚡ **秒级启动**  
-  利用 Go 的 `init()` 机制实现 Bean 主动注册，省去运行时扫描，提升应用启动速度。
-
-- 🧩 **极致易用**  
-  支持结构体标签注入和链式 API 配置，开发者无需编写复杂的模板代码，快速上手开发。
-
-- 🔄 **配置热更新**  
-  支持动态属性绑定与运行时刷新，无需重启应用即可实时生效，适用于灰度发布、动态调整等场景。
+## 🌟 框架亮点
 
-- 📦 **微服务原生支持**  
-  内置标准 HTTP Server 启动器与注册机制，具备丰富的生命周期钩子，构建微服务更高效。
+1. ⚡ **秒级启动:** 利用 Go 的 `init()` 机制实现 Bean 主动注册，省去运行时扫描，提升应用启动速度。
+2. 🧩 **极致易用:** 支持结构体标签注入和链式 API 配置，开发者无需编写复杂的模板代码，快速上手开发。
+3. 🔄 **配置热更新:** 支持属性绑定与运行时刷新，无需重启应用即可实时生效，适用于灰度发布、动态调整等场景。
+4. 📦 **微服务原生支持:** 内置标准 HTTP Server 启动器与注册机制，具备丰富的生命周期钩子，构建微服务更高效。
+5. 🧪 **完善的测试能力:** 提供 Mock 与单元测试工具，便于开发者编写高质量、可验证的测试用例。
+6. 🔍 **运行时零反射:** 框架仅在启动时使用反射完成 Bean 构造与注入，运行时不依赖反射，保障性能表现。
+7. 💡 **零侵入式设计:** 框架对业务代码无强依赖，使用者无需实现特定接口即可被管理，保持代码干净、易迁移。
 
-- 🧪 **完善的测试能力**  
-  提供 Mock 与单元测试工具，便于开发者编写高质量、可验证的测试用例。
+## ✨ 核心功能
 
-- 🔍 **运行时零反射**  
-  框架仅在启动时使用反射完成 Bean 构造与注入，运行时不依赖反射，保障性能表现。
+1. **🚀 自动配置:** 自动加载配置文件、构建 Bean，支持环境隔离与多文件合并。
+2. **⚙️ 依赖注入:** 结构体字段注入、构造函数注入、接口注入等多种形式。
+3. **🌀 配置热更新:** 支持运行时刷新配置，动态响应配置变更。
+4. **🔄 生命周期管理:** 支持自定义初始化与销毁函数，并提供优雅的退出机制。
+5. **🔌 服务注册:** 原生兼容 HTTP，支持自定义 Server 模型。
+6. **🧪 条件注入:** 支持按属性、环境、Bean 存在与否等灵活注入控制。
+7. **🔧 Bean 注册管理:** 提供灵活的 Bean 注册与构建 API。
+8. **📡 微服务支持:** 内建 Job、Runner、Server 三种运行模型，助力构建多形态微服务架构。
+9. **🧪 单元测试支持:** 内置 Mock、自动注入等机制，支持高质量测试开发。
 
-- 💡 **零侵入式设计**  
-  框架对业务代码无强依赖，使用者无需实现特定接口即可被管理，保持代码干净、易迁移。
-
-## ✨ 核心功能总览
-
-| 功能           | 描述                                       |
-|--------------|------------------------------------------|
-| 🚀 自动配置      | 自动加载配置文件、构建 Bean，支持环境隔离与多文件合并            |
-| ⚙️ 依赖注入      | 结构体字段注入、构造函数注入、接口注入等多种形式                 |
-| 🌀 配置热更新     | 支持运行时刷新配置，动态响应配置变更                       |
-| 🔄 生命周期管理    | 支持自定义初始化与销毁函数，并提供优雅的退出机制                 |
-| 🔌 服务注册      | 原生兼容 HTTP，支持自定义 Server 模型                |
-| 🧪 条件注入      | 支持按属性、环境、Bean 存在与否等灵活注入控制                |
-| 🔧 Bean 注册管理 | 提供灵活的 Bean 注册与构建 API                     |
-| 📡 微服务支持     | 内建 Job、Runner、Server 三种运行模型，助力构建多形态微服务架构 |
-| 🧪 单元测试支持    | 内置 Mock、自动注入等机制，支持高质量测试开发                |
-
-## 📦 安装
+## 📦 安装方式
 
 Go-Spring 使用 Go Modules 管理依赖，安装非常简单：
 
@@ -66,7 +54,7 @@ Go-Spring 的核心理念之一就是**开箱即用**。下面通过两个简单
 
 ```go
 func main() {
-    http.HandleFunc("/echo", func(w http.ResponseWriter, r *http.Request) {
+    http.HandleFunc("/echo", func (w http.ResponseWriter, r *http.Request) {
         _, _ = w.Write([]byte("hello world!"))
     })
     gs.Run()
@@ -93,14 +81,14 @@ curl http://127.0.0.1:9090/echo
 func init() {
     // Register the Service struct as a bean.
     gs.Object(&Service{})
-
+    
     // Provide a [*http.ServeMux] as a bean.
-    gs.Provide(func(s *Service) *http.ServeMux {
+    gs.Provide(func (s *Service) *http.ServeMux {
         http.HandleFunc("/echo", s.Echo)
         http.HandleFunc("/refresh", s.Refresh)
         return http.DefaultServeMux
     })
-
+    
     sysconf.Set("start-time", time.Now().Format(timeLayout))
     sysconf.Set("refresh-time", time.Now().Format(timeLayout))
 }
@@ -118,8 +106,8 @@ type Service struct {
 
 func (s *Service) Echo(w http.ResponseWriter, r *http.Request) {
     str := fmt.Sprintf("start-time: %s refresh-time: %s",
-    s.StartTime.Format(timeLayout),
-    s.RefreshTime.Value().Format(timeLayout))
+        s.StartTime.Format(timeLayout),
+        s.RefreshTime.Value().Format(timeLayout))
     _, _ = w.Write([]byte(str))
 }
 
@@ -151,28 +139,22 @@ curl http://127.0.0.1:9090/echo
 # 输出中的 refresh-time 已更新
 ```
 
-## 🔧 配置管理
+### 更多示例
 
-Go-Spring 提供了灵活强大的配置加载机制，支持从多种来源获取配置项，轻松满足多环境、多部署场景的需求。
+访问 [gs/examples](gs/examples) 查看更多示例。
 
-### 🔍 支持的配置来源
+## 🔧 配置管理
 
-| 来源类型      | 描述                                          |
-|-----------|---------------------------------------------|
-| `sysconf` | 内存配置，适用于测试或临时注入                             |
-| 本地文件      | 支持 `.yaml`、`.yml`、`.properties`、`.toml` 等格式 |
-| 远程文件      | 通过远程 URL 拉取配置，支持定时轮询更新                      |
-| 环境变量      | 读取系统环境变量作为配置项                               |
-| 命令行参数     | 以 `--key=value` 形式注入参数，覆盖配置文件与环境变量          |
+Go-Spring 提供了灵活强大的配置加载机制，支持从多种来源获取配置项，轻松满足多环境、多部署场景的需求。
 
-### 🔗 配置加载优先级（从高到低）
+1. **命令行参数（最高优先级）** 以 `-Dkey=value` 形式注入参数
+2. **环境变量** 读取系统环境变量作为配置项
+3. **远程文件** 获取远程配置文件，支持定时轮询更新
+4. **本地文件** 支持格式：`.yaml`/`.yml`/`.properties`/`.toml`等
+5. **`sysconf`内存配置** 适用于测试或临时注入
+6. **默认值（最低优先级）** 通过结构体标签设置
 
-1. 命令行参数
-2. 环境变量
-3. 远程配置文件
-4. 本地配置文件
-5. `sysconf` 内存设置
-6. 默认值（通过结构体标签设置）
+> 注：优先级从1到6依次降低，高优先级的配置会覆盖低优先级的配置。
 
 #### 示例配置文件：
 
@@ -194,24 +176,6 @@ type AppConfig struct {
 }
 ```
 
-### 🌡️ 热更新配置
-
-Go-Spring 支持热更新，结合 `gs.Dync[T]` 类型，可以实时响应配置变化，而无需重启服务。
-
-```go
-type AppInfo struct {
-    Version gs.Dync[string] `value:"${app.version}"`
-}
-```
-
-运行时触发刷新：
-
-```go
-_ = gs.RefreshProperties()
-```
-
-刷新后，所有 `gs.Dync[T]` 绑定字段会自动更新。
-
 ## 🔧 Bean 管理
 
 在 Go-Spring 中，**Bean 是应用的核心构建单元**。框架采用显式注册 + 标签声明的模式，结合灵活的条件装配，
@@ -221,12 +185,10 @@ _ = gs.RefreshProperties()
 
 Go-Spring 提供多种方式注册 Bean：
 
-| 方法                          | 描述                       |
-|-----------------------------|--------------------------|
-| `gs.Object(obj)`            | 将已有对象注册为 Bean            |
-| `gs.Provide(ctor, args...)` | 使用构造函数生成并注册 Bean         |
-| `gs.Register(bd)`           | 注册完整 Bean 定义，适合底层封装或高级用法 |
-| `gs.GroupRegister(fn)`      | 批量注册多个 Bean，常用于模块初始化等场景  |
+- **`gs.Object(obj)`** - 将已有对象注册为 Bean
+- **`gs.Provide(ctor, args...)`** - 使用构造函数生成并注册 Bean
+- **`gs.Register(bd)`** - 注册完整 Bean 定义（适合底层封装或高级用法）
+- **`gs.GroupRegister(fn)`** - 批量注册多个 Bean（常用于模块初始化等场景）
 
 #### 示例
 
@@ -235,12 +197,7 @@ gs.Object(&Service{})  // 注册结构体实例
 gs.Provide(NewService) // 使用构造函数注册
 gs.Provide(NewRepo, ValueArg("db")) // 构造函数带参数
 gs.Register(gs.NewBean(NewService)) // 完整定义注册
-```
-
-批量注册：
-
-```go
-gs.GroupRegister(func(p Properties) []*BeanDefinition {
+gs.GroupRegister(func (p Properties) []*BeanDefinition { // 批量注册
     return []*BeanDefinition{
         gs.NewBean(NewUserService),
         gs.NewBean(NewOrderService),
@@ -284,20 +241,18 @@ gs.Provide(NewService)
 
 ```go
 gs.Provide(NewService,
-    TagArg("${log.level}"), // 从配置注入
+    TagArg("${log.level}"),        // 从配置注入
     ValueArg("some static value"), // 直接值注入
     BindArg(parseFunc, "arg"), // option 函数注入
 )
 ```
 
 可用的参数类型：
 
-| 参数类型                | 描述          |
-|---------------------|-------------|
-| `TagArg(tag)`       | 从配置中提取值     |
-| `ValueArg(value)`   | 使用固定值       |
-| `IndexArg(i, v)`    | 按参数位置注入     |
-| `BindArg(fn, args)` | option 函数注入 |
+- **`TagArg(tag)`**：从配置中提取值
+- **`ValueArg(value)`**：使用固定值
+- **`IndexArg(i, v)`**：按参数位置注入
+- **`BindArg(fn, args)`**：通过 option 函数注入
 
 ### 🔄 Bean 生命周期配置
 
@@ -306,8 +261,8 @@ gs.Provide(NewService,
 ```go
 gs.Provide(NewService).
     Name("myService").
-    Init(func(s *Service) { ... }).
-    Destroy(func(s *Service) { ... }).
+    Init(func (s *Service) { ... }).
+    Destroy(func (s *Service) { ... }).
     Condition(OnProperty("feature.enabled")).
     DependsOn("logger").
     Export((*MyInterface)(nil)).
@@ -316,17 +271,15 @@ gs.Provide(NewService).
 
 配置项说明：
 
-| 方法               | 说明                    |
-|------------------|-----------------------|
-| `Name(string)`   | 指定 Bean 名称            |
-| `Init(fn)`       | 初始化函数（支持方法名字符串）       |
-| `Destroy(fn)`    | 销毁函数（支持方法名字符串）        |
-| `DependsOn(...)` | 指定依赖的其他 Bean 名称       |
-| `Condition(...)` | 条件装配控制（见下一节）          |
-| `Export(...)`    | 将 Bean 作为接口导出，支持多接口导出 |
-| `AsRunner()`     | 注册为 `Runner`，运行在主线程   |
-| `AsJob()`        | 注册为后台任务 Job           |
-| `AsServer()`     | 注册为服务 Server（需实现接口）   |
+- **`Name(string)`**：指定 Bean 名称
+- **`Init(fn)`**：初始化函数（支持方法名字符串）
+- **`Destroy(fn)`**：销毁函数（支持方法名字符串）
+- **`DependsOn(...)`**：指定依赖的其他 Bean 名称
+- **`Condition(...)`**：条件装配控制（见下一节）
+- **`Export(...)`**：将 Bean 作为接口导出，支持多接口导出
+- **`AsRunner()`**：注册为 `Runner`，运行在主线程
+- **`AsJob()`**：注册为后台任务 Job
+- **`AsServer()`**：注册为服务 Server（需实现接口）
 
 ## ⚙️ 条件注入（Condition）
 
@@ -337,14 +290,12 @@ Go-Spring 支持基于条件的 Bean 注入机制，这使得组件可以根据
 
 ### 🎯 支持的条件类型
 
-| 条件方法                                 | 描述                      |
-|--------------------------------------|-------------------------|
-| `OnProperty("key")`                  | 指定配置 key 存在并有值时激活       |
-| `OnMissingProperty("key")`           | 指定配置 key 不存在时激活         |
-| `OnBean[Type]("name")`               | 当指定类型/名称的 Bean 存在时激活    |
-| `OnMissingBean[Type]("name")`        | 当指定类型/名称的 Bean 不存在时激活   |
-| `OnSingleBean[Type]("name")`         | 当指定类型/名称的 Bean 是唯一实例时激活 |
-| `OnFunc(func(ctx CondContext) bool)` | 自定义条件逻辑                 |
+- **`OnProperty("key")`**：当指定配置 key 存在且有值时激活
+- **`OnMissingProperty("key")`**：当指定配置 key 不存在时激活
+- **`OnBean[Type]("name")`**：当指定类型/名称的 Bean 存在时激活
+- **`OnMissingBean[Type]("name")`**：当指定类型/名称的 Bean 不存在时激活
+- **`OnSingleBean[Type]("name")`**：当指定类型/名称的 Bean 是唯一实例时激活
+- **`OnFunc(func(ctx CondContext) bool)`**：使用自定义条件逻辑判断是否激活
 
 ### 🔍 示例：按属性控制注册
 
@@ -359,12 +310,10 @@ gs.Provide(NewService).
 
 Go-Spring 支持组合多个条件，构建更复杂的判断逻辑：
 
-| 方法          | 描述          |
-|-------------|-------------|
-| `Not(...)`  | 条件取反        |
-| `And(...)`  | 所有条件都满足时成立  |
-| `Or(...)`   | 任一条件满足即成立   |
-| `None(...)` | 所有条件都不满足时成立 |
+- **`Not(...)`** - 对条件取反
+- **`And(...)`** - 所有条件都满足时成立
+- **`Or(...)`** - 任一条件满足即成立
+- **`None(...)`** - 所有条件都不满足时成立
 
 #### 示例：组合条件控制 Bean 激活
 
@@ -380,7 +329,7 @@ gs.Provide(NewService).
 
 该 Bean 会在 `feature.enabled` 开启且未注册 `*DeprecatedService` 时启用。
 
-## 🔁 配置动态刷新（热更新）
+## 🔁 配置动态刷新
 
 Go-Spring 内置了轻量的配置热更新能力。通过 `gs.Dync[T]` 类型与 `gs.RefreshProperties()` 方法的组合，
 可以实现应用在运行中动态响应配置变化，无需重启。
@@ -389,7 +338,7 @@ Go-Spring 内置了轻量的配置热更新能力。通过 `gs.Dync[T]` 类型
 
 ### 🌡 使用方式
 
-#### 1. 使用 `gs.Dync[T]` 声明动态字段
+1. 使用 `gs.Dync[T]` 声明动态字段
 
 通过泛型类型 `gs.Dync[T]` 包装字段，即可监听配置变化并自动更新：
 
@@ -401,7 +350,7 @@ type Config struct {
 
 > 调用时通过 `.Value()` 获取当前值，框架在配置变更时会自动更新该值。
 
-#### 2. 调用 `gs.RefreshProperties()` 手动触发刷新
+2. 调用 `gs.RefreshProperties()` 手动触发刷新
 
 在配置发生变化后，调用此方法可以让所有动态字段立即更新：
 
@@ -433,15 +382,15 @@ func RefreshVersion(w http.ResponseWriter, r *http.Request) {
 
 ```go
 gs.Object(&App{})
-gs.Provide(func(app *App) *http.ServeMux {
+gs.Provide(func (app *App) *http.ServeMux {
     http.Handle("/", app)
     http.HandleFunc("/refresh", RefreshVersion)
     return http.DefaultServeMux
 })
 gs.Run()
 ```
 
-访问 `/` 会输出当前版本，访问 `/refresh` 后，再次访问 `/` 即可看到更新后的版本号。
+运行程序后，访问 `/` 会输出当前版本，访问 `/refresh` 后，再次访问 `/` 即可看到更新后的版本号。
 
 ## 🖥️ 自定义 Server
 
@@ -468,7 +417,7 @@ type ReadySignal interface {
 }
 ```
 
-用于协调服务“何时准备好”。你可以在 `ListenAndServe` 中等到主流程触发启动完成信号，然后正式对外提供服务。
+你可以在 `ListenAndServe` 中等到主流程触发启动完成信号，然后正式对外提供服务。
 
 ### 🛠 示例：标准库 HTTP Server 接入
 
@@ -523,7 +472,7 @@ func (s *GRPCServer) ListenAndServe(sig gs.ReadySignal) error {
 
 func (s *GRPCServer) Shutdown(ctx context.Context) error {
     stopped := make(chan struct{})
-    go func() {
+    go func () {
         s.svr.GracefulStop()
         close(stopped)
     }()
@@ -583,16 +532,16 @@ type Job struct{}
 
 func (j *Job) Run(ctx context.Context) error {
     for {
-        select {
-        case <-ctx.Done():
-            fmt.Println("job exit")
+    select {
+    case <-ctx.Done():
+        fmt.Println("job exit")
+        return nil
+    default:
+        if gs.Exiting() {
             return nil
-        default:
-            if gs.Exiting() {
-                return nil
-            }
-            time.Sleep(300 * time.Millisecond)
-            fmt.Println("job tick")
+        }
+        time.Sleep(300 * time.Millisecond)
+        fmt.Println("job tick")
         }
     }
 }