【转】dependency injection 的例子

Dependency Injection in PHP. Create your own DI container.

/ blog / PHP

By my opinion one of the biggest problems in programming are dependencies. If you want to have a good well written application you should avoid dependencies between your modules/classes. There is a design pattern which could help and it's called Dependency Injection (DI). It allows you to inject objects into a class, instead of creating them there.

The files of that article could be found here https://github.com/krasimir/php-dependency-injection.

Actually I'm sure that you already used dependency injection in your code. And I bet that you are doing that pretty often. You just don't know that it is called dependency injection. For example let's take the following example:

class Person {
	private $skills;
	public function __construct() {
		$this->skills = array("PHP", "HTML", "CSS", "JavaScript");
	}
	public function totalSkills() {
		return count($this->skills);
	}
}
$p = new Person();
echo $p->totalSkills();

There are three big problems with the class above.

• When we want to add some new skill we should edit the class, which is not good. Every class should be written as a black box. I.e. you should be able to fully operate with the class only by using its public properties and variables.

• What if we want to set different skills for the different instances of class Person. It is currently not possible, because the private property $skills is created inside the constructor of the class.

• What if we have something more then an array. For example another object and that object has its own needs. Then we should send the needed things to Person class so we can initialize our variable.

The solution of the problem could be something like:

class Person {
	private $skills;
	public function __construct($skills) {
		$this->skills = $skills;
	}
	public function totalSkills() {
		return count($this->skills);
	}
}
$mySkills = array("PHP", "HTML", "CSS", "JavaScript");
$p = new Person($mySkills);
echo $p->totalSkills();

I.e. passing the skills from outside the class. We could say that we injected an object in class Person. The example is really simple, but it perfectly illustrates how helpful could be this approach.

In the example above we used injection to make our class looks better. We solved two problems, but another one comes. Now our class depends on the provided $skills variable. In our case that's just an array, but it could be something very complex or even worst - you could have several very complex objects and some of them could have another dependencies, which also have dependencies and so on. If that's the case then you should pass their dependencies too and your class will become bigger and bigger. You need something that will handle the dependencies for you and that thing is called Dependency Injection container. In the example below I'll show you how you can create and use DI container in PHP.

Let's imagine that we have a MVC written application and we want to show the users in our system.
We have a view which displays information to the visiter:

class View {
    public function show($str) {
        echo "<p>".$str."</p>";
    }
}

A model which delivers the users' information:

class UsersModel {
    public function get() {
        return array(
            (object) array("firstName" => "John", "lastName" => "Doe"),
            (object) array("firstName" => "Mark", "lastName" => "Black")
        );
    }
}

A navigation of the page which uses the view to show main menu links:

class Navigation {
    private $view;
    public function __construct() {
        $this->view = new View();
    }
    public function show() {
        $this->view->show('
            <a href="#" title="Home">Home</a> |
            <a href="#" title="Home">Products</a> |
            <a href="#" title="Home">Contacts</a>
        ');
    }
}

A class which shows the content of the page:

class Content {
    private $title;
    private $view;
    private $usersModel;

    public function __construct($title) {
        $this->title = $title;
        $this->view = new View();
        $this->usersModel = new UsersModel();
    }
    public function show() {
        $users = $this->usersModel->get();
        $this->view->show($this->title);
        foreach($users as $user) {
            $this->view->show($user->firstName." ".$user->lastName);
        }
    }
}

Controller which combines everything:

class PageController {
    public function show() {
        $navigation = new Navigation();
        $content = new Content("Content title!");
        $navigation->show();
        $content->show();
    }
}

At the end - running the controller:

$page = new PageController();
$page->show();

The result:

<p>
<a href="#" title="Home">Home</a> |
<a href="#" title="Home">Products</a> |
<a href="#" title="Home">Contacts</a>
</p>
<p>Content title!</p>
<p>John Doe</p>
<p>Mark Black</p>

Basically nothing wrong with the code. It works, shows the navigation, the title and the users. The problem here is that the classes are configure by themselfs and a lot of dependencies are created. For example if we want to use the Content with another model or another view we should make changes inside the constructor of the class. All the objects are tightly connected to each other and it is difficult to use them out of the current context.

The role of the DI container that we are going to create is to initializes objects instead of you and inject the dependencies which are required by the new object. We will start with the mapping mechanism. I.e. the setting of rules which will define what to be injected and where. Here is how the class looks in its first form:

class DI {
    public static function getInstanceOf($className, $arguments = null);
    public static function mapValue($key, $value);
    public static function mapClass($key, $value, $arguments = null);
    public static function mapClassAsSingleton($key, $value, $arguments = null);
}

• getInstanceOf - creates instance of type $className by passing $argumentsto the class's constructor.
• mapValue - associate $key with $value. The value could be anything - array, string or object. The key is used by the container to find out what exactly to inject.
• mapClass - same as mapValue, but class name should be passed as a value. We can also send $arguments to class's constructor.
• mapClassAsSingleton - same as mapClass, but once the class is created its instance is returned during the next injection.

Here is the mapping code:

class DI {

    private static $map;

