CODEWITHSUNDEEP
phpsymfonyinversion-of-controlioc-container
Run
Run

Reputation: 57176

DI Container - correct way of doing it?

I have a long list of dependency injections to display a page with an article, navigation, etc. And currently I put them in a file called index.php to glue them together.

index.php,

use MyCustomVerndorName\Constant\Mapper\ConstantsMapper;
use MyCustomVerndorName\Slug\Mapper\SlugMapper;
.... (more)

$ConstantService = new ConstantService();
$ConstantController = new ConstantController();

$ArticleService = new ArticleService();
$ArticleController = new ArticleController();

// Prepare Nav model.
$NavModel = new NavModel();
$NavMapper = new NavMapper($PdoAdapter);
$NavService->setMapper($NavMapper)->setModel($NavModel);

// Prepare Article model.
$ArticleModel = new ArticleModel();
$ArticleMapper = new ArticleMapper($PdoAdapter);

// Prepare components.
$ArticleContentComponent = new ArticleContentComponent($PdoAdapter);
... (more)

// Inject components.
$ArticleMapper->addComponent($ArticleContentComponent);
... (more)

$NavChildrenComponent = new NavChildrenComponent($PdoAdapter);
... (more)

// Inject components.
$NavMapper->addComponent($NavChildrenComponent);
$NavMapper->addComponent($NavLanguageComponent);

// Controll the slug.
$SlugController->setService($SlugService)->fetchRow([
    "url"   =>  $url
]);

// Control the nav.
$NavController->setService($NavService)->fetchRows();

// Controll the article.
$ArticleService->setMapper($ArticleMapper)->setModel($ArticleModel);
$ArticleController->setService($ArticleService)->fetchRow([
    "url"   =>  $url
]);

// Prepare template.
$PageTemplate = new PageTemplate();

// Prepare view.
$ArticleView = new ArticleView($PageTemplate, $ArticleModel);
$ArticleView->setSlug($SlugModel);
$ArticleView->setNav($NavModel);

// Render the view.
echo $ArticleView->render('index.php');

in my router.php (I'm using AltoRouter),

use AltoRouter as Router;

$Router = new Router();.
$Router->map('GET', '/', '/article/container');
... (and other routes)

if($match)
{
    $target = $match['target'];
    $url = isset($match['params']['url']) ? $match['params']['url'] : DEFAULT_HOMEPAGE;
    $language = isset($match['params']['language']) ? $match['params']['language'] : null;

    include __DIR__ . $target . '.php';

}

I'm thinking to make the list of dependency injections in index.php into a container class so I can call this class whenever it is needed,

For instace in the router.php, 

$Router->map('GET', '/', 'MyCustomVerndorName\Article\Container\ArticleContainer');
....
new $target($PdoAdapter, $url, $language);

And this container class,

namespace MyCustomVerndorName\Article\Container;

// Mapper.
use MyCustomVerndorName\Constant\Mapper\ConstantsMapper;
...

class ArticleContainer
{

    /*
     * Construct dependency.
     */ 
    public function __construct(\MyCustomVerndorName\Adapter\PdoAdapter $PdoAdapter, $url, $language)
    {
        $ConstantService = new ConstantService();
        $ConstantController = new ConstantController();

        // Slug.
        $SlugService = new SlugService();
        $SlugController = new SlugController();

        // Nav.
        $NavService = new NavService();
        $NavController = new NavController();

        // Article.
        $ArticleService = new ArticleService();
        $ArticleController = new ArticleController();

        // Prepare Article model.
        $ArticleModel = new ArticleModel();
        $ArticleMapper = new ArticleMapper($PdoAdapter);

        // Prepare components.
        $ArticleContentComponent = new ArticleContentComponent($PdoAdapter);
        ...

        // Inject components.
        $ArticleMapper->addComponent($ArticleContentComponent);
        ...

        // Control the nav.
        $NavController->setService($NavService)->fetchRows();

        // Controll the article.
        $ArticleService->setMapper($ArticleMapper)->setModel($ArticleModel);
        $ArticleController->setService($ArticleService)->fetchRow([
            "url"   =>  $url
        ]);


        // Prepare template.
        $PageTemplate = new PageTemplate();

        // Prepare view.
        $ArticleView = new ArticleView($PageTemplate, $ArticleModel);
        $ArticleView->setSlug($SlugModel);
        $ArticleView->setNav($NavModel);

        // Render the view.
        echo $ArticleView->render('index.php');
    }
}

Basically, I put all the dependency list into __construct,

public function __construct(\MyCustomVerndorName\Adapter\PdoAdapter $PdoAdapter, $url, $language)
{
...
}

So, is this the correct way of doing a DI Container without relying on the well known containers out there for PHP (such as Pimple, Symfony\DependencyInjection, etc)?

Upvotes: 0

Views: 133

Answers (1)

Cerad
Cerad

Reputation: 48865

Traditionally, a DI container returns services upon demand. What you are calling ArticleContainer is really just a function then renders a view. It does a lot of DI injecting but it's not a container.

Let's assume you had a real container all properly initialized. Your code would look like:

$container = new Container();

// Some initialization

// Now use it
$viewArticle = $container->get('view_article');
echo $viewArticle->render('index.php');

Hopefully you can see the difference. Once the initialization is complete your application just pulls out the view it needs and renders it. No need to worry about pdo or url etc.

So how do we get our article view service into the container?

$container = new Container();

// Some initialization
$container->set('page_template',function($container)
{
  return new PageTemplate();
}
$container->set('article_view',function($container)
{
  $articleView = new ArticleView(
    $container->get('page_template', 
    $container->get('article_model')
  );
  $articleView->setSlug($container->get('slug_model');
  $articleView->setNav ($container->get('nav_model');

  return $articleView;
};
// Now use it
$viewArticle = $container->get('article_view');
echo $viewArticle->render('index.php');

So we defined two service functions for our container. When we do $container->get('article_view');, the container calls the function with the container itself as an argument. The function creates the desired class by pulling dependencies out of the container and then returns the new object.

One assumes that you will probably have more page views in your application and that most of them will need a page_template. The same page_template service we defined can be used by your other views as well. So we start to get some reuse out of the container.

You basically just continue to add services to the container.

You can use Pimple for this but it's also instructive to make your own container. Really not much to it.

Upvotes: 1

Related Questions