lifecycle

package
v0.0.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 2, 2026 License: MIT Imports: 3 Imported by: 0

README

lifecycle 包 — 生命周期管理

所属层级: Core Layer
设计理念: 阶段管理，生命周期回调
设计灵感: Spring Lifecycle + Uber fx

概述

lifecycle 包提供完整的生命周期管理功能，包括应用生命周期阶段管理和 Bean 生命周期回调。

核心功能
功能 说明
应用生命周期阶段管理 PhaseInitializing → PhaseConfiguring → PhaseContextRefreshed → PhaseReady → PhaseRunning → PhaseStopping → PhaseStopped
Bean 生命周期回调 BeanInitFunc（初始化）和 BeanDestroyFunc（销毁）
生命周期钩子 Hook 接口（OnInit/OnStart/OnStop）
生命周期构建器 支持链式配置生命周期管理器

核心接口

ApplicationPhase 应用生命周期阶段
type ApplicationPhase int

const (
    PhaseInitializing     ApplicationPhase = iota // 初始化阶段：创建容器和基础组件
    PhaseConfiguring                              // 配置阶段：加载配置、注册 Bean
    PhaseContextRefreshed                         // 上下文刷新完成：所有 Bean 已注册
    PhaseReady                                    // 就绪阶段：应用准备就绪但尚未开始服务
    PhaseRunning                                  // 运行阶段：应用正常运行，处理请求
    PhaseStopping                                 // 停止阶段：应用正在停止，释放资源
    PhaseStopped                                  // 已停止：应用完全停止
)
阶段转换规则
  • 只允许正向转换(从早期阶段到后期阶段)
  • 不允许回退或跳跃转换
  • 转换时会通知所有注册的监听器
PhaseListener 阶段监听器
type PhaseListener interface {
    OnPhaseChange(oldPhase, newPhase ApplicationPhase) error
}

实现此接口可以在阶段变更时执行自定义逻辑。

LifecycleManager 生命周期管理器
type LifecycleManager struct {
    // ...
}
创建
manager := lifecycle.NewLifecycleManager()
阶段操作
// 获取当前阶段
phase := manager.GetPhase()

// 设置新阶段(会通知所有监听器)
err := manager.SetPhase(lifecycle.PhaseRunning)

// 添加阶段监听器
manager.AddListener(&myListener{})

// 设置错误处理回调
manager.SetErrorHandler(func(old, new lifecycle.ApplicationPhase, err error) {
    log.Printf("Phase transition error: %v", err)
})
Bean 生命周期回调
BeanInitFunc 初始化钩子
type BeanInitFunc func(bean any) error

在 Bean 创建后调用，替代 Spring 风格的 InitializingBean 接口：

initHook := lifecycle.BeanInitFunc(func(bean any) error {
    if db, ok := bean.(*Database); ok {
        return db.Connect()
    }
    return nil
})
BeanDestroyFunc 销毁钩子
type BeanDestroyFunc func(bean any) error

在 Bean 销毁前调用，替代 Spring 风格的 DisposableBean 接口：

destroyHook := lifecycle.BeanDestroyFunc(func(bean any) error {
    if db, ok := bean.(*Database); ok {
        return db.Close()
    }
    return nil
})
Hook 生命周期钩子接口
type Hook interface {
    OnInit(ctx context.Context) error
    OnStart(ctx context.Context) error
    OnStop(ctx context.Context) error
}
函数式钩子
// 创建完整钩子
hook := lifecycle.NewHookFunc(onInit, onStart, onStop)

// 创建单一钩子
hook := lifecycle.OnInitFunc(func(ctx context.Context) error {
    // 初始化逻辑
    return nil
})
HookRegistry 钩子注册表
registry := lifecycle.NewHookRegistry()
registry.Register(hook)

// 按注册顺序执行 OnInit
registry.InitAll(ctx)

// 按注册顺序执行 OnStart
registry.StartAll(ctx)

// 按注册逆序执行 OnStop
registry.StopAll(ctx)
LifecycleBuilder 生命周期构建器
manager := lifecycle.NewLifecycleBuilder().
    InitialPhase(lifecycle.PhaseConfiguring).
    Listener(&myListener{}).
    Build()

快速开始

基本生命周期管理
package main

import (
    "context"
    "fmt"
    "github.com/xudefa/enhance/lifecycle"
)

func main() {
    manager := lifecycle.NewLifecycleManager()

    // 添加阶段监听器
    manager.AddListener(&lifecycle.PhaseListenerFunc(func(old, new lifecycle.ApplicationPhase) error {
        fmt.Printf("Phase changed from %v to %v\n", old, new)
        return nil
    }))

    // 设置阶段
    manager.SetPhase(lifecycle.PhaseRunning)
    fmt.Println("Current phase:", manager.GetPhase())
}