    private static function addToMap($key, $obj) {
        if(self::$map === null) {
            self::$map = (object) array();
        }
        self::$map->$key = $obj;
    }
    public static function mapValue($key, $value) {
        self::addToMap($key, (object) array(
            "value" => $value,
            "type" => "value"
        ));
    }
    public static function mapClass($key, $value, $arguments = null) {
        self::addToMap($key, (object) array(
            "value" => $value,
            "type" => "class",
            "arguments" => $arguments
        ));
    }
    public static function mapClassAsSingleton($key, $value, $arguments = null) {
        self::addToMap($key, (object) array(
            "value" => $value,
            "type" => "classSingleton",
            "instance" => null,
            "arguments" => $arguments
        ));
    }

}

So far so good. Now we have to find some way to write instructions to the container. These instructions should be placed inside the classes which will be used during the injection. The other programming languages offer various ways to handle this. For example in ActionScript we could use meta tags, but in PHP we don't have any simple and elegant solution. There are several implementations of Dependency Injection in PHP. Some of them are reading your php file as a plain text and parsing its content. I decided to use ReflectionClass and to put everything in the class's docs. For example:

/**
* @Inject view
*/
class Navigation {
    public function show() {
        $this->view->show(...);
    }
}

When you want to have an object of type Navigation you should call the getInstanceOf method of the container. The line @Inject view means that you will have a public property injected called view. The value of view depends of your mapping rules. In the example below $view is an instance of View class.
The code of getInstanceOf:

public static function getInstanceOf($className, $arguments = null) {

    // checking if the class exists
    if(!class_exists($className)) {
        throw new Exception("DI: missing class '".$className."'.");
    }

    // initialized the ReflectionClass
    $reflection = new ReflectionClass($className);

    // creating an instance of the class
    if($arguments === null || count($arguments) == 0) {
       $obj = new $className;
    } else {
        if(!is_array($arguments)) {
            $arguments = array($arguments);
        }
       $obj = $reflection->newInstanceArgs($arguments);
    }

    // injecting
    if($doc = $reflection->getDocComment()) {
        $lines = explode("\n", $doc);
        foreach($lines as $line) {
            if(count($parts = explode("@Inject", $line)) > 1) {
                $parts = explode(" ", $parts[1]);
                if(count($parts) > 1) {
                    $key = $parts[1];
                    $key = str_replace("\n", "", $key);
                    $key = str_replace("\r", "", $key);
                    if(isset(self::$map->$key)) {
                        switch(self::$map->$key->type) {
                            case "value":
                                $obj->$key = self::$map->$key->value;
                            break;
                            case "class":
                                $obj->$key = self::getInstanceOf(self::$map->$key->value, self::$map->$key->arguments);
                            break;
                            case "classSingleton":
                                if(self::$map->$key->instance === null) {
                                    $obj->$key = self::$map->$key->instance = self::getInstanceOf(self::$map->$key->value, self::$map->$key->arguments);
                                } else {
                                    $obj->$key = self::$map->$key->instance;
                                }
                            break;
                        }
                    }
                }
            }
        }
    }

    // return the created instance
    return $obj;

}

The interesting part is the usage of the ReflectionClass on line 18 (creating the new instance) and line 22 (getting the docs of the class). The rest of the code is just parsing the documentation text line by line and injecting the objects as a public properties.

Now, when everything is done we can transform our little project in something more modular.
Here are the mapping rules that we have to set:

DI::mapClass("navigation", "Navigation");
DI::mapClass("content", "Content", array("Content title!"));
DI::mapClass("view", "View");
DI::mapClassAsSingleton("usersModel", "UsersModel");

The view and the model remain the same.

class View {
    public function show($str) {
        echo "<p>".$str."</p>";
    }
}
class UsersModel {
    public function get() {
        return array(
            (object) array("firstName" => "John", "lastName" => "Doe"),
            (object) array("firstName" => "Mark", "lastName" => "Black")
        );
    }
}

We can inject the view inside the Navigation instead of creating it there:

/**
* @Inject view
*/
class Navigation {
    public function show() {
        $this->view->show('
            <a href="#" title="Home">Home</a> |
            <a href="#" title="Home">Products</a> |
            <a href="#" title="Home">Contacts</a>
        ');
    }
}

The situation with the Content class is the same. Injecting the view and the model:

/**
* @Inject usersModel
* @Inject view
*/
class Content {
    private $title;
    public function __construct($title) {
        $this->title = $title;
    }
    public function show() {
        $this->users = $this->usersModel->get();
        $this->view->show($this->title);
        foreach($this->users as $user) {
            $this->view->show($user->firstName." ".$user->lastName);
        }
    }
}

Injecting the navigation and the content into the controller:

/**
* @Inject navigation
* @Inject content
*/
class PageController {
    public function show() {
        $this->navigation->show();
        $this->content->show();
    }
}

And at the end initializing and running the controller:

$page = DI::getInstanceOf("PageController");
$page->show();

The benefits of that transformations are a lot. For example if some of our classe uses the model and if we are wondering where exactly is the problem - into the model's data or into the class, we can easily test by placing a dummy model which always return corret data. We don't have to deal with very complex classes tree and searching where is every object coming from.

Of course this implementation of dependency injection container is not perfect at all. Could be improved a lot, but it is good as a start. Let me know if you have any suggestions.

The files of that article could be found here https://github.com/krasimir/php-dependency-injection.