Dependency Injection Container PHP

Question

I've recently learned about the advantages of using Dependency Injection (DI) in my PHP application.

However, I'm still unsure how to create my container for the dependencies. Before, I use a container from a framework and I want to understand how is he doing things in back and reproduce it.

For example:

The container from Zend 2. I understand that the container make class dynamic, he does not have to know about them from the beginning, he checks if he already has that class in his registry and if he has not he check if that class exist and what parameters has inside constructor and put it in his own registry so next time could take it from there, practical is doing everything dynamic and it is completing his own registry, so we do not have to take care of nothing once we implement the container as he can give as any class we want even if we just make that class.

Also if I want to getInstance for A which needs B and B needs C I understand that he doing this recursive and he goes and instantiate C then B and finally A.

So I understand the big picture and what is he suppose to do but I am not so sure about how to implement it.

Answer 1

You may be better off using one of the existing Dependency Containers out there, such as PHP-DI or Pimple. However, if you are looking for a simpler solution, then I've implemented a Dependency Container as part of an article that I wrote here: http://software-architecture-php.blogspot.com/

Here is the code for the container

    class Container implements \DecoupledApp\Interfaces\Container\ContainerInterface 
{
    /**
     * This function resolves the constructor arguments and creates an object
     * @param string $dataType
     * @return mixed An object
     */
    private function createObject($dataType)
    {
        if(!class_exists($dataType)) {
            throw new \Exception("$dataType class does not exist");
        }
        $reflectionClass = new \ReflectionClass($dataType);
        $constructor = $reflectionClass->getConstructor();
        $args = null;
        $obj = null;
        if($constructor !== null)
        {
            $block = new \phpDocumentor\Reflection\DocBlock($constructor);

            $tags = $block->getTagsByName("param");
            if(count($tags) > 0)
            {
                $args = array();
            }
            foreach($tags as $tag)
            {
                //resolve constructor parameters
                $args[] = $this->resolve($tag->getType());
            }
        }
        if($args !== null)
        {
            $obj = $reflectionClass->newInstanceArgs($args);
        }
        else
        {
            $obj = $reflectionClass->newInstanceArgs();
        }

        return $obj;
    }

