digo

English | 简体中文

digo

Note: Go version 1.20+ is required.

An annotation-based tool for compile-time dependency injection in Golang.

Features

• Use annotations in comments.
• Automatic code generation.
• Automatic detection of circular dependencies.
• Compile-time dependency injection.
• Automatic initialization.
• Support for managing instance groups.

Quick Start

For more examples, please refer to: examples.

Write Code and Annotations

package main

import (
	"log"

	"github.com/werbenhu/digo"
)

// @provider({"id":"main.db.url"})
func NewDbUrl() string {
	return "localhost:3306"
}

type Db struct {
	url string
}

// @provider({"id":"main.db"})
// @inject({"param":"url", "id":"main.db.url"})
func NewDb(url string) *Db {
	return &Db{
		url: url,
	}
}

type Redis struct {
}

// @provider({"id":"main.redis"})
func NewRedis() *Redis {
	return &Redis{}
}

type App struct {
	db    *Db
	redis *Redis
}

// @provider({"id":"main.app"})
// @inject({"param":"db", "id":"main.db"})
// @inject({"param":"redis", "id":"main.redis"})
func NewApp(db *Db, redis *Redis) *App {
	return &App{
		db:    db,
		redis: redis,
	}
}

func (a *App) Start() {
	log.Printf("app strat, db:%s\n", a.db.url)
}

func main() {
	app, err := digo.Provide("main.app")
	if err == nil {
		app.(*App).Start()
	}
}

Install digogen Tool

go install github.com/werbenhu/digo/digogen@v1.0.3

Generate Dependency Injection Code

Open the command line and execute the following command. digogen will automatically generate the digo.generated.go source code file based on the annotations.

cd examples/simple
digogen

Run the Code

go run .\digo.generated.go .\main.go

Annotation Details

@provider

The @provider annotation indicates that it is an instance provider, and the instance is a singleton.

• Example:

// @provider({"id":"main.db"})

• Supported parameters:

To obtain an instance, you can use digo.Provide(providerId) to retrieve the instance of a specific provider.

app, err := digo.Provide("main.app")
if err == nil {
	app.(*App).Start()
}

@inject

The @inject annotation indicates injecting an instance into a parameter. The @inject annotation must coexist with either @provider or @group.

• Example:

// @inject({"param":"db", "id":"main.db"})

• Supported parameters:

The pkg parameter is used when you need to import a specific package. For example, if you need to import the package github.com/xxx/tool/v1, you would use the package name as *tool.Struct, not *v1.Struct. In such cases, you need to explicitly specify the import of the github.com/xxx/tool/v1 package.

// @inject({"param":"tool", "id":"main.tool", "pkg":"github.com/xxx/tool/v1"})

@group

The @group annotation indicates registering an instance to a group.

• Example:

// @group({"id":"main.controllers"})

• Supported parameters:

To retrieve all instances of a group, you can use digo.Members(groupId) to get all the instances of the group.

ctrls, err := digo.Members("main.controllers")
if err == nil {
    for _, controller := range ctrls {
        // TODO:
    }
}