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.

General

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.

The idea of relying on injection

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.

Service container

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 withbind,makeTwo methods

bind is to bind the service object to the container.

make takes out the object from the container.

bind

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.

make

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!