<?php
class newDI implements IDI{
private $_useLazyLoad = false;
private $_useCompilation = false;
private $_map;
private $_association;
private $_specialAssociation;
private $_serviceArg;
private $_singletons = [];
private $_singletonsInterface = [];
private function isSingleton($service)
{
$ref = new ReflectionClass($service);
$interfaces = $ref->getInterfaces();
foreach($interfaces as $interface){
if(array_search($interface->name, $this->_singletonsInterface) !== false){//?
return true;
}
}
if(array_search($service, $this->_singletonsInterface)){
return true;
}
return false;
}
private function setSingleton($service, $object){
$this->_singletons[$service] = $object;
}
private function getSingleton($service){
if(!empty($this->_singletons[$service])){
return $this->_singletons[$service];
}else{
$object = $this->getService($service);
$this->setSingleton($service, $object);
return $object;
}
}
private function getMap($service)
{
if(isset($this->_map[$service])){
return $this->_map[$service];
}else{
return $this->_map[$service] = $this->createMap($service);
}
}
private function createMap($service)
{
$map = [];
$reflection = new ReflectionClass($service);
if($constructor = $reflection->getConstructor()){
$parameters = $constructor->getParameters();
if($parameters){
$map['arguments'];
foreach($parameters as $parameter){
if($dependencyClass = $parameter->getClass()){
if($dependencyClass->isInterface()){
$type = 'interface';
}elseif($dependencyClass->isAbstract()){
$type = 'abstract';
}else{
$type = 'class';
}
$map['arguments'][]['dependency'][$dependencyClass->name] = $type;
}else{
if($parameter->isDefaultValueAvailable()){
$map['arguments'][]['parameter'][$parameter->name] = ['defaultValue'=>$parameter->getDefaultValue()];
}else{
$map['arguments'][]['parameter'][$parameter->name] = null;
}
}
}
}
}
$map['implements'] = $reflection->getInterfaceNames();
$map['extend'] = $reflection->getParentClass();
if($reflection->isInterface()){
$map['type'] = 'interface';
}elseif($reflection->isAbstract()){
$map['type'] = 'abstract';
}else{
$map['type'] = 'class';
}
$map['isService'] = $reflection->isInstantiable();
return $map;
}
private function createService($service, $arguments=null)
{
if(null === $arguments){
return new $service;
}else{
//switch-case or Reflection
}
}
private function checkRelation($interface, $class)
{
if(isset($this->_map[$interface])){
$mapInterface = $this->_map[$interface];
}else{
$mapInterface = ($this->_map[$interface] = $this->createMap($interface));
}
if(isset($this->_map[$class])){
$mapClass = $this->_map[$class];
}else{
$mapClass = ($this->_map[$class] = $this->createMap($class));
}
if(array_search($interface, $mapClass['implements']) !== false){
return true;
}
if($mapInterface === $mapClass['extend']){
return true;
}
return false;
}
public function get($service, array $arguments=null)
{
if($this->isSingleton($service)){
return $this->getSingleton($service);
}else{
return $this->getService($service, $arguments);
}
}
public function bindSingletonInterface($interface)
{
$this->_singletonsInterface[] = $interface;
}
private function getService($serviceName, $args=null)
{
$map = $this->getMap($serviceName);
if(!empty($map['arguments'])){
$injectProperty = [];
foreach($map['arguments'] as $argument){
if(isset($argument['dependency'])){
$dependencyName = key($argument['dependency']);
$dependencyType = $argument['dependency'][$dependencyName];
if(isset($this->_specialAssociation[$serviceName][$dependencyName])){
$injectProperty[] = $this->get($this->_specialAssociation[$serviceName][$dependencyName]);
}elseif(isset($this->_association[$dependencyName])){
$injectProperty[] = $this->get($this->_association[$dependencyName]);
}elseif($dependencyName === __CLASS__){
$injectProperty[] = $this;
}elseif($dependencyType === 'class'){
$injectProperty[] = $this->get($dependencyName);
}else{
throw new Exception('Нет ассоциации для '.$dependencyType.' '.$dependencyName);
}
}else{
$propertyName = key($argument['parameter']);
if(!empty($args[$propertyName])){
$injectProperty[] = $args[$propertyName];
}elseif(!empty($this->_serviceArg[$serviceName][$propertyName])){
$injectProperty[] = $this->_serviceArg[$serviceName][$propertyName];
}elseif(!empty($argument['parameter'][$propertyName]['defaultValue'])){
$injectProperty[] = $argument['parameter'][$propertyName]['defaultValue'];
}else{
throw new Exception('Нет аргумента '.$propertyName.' для класс сервиса '.$serviceName);
}
}
}
return (new ReflectionClass($serviceName))->newInstanceArgs($injectProperty);
}else{
return new $serviceName;
}
}
private function isService($service){
if(isset($this->_map[$service])){
return $this->_map[$service]['isService'];
}else{
$this->_map[$service] = $this->createMap($service);
return $this->_map[$service]['isService'];
}
}
public function bind($interface, $service, $share = false)
{
if($this->checkRelation($interface, $service)){
if($this->isService($service)){
$this->_association[$interface] = $service;
(!$share)?:$this->_singletonsInterface[] = $service;
}else{
throw new Exception('Сервис не является классом');
}
}
}
public function bindFor($service, $interface, $dependencyService)
{
if($this->checkRelation($interface, $service)){
if($this->isService($service))
$this->_specialAssociation[$service] = [$interface=>$service];
}else{
throw new Exception('Сервис не является классом');
}
}
public function shareInterface($interface)
{
$this->_singletonsInterface[] = $interface;
}
public function setArgumentFor($service, array $arguments)
{
$this->_serviceArg[$service] = $arguments;
}
public function bindArgumentAsDependency($service, $argument, $dependencyService)
{
// TODO: Implement bindArgumentAsDependency() method.
}
public function bindArgumentsAsDependency($service, array $dependency)
{
// TODO: Implement bindArgumentsAsDependency() method.
}
public function useLazyLoad($bool=true)
{
// TODO: Implement useLazyLoad() method.
}
public function useCompilation($bool=true)
{
// TODO: Implement useCompilation() method.
}
}
В противном случае это service locator
