Dependency Injection

How to do it right

@MrDanack

What is dependency injection?

• Fancy way of saying passing parameters
• Easier to test
• Easier to write & refactor code
• Easier to add new services
• More reasonable code

Service locator

function foo($sl) {
    $storage = $sl->get('fileUploader');
    …
    …
    …
    if ($criticalError) {
        $notification = $sl->get('ErrorNotifier');
    }
}

Also a Service locator

class FooController extends ContainerAware {
    function foo() {
         $db = $this->get('storage');
    }
}

So....how to do DI right?

Depdendency Injection is literally just passing in parameters

    
function backupFile(S3Storage $s3Storage, EntityManager $em)
{
    // ...
}
    
backupFile($s3Storage, $entityManager);
    

Code shouldn't be aware of injector

Typehints

function backupFile(S3Storage $s3Storage, EntityManager $em)
{
    // ...
}

Interfaces are best, so ignore that PSR-2 bye-law

Actually, can we just start calling them types now?

Constructor injection

$fooController = new FooController();
    
// Any code that touches $fooController between constructor
// and setter will behave...poorly

$foo->setDBConnection($dbConnection);

Use types for all dependencies

    $logger = $di->make('log_service');

    $logger = $di->make(Psr\Log\LoggerInterface::class);

No really - use types for all dependencies

class S3Config
{
    public $key;
    public $secret;
    public $region;
    ...
}

class TmpPath
{
    public $value;
    function __construct($value) {
        $this->value = $value
    }
}

Use a Dependency Injection Container

https://github.com/rdlowrey/auryn

Using a 'Dependency Injection Container' makes life easy

function backupFile(S3Storage $s3Storage, EntityManager $em)
{
    // ...
}

$injector->execute('backupFile');    

Injector - makes life easy

class BackupController {
    function backupFile(...) {
    }
}

$instance = $injector->make('BackupController');
$instance->backupFile();

$injector->execute(['BackupController', 'backupFile']);

Injector - makes life easy

$route = $router->matchRequest();

$callable = $route->getCallable();

$injector->execute($callable);

Configuring the injector

$injector->alias('FileUploader', 'S3FileUploader');

$injector->share('S3FileUploader');

$injector->define(
    'S3Config', 
    array(
        ':aws_key'    => 'abcde12345',
        ':aws_secret' => 'fghij67890'
        ':region'     => 'EU_WEST'
    )
);

Configuring the injector

function createS3Config() {
    $key    = getenv('aws.s3.key');
    $secret = getenv('aws.s3.secret');
    $region = getenv('aws.s3.region');

    return new S3Config($key, $secret, $region)
}

$injector->delegate('S3Config', 'createS3Config');

function backupFile(S3Storage $s3Storage,
    Request $request, \Doctrine\ORM\EntityManager $entityManager)
{
    $backupRepository = $entityManager->getRepository('Backup');
    $sourceFile = $backupRepository->getNextFilename();
    $backupFilename = $sourceFile.'_'.date("Y_m_d_H_i_s");

    try {
        $s3Storage->putFile($sourceFile, $backupFilename);
    }
    catch(S3Exception $s3Exception) {
        return new ServerErrorResponse("Somethings borked");
    }
    $responseData = ['backupFilename' => $backupFilename];
    $acceptHeader = $request->getHeader('Accept');
    if (strcmp($acceptHeader, "text/xml") === 0) {
        return new XMLResponse($responseData);
    }

    return new JsonResponse($responseData);
}

Wrong dependency

function backupFile(\Doctrine\ORM\EntityManager $em)
{
    ...
    $backupRepository = $entityManager->getRepository('Backup');
    ...
}

function backupFile(BackupRepository $backupRepository)
{
    ...
}

Delegation removes coupling

function getBackupRepository(EntityManager $em)
{
    return $em->getRepository('Backup');
}

$injector->delegate(BackupRepository::class, 'getBackupRepository');

new is a smell...

function backupFile(..., Request $request, ...)
{
    ...
    $acceptHeader = $request->getHeader('Accept');

    if (strcmp($acceptHeader, "text/xml") === 0) {
        return new XMLResponse($responseData);
    }
    return new JsonResponse($responseData);
}

Factories are objects!!1!

• They encapsulate information. In this case neither neither JsonResponse nor XMLResponse need to know about 'Request'.
• Named constructors are fine - http://verraes.net/2014/06/named-constructors-in-php/

class RequestResponseFactory implements ResponseFactory
{
    private $request;

    function __construct(Request $request) {
        $this->request = $request;
    }
    
    function create(array $responseData) {
        $acceptHeader = $this->request->getHeader('Accept');
        if (strpos($acceptHeader, "text/xml") === 0) {
            return new XMLResponse($responseData);
        }

        return new JsonResponse($responseData);	
    }
}

$injector->alias('ResponseFactory', 'RequestResponseFactory');

Depending on an implementation...

function backupFile(S3Client $s3Client, ...)
{
    ...
    try {
        $s3Client->putFile($sourceFile, $backupFilename);
    }
    catch(S3Exception $s3Exception) {
        return new ServerErrorResponse("Somethings borked");
    }
    ...
}

This is the D in SOLID. "Dependency inversion principle" == "Depend upon Abstractions. Do not depend upon concretions.”

Interface has less coupling

class S3FileUploader implements FileUploader
{
    function __construct(S3Client $s3Client) {
        $this->s3Client = $s3Client;
    }

    function putFile($sourceFilename, $backupFilename) {
        try {
            $this->s3Client->putFile($sourceFilename, $backupFilename));
        }
        catch(\Exception $exception) {
           throw new FileUploaderException(
               "FileUploader exception: ".$exception->getMessage(),
               $exception->getCode(),
               $exception
           );
        }
    }
}

After refactoring

function backupFile(FileUploader $fileUploader,
    ResponseFactory $responseFactory, 
    BackupRepository $backupRepository)
{
    $sourceFile = $backupRepository->getNextFilename();
    $backupFilename = $sourceFile.'_'.date("Y_m_d_H_i_s");

    try {
        $fileUploader>putFile($sourceFile, $backupFilename);
    }
    catch(FileResponseException $exception) {
        return new ServerErrorResponse("Somethings borked");
    }

    return $responseFactory->create(['backupFilename' => $backupFilename]);
}

DI not appropriate ... for trivial apps

DI not appropriate ... where the dependencies can't be resolved cleanly

function archiveOldData(DBConnection $liveDB, DBConnection $archiveDB) {
   ...
}

    

This is a form of flow-based programming......probably.
http://www.jpaulmorrison.com/fbp/

Demo time

No time....example app is at www.github.com/danack/Tier

Fin

• Pass parameters in
• Depend on the correct things
• Use an injector https://github.com/rdlowrey/auryn
• J.B. Rainsberger - Integrated Tests Are A Scam http://vimeo.com/80533536
• Questions?

Encapsulated Context Pattern

"The ability to bind the lifecycle and interactions of stateful components to well-defined but extensible lifecycle contexts."

class MarketContext {
    public $tradeExecutor;
    public $logManager;
    public $priceValidator;

}

Stops lower tier code from being able to look up services, making it easier to reason about what is injected. Probably useful for views.

Why not other DICs?

$container['session_storage'] = function ($c) {
    return new SessionStorage('SESSION_ID');
};

$container['session'] = function ($c) {
    return new Session($c['session_storage']);
};

Current static methods:

interface Info {
    static function getInfo();
}

class Foo implements Info {
    static function getInfo() {
    }
}

“For years there has been a theory that millions of monkeys typing at random on millions of typewriters would reproduce the entire works of Shakespeare. The Internet has proven this theory to be untrue.”