everon / factory
Everon Factory Component
Installs: 2 738 421
Dependents: 3
Suggesters: 0
Security: 0
Stars: 0
Watchers: 1
Forks: 0
Open Issues: 0
Requires
- php: ^8
- everon/collection: ^3
- everon/utils: ^3
Requires (Dev)
- mockery/mockery: ^1
- phpunit/phpunit: ^9
README
Library to handle dependency injection and instantiation. Allows to produce code that is easy to test.
Versions
- Use v1.x and v2.x with PHP 7.2+
- Use v3.x with PHP 8+
Features
- One line, lazy loaded dependency injection (via setters or constructors)
- Trait based, simple to use and implement, no hassle with config files, pure PHP
- Factory/FactoryWorker gives full control and overview, on how each and every object is created
- FactoryWorker allows for custom implementation of Factory methods
- Full control when a dependency should be reused (via Dependency Container) or created from scratch (eg. Logger vs Value Object)
- Minimized file/memory access/usage due to callbacks and lazy load
- Intuitive Interface: clear, small and simple API
- Convention over configuration
- Clean code
How it works
Every instantiation should happen only inside of the FactoryWorker
class.
Its role is similar of AbstractFactory
. It sits between Everon Factory Component and the client code that uses it, so there is no direct coupling.
It's easy to implement and manage, because injection is cheap and dependency setup happens in one place.
This makes testing much easier, as everything can be easily mocked/stubbed/faked.
It's ok to use new
operator outside of Factory methods for simple value object like classes. For example new Collection()
.
For a particular module or application, the registerBeforeWork
method of FactoryWorker
is one of a places where you could setup your dependency tree.
Or you could use Root Composition pattern and handle your whole dependency graph outside of your application.
Easy Dependency Injection
To use dependency injection, register it with Dependency Container
and use one line trait to inject it.
For example, this will auto inject a predefined Logger
instance via setter injection into Foo
class.
class Foo { use Dependency\Setter\Logger; }
Register with Dependency Container
Use register
method to register the dependency under Logger
name.
$Container->register('Logger', function () use ($FactoryWorker) { return $FactoryWorker->buildLogger(); });
Define the traits and interface
Example of Logger
dependency trait, which is reused between all of the classes that use Dependency\Setter\Logger
trait.
The only thing to remember is that, the name of the trait should be the same,
as the name under which the dependency was registered with the Dependency Container
.
trait Logger { /** * @var LoggerInterface */ protected $Logger; /** * @inheritdoc */ public function getLogger() { return $this->Logger; } /** * @inheritdoc */ public function setLogger(LoggerInterface $Logger) { $this->Logger = $Logger; } }
Bonus: You can also define and assign the LoggerAwareInterface
too all classes that are being injected with Logger
instance.
interface LoggerAwareInterface { /** * @return LoggerInterface */ public function getLogger(); /** * @param Logger LoggerInterface */ public function setLogger(LoggerInterface $Logger); }
Define the setter injection trait.
The only requirement is that the name ends with Dependency\Setter\<dependency name>
.
You can reuse already defined Dependency\Logger
trait, in every class that implements LoggerAwareInterface.
namespace Application\Modules\Logger\Dependency\Setter; use Application\Modules\Logger\Dependency; trait Logger { use Dependency\Logger; }
Register with Factory
Use registerWorkerCallback
to register callback which will return instance of required FactoryWorker.
$Factory->registerWorkerCallback('ApplicationFactoryWorker', function() use ($Factory) { return $Factory->buildWorker(Application::class); });
Build with FactoryWorker
To build your dependencies use the FactoryWorker
classes.
class ApplicationFactoryWorker extends AbstractWorker implements FactoryWorkerInterface { /** * @inheritdoc */ protected function registerBeforeWork() { $this->getFactory()->registerWorkerCallback('ApplicationFactoryWorker', function () { return $this->getFactory()->buildWorker(self::class); }); } /** * @return Logger */ public function buildLogger() { $Logger = new Logger(); $this->getFactory()->injectDependencies(Logger::class, $Logger); return $Logger; } /** * @param LoggerInterface $Logger * @param string $anotherArgument * @param array $data * * @return ApplicationInterface */ public function buildApplication(LoggerInterface $Logger) { $Application = new Application($Logger); $this->getFactory()->injectDependencies(Application::class, $Application); return $Application; } /** * @param LoggerInterface $Logger * * @return UserManagerInterface */ public function buildUserManager(LoggerInterface $Logger) { $UserManager = new UserManager($Logger); $this->getFactory()->injectDependencies(UserManager::class, $UserManager); return $UserManager; } }
Resolve with Dependency Container
Use resolve
to receive dependency defined earlier with register
or propose
.
So you can pass the same instance to another class via constructor injection.
$Container->register('Logger', function () use ($FactoryWorker) { return $FactoryWorker->buildLogger(); }); $Container->register('UserManager', function () use ($FactoryWorker, $Container) { $Logger = $Container->resolve('Logger'); return $FactoryWorker->buildUserManager($Logger); }); $Container->register('Application', function () use ($FactoryWorker, $Container) { $Logger = $Container->resolve('Logger'); return $FactoryWorker->buildApplication($UserManager, $Logger); });
Now Application
and UserManager
will share the same instance of Logger
class.
$Application->getLogger()->log('It works'); $UserManager->getLogger()->log('It works, too');
If you don't do any work in constructors, and you shouldn't, and only require the Logger
functionality later, it would be easier
to just use the Logger
as the infrastructure type dependency and just inject it via setter injection with one line.
The end result is the same.
Every required class will be injected with the same Logger
instance,
that was registered with the Dependency Container
and assembled by FactoryWorker
in Factory
.
Ensures Tests Ready Code (TM)
Writing tests of classes that use Everon Factory
for the dependency injection
and instantiation removes the hassle of dealing with dependency problems since everything is so easy to mock.
Dependency Container, Factory and FactoryWorker
Instantiate new Dependency Container
and assign it to Factory
.
Use Factory
to get instance of your specific FactoryWorker
.
The best thing is, that the classes which are being instantiated with the FactoryWorker
are not aware
about the Dependency Container
at all.
It could be in separate files, obviously, split by the application type and the dependencies it needs.
An example, of using the same instance of Logger
, in every class, through out whole application,
which required Logger
dependency.
$Container = new Dependency\Container(); $Factory = new Factory($Container); $Factory->registerWorkerCallback('ApplicationFactoryWorker', function() use ($Factory) { return $Factory->buildWorker(Application::class); }); $FactoryWorker = $Factory->getWorkerByName('ApplicationFactoryWorker'); $Container->register('Application', function () use ($FactoryWorker, $Container) { $UserManager = $Container->resolve('UserManager'); $Logger = $Container->resolve('Logger'); return $FactoryWorker->buildApplication($UserManager, $Logger); }); $Container->register('UserManager', function () use ($FactoryWorker) { $Logger = $FactoryWorker->getFactory()->getDependencyContainer()->resolve('Logger'); return $FactoryWorker->buildUserManager($UserRepository, $Logger); }); $Container->register('Logger', function () use ($FactoryWorker) { return $FactoryWorker->buildLogger(); }); //.. //.. Instantiate your application, and proceed as usual //.. $Application = $Container->resolve('Application'); $Application ->bootstrap() ->run();
What's the best way to inject dependencies?
Use constructor for dependencies that are part of what the class is doing, and use setters/getters for infrastructure type dependencies.
In general, a Logger
or FactoryWorker
could be good examples of infrastructure type dependencies.
Test Driven
See tests for more examples with trait dependencies.
Example
Check Everon Criteria Builder to see how to use Everon Factory by example.