php 如何理解依赖注入,谈谈怎样理解php依赖注入和控制反转

要想理解php依赖注入和控制反转两个概念，就必须搞清楚如下的问题：

DI——Dependency Injection   依赖注入

IoC——Inversion of Control  控制反转

1、参与者都有谁？

答：一般有三方参与者，一个是某个对象；一个是IoC/DI的容器；另一个是某个对象的外部资源。又要名词解释一下，某个对象指的就是任意的、普通的Java对象; IoC/DI的容器简单点说就是指用来实现IoC/DI功能的一个框架程序；对象的外部资源指的就是对象需要的，但是是从对象外部获取的，都统称资源，比如：对象需要的其它对象、或者是对象需要的文件资源等等。

2、依赖：谁依赖于谁？为什么会有依赖？

答：某个对象依赖于IoC/DI的容器。依赖是不可避免的，在一个项目中，各个类之间有各种各样的关系，不可能全部完全独立，这就形成了依赖。传统的开发是使用其他类时直接调用，这会形成强耦合，这是要避免的。依赖注入借用容器转移了被依赖对象实现解耦。

3、注入：谁注入于谁？到底注入什么？

答：通过容器向对象注入其所需要的外部资源

4、控制反转：谁控制谁？控制什么？为什么叫反转？

答：IoC/DI的容器控制对象，主要是控制对象实例的创建。反转是相对于正向而言的，那么什么算是正向的呢？考虑一下常规情况下的应用程序，如果要在A里面使用C，你会怎么做呢？当然是直接去创建C的对象，也就是说，是在A类中主动去获取所需要的外部资源C，这种情况被称为正向的。那么什么是反向呢？就是A类不再主动去获取C，而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向的注入到A类中。

5、依赖注入和控制反转是同一概念吗？

答：从上面可以看出：依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

下面我们通过例子来具体看看依赖注入的一些实现方式：

1.构造器注入

class Book {

private $db_conn;

public function __construct($db_conn) {

$this->db_conn = $db_conn;

}

}

2、setter注入

复制代码

复制代码

class book{

private $db;

private $file;

function setdb($db){

$this->db=$db;

}

function setfile($file){

$this->file=$file;

}

}

class file{}

class db{}

...

class test{

$book = new Book();

$book->setdb(new db());

$book->setfile(new file());

}

?>

复制代码

复制代码

上面俩种方法代码很清晰，但是当我们需要注入很多个依赖时，意味着又要增加很多行，会比较难以管理。

比较好的解决办法是 建立一个class作为所有依赖关系的container，在这个class中可以存放、创建、获取、查找需要的依赖关系

复制代码

复制代码

class Ioc {

protected $db_conn;

public static function make_book() {

$new_book = new Book();

$new_book->set_db(self::$db_conn);

//...

//...

//其他的依赖注入

return $new_book;

}

}

复制代码

此时，如果获取一个book实例，只需要执行$newone = Ioc::makebook();

以上是container的一个具体实例，最好还是不要把具体的某个依赖注入写成方法，采用registry注册，get获取比较好

class Ioc {

/**

* @var 注册的依赖数组

*/

protected static $registry = array();

/**

* 添加一个resolve到registry数组中

* @param string $name 依赖标识

* @param object $resolve 一个匿名函数用来创建实例

* @return void

*/

public static function register($name, Closure $resolve)

{

static::$registry[$name] = $resolve;

}

/**

* 返回一个实例

* @param string $name 依赖的标识

* @return mixed

*/

public static function resolve($name)

{

if ( static::registered($name) )

{

$name = static::$registry[$name];

return $name();

}

throw new Exception('Nothing registered with that name, fool.');

}

/**

* 查询某个依赖实例是否存在

* @param string $name id

* @return bool

*/

public static function registered($name)

{

return array_key_exists($name, static::$registry);

}

}

复制代码

复制代码

现在就可以通过如下方式来注册和注入一个

复制代码

复制代码

$book = Ioc::registry('book', function(){

$book = new Book;

$book->setdb('...');

$book->setprice('...');

return $book;

});

//注入依赖

$book = Ioc::resolve('book');

?>

复制代码

复制代码

以上就是针对php依赖注入和控制反转的理解，希望对大家学习PHP程序设计有所帮助

php依赖注入和控制反转

依赖注入是一种设计模式，又名 控制反转 ，为了降低耦合度

1：控制反转(Inversion of Control )的实现方式

简称：IOC

理解：A类不需要主动去获取C，而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向的注入到A类中。比如说，A类中需要用到C类，也可能是B类，而这时候，不需要再A类内部代码中去实例化C类或者B类，这样代码耦合性太高，不容易维护，为了降低耦合度，从而设计成A类中传递一个参数，而这个参数就是B类或者C类。

/ 定义写日志的接口规范

interface logApi {

public function write();

}

// 文件记录日志

class FileLog implements logApi {

public function write() {

echo 'file log write...';

}

}

// 数据库记录日志

class DatabaseLog implements logApi {

public function write() {

echo 'database log write...';

}

}

// 程序操作类

class User {

protected $fileLog;

public function __construct() {

$this->fileLog = new FileLog();

}

public function login()  {

// 登录成功，记录登录日志

echo 'login success...';

$this->fileLog->write();

}

}

$user = new User();

$result = $user -> login();

代码这样写，耦合度高，如果将user类改成一下形式：

// 程序操作类

class User {

protected $fileLog;

public function __construct(Log $log) {

$this->fileLog = $log;

}

public function login()  {

// 登录成功，记录登录日志

echo 'login success...';

$this->fileLog->write();

}

}

$user = new User(new FileLog());

$result = $user -> login();

这样想用任何方式记录操作日志都不需要去修改过User类了，只需要通过构造函数参数传递就可以实现，其实这就是“控制反转”。不需要自己内容修改，改成由外部外部传递。这种由外部负责其依赖需求的行为，我们可以称其为 “控制反转(IoC)

2：依赖注入

特点：

创建一个容易类，将用到的其他的类进行绑定到这个容器中，然后随时可以取用。

class luntai {

public function luntai1(){

echo "这是luntai.
";

}

}

class bmn {

private $luntaiClass;

public function __construct($luntai){

$this->luntaiClass = $luntai;

}

public function bmn(){

$this->luntaiClass->luntai1();

echo "这是bmn.
";

}

}

class Container {

static $register;

public static function bind($name,Closure $clo){

self::$register[$name] = $clo;

}

public static function make($name){

$clo = self::$register[$name];

return $clo();

}

}

Container::bind('luntai',function(){

return new luntai();

});

Container::bind('bmn',function(){

return new bmn(Container::make('luntai'));

});

$bmn = Container::make('bmn');

$bmn->bmn();

最后建议大家深入理解面向对象和多敲代码去理解它。