API 参考

Bean 生命周期回调
// 注册初始化钩子
container.RegisterBean(
    reflect.TypeOf(&Database{}),
    core.Bean(func() (*Database, error) {
        return &Database{}, nil
    }),
    core.InitFunc(func(bean any) error {
        db := bean.(*Database)
        return db.Connect()
    }),
    core.DestroyFunc(func(bean any) error {
        db := bean.(*Database)
        return db.Close()
    }),
)
生命周期钩子
// 创建钩子
hook := lifecycle.NewHookFunc(
    func(ctx context.Context) error {
        fmt.Println("Initializing...")
        return nil
    },
    func(ctx context.Context) error {
        fmt.Println("Starting...")
        return nil
    },
    func(ctx context.Context) error {
        fmt.Println("Stopping...")
        return nil
    },
)

// 注册钩子
registry := lifecycle.NewHookRegistry()
registry.Register(hook)

// 执行生命周期
registry.InitAll(ctx)
registry.StartAll(ctx)
registry.StopAll(ctx)

使用示例

应用启动和关闭
func main() {
    manager := lifecycle.NewLifecycleManager()

    // 注册钩子
    registry := lifecycle.NewHookRegistry()
    registry.Register(lifecycle.NewHookFunc(
        func(ctx context.Context) error {
            // 初始化数据库连接
            db.Connect()
            return nil
        },
        func(ctx context.Context) error {
            // 启动 HTTP 服务器
            server.Start()
            return nil
        },
        func(ctx context.Context) error {
            // 关闭数据库连接
            db.Close()
            return nil
        },
    ))

    // 设置阶段
    manager.SetPhase(lifecycle.PhaseInitializing)
    registry.InitAll(ctx)

    manager.SetPhase(lifecycle.PhaseRunning)
    registry.StartAll(ctx)

    // 等待信号
    <-signalChan

    // 关闭应用
    manager.SetPhase(lifecycle.PhaseStopping)
    registry.StopAll(ctx)
    manager.SetPhase(lifecycle.PhaseStopped)
}
自定义阶段监听器
type LoggingPhaseListener struct{}

func (l *LoggingPhaseListener) OnPhaseChange(old, new lifecycle.ApplicationPhase) error {
    log.Printf("Application phase changed: %v -> %v", old, new)
    return nil
}

manager.AddListener(&LoggingPhaseListener{})

与 fx/go-spring/spring-boot 对比

特性 fx go-spring spring-boot enhance (Go 风格)
生命周期钩子 Invoke/Close 7 阶段状态机 BeanPostProcessor Hook(OnInit/OnStart/OnStop)
Bean 初始化 构造函数 InitializingBean @PostConstruct BeanInitFunc
Bean 销毁 Close() DisposableBean @PreDestroy BeanDestroyFunc
类型安全 泛型 反射 反射 泛型 + 反射
代码风格 Go 风格 Java 风格 Java 风格 Go 风格

最佳实践

1. 使用生命周期管理器管理应用状态
// ✅ 推荐：使用 LifecycleManager 管理阶段
manager := lifecycle.NewLifecycleManager()
manager.SetPhase(lifecycle.PhaseInitializing)
// 初始化逻辑
manager.SetPhase(lifecycle.PhaseRunning)

// ⚠️ 不推荐：手动管理状态
var phase string
phase = "initializing"
// 初始化逻辑
phase = "running"
2. 使用钩子注册表管理生命周期
// ✅ 推荐：使用 HookRegistry 统一管理
registry := lifecycle.NewHookRegistry()
registry.Register(dbHook)
registry.Register(serverHook)
registry.InitAll(ctx)
registry.StartAll(ctx)
defer registry.StopAll(ctx)

// ⚠️ 不推荐：分散的生命周期逻辑
db.Connect()
server.Start()
defer db.Close()
defer server.Stop()
3. 使用 Builder 模式配置生命周期
// ✅ 推荐：使用 Builder 链式配置
manager := lifecycle.NewLifecycleBuilder().
    InitialPhase(lifecycle.PhaseConfiguring).
    Listener(&myListener{}).
    ErrorHandler(func(old, new lifecycle.ApplicationPhase, err error) {
        log.Printf("Error: %v", err)
    }).
    Build()

// ⚠️ 不推荐：手动配置每个选项
manager := lifecycle.NewLifecycleManager()
manager.SetPhase(lifecycle.PhaseConfiguring)
manager.AddListener(&myListener{})
manager.SetErrorHandler(...)
4. 使用 Bean 生命周期回调
// ✅ 推荐：使用 InitFunc 和 DestroyFunc
container.RegisterBean(
    reflect.TypeOf(&Database{}),
    core.Bean(newDatabase),
    core.InitFunc(func(bean any) error {
        return bean.(*Database).Connect()
    }),
    core.DestroyFunc(func(bean any) error {
        return bean.(*Database).Close()
    }),
)

