Parsley is a powerful, easy-to-use reflection-based dependency injection package that integrates seamlessly into any Go application.
Just like the versatile green herb it's named after, Parsley enhances the flavor of your codebase by keeping your dependencies clean, organized, and easy to manage. Whether you're working on a small project or a complex system, Parsley brings the convenience of automated dependency injection to Go, inspired by the best practices from other languages. With features like automated lifetime management, proxy generation, and method interception, Parsley is the ingredient that makes your Go applications more maintainable and scalable.
While dependency injection (DI) is less common in Golang compared to other languages, the complexity it introduces can often be outweighed by the benefits it brings, especially in larger projects. As projects grow, the need for indirection and modularity becomes inevitable, and a DI framework like Parsley can seamlessly bridge the gap between dependency management and service activation. Parsley goes beyond resolving dependencies—it automates key aspects such as lifetime management, proxy generation, and interception, reducing boilerplate and enhancing maintainability. With these powerful features, why not let Parsley handle the heavy lifting for you?
-
Constructor Functions: Register types via constructor functions.
-
Resolve by Type: Resolve objects by both interface and pointer types.
- Constructor Injection: Supported.
- Field Injection: ⏳ Will be supported via struct tags (in progress).
- Setter Method Injection: ❌ Not supported.
- Safe Casts: Convenience function
ResolveRequiredService[T]
to resolve and safely cast objects.
-
Lifetime Management: Register types with different lifetimes.
- Singleton: Available.
- Register Instances as Singletons: Use
RegisterInstance[T]
(whereT
must be an interface type). - Scoped: Requires a
NewScopedContext(context.Background)
. UseRegisterScoped()
. - Transient: Available for objects with a transient lifetime.
-
Modular Registrations: Bundle type registrations as modules, register them via
RegisterModule
as a unit. -
On-Demand Resolution: Resolve objects only when needed.
- Custom Factories: Allow consumption of
Resolver
instead of custom factories. - Lazy Loading: Inject dependencies lazily using
Lazy[T]
. - Factory Functions: Register factories to create service instances dynamically at runtime.
- Service Validation: Validate services during startup and fail early if missing registrations or circular dependencies are found.
- Non-Registered Types: Resolve non-registered types using
ResolveWithOptions[T]
. - Override Type Registrations: Provide custom service instances when resolving service instances.
- Custom Factories: Allow consumption of
- Named Services: Register and resolve multiple services for the same interface, via
func(key string) T
. - Service Lists: Resolve services as a list. Enable list dependencies via
RegisterList
.
- Proxies as Drop-in Replacements: Generate proxy types that can be used in place of target services.
- Extensible Proxies: Proxies are extensible with
MethodInterceptor
services.
- Generate Mocks: Generate configurable mocks via
//go:parsley-cli generate mocks
to boost automated testing.
Getting started with Parsley is as simple as adding it to your project and letting it take care of your dependencies. Here’s how you can use Parsley to wire up a small example application.
First, add Parsley to your project:
go get github.com/matzefriedrich/parsley
For more advanced features, you can install the parsley-cli
utility:
go install github.com/matzefriedrich/parsley/cmd/parsley-cli
Imagine you're building a service that greets users and logs those greetings. Instead of manually wiring everything together, Parsley can handle the setup. Start by defining the interfaces for your services:
// Greeter defines a service that greets users.
type Greeter interface {
SayHello(name string) string
}
// Logger defines a service that logs messages.
type Logger interface {
Log(message string)
}
Now, create the implementations for these interfaces:
type greeterServiceImpl struct {
logger LoggerService
}
func (g *greeterServiceImpl) SayHello(name string) string {
greeting := "Hello, " + name + "!"
g.logger.Log("Generated greeting: " + greeting)
return greeting
}
type loggerServiceImpl struct{}
func (l *loggerServiceImpl) Log(message string) {
fmt.Println("Log:", message)
}
To wire everything together, define constructor functions:
func NewGreetService(logger LoggerService) GreetService {
return &greetServiceImpl{logger: logger}
}
func NewLoggerService() LoggerService {
return &loggerServiceImpl{}
}
With Parsley, registering these services and resolving them is straightforward:
func main() {
registry := registration.NewServiceRegistry()
// Register services with their lifetimes
registration.RegisterSingleton(registry, NewLoggerService)
registration.RegisterScoped(registry, NewGreetService)
// Create a resolver
resolver := resolving.NewResolver(registry)
// Resolve and use the Greeter service instance
scope := resolving.NewScopedContext(context.Background())
greeter, _ := resolving.ResolveRequiredService[Greeter](resolver, scope)
// Use the service
fmt.Println(greeter.SayHello("World"))
}
When you run this application, you’ll see that Parsley automatically handles the dependencies for you:
Log: Generated greeting: Hello, World!
Hello, World!
In this example, you defined two services, Greeter
and Logger
. You then registered these services with Parsley, specifying that Logger
should have a singleton lifetime while Greeter
should be scoped. Parsley injected a Logger
instance into the Greeter
instance during creation, ensuring everything was wired up correctly.
By using Parsley, you avoid the hassle of manual dependency wiring, keeping your code clean and focused on business logic. But that is not all - there are more features to explore: head over to the official docs at https://matzefriedrich.github.io/parsley-docs/ to find more usage examples.
Copyright 2024 - Matthias Friedrich