第一章：IoC容器在Go生态中的演进与定位
Go语言自诞生起便强调简洁性与可组合性，其标准库未内置IoC（Inversion of Control）容器，这与Spring或.NET等传统生态形成鲜明对比。早期Go项目普遍采用手动依赖注入——通过构造函数显式传递依赖，虽清晰可控，但随着模块规模增长，重复的初始化逻辑与深层嵌套依赖逐渐暴露维护瓶颈。
Go社区对依赖管理的渐进探索
开发者最初尝试用工厂函数或全局变量简化对象创建，但易导致隐式耦合与测试困难。随后，轻量级DI库如wire（由Google维护）和dig（Uber开源）成为主流选择。wire采用编译期代码生成，杜绝运行时反射开销；dig则基于运行时反射实现灵活的生命周期管理。二者代表了Go生态中“零反射”与“适度反射”两条技术路径。
IoC容器的核心价值重定义
在Go语境下，IoC容器并非替代手动注入，而是聚焦于：
- 类型安全的依赖图构建：避免
interface{}泛型擦除带来的运行时错误 - 生命周期协同管理：统一处理
io.Closer、sync.WaitGroup等资源释放 - 环境感知配置注入：根据
GO_ENV=prod自动切换数据库连接池参数
实践示例：使用Wire声明依赖图
// wire.go
package main
import "github.com/google/wire"
// 定义提供者函数（返回具体实现）
func NewDB() *DB { return &DB{} }
func NewCache() *RedisCache { return &RedisCache{} }
func NewService(db *DB, cache *RedisCache) *Service {
return &Service{db: db, cache: cache}
}
// 构建依赖图
var SuperSet = wire.NewSet(NewDB, NewCache, NewService)执行go generate ./...后，Wire自动生成InitializeService()函数，将所有依赖按拓扑序实例化并注入。该过程在编译期完成，无反射、无运行时开销，契合Go的工程哲学。
| 方案 | 反射依赖 | 生成代码 | 启动性能 | 调试友好性 |
|---|---|---|---|---|
| 手动注入 | 无 | 无 | 最优 | 最高 |
| Wire | 无 | 有 | 接近最优 | 高 |
| Dig | 有 | 无 | 中等 | 中等 |
第二章：trace.EventLog注册机制的底层实现与生命周期陷阱
2.1 Go标准库trace包的事件注册模型与IoC注入耦合点
Go 的 runtime/trace 包通过静态注册与动态激活双阶段机制实现低开销可观测性。核心在于 trace.Event 的隐式注册与 trace.Start 的上下文绑定。
事件注册的隐式契约
trace.WithRegion、trace.Log 等函数不显式注册，而是依赖编译器内联与运行时符号解析，在首次调用时惰性初始化 trace event descriptor 表。
IoC 耦合关键点
trace.Start接收io.Writer，天然支持依赖注入（如bytes.Buffer或自定义TracingWriter）trace.StartRegion的ctx context.Context参数可携带 span ID、tenant info 等业务上下文
// 注入自定义 writer 并关联请求上下文
buf := &bytes.Buffer{}
trace.Start(buf) // Writer 被注入至全局 trace state
defer trace.Stop()
ctx := context.WithValue(context.Background(), "req_id", "abc123")
trace.StartRegion(ctx, "http_handler") // ctx 携带业务元数据该调用将
ctx中的值透传至 trace event 的user_data字段，为后续链路分析提供 IoC 注入锚点。
| 注入点 | 类型 | 可替换性 | 说明 |
|---|---|---|---|
io.Writer |
接口注入 | 高 | 支持网络流、文件、内存缓冲 |
context.Context |
上下文注入 | 中 | 依赖 context.WithValue 语义 |
graph TD
A[trace.Start] --> B[注册 global writer]
B --> C[激活 runtime tracer]
C --> D[trace.StartRegion]
D --> E[提取 ctx.Value]
E --> F[写入 event.user_data]2.2 EventLog注册未注销导致goroutine泄漏的内存堆栈实证分析
问题复现场景
当 EventLog 实例在 goroutine 中持续监听但未调用 Unregister()，会导致监听协程永久阻塞在 ch := <-e.ch。
// 注册后未配对注销，引发泄漏
log := NewEventLog()
log.Register("user.created", handler) // 启动监听goroutine
// 忘记调用 log.Unregister("user.created")该注册逻辑内部启动常驻 goroutine：go func() { for range e.ch { ... } }()，通道永不关闭，协程无法退出。
堆栈关键特征
通过 pprof/goroutine?debug=2 可捕获典型泄漏堆栈： |
goroutine ID | 状态 | 调用栈片段 |
|---|---|---|---|
| 127 | runnable | runtime.gopark → eventlog.(*EventLog).listen → … |
泄漏链路示意
graph TD
A[Register] --> B[创建独立goroutine]
B --> C[阻塞读取无缓冲channel]
C --> D[无Unregister则channel永不下线]2.3 基于pprof+gdb的生产环境goroutine堆积现场还原实验
为复现典型 goroutine 泄漏场景，我们构造一个未关闭 channel 导致 select 永久阻塞的 HTTP 服务：
func handler(w http.ResponseWriter, r *http.Request) {
ch := make(chan int)
go func() { ch <- 42 }() // goroutine 启动后无法退出
select {
case <-ch:
w.Write([]byte("done"))
}
// ch 无 close，goroutine 无法被 GC，持续堆积
}该代码中 ch 是无缓冲 channel，子 goroutine 发送后因无人接收而永久阻塞；主 goroutine 在 select 返回后结束，但子 goroutine 仍存活——这是典型的泄漏模式。
关键诊断链路
curl http://localhost:8080/debug/pprof/goroutine?debug=2获取完整栈快照go tool pprof http://localhost:8080/debug/pprof/goroutine进入交互式分析- 使用
top、web查看阻塞点，定位runtime.gopark调用链
gdb 辅助验证（容器内）
| 步骤 | 命令 | 说明 |
|---|---|---|
| 1 | gdb -p $(pidof myserver) |
附加运行中进程 |
| 2 | info goroutines |
列出所有 goroutine ID 及状态 |
| 3 | goroutine 123 bt |
查看指定 goroutine 的 C/Go 混合调用栈 |
graph TD
A[HTTP 请求触发] --> B[创建无缓冲 channel]
B --> C[启动发送 goroutine]
C --> D[send on full chan 阻塞]
D --> E[goroutine 状态：waiting]2.4 IoC容器启动/关闭阶段对trace资源管理的职责边界缺失剖析
Spring IoC容器生命周期与分布式链路追踪（如OpenTelemetry）存在天然职责错位：容器不感知trace SDK的资源释放时机。
启动阶段的隐式资源绑定
@Bean
public Tracer tracer() {
return OpenTelemetrySdk.builder()
.setResource(Resource.getDefault() // ← 依赖全局Resource，但未注册到ApplicationContext
.merge(Resource.create(Attributes.of(KEY, "app"))))
.build().getTracer("my-app");
}该Tracer实例被Spring托管，但底层SDK持有的SdkTracerProvider、SpanProcessor等资源未纳入DisposableBean或Closeable契约，导致GC不可控。
关闭阶段的资源泄漏路径
- ApplicationContext关闭时仅调用
destroy()方法，不触发SdkTracerProvider.shutdown() BatchSpanProcessor后台线程持续运行，持有ScheduledExecutorServiceOtlpGrpcSpanExporter连接池未显式关闭
| 阶段 | 容器行为 | trace SDK状态 | 是否可预测释放 |
|---|---|---|---|
| refresh() | 调用afterPropertiesSet() | 初始化Exporter/Processor | 否 |
| close() | 销毁单例Bean | shutdown()未被调用 |
❌ |
graph TD
A[ApplicationContext.close()] --> B[DefaultListableBeanFactory.destroySingletons]
B --> C[Bean.destroy()]
C --> D[Tracer实例销毁]
D --> E[SDK底层资源仍存活]2.5 复现案例：gin+wire组合下EventLog隐式注册引发的OOM压测报告
压测现象还原
在 QPS=1200 的持续压测中，服务 RSS 内存每分钟增长 180MB，12 分钟后触发 OOM Killer。堆内存分析显示 *eventlog.Event 实例数达 370 万，远超业务事件实际发生量（
隐式注册链路
// wire.go 中隐式绑定（无显式 Provider 声明）
func buildApp() *App {
wire.Build(
gin.New, // ← gin.Engine 被注入
eventlog.Register, // ← 该函数内部调用 global.Register()
handlerSet,
)
return nil
}eventlog.Register() 在 wire 构建期执行，但因未声明依赖边界，导致每次 HTTP 请求都触发新 EventLog 实例注册——wire 将其误判为“单例构造副作用”，而非一次初始化行为。
关键参数影响
| 参数 | 默认值 | 危险表现 |
|---|---|---|
eventlog.GlobalRegistry |
全局 map | 并发写入未加锁，扩容时触发内存倍增 |
gin.Context.Value() 缓存 |
无清理机制 | 每个请求携带冗余 *EventLog 引用 |
根本修复路径
- ✅ 将
eventlog.Register()移出 wire.Build，改为init()显式调用 - ✅ 为
EventLog添加sync.Pool复用机制 - ❌ 禁止在 wire provider 函数中执行全局状态变更
graph TD
A[wire.Build] --> B[gin.New]
A --> C[eventlog.Register]
C --> D[global.Register\\n→ map[interface{}]any]
D --> E[HTTP Handler\\n→ ctx.Value\\n→ 引用逃逸]
E --> F[GC 无法回收\\n→ OOM]第三章：IoC依赖注入框架对可观测性组件的生命周期治理规范
3.1 Wire/Dig/GoDI等主流框架对trace、metrics、log等可观测性依赖的注入契约对比
注入契约设计哲学差异
Wire 强调编译期显式声明，Dig 采用运行时反射解析，GoDI 则通过结构标签实现轻量契约。
可观测性依赖注入方式对比
| 框架 | Trace 注入方式 | Metrics 绑定机制 | Log 实例传递模型 |
|---|---|---|---|
| Wire | wire.Build(tracerProvider) |
wire.Bind(new(*prometheus.Registry), newRegistry) |
接口字段显式注入 |
| Dig | dig.Provide(otel.Tracer) |
dig.Provide(prom.NewRegistry) |
dig.As[*zap.Logger] |
| GoDI | @InjectLogger 标签 |
@InjectMetrics("http") |
@InjectTracer("api") |
// Wire 示例：trace 与 logger 的组合注入
func provideApp(logger *zap.Logger, tracer trace.Tracer) *App {
return &App{logger: logger, tracer: tracer}
}
// 参数说明：logger 和 tracer 均由 wire.Provider 显式构造并注入，确保可观测性组件在构建图中可追溯、可替换数据同步机制
Dig 在 invoke 时动态注入，支持运行时 trace span 上下文传播；GoDI 通过构造器拦截实现日志字段自动 enrich。
graph TD
A[Root Provider] --> B[Tracer]
A --> C[Logger]
A --> D[Metrics Registry]
B --> E[HTTP Handler]
C --> E
D --> E3.2 基于Context取消与io.Closer接口的EventLog自动注销模式设计
核心设计思想
将 context.Context 的生命周期与 EventLog 资源管理解耦，通过组合 io.Closer 接口实现“即用即销”的自动化清理。
自动注销机制
EventLog实现io.Closer，Close()触发日志通道关闭与 goroutine 清理- 构造时接收
context.Context，监听ctx.Done()并触发Close() - 避免手动调用
Close()导致的资源泄漏
关键代码示例
type EventLog struct {
closeCh chan struct{}
ctx context.Context
cancel context.CancelFunc
}
func NewEventLog(ctx context.Context) *EventLog {
ctx, cancel := context.WithCancel(ctx)
el := &EventLog{
closeCh: make(chan struct{}),
ctx: ctx,
cancel: cancel,
}
go el.watchCancel() // 启动监听协程
return el
}
func (el *EventLog) watchCancel() {
select {
case <-el.ctx.Done():
el.Close() // 自动注销
}
}逻辑分析：
watchCancel协程阻塞等待ctx.Done()，一旦上下文取消（如超时或主动 cancel），立即调用Close()。cancel函数由WithCancel生成，确保ctx.Done()可被主动触发；closeCh用于同步关闭信号，避免重复 Close。
生命周期对比表
| 场景 | 手动 Close 模式 | Context + Closer 模式 |
|---|---|---|
| 超时自动释放 | ❌ 需额外 timer | ✅ 内置支持 |
| panic 时资源清理 | ❌ 易遗漏 | ✅ defer+Close 保障 |
| 多层嵌套调用 | ❌ 易重复 Close | ✅ Close 幂等设计 |
graph TD
A[NewEventLog] --> B[WithCancel ctx]
B --> C[启动 watchCancel goroutine]
C --> D{ctx.Done?}
D -->|Yes| E[调用 Close]
D -->|No| C
E --> F[关闭 channel<br>释放 goroutine]3.3 生产就绪型IoC初始化模板：含trace资源注册/注销双钩子的StandardModule实现
StandardModule 是轻量级、可组合的模块化单元，其核心价值在于将依赖注入生命周期与可观测性原语深度耦合。
双钩子契约设计
onRegister()：在容器注入完成、实例化后立即触发，用于注册 OpenTelemetryTracerProvider、MeterProvider等 trace/metrics 资源；onUnregister()：在模块卸载前同步调用，确保shutdown()显式释放资源，避免内存泄漏与 span/metric 数据丢失。
核心实现片段
public class StandardModule implements Module {
private final Tracer tracer;
private final Meter meter;
public StandardModule(TracerProvider tracerProvider, MeterProvider meterProvider) {
this.tracer = tracerProvider.get("io.example.module");
this.meter = meterProvider.get("io.example.module");
}
@Override
public void onRegister(Injector injector) {
injector.bind(Tracer.class).toInstance(tracer); // 绑定至IoC上下文
injector.bind(Meter.class).toInstance(meter);
}
@Override
public void onUnregister() {
tracer.shutdown(); // 同步阻塞，保障flush完成
meter.shutdown();
}
}逻辑分析：
onRegister()将 trace/metric 实例注入容器，使业务组件可通过构造注入直接使用；onUnregister()的shutdown()调用必须同步且幂等，否则可能引发RejectedExecutionException。参数tracerProvider和meterProvider来自全局 SDK 初始化，确保跨模块 trace 上下文一致性。
生命周期对齐示意
graph TD
A[Module.load] --> B[IoC实例化]
B --> C[onRegister触发]
C --> D[Tracer/Meter绑定]
E[Module.unload] --> F[onUnregister触发]
F --> G[资源shutdown]第四章：面向生产稳定的IoC可观测性加固实践体系
4.1 静态扫描规则：基于go/analysis检测未配对EventLog.Register/Unregister调用
检测原理
利用 go/analysis 框架构建自定义检查器，遍历 AST 中所有函数调用节点，识别 EventLog.Register 与 EventLog.Unregister 调用，并在作用域内进行配对匹配。
核心代码逻辑
func run(pass *analysis.Pass) (interface{}, error) {
for _, file := range pass.Files {
ast.Inspect(file, func(n ast.Node) bool {
if call, ok := n.(*ast.CallExpr); ok {
if isRegisterCall(pass, call) { /* 记录注册点 */ }
if isUnregisterCall(pass, call) { /* 记录注销点 */ }
}
return true
})
}
return nil, nil
}该分析器按作用域（函数体）收集调用位置，通过 pass.TypesInfo.TypeOf() 精确识别方法接收者类型，避免误判第三方同名方法。
匹配策略对比
| 策略 | 精确性 | 支持嵌套作用域 | 误报率 |
|---|---|---|---|
| 全局符号扫描 | 低 | 否 | 高 |
| AST+作用域分析 | 高 | 是 | 低 |
检测流程
graph TD
A[解析Go源码] --> B[遍历AST调用节点]
B --> C{是否为Register/Unregister?}
C -->|是| D[记录作用域内位置]
C -->|否| B
D --> E[按函数粒度配对]
E --> F[报告未配对调用]4.2 运行时防护：IoC容器内嵌trace泄漏检测中间件与告警熔断机制
在微服务链路追踪场景中，未清理的 TraceContext 易随 Bean 生命周期残留，导致跨请求 traceID 泄漏与上下文污染。
检测原理
基于 Spring 的 BeanPostProcessor 在 postProcessAfterInitialization 阶段注入检测逻辑，扫描所有单例 Bean 是否意外持有 Tracer 或 Span 引用。
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (isTraceHolder(bean)) { // 反射检查字段是否含 Tracer/Span 类型
alarmService.trigger("TRACE_LEAK", beanName); // 触发告警
if (circuitBreaker.isOpen()) { // 熔断器状态判定
throw new TraceLeakException("Blocked due to repeated leaks");
}
}
return bean;
}逻辑分析：该钩子在 Bean 初始化完成后执行；
isTraceHolder()递归扫描非静态字段类型；alarmService支持钉钉/Webhook 多通道推送；circuitBreaker基于滑动窗口统计 1 分钟内泄漏次数（阈值默认 3 次）。
熔断策略对比
| 策略 | 触发条件 | 恢复方式 | 影响范围 |
|---|---|---|---|
| 半开模式 | 连续5次健康探测成功 | 自动降级恢复 | 全局容器 |
| 局部熔断 | 单Bean泄漏超限 | 手动重启Bean | 仅该Bean实例 |
防护流程
graph TD
A[Bean初始化完成] --> B{是否持有Trace引用？}
B -->|是| C[记录泄漏事件]
B -->|否| D[放行]
C --> E[更新熔断计数器]
E --> F{是否触发熔断？}
F -->|是| G[抛出异常并阻断后续注入]
F -->|否| H[发送告警]4.3 治理工具链：自研ioc-trace-linter + k8s sidecar级goroutine健康度巡检器
设计动机
微服务调用链中，隐式依赖与未闭合的 goroutine 泄漏常导致内存持续增长。传统 APM 工具难以在编译期拦截 IOC 容器注入缺陷，也缺乏容器粒度的实时协程健康快照能力。
ioc-trace-linter：静态注入合规性校验
// 示例：检测无构造函数注入的单例Bean（易引发竞态）
func (l *Linter) CheckSingletonWithConstructor(node ast.Node) error {
if bean, ok := node.(*ast.TypeSpec); ok &&
hasTag(bean, "singleton") &&
!hasConstructorInjection(bean) { // 关键规则：强制构造器注入
return fmt.Errorf("singleton %s lacks constructor injection", bean.Name.Name)
}
return nil
}该检查在 CI 阶段介入，阻断 new() 直接实例化单例、绕过 IOC 管理的反模式，确保 trace 上下文可穿透。
Sidecar级goroutine巡检器
通过 /debug/pprof/goroutine?debug=2 实时抓取，聚合分析阻塞态、超时运行（>5s）、异常栈深度（>100）三类风险指标：
| 指标类型 | 阈值 | 告警等级 | 触发动作 |
|---|---|---|---|
| 阻塞 goroutine | >50个 | CRITICAL | 自动扩容+dump栈 |
| 超时运行 | >3个 | HIGH | 标记Pod并通知SRE |
| 栈深度异常 | >100层 | MEDIUM | 记录采样日志 |
协同治理流
graph TD
A[CI Pipeline] --> B[ioc-trace-linter]
B -->|阻断| C[镜像构建]
C --> D[Sidecar注入]
D --> E[每30s采集pprof]
E --> F[指标聚合→Prometheus]
F --> G[告警联动Auto-Scaling]4.4 SRE协同方案：将EventLog生命周期纳入Service Level Indicator（SLI）指标看板
为实现可观测性闭环，需将EventLog从采集、解析、归档到过期的全生命周期映射为可量化SLI。
数据同步机制
通过Prometheus Exporter暴露关键阶段延迟指标：
# eventlog_slis_exporter.py
from prometheus_client import Gauge
# SLI维度：事件处理时效性（P95 < 2s视为达标）
event_processing_latency = Gauge(
'eventlog_processing_latency_seconds',
'P95 latency from ingestion to indexed availability',
['stage', 'service'] # stage: 'ingest', 'parse', 'store'
)逻辑分析：stage标签区分生命周期阶段，service标识归属服务；该Gauge被定时更新为各阶段P95延迟值，直接驱动SLI计算引擎。
SLI达标判定规则
| SLI名称 | 计算方式 | 目标阈值 |
|---|---|---|
| EventLog Availability | success_events / total_events |
≥ 99.9% |
| Log Processing Latency | rate(eventlog_processing_latency{stage="store"}[1h]) |
≤ 2s |
协同流程
graph TD
A[EventLog写入] --> B[实时采样打标]
B --> C[SLI指标聚合]
C --> D[告警/自动降级决策]
D --> E[运维工单联动]第五章：从内存泄漏到架构韧性：IoC治理范式的升维思考
一次生产事故的溯源：Spring Bean生命周期失控引发的OOM
某电商大促期间，订单服务在流量峰值后持续内存占用攀升，JVM堆内存使用率稳定在98%以上。通过 jmap -histo 和 MAT 分析发现，OrderProcessorImpl 实例数达12万+，而其依赖的 RedisTemplate 被注入了37个不同命名空间的 StringRedisTemplate Bean。根本原因在于：@Configuration 类中误用 @Bean 方法返回 new RedisTemplate() 并未声明 @Scope("prototype")，导致每次调用 orderService.process() 时均触发新 Bean 创建，且因未被 Spring 容器托管，GC 无法回收。
治理工具链落地：基于 ByteBuddy 的 IoC 行为审计探针
我们嵌入轻量级字节码增强探针，在 AbstractAutowireCapableBeanFactory.createBean() 前后埋点，采集以下维度数据：
| 维度 | 采集项 | 示例值 |
|---|---|---|
| Bean元信息 | beanName, beanClass, scope |
redisTemplateV2, org.springframework.data.redis.core.StringRedisTemplate, singleton |
| 生命周期事件 | preInstantiate, postDestroy |
true, false（未注册销毁回调） |
| 依赖图谱 | dependentOn, dependsOn |
["redisConnectionFactory"], [] |
探针日志自动上报至 ELK，并触发告警规则：scope == "singleton" && isPrototypeUsedInLoop == true && destroyMethodNotDeclared == true。
架构韧性设计：三级 IoC 防护网
- 编译期防护：自定义 Lombok
@Component注解处理器，校验@Scope与构造函数参数类型匹配性（如@Scope("prototype")的 Bean 不得注入@Singleton的DataSource）； - 启动期防护：Spring Boot Actuator 扩展端点
/actuator/ioc-health，实时输出循环依赖检测、未销毁 Bean 数量、动态代理类加载数等指标； - 运行期防护：基于
ApplicationContext事件监听器，在ContextRefreshedEvent后自动扫描所有@Component类，对含@PostConstruct但无@PreDestroy的 Bean 发起 Slack 告警并标记为“高风险”。
@Component
public class IoCDestructGuard implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) {
applicationContext.getBeansOfType(Object.class).values().stream()
.filter(bean -> bean.getClass().isAnnotationPresent(Component.class))
.filter(bean -> hasPostConstruct(bean) && !hasPreDestroy(bean))
.forEach(bean -> notifyRisk("Missing @PreDestroy on " + bean.getClass().getName()));
}
}案例复盘：从单点修复到范式迁移
某支付网关将原 @Service 层的 PaymentStrategyFactory 改造为策略注册中心，采用 Map<String, PaymentStrategy> 注入方式。初期仅修复了 getStrategy() 方法中的 new StrategyImpl() 内存泄漏，后续通过引入 @Lookup 方法 + @Scope("prototype")，结合 StrategyRegistry Bean 在 @PostConstruct 中预热全部策略实例，并在 @PreDestroy 中显式清空缓存引用，使 GC 回收率提升至99.7%。该模式已沉淀为团队《IoC 设计规范 v2.3》第7条强制条款。
graph LR
A[BeanDefinition 解析] --> B{是否声明 @Scope}
B -->|singleton| C[放入 singletonObjects 缓存]
B -->|prototype| D[每次 createBean() 新建实例]
D --> E[检查是否实现 DisposableBean]
E -->|否| F[触发 JVM Finalizer 队列延迟回收]
E -->|是| G[注册到 disposableBeans 清单]
G --> H[ContextCloseEvent 触发 destroy()]治理成效量化：2024年Q2全栈应用健康度对比
| 应用模块 | 内存泄漏事件数 | 平均 GC pause(ms) | Bean 初始化耗时(ms) | IoC 相关线上故障占比 |
|---|---|---|---|---|
| 支付核心 | 0 | 42 | 86 | 0% |
| 用户中心 | 1 | 117 | 213 | 1.2% |
| 商品服务 | 3 | 298 | 476 | 4.8% |
技术债清理：自动化重构脚本实践
开发 Python 脚本 ioc-scope-fixer.py，静态分析 Maven 工程中所有 @Bean 方法体，识别 new XxxService() 模式并自动替换为 return applicationContext.getBean(XxxService.class)，同时注入 @Scope("prototype") 注解。已覆盖 83 个存量模块，修复 217 处硬编码实例创建问题。