// ⚠️ 不推荐：手动管理 Bean 生命周期
db := newDatabase()
db.Connect()
defer db.Close()
5. 实现自定义阶段监听器
// ✅ 推荐：实现 PhaseListener 接口
type MetricsPhaseListener struct {
    metrics metrics.MeterRegistry
}

func (l *MetricsPhaseListener) OnPhaseChange(old, new lifecycle.ApplicationPhase) error {
    l.metrics.Counter("lifecycle.phase.changes", "from", old.String(), "to", new.String()).Inc()
    return nil
}

// ⚠️ 不推荐：硬编码阶段变更逻辑
func setPhase(phase lifecycle.ApplicationPhase) {
    currentPhase = phase
    metrics.Increment("phase_changes")
}

Documentation

Overview

Package lifecycle 提供生命周期管理功能，用于 enhance 框架。

该模块管理应用和组件的生命周期回调，包括初始化、启动、停止等阶段。 参考 Spring 的 Lifecycle 接口设计。

架构设计

  • ApplicationPhase: 应用生命周期阶段枚举
  • PhaseListener: 生命周期阶段监听器接口
  • LifecycleManager: 生命周期管理器
  • LifecycleBuilder: 生命周期构建器，支持链式配置
  • PhaseTransition: 阶段转换辅助结构
  • BeanInitFunc: Bean 初始化钩子函数类型
  • BeanDestroyFunc: Bean 销毁钩子函数类型

核心功能

  • 阶段管理: 支持 INIT → RUNNING → STOPPED 三阶段转换
  • 监听器: 支持注册阶段变更监听器
  • Bean 生命周期: 支持 Bean 初始化和销毁钩子
  • 错误处理: 支持自定义错误处理回调

使用方式

实现 PhaseListener 接口： 

type MyListener struct{}

func (m *MyListener) OnPhaseChange(oldPhase, newPhase lifecycle.ApplicationPhase) error {
    fmt.Printf("Phase changed: %s -> %s\n", oldPhase, newPhase)
    return nil
}

注册到生命周期管理器： 

manager := lifecycle.NewLifecycleManager()
manager.AddListener(&MyListener{})
manager.SetPhase(lifecycle.PhaseRunning)

执行顺序

阶段转换必须是正向的：INIT → RUNNING → STOPPED。 反向转换会返回错误。

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func RegisterHook 

func RegisterHook(hook Hook)

RegisterHook 注册到全局钩子注册表

func RegisterHookFunc 

func RegisterHookFunc(onInit, onStart, onStop func(context.Context) error)

RegisterHookFunc 通过函数注册到全局钩子注册表

Types

type ApplicationPhase 

type ApplicationPhase int

ApplicationPhase 应用生命周期阶段。

简化为 3 阶段：PhaseInit → PhaseRunning → PhaseStopped 

const (
	PhaseInit    ApplicationPhase = iota // 初始化阶段：创建容器、加载配置、注册 Bean
	PhaseRunning                         // 运行阶段：应用正常运行，处理请求
	PhaseStopped                         // 已停止：应用完全停止
)

应用生命周期阶段定义。

func (ApplicationPhase) String 

func (p ApplicationPhase) String() string

String 返回阶段的字符串表示。

type BeanDestroyFunc 

type BeanDestroyFunc func(bean any) error

BeanDestroyFunc Bean 销毁钩子函数类型。

在 Bean 销毁前调用，替代 Spring 风格的 DisposableBean 接口。 使用函数类型而非接口，更符合 Go 惯用法。

type BeanInitFunc 

type BeanInitFunc func(bean any) error

BeanInitFunc Bean 初始化钩子函数类型。

在 Bean 创建后调用，替代 Spring 风格的 InitializingBean 接口。 使用函数类型而非接口，更符合 Go 惯用法。

type Hook 

type Hook interface {
	OnInit(ctx context.Context) error
	OnStart(ctx context.Context) error
	OnStop(ctx context.Context) error
}

Hook 生命周期钩子接口。

func NewHookFunc 

func NewHookFunc(onInit, onStart, onStop func(context.Context) error) Hook

NewHookFunc 创建函数式钩子

func OnInitFunc 

func OnInitFunc(fn func(context.Context) error) Hook

OnInitFunc 创建仅实现 OnInit 的钩子

func OnStartFunc 

func OnStartFunc(fn func(context.Context) error) Hook

OnStartFunc 创建仅实现 OnStart 的钩子

func OnStopFunc 

func OnStopFunc(fn func(context.Context) error) Hook

