sroze / chain-of-responsibility
A light library that simplify the implementation of a chain of responsibility
Installs: 10 325
Dependents: 1
Suggesters: 0
Security: 0
Stars: 24
Watchers: 3
Forks: 3
Open Issues: 0
Requires
- mareg/dependency-graph: 0.2.*
Requires (Dev)
- fabpot/php-cs-fixer: ~1.9
- phpunit/phpunit: ~4.5.0
This package is auto-updated.
Last update: 2024-11-16 13:10:57 UTC
README
This light library helps to implement quickly a chain of responsibility. This pattern is especially useful when you need a clear process that involve multiple steps.
Installation
The suggested installation method is via composer:
composer require sroze/chain-of-responsibility
Usage
There's two components:
- The Runner that will take a brunch of processes, decorates them to create the chain-of-responsibility and execute the head.
- The builder adds a little bit of like to processes because they can declare a list of other processes that needs to be run before.
Runner
Create your processes classes that implements the ChainProcessInterface
. This interface only has one execute
method
that take a ChainContext
object as parameter. This parameter is usable like an array and will provides your processes
a common way to exchange information between them.
use SRIO\ChainOfResponsibility\ChainContext; use SRIO\ChainOfResponsibility\ChainProcessInterface; class LambdaProcess implements ChainProcessInterface { /** * {@inheritdoc} */ public function execute(ChainContext $context) { // Do whatever you want in this small process, such as // sending a mail, manipulating files, ... } }
Create the chain runner with a list of given processes. The list order is quite important since it'll be the order of execution of processes.
$runner = new ChainRunner([ new FirstProcess(), new SecondProcess(), new ThirdProcess() ]);
Then, use the run
method to run each process, with an optional ChainContext
argument.
$runner->run(new ArrayChainContext([ 'foo' => 'bar' ]));
Builder
The builder is able to construct your chain of responsibility based on dependencies between processes. To declare
dependencies, your process have to implement the DependentChainProcessInterface
interface.
use SRIO\ChainOfResponsibility\ChainContext; use SRIO\ChainOfResponsibility\DependentChainProcessInterface; class FooProcess implements DependentChainProcessInterface { /** * {@inheritdoc} */ public function execute(ChainContext $context) { // Do whatever you want... } /** * {@inheritdoc} */ public function getName() { return 'foo'; } /** * {@inheritdoc} */ public function dependsOn() { return ['bar']; } }
Then, create another BarProcess
which getName
method will return bar
and its dependsOn
will return an empty
array.
Create a ChainBuilder
by creating an instance of it and pass an array of processes that implement at least the
ChainProcessInterface
. As the ChainRunner
, you also can call the add
method to add one or more processes.
$builder = new ChainBuilder([ new FooProcess(), new BarProcess(), ]);
You now can retrieve the chain runner by calling the getRunner
method.
$runner = $builder->getRunner(); $runner->run();
We the given previous example, the bar
process will be executed before the foo
one.
Advanced
Use a custom process decorator
To create the chain, the ChainBuilder
decorate your processes with the ChainProcessDecorator
class. If you want to
use your own decorator to add additional logic such as error recovering or logging, you can easily override the decorator
by providing an object that implements DecoratorFactoryInterface
.
$decoratorFactory = new DecoratorFactory(); $runner = new ChainRunner([], $decoratorFactory);