随笔- 1793 文章- 1 评论- 61 阅读- 298万

php中var_dump() 打印出一个对象的时候，信息怎么看？

php 的一个依赖注入容器，说白了，就是用php 的反射类，来在运行的时候动态的分析类具有的函数，以及动态分析函数的参数，从而实例化类，并执行类的方法。

另外，php 中的 typehint 还是很有用的，反射的时候就有用到！

下面贴出代码：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

<?php
class Bim
{
    public function doSomething()
    {
        echo __METHOD__, '|';
    }
}
 
class Bar
{
    private $bim;
 
    public function __construct(Bim $bim)
    {
        $this->bim = $bim;
    }
 
    public function doSomething()
    {
        $this->bim->doSomething();
        echo __METHOD__, '|';
    }
}
 
class Foo
{
    private $bar;
 
    public function __construct(Bar $bar)
    {
        $this->bar = $bar;
    }
 
    public function doSomething()
    {
        $this->bar->doSomething();
        echo __METHOD__;
    }
}
 
class Container
{
    private $s = array();
 
    public function __set($k, $c)
    {
        $this->s[$k] = $c;
    }
 
    public function __get($k)
    {
        // return $this->s[$k]($this);
        return $this->build($this->s[$k]);
    }
 
    /**
     * 自动绑定（Autowiring）自动解析（Automatic Resolution）
     *
     * @param string $className
     * @return object
     * @throws Exception
     */
    public function build($className)
    {
        echo "<pre>";var_dump($className);
        // 如果是匿名函数（Anonymous functions），也叫闭包函数（closures）
        if ($className instanceof Closure) {
            // 执行闭包函数，并将结果
            return $className($this);
        }
 
        /** @var ReflectionClass $reflector */
        $reflector = new ReflectionClass($className);
 
        // 检查类是否可实例化, 排除抽象类abstract和对象接口interface
        if (!$reflector->isInstantiable()) {
            throw new Exception("Can't instantiate this.");
        }
 
        /** @var ReflectionMethod $constructor 获取类的构造函数 */
        $constructor = $reflector->getConstructor();
 
        // 若无构造函数，直接实例化并返回
        if (is_null($constructor)) {
            return new $className;
        }
 
        // 取构造函数参数,通过 ReflectionParameter 数组返回参数列表
        $parameters = $constructor->getParameters();
 
        // 递归解析构造函数的参数
        $dependencies = $this->getDependencies($parameters);
 
 
        // 创建一个类的新实例，给出的参数将传递到类的构造函数。
        return $reflector->newInstanceArgs($dependencies);
    }
 
    /**
     * @param array $parameters
     * @return array
     * @throws Exception
     */
    public function getDependencies($parameters)
    {
        $dependencies = [];
 
        /** @var ReflectionParameter $parameter */
        foreach ($parameters as $parameter) {
            /** @var ReflectionClass $dependency */
            $dependency = $parameter->getClass();
            if (is_null($dependency)) {
                // 是变量,有默认值则设置默认值
                $dependencies[] = $this->resolveNonClass($parameter);
            } else {
                // 是一个类，递归解析
                $dependencies[] = $this->build($dependency->name);
            }
        }
 
        return $dependencies;
    }
 
    /**
     * @param ReflectionParameter $parameter
     * @return mixed
     * @throws Exception
     */
    public function resolveNonClass($parameter)
    {
        // 有默认值则返回默认值
        if ($parameter->isDefaultValueAvailable()) {
            return $parameter->getDefaultValue();
        }
 
        throw new Exception('I have no idea what to do here.');
    }
}
 
// ----
//$c = new Container();
//$c->bar = 'Bar';
//$c->foo = function ($c) {
//    return new Foo($c->bar);
//};
//// 从容器中取得Foo
//$foo = $c->foo;
//$foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething
 
///*// ----
$di = new Container();
//
$di->foo = 'Foo';
//
///** @var Foo $foo */
$foo = $di->foo;
//
var_dump($foo);exit;
echo "<pre>";var_dump($foo->doSomething());
 
var_dump( get_class($foo));
die();
///*
//Foo#10 (1) {
//  private $bar =>
//  class Bar#14 (1) {
//    private $bim =>
//    class Bim#16 (0) {
//    }
//  }
//}
//*/
//
$foo->doSomething(); // Bim::doSomething|Bar::doSomething|Foo::doSomething*/