Home > Article > Backend Development > Related analysis of service containers and dependency injection in PHP
Dependency Injection
When class A needs to depend on class B, that is to say, class B needs to be instantiated in class A When an object is used, if the functions in class B change, the places where class B is used in class A will also be modified, resulting in high coupling between class A and class B. The solution at this time is that class A should rely on the interface of class B and hand over the instantiation of specific classes to the outside.
Take the notification module commonly used in our business.
<?php /** * 定义了一个消息类 * Class Message */ class Message{ public function seed() { return '灰太狼准备吃羊'; } } /* * 订单产生的时候 需要发送消息 */ class Order{ protected $messager = ''; function __construct() { $this->messager = new Message(); } public function seed_msg() { return $this->messager->seed(); } } $Order = new Order(); echo $Order->seed_msg();
The above code is our traditional way of writing. First, the class sent by the message. Then where we need to send a message, call the interface for sending the message. One day you need to add an interface for sending text messages to meet different needs. Then you will find that you need to make changes in the Message class. You also need to make modifications in the Order class. This seems very troublesome. At this time, the idea of dependency injection came into being.
<?php /** * 为了约束我们先定义一个消息接口 * Interface Message */ interface Message{ public function seed(); } /** * 有一个发送邮件的类 * Class SeedEmail */ class SeedEmail implements Message { public function seed() { return '灰太狼发邮件给红太狼说要吃烤全羊'; } } /** *新增一个发送短信的类 * Class SeedSMS */ class SeedSMS implements Message { public function seed() { return '灰太狼发短信给红太狼说要吃烤全羊'; } } /* * 订单产生的时候 需要发送消息 */ class Order{ protected $messager = ''; function __construct(Message $message) { $this->messager = $message; } public function seed_msg() { return $this->messager->seed(); } } //我们需要发送邮件的时候 $message = new SeedEmail(); //将邮件发送对象作为参数传递给Order $Order = new Order($message); echo $Order->seed_msg(); echo "\n"; //我们需要发送短信的时候 $message = new SeedSMS(); $Order = new Order($message); echo $Order->seed_msg();
The service container I understand is a factory that automatically generates classes.
<?php /** * 为了约束我们先定义一个消息接口 * Interface Message */ interface Message{ public function seed(); } /** * 有一个发送邮件的类 * Class SeedEmail */ class SeedEmail implements Message { public function seed() { return '灰太狼发邮件给红太狼说要吃烤全羊'; } } /** *新增一个发送短信的类 * Class SeedSMS */ class SeedSMS implements Message { public function seed() { return '灰太狼发短信给红太狼说要吃烤全羊'; } } /** * 这是一个简单的服务容器 * Class Container */ class Container { protected $binds; protected $instances; public function bind($abstract, $concrete) { if ($concrete instanceof Closure) { $this->binds[$abstract] = $concrete; } else { $this->instances[$abstract] = $concrete; } } public function make($abstract, $parameters = []) { if (isset($this->instances[$abstract])) { return $this->instances[$abstract]; } array_unshift($parameters, $this); return call_user_func_array($this->binds[$abstract], $parameters); } } //创建一个消息工厂 $message = new Container(); //将发送短信注册绑定到工厂里面 $message->bind('SMS',function (){ return new SeedSMS(); }); //将发送邮件注册绑定到工厂 $message->bind('EMAIL',function (){ return new SeedEmail(); }); //需要发送短信的时候 $SMS = $message->make('SMS'); echo $SMS->seed(); echo "\n"; $EMAIL = $message->make('EMAIL'); echo $EMAIL->seed();
container is a simple service container with bind,makeTwo methods
bind is to bind the service object to the container.
make takes out the object from the container.
In the bind method, you need to pass in a concrete. We can pass in an instance object or a closure function.
You can see that I am using a closure function. In fact, you can also write it like this
$sms = new SeedSMS(); $message->bind('SMS',$sms);
The difference between this latter writing method and closure is that we need to instantiate the object first before we can proceed easily. Binding services. Closures only instantiate objects when we use this service. It can be seen that closures have many advantages.
The make method is the method to exit the container. It first determines whether there is a current and existing service object in the instances variable, and if so, returns it directly. If not, an object will be returned through call_user_func_array. For the use of call_user_func_array, you can view the use of call_user_func in
PHP
For more PHP related technical articles, please visitPHP Tutorialcolumn for learning!
The above is the detailed content of Related analysis of service containers and dependency injection in PHP. For more information, please follow other related articles on the PHP Chinese website!