    /**
     * Resolves the properities that have a type that is registered with the Container. 
     * @param mixed $obj
     */
    private function resolveProperties(&$obj)
    {
        $reflectionClass = new \ReflectionClass(get_class($obj));
        $props = $reflectionClass->getProperties();
        foreach($props as $prop)
        {
            $block = new \phpDocumentor\Reflection\DocBlock($prop);

            //This assumes that there is only one "var" tag.
            //If there are more than one, then only the first one will be considered.
            $tags = $block->getTagsByName("var");
            if(isset($tags[0]))
            {
                $value = $this->resolve($tags[0]->getType());

                if($value !== null)
                {
                    if($prop->isPublic()) {
                        $prop->setValue($obj, $value);
                    } else {
                        $setter = "set".ucfirst($prop->name);
                        if($reflectionClass->hasMethod($setter)) {
                            $rmeth = $reflectionClass->getMethod($setter);
                            if($rmeth->isPublic()){
                                $rmeth->invoke($obj, $value);
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 
     * @param string $dataType
     * @return object|NULL If the $dataType is registered, the this function creates the corresponding object and returns it;
     * otherwise, this function returns null
     */
    public function resolve($dataType) 
    {
        $dataType = trim($dataType, "\\");
        $obj = null;
        if(isset($this->singletonRegistry[$dataType])) 
        {
            //TODO: check if the class exists
            $className = $this->singletonRegistry[$dataType];
            $obj = $className::getInstance();
        } 
        else if(isset($this->closureRegistry[$dataType]))
        {
            $obj = $this->closureRegistry[$dataType]();
        }
        else if(isset($this->typeRegistry[$dataType])) 
        {
            $obj = $this->createObject($this->typeRegistry[$dataType]);
        }

        if($obj !== null) 
        {
            //Now we need to resolve the object properties
            $this->resolveProperties($obj);
        }
        return $obj;
    }

    /**
     * @see \DecoupledApp\Interfaces\Container\ContainerInterface::make()
     */
    public function make($dataType)
    {
        $obj = $this->createObject($dataType);
        $this->resolveProperties($obj);
        return $obj;
    }

    /**
     *
     * @param Array $singletonRegistry
     * @param Array $typeRegistry
     * @param Array $closureRegistry
     */
    public function __construct($singletonRegistry, $typeRegistry, $closureRegistry) 
    {
        $this->singletonRegistry = $singletonRegistry;
        $this->typeRegistry = $typeRegistry;
        $this->closureRegistry = $closureRegistry;
    }

    /**
     * An array that stores the mappings of an interface to a concrete singleton class. 
     * The key/value pair corresond to the interface name/class name pair.
     * The interface and class names are all fully qualified (i.e., include the namespaces).
     * @var Array
     */
    private $singletonRegistry;

    /**
     * An array that stores the mappings of an interface to a concrete class. 
     * The key/value pair corresond to the interface name/class name pair.
     * The interface and class names are all fully qualified (i.e., include the namespaces).
     * @var Array
     */
    private $typeRegistry;

    /**
     * An array that stores the mappings of an interface to a closure that is used to create and return the concrete object.
     * The key/value pair corresond to the interface name/class name pair.
     * The interface and class names are all fully qualified (i.e., include the namespaces).
     * @var Array
     */
    private $closureRegistry;

}

The above code can be found here: https://github.com/abdulla16/decoupled-app (under the /Container folder)

You can register your dependencies as a singleton, as a type (every time a new object will be instantiated), or as a closure (the container will call the function that you register and that function is expected to return the instance).

For example,

$singletonRegistry = array();
$singletonRegistry["DecoupledApp\\Interfaces\\UnitOfWork\\UnitOfWorkInterface"] =
    "\\DecoupledApp\\UnitOfWork\\UnitOfWork";


$typeRegistry = array();
$typeRegistry["DecoupledApp\\Interfaces\\DataModel\\Entities\\UserInterface"] = 
    "\\DecoupledApp\\DataModel\\Entities\\User";

$closureRegistry = array();
$closureRegistry["DecoupledApp\\Interfaces\\DataModel\\Repositories\\UserRepositoryInterface"] = 
    function() {
        global $entityManager;
        return $entityManager->getRepository("\\DecoupledApp\\DataModel\\Entities\\User");
    };

$container = new \DecoupledApp\Container\Container($singletonRegistry, $typeRegistry, $closureRegistry);

This Container resolves properties of a class as well as the constructor parameters.

Answer 2

I have done a very simple IoC class which works as intended. I've investigated the IoC and DI pattern and especially after reading this answer. Let me know if something is not right or you have any questions .

<?php

class Dependency {
 protected $object = null;
 protected $blueprint = null;

 /**
  * @param $instance callable The callable passed to the IoC object.
  */
 public function __construct($instance) {
   if (!is_object($instance)) {
     throw new InvalidArgumentException("Received argument should be object.");
   }

   $this->blueprint = $instance;
 }

 /**
  * (Magic function)
  *
  * This function serves as man-in-the-middle for method calls,
  * the if statement there serves for lazy loading the objects
  * (They get created whenever you call the first method and
  * all later calls use the same instance).
  *
  * This could allow laziest possible object definitions, like
  * adding annotation parsing functionality which can extract everything during
  * the call to the method. once the object is created it can get the annotations
  * for the method, automatically resolve its dependencies and satisfy them,
  * if possible or throw an error.
  *
  * all arguments passed to the method get passed to the method
  * of the actual code dependency.
  *
  * @param $name string The method name to invoke
  * @param $args array The array of arguments which will be passed
  *               to the call of the method
  *
  * @return mixed the result of the called method.
  */
 public function __call($name, $args = array())
 {
   if (is_null($this->object)) {
     $this->object = call_user_func($this->blueprint);
   }

   return call_user_func_array(array($this->object, $name), $args);
 }
}

/*
 * If the object implements \ArrayAccess you could
 * have easier access to the dependencies.
 *
 */
class IoC {
  protected $immutable = array(); // Holds aliases for write-protected definitions
  protected $container = array(); // Holds all the definitions

  /**
   * @param $alias string Alias to access the definition
   * @param $callback callable The calback which constructs the dependency
   * @param $immutable boolean Can the definition be overriden?
   */
  public function register ($alias, $callback, $immutable = false) {
    if (in_array($alias, $this->immutable)) {
      return false;
    }

    if ($immutable) {
      $this->immutable[] = $alias;
    }

    $this->container[$alias] = new Dependency($callback);
    return $this;
  }

  public function get ($alias) {
    if (!array_key_exists($alias, $this->container)) {
      return null;
    }

    return $this->container[$alias];
  }
}

class FooBar {
  public function say()
  {
    return 'I say: ';
  }

  public function hello()
  {
    return 'Hello';
  }

  public function world()
  {
    return ', World!';
  }
}

class Baz {
  protected $argument;

  public function __construct($argument)
  {
    $this->argument = $argument;
  }

  public function working()
  {
    return $this->argument->say() . 'Yep!';
  }
}

/**
 * Define dependencies
 */

$dic = new IoC;
$dic->register('greeter', function () {
  return new FooBar();
});

$dic->register('status', function () use ($dic) {
  return new Baz($dic->get('greeter'));
});

/**
 * Real Usage
 */
$greeter = $dic->get('greeter');

print $greeter->say() . ' ' . $greeter->hello() . ' ' . $greeter->world() . PHP_EOL . '<br />';

$status = $dic->get('status');
print $status->working();
?>

I think the code is pretty self-explanatory, but let me know if something is not clear

Answer 3

Because I haven't find anything near what I wanted,I tried to implement on my own a container and I want to hear some opinion about how is looking,because I've start to learn php and oop a month ago a feedback is very important for me because I know I have many things to learn,so please feel free to bully my code :))

<!DOCTYPE html>
<!--
To change this license header, choose License Headers in Project Properties.
To change this template file, choose Tools | Templates
and open the template in the editor.
-->
<?php

class ioc
{
    private $defs;
    static $instance;
    private $reflection;
    private function __construct()
    {
        $defs       = array();
        $reflection = array();
    }
    private function __clone()
    {
        ;
    }
    public static function getInstance()
    {
        if (!self::$instance) {
            self::$instance = new ioc();
        }
        return self::$instance;
    }
    public function getInstanceOf($class)
    {
        if (is_array($this->defs) && key_exists($class, $this->defs)) {
            if (is_object($this->defs[$class])) {
                return $this->defs[$class];
            }
        } else {
            if (class_exists($class)) {
                if (is_array($this->reflection) && key_exists($class, $this->reflection)) {
                    $reflection = $this->reflection[$class];
                } else {
                    $reflection               = new ReflectionClass($class);
                    $this->reflection[$class] = $reflection;

                }
                $constructor = $reflection->getConstructor();
                if ($constructor) {
                    $params = $constructor->getParameters();
                    if ($params) {
                        foreach ($params as $param) {
                            $obj[] = $this->getInstanceOf($param->getName());

                        }
                        $class_instance = $reflection->newInstanceArgs($obj);
                        $this->register($class, $class_instance);
                        return $class_instance;
                    }
                }
                if (!$constructor || !$params) {
                    $class_instance = new $class;
                    $this->register($class, $class_instance);
                    return $class_instance;
                }

            }
        }
    }
    public function register($key, $class)
    {
        $this->defs[$key] = $class;
    }

}
?>