# README

Overview

Component Manager provides dependency injection and lifecycle management for component-based monolith architecture apps.

See Demo application

A Component is a struct which can have dependencies and/or can implement lifecycle interfaces.

Features

two step initialization
reflect based dependency injection for interfaces
resolving circular dependency
components lifecycle support
ordered start, gracefully stop with reverse order
easy component and integration tests with mock
subcomponents support
reduce boilerplate code

Contetns

Basic usage
- Object definition
- Component lifecycle

Basic usage

Object definition

A Component is a struct which can have dependencies and/or can implement lifecycle interfaces.

Dependencies defined as fields in the struct and must be an interface type. have to be exportable because reflect can set only exportable struct fields. Also Dependencies must have tag inject:"".

type Supermarket struct {
	Warehouse core.Warehouse `inject:""`
}

	cm := component.NewManager(nil)
	cm.Register(producer.NewFarm(), producer.NewDoorFactory())
	cm.Register(&supermarket.Supermarket{}, &warehouse.Warehouse{})
	cm.Register(NewCustomer("Bob"), NewCustomer("Alice"))
	cm.Inject()

Component lifecycle

Usually components lives from app process executes till process finished.

new(instance created, first initialization)
inject(required dependency injected)
init(second initialization)
start(component can call their dependency interfaces, run goroutines)
prepare stop(optional)
stop (gracefully stop goroutines, close descriptors)

Component constructor

Constructor with config as param.

Init and start

When should use Init and when Start? What does it means.

Stop and gracefully stop

tbd

intefaces

type Initer interface {
	Init(ctx context.Context) error
}

type Starter interface {
	Start(ctx context.Context) error
}

type Stopper interface {
	Stop(ctx context.Context) error
}