OnStopFunc 创建仅实现 OnStop 的钩子

type HookFunc 

type HookFunc struct {
	// contains filtered or unexported fields
}

HookFunc 函数式钩子。

func (*HookFunc) OnInit 

func (h *HookFunc) OnInit(ctx context.Context) error

OnInit 在容器初始化完成后调用

func (*HookFunc) OnStart 

func (h *HookFunc) OnStart(ctx context.Context) error

OnStart 在应用启动时调用

func (*HookFunc) OnStop 

func (h *HookFunc) OnStop(ctx context.Context) error

OnStop 在应用停止时调用

type HookRegistry 

type HookRegistry struct {
	// contains filtered or unexported fields
}

HookRegistry 钩子注册表

管理多个 Hook，按注册顺序执行 OnInit/OnStart，逆序执行 OnStop。 使用 RWMutex 优化读多写少场景，读操作无写锁竞争。

func GlobalHookRegistry 

func GlobalHookRegistry() *HookRegistry

GlobalHookRegistry 获取全局钩子注册表

func NewHookRegistry 

func NewHookRegistry() *HookRegistry

NewHookRegistry 创建钩子注册表

func (*HookRegistry) Count 

func (r *HookRegistry) Count() int

Count 返回已注册的钩子数量

func (*HookRegistry) GetAll 

func (r *HookRegistry) GetAll() []Hook

GetAll 返回所有已注册的钩子

func (*HookRegistry) InitAll 

func (r *HookRegistry) InitAll(ctx context.Context) error

InitAll 按注册顺序执行所有 OnInit

func (*HookRegistry) Register 

func (r *HookRegistry) Register(hook Hook)

Register 注册一个钩子

func (*HookRegistry) RegisterFunc 

func (r *HookRegistry) RegisterFunc(onInit, onStart, onStop func(context.Context) error)

RegisterFunc 通过函数注册钩子

func (*HookRegistry) StartAll 

func (r *HookRegistry) StartAll(ctx context.Context) error

StartAll 按注册顺序执行所有 OnStart

func (*HookRegistry) StopAll 

func (r *HookRegistry) StopAll(ctx context.Context) error

StopAll 按注册逆序执行所有 OnStop

type LifecycleBuilder 

type LifecycleBuilder struct {
	// contains filtered or unexported fields
}

LifecycleBuilder 生命周期构建器，支持链式配置。

func NewLifecycleBuilder 

func NewLifecycleBuilder() *LifecycleBuilder

NewLifecycleBuilder 创建生命周期构建器。

func (*LifecycleBuilder) Build 

func (b *LifecycleBuilder) Build() *LifecycleManager

Build 构建生命周期管理器

func (*LifecycleBuilder) InitialPhase 

func (b *LifecycleBuilder) InitialPhase(phase ApplicationPhase) *LifecycleBuilder

InitialPhase 设置初始阶段

func (*LifecycleBuilder) Listener 

func (b *LifecycleBuilder) Listener(listener PhaseListener) *LifecycleBuilder

Listener 添加监听器

func (*LifecycleBuilder) OnError 

func (b *LifecycleBuilder) OnError(handler func(oldPhase, newPhase ApplicationPhase, err error)) *LifecycleBuilder

OnError 设置错误处理回调

type LifecycleManager 

type LifecycleManager struct {
	// contains filtered or unexported fields
}

LifecycleManager 生命周期管理器。

func NewLifecycleManager 

func NewLifecycleManager() *LifecycleManager

NewLifecycleManager 创建生命周期管理器。

func (*LifecycleManager) AddListener 

func (m *LifecycleManager) AddListener(listener PhaseListener)

AddListener 添加生命周期阶段监听器

func (*LifecycleManager) GetPhase 

func (m *LifecycleManager) GetPhase() ApplicationPhase

GetPhase 返回当前生命周期阶段

func (*LifecycleManager) SetErrorHandler 

func (m *LifecycleManager) SetErrorHandler(handler func(oldPhase, newPhase ApplicationPhase, err error))

SetErrorHandler 设置错误处理回调

func (*LifecycleManager) SetPhase 

func (m *LifecycleManager) SetPhase(newPhase ApplicationPhase) error

SetPhase 设置新的生命周期阶段并通知所有监听器

type PhaseListener 

type PhaseListener interface {
	// OnPhaseChange 处理阶段变更事件。
	OnPhaseChange(oldPhase, newPhase ApplicationPhase) error
}

PhaseListener 生命周期阶段监听器。

type PhaseTransition 

type PhaseTransition struct {
	OldPhase ApplicationPhase
	NewPhase ApplicationPhase
}

PhaseTransition 阶段转换辅助结构。

func (PhaseTransition) String 

func (t PhaseTransition) String() string

String 返回转换描述。

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.