Разработка архитектуры приложения с использованием инверсии зависимости

В этой статье я хочу ещё раз поговорить о разработке архитектуры приложения с использованием инверсии зависимости (Inversion of Control).
Я уже писал на хабре о библиотеке IoC и о Modular. Теперь я пошел ещё дальше и упростил все что только можно и попробую объяснить принципы построения архитектуры. А так же расскажу о новой библиотеке Granula.

Давайте представим, что мы хотим сделать библиотеку для управления пользователями на сайте. Первое что нам понадобится, это место где мы будем хранить информацию о
наших пользователях.
Опишем интерфейс хранилища:

interface StorageInterface
{
    public function set($key, $value);
    public function get($key);
    public function save();
    public function load();
}

Отлично, теперь нам нужна реализация этого интерфейса. Для начала будем хранить информацию в файлах. Создадим класс FileStorage.

FileStorage.php

class FileStorage implements StorageInterface
{
	private $file = 'data.json';
	private $data = array();	

    public function set($key, $value)
    {
    	$this->data[$key] = $value;
    }

    public function get($key) 
    {
    	return $this->data[$key];
    }

    public function save()
    {
 	file_put_contents($this->file, json_encode($this->data));
    }

    public function load()
    {
    	$this->data = json_decode(file_get_contents($this->file));
    }
}

Теперь создадим класс пользователя

class User
{
    public function __construct(StorageInterface $storage)
    {
    }
}

Теперь чтобы создать экземпляр класса User:

$user = new User(new FileStorage());

Отлично, а что если какой-нибудь другой программист захочет вместо файлов использовать базу данных? Для этого ему нужно создать класс DatabaseStorage, реализовать интерфейс StorageInterface и заменить все вхождения FileStorage. Но изменение библиотеки сулит проблемы с её обновлениями.
Что бы этого избежать, давайте, введём опции:

$options = array(
    'StorageInterface' => 'FileStorage',
);

$user = new User($option['StorageInterface']);

Теперь что бы заменить FileStorage на DatabaseStorage, нужно всего лишь указать это в опциях:

$options['StorageInterface'] = 'DatabaseStorage';

То, что мы сейчас назвали опциями, на самом деле является контейнером IoC.

Именно такая архитектура позволяет строить наиболее гибкие приложения и библиотеки.
В своей предыдущей статье я рассказывал о библиотеке Modular, я продолжил развивать её, постарался упростить все для наилучшего понимания. Её основной задачей является обучение применения IoC на практике, создания модульной архитектуры приложения.

Теперь она называется Granula.

Любая библиотека может быть модулем для гранулы. Например из компонентов Symfony Components можно создать MVC приложение на подобии самой Symfony.

Каждый модуль гранулы должен быть описан своим классом:

use Granula\Module;
use Inversion\Container;
 
class MyModule extends Module
{
    public function build(Container $container)
    {
        // Опишите свой модуль здесь.
    }
}

Например, описание библиотеки, которую мы создавали в начале статьи будет таким:

$container['StorageInterface'] = 'FileStorage';

Можно даже сократить ещё больше:

$container[] = 'FileStorage';

Но в таком случае не будет работать ленивая загрузка классов, так как FileStorage будет загружен Inversion(библиотекой IoC контейнеров) сразу для определения его интерфейсов.

Пример описания модуля для Symfony Routing Component

        $container['request']
            = $container['Symfony\Component\HttpFoundation\Request']
            = new Factory('Symfony\Component\HttpFoundation\Request', 'createFromGlobals');

        $container['Symfony\Component\Config\FileLocator']
            = 'Symfony\Component\Config\FileLocator';

        $container['Doctrine\Common\Annotations\Reader']
            = 'Doctrine\Common\Annotations\AnnotationReader';

        $container['Symfony\Component\Routing\Loader\AnnotationClassLoader']
            = 'Granula\Router\AnnotatedRouteControllerLoader';

        $container['Symfony\Component\Config\Loader\LoaderInterface']
            = 'Symfony\Component\Routing\Loader\AnnotationDirectoryLoader';

        $container['request.context']
            = $container['Symfony\Component\Routing\RequestContext']
            = new Service('Symfony\Component\Routing\RequestContext');

        $container['router']
            = $container['Symfony\Component\Routing\RouterInterface']
            = new Factory('Granula\Router\RouterFactory');

Теперь можно создавать экземпляры как в Symfony при помощи контейнера:

$object = $container->get('Class');

Либо при момощи фабрики (при использовании trait):

$user = User::create();

Затем все необходимые модули указываются в Front Controller:

class App extends Granula\App
{
    public function register()
    {
        return array(
            new MyModule(),
            // Список модулей
        );
    }
}

И в файле index.php запускаются:

$app = new App();
$app->run();

Я оформил все необходимые модули для создания полноценного MVC приложения. Что бы поиграться с ним используйте Composer для установки:

composer create-project granula/app www

В него включены:

• Symfony Components
• Twig
• Doctrine ORM

Полезные ссылки

• Управление зависимостями в PHP-коде
• Granula on GitHub
• Inversion — библиотека IoC может быть использована отдельно от гранулы.

Contributors are Welcome!