Golang依赖注入框架Fx使用指南

Fx是Uber开源的Go语言依赖注入框架，它可以帮助开发者构建模块化、可测试的应用程序。下面详细介绍Fx的核心概念和使用方法。

一、Fx核心概念

1. Provide：注册构造函数，Fx会调用这些函数来创建依赖项
2. Invoke：注册需要在应用启动时执行的函数
3. Module：将相关的Provide和Invoke组织在一起的功能模块

二、基本使用示例

package main

import (
	"context"
	"go.uber.org/fx"
	"log"
	"net/http"
)

// 数据库服务
type Database struct {
	conn string
}

func NewDatabase() *Database {
	return &Database{conn: "db_connection"}
}

// 用户服务
type UserService struct {
	db *Database
}

func NewUserService(db *Database) *UserService {
	return &UserService{db: db}
}

func (s *UserService) GetUser(id string) string {
	return "user_" + id + "_from_" + s.db.conn
}

// HTTP处理器
type Handler struct {
	userService *UserService
}

func NewHandler(userService *UserService) *Handler {
	return &Handler{userService: userService}
}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	userID := r.URL.Query().Get("id")
	_, _ = w.Write([]byte(h.userService.GetUser(userID)))
}

// 启动HTTP服务器
func StartServer(lc fx.Lifecycle, handler *Handler) {
	server := &http.Server{
		Addr:    ":8080",
		Handler: handler,
	}

	lc.Append(fx.Hook{
		OnStart: func(ctx context.Context) error {
			go func() {
				log.Println("Starting server on :8080")
				if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
					log.Fatal(err)
				}
			}()
			return nil
		},
		OnStop: func(ctx context.Context) error {
			log.Println("Stopping server")
			return server.Shutdown(ctx)
		},
	})
}

func main() {
	app := fx.New(
		// 提供依赖项
		fx.Provide(
			NewDatabase,
			NewUserService,
			NewHandler,
		),
		// 启动时执行
		fx.Invoke(StartServer),
	)

	app.Run()
}

三、高级特性

1. 使用模块组织代码

// user_module.go
package user

import "go.uber.org/fx"

var Module = fx.Module("user",
	fx.Provide(
		NewUserService,
	),
)

// database_module.go
package database

import "go.uber.org/fx"

var Module = fx.Module("database",
	fx.Provide(
		NewDatabase,
	),
)

// main.go
app := fx.New(
	database.Module,
	user.Module,
	fx.Provide(NewHandler),
	fx.Invoke(StartServer),
)

2. 可选依赖

type Config struct {
	fx.In
	DB *Database `optional:"true"` // 如果Database不可用，DB将为nil
}

func NewService(cfg Config) *Service {
	if cfg.DB != nil {
		// 使用数据库
	}
	// 其他逻辑
}

3. 参数对象模式

type Params struct {
	fx.In
	UserService *UserService
	DB          *Database
	Logger      *log.Logger `optional:"true"`
}

func NewHandler(p Params) *Handler {
	return &Handler{
		userService: p.UserService,
		db:          p.DB,
		logger:      p.Logger,
	}
}

4. 结果对象模式

type Result struct {
	fx.Out
	Service *Service
	Client  *Client
}

func NewServiceAndClient() Result {
	s := &Service{}
	c := &Client{}
	return Result{
		Service: s,
		Client:  c,
	}
}

四、生命周期管理

Fx提供了优雅的生命周期管理：

func StartWithLifecycle(lc fx.Lifecycle, service *SomeService) {
	lc.Append(fx.Hook{
		OnStart: func(ctx context.Context) error {
			// 启动时执行
			return service.Start()
		},
		OnStop: func(ctx context.Context) error {
			// 停止时执行
			return service.Stop()
		},
	})
}

五、错误处理

app := fx.New(
	fx.Provide(
		func() (*Database, error) {
			if err := checkConfig(); err != nil {
				return nil, err
			}
			return &Database{}, nil
		},
	),
	fx.Invoke(func(db *Database) {
		// 使用db
	}),
)

if err := app.Err(); err != nil {
	log.Fatal(err)
}

六、测试中使用Fx

func TestService(t *testing.T) {
	testApp := fx.New(
		fx.Provide(
			func() *Database {
				return &Database{conn: "test_connection"}
			},
			NewUserService,
		),
		fx.NopLogger, // 禁用日志
	)

	err := testApp.Start(context.Background())
	defer testApp.Stop(context.Background())
	
	require.NoError(t, err)
	
	var service *UserService
	err = testApp.Err()
	require.NoError(t, testApp.Err())
	require.NoError(t, testApp.Populate(&service))
	
	assert.Equal(t, "user_123_from_test_connection", service.GetUser("123"))
}

Fx框架通过依赖注入简化了Go应用的构建过程，使代码更加模块化和可测试。合理使用Fx可以显著提高大型应用的开发效率和可维护性。