Ore: Advanced Dependency Injection Package for Go-Golang-php.cn

Ore: Advanced Dependency Injection Package for Go

Ore: Advanced dependency injection package for Go language

Ore Documentation Website

GitHub repository

The Go language is known for its simplicity and high performance, but developers often face challenges when it comes to dependency management. Although the Go language does not have a built-in DI framework like some other languages, there are many third-party libraries that can help. Ore is such a package that provides a lightweight and efficient solution for dependency injection (DI) in Go applications.

Ore is designed to simplify and improve DI efficiency without introducing significant performance overhead. Unlike many other DI libraries, Ore utilizes Go Generics instead of reflection or code generation, ensuring your application remains fast and type-safe. This makes Ore ideal for developers looking for an efficient, easy-to-use DI solution. In this article, we will introduce the key features of Ore and how they can help you manage dependencies in Go. We will also show some basic code examples to demonstrate how Ore can be used in real applications.

Ore’s key features

1.

Generic-based dependency injection

Ore utilizes

Go generics

to register and resolve dependencies. This design choice avoids the performance overhead typically associated with reflection and code generation. By using generics, Ore ensures that dependency resolution is type-safe and efficient, without any kind of runtime checking. This approach makes Ore a high-performance DI solution because it avoids the pitfalls of reflection and code generation that are common in many other DI frameworks.

Simple and flexible registration

Ore provides multiple ways to register services, allowing you to flexibly choose according to the life cycle of the service (for example, singleton, scope, transient). Whether you need a single instance, a scoped instance for a specific context, or a transient instance created on every request, Ore has you covered.

Keying Service

Ore allows you to register and resolve multiple implementations of the same interface using a

keyed service

. This feature is useful when you need to manage multiple versions of a service or need to implement different behavior based on certain conditions. For example, you can create multiple implementations of a service for different environments (e.g., test, production) or different configurations (e.g., based on user roles).

Placeholder Service

Ore also supports

Placeholder Services

, allowing you to register services with unresolved dependencies that can be populated at runtime. This feature is useful when some values or services are not available at registration time, but become available later. For example, you can register a service that requires configuration values and then dynamically provide the actual configuration based on context (e.g., user role or environment).

5. Verification

Ore includes built-in Registration Verification that catches common issues such as:

Missing dependencies: Make sure all required services are registered.
Circular Dependencies: Detect and prevent circular dependency chains.
Lifecycle mismatch: Ensure that services with longer lifecycles do not depend on services with shorter lifecycles.

This validation occurs automatically when you use ore.Get or ore.GetList to resolve the service, but you can also trigger validation manually using ore.Validate(). This ensures your dependency graph is correct and avoids runtime errors due to misconfiguration.

Additionally, you can disable validation for performance reasons or seal the container to prevent further modifications after registering all services.

6. High performance

Performance is a key consideration in Ore. By avoiding reflection and code generation, Ore remains fast, even in large applications with complex dependency graphs. Ore's benchmark results demonstrate its efficiency, with certain operations taking just a few nanoseconds to complete. This makes Ore an excellent choice for high-performance Go applications that require efficient DI without additional overhead.

7. Modularization and Scope Containers

Ore supports modular containers, allowing you to define separate containers for different parts of your application. This is particularly useful for modular applications, where different components or modules have different dependencies. You can define scoped containers for different use cases, making your dependency management more organized and easier to maintain.

Code Example

To better understand how Ore works, let’s look at a few simple examples using the default Ore container.

Example 1: Basic Service registration and resolution

<code class="language-go">package main

import (
    "context"
    "fmt"
    "github.com/firasdarwish/ore"
)

// 定义一个接口
type Greeter interface {
    Greet() string
}

// 定义一个服务实现
type FriendlyGreeter struct{}

func (g *FriendlyGreeter) Greet() string {
    return "Hello, world!"
}

func main() {
    // 使用默认Ore容器注册服务
    ore.RegisterFunc[Greeter](ore.Singleton, func(ctx context.Context) (Greeter, context.Context) {
        return &FriendlyGreeter{}, ctx
    })

    // 从默认Ore容器解析服务
    greeter, _ := ore.Get[Greeter](context.Background())
    fmt.Println(greeter.Greet()) // 输出：Hello, world!
}</code>

Copy after login

This example demonstrates the registration of a service. Here, we define a Greeter interface and a FriendlyGreeter implementation, register it as a singleton, and then resolve it using the default Ore container.

Example 2: Keyed service used in multiple implementations

<code class="language-go">package main

import (
    "context"
    "fmt"
    "github.com/firasdarwish/ore"
)

// 定义一个接口
type Greeter interface {
    Greet() string
}

// 定义多个实现
type FriendlyGreeter struct{}

func (g *FriendlyGreeter) Greet() string {
    return "Hello, friend!"
}

type FormalGreeter struct{}

func (g *FormalGreeter) Greet() string {
    return "Good day, Sir/Madam."
}

func main() {
    // 使用键注册多个实现
    ore.RegisterKeyedFunc[Greeter](ore.Singleton, func(ctx context.Context) (Greeter, context.Context) {
        return &FriendlyGreeter{}, ctx
    }, "friendly")

    ore.RegisterKeyedFunc[Greeter](ore.Singleton, func(ctx context.Context) (Greeter, context.Context) {
        return &FormalGreeter{}, ctx
    }, "formal")

    // 根据键解析特定实现
    greeter, _ := ore.GetKeyed[Greeter](context.Background(), "friendly")
    fmt.Println(greeter.Greet()) // 输出：Hello, friend!

    greeter, _ = ore.GetKeyed[Greeter](context.Background(), "formal")
    fmt.Println(greeter.Greet()) // 输出：Good day, Sir/Madam.
}</code>

Copy after login

In this example, we register two implementations of the Greeter interface with the keys ("friendly" and "formal") and resolve them based on the required keys. This flexibility allows you to easily manage different implementations.

Conclusion

Ore provides a concise, simple and efficient dependency injection solution for Go. By using Go generics, Ore provides fast and type-safe dependency resolution without the performance overhead of reflection. It is flexible and easy to use and includes features such as Keyed Services, Placeholder Services and Validation to ensure your application remains robust.

Ore Documentation Website

GitHub repository

The above is the detailed content of Ore: Advanced Dependency Injection Package for Go. For more information, please follow other related articles on the PHP Chinese website!