ioc 代码

<?php 
class c
{
    public function say()
    {
        echo 'hello';
    }
}

/**
 * Class a
 */
class a
{
    private $c;
    public function setC(C $c)
    {
        $this->c = $c; // 实例化创建C类
    }

    public function sayC()
    {
        echo $this->c->say(); // 调用C类中的方法
    }
}

$c = new C();
$a = new a();
$a->setC($c);
$a->sayC();
?> 
 

 

 

<?php


error_reporting(0);


class Container {


    protected $bindings = [];


    public function __construct() {
        echo '<pre>';
    }


    public function bind($abstract, $concrete = null, $shared = false) {


        echo $abstract.$concrete.'<br>';
        if (!$concrete instanceof Closure) {


            $concrete = $this->getClosure($abstract, $concrete);
        }
        $this->bindings[$abstract] = compact('concrete', 'shared');
    }


    protected function getClosure($abstract, $concrete) {
        return function ($c) use ($abstract, $concrete) {
         //   print_r($c);
            $method = ($abstract === $concrete) ? 'build' : 'make';
              echo 'getclosure'. $abstract.$concrete.$method.'<br>';
            return $c->$method($concrete);
        };
    }


    public function make($abstract) {
        $concrete = $this->getConcrete($abstract);
        if ($this->isBuildable($concrete, $abstract)) {
            $object = $this->build($concrete);
        } else {
            $object = $this->make($concrete);
        }
        return $object;
    }


    protected function isBuildable($concrete, $abstract) {
        return $concrete === $abstract || $concrete instanceof Closure;
    }


    protected function getConcrete($abstract) {
        if (!isset($this->bindings[$abstract])) {
            return $abstract;
        }
        return $this->bindings[$abstract]['concrete'];
    }


    public function build($concrete) {
        if ($concrete instanceof Closure) {
            return $concrete($this);
        }


        $reflector = new ReflectionClass($concrete);
        if (!$reflector->isInstantiable()) {
            echo $message = "Target [$concrete] is not instantiable";
        }


        $constructor = $reflector->getConstructor();
        if (is_null($constructor)) {
            return new $concrete;
        }


        $dependencies = $constructor->getParameters();
        $instances = $this->getDependencies($dependencies);
        return $reflector->newInstanceArgs($instances);
    }


    protected function getDependencies($parameters) {


        $dependencies = [];
        foreach ($parameters as $parameter) {
            $dependency = $parameter->getClass();
            if (is_null($dependency)) {
                $dependencies[] = null;
            } else {
                $dependencies[] = $this->resolveClass($parameter);
            }
        }


        return (array) $dependencies;
    }


    protected function resolveClass(ReflectionParameter $parameter) {
        return $this->make($parameter->getClass()->name);
    }


}


class Traveller {


    protected $trafficTool;


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


    public function visitTibet() {
        $this->trafficTool->go();
    }


}


interface Visit {


    public function go();
}


class Train implements Visit {


    public function go() {
        echo 'drive car to tibet!!!'
        ;
    }


}


$app = new Container;
$app->bind("Visit", 'train');
$app->bind('traveller', 'Traveller');




$tra = $app->make('traveller');
$tra->visitTibet();