Detailed introduction to dependency injection and IoC in Laravel (with examples)

This article brings you a detailed introduction to dependency injection and IoC in Laravel (with examples). It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

As developers, we are always trying to find new ways to write well-designed and robust code by using design patterns and trying new robust frameworks. In this article, we'll explore the Dependency Injection design pattern with Laravel's IoC components and see how it can improve our designs.

Dependency Injection

The term dependency injection is a term proposed by Martin Fowler, which is the act of injecting components into an application. As Ward Cunningham said:

Dependency injection is a key element in agile architecture.

Let's look at an example:

class UserProvider{ protected $connection; public function __construct(){ $this->connection = new Connection; } public function retrieveByCredentials( array $credentials ){ $user = $this->connection ->where( 'email', $credentials['email']) ->where( 'password', $credentials['password']) ->first(); return $user; } }

If you want to test or maintain this class, you must access the instance of the database to perform some queries. To avoid having to do this, you candecouplethis class from other classes, you have one of three options to inject theConnectionclass without using it directly.

When injecting components into a class, you can use one of the following three options:

Constructor method injection

class UserProvider{ protected $connection; public function __construct( Connection $con ){ $this->connection = $con; } ...

Setter method injection

Similarly, we also Dependencies can be injected using the Setter method:

class UserProvider{ protected $connection; public function __construct(){ ... } public function setConnection( Connection $con ){ $this->connection = $con; } ...

Interface injection

interface ConnectionInjector{ public function injectConnection( Connection $con ); } class UserProvider implements ConnectionInjector{ protected $connection; public function __construct(){ ... } public function injectConnection( Connection $con ){ $this->connection = $con; } }

When a class implements our interface, we define theinjectConnectionmethod to resolve dependencies.

Advantages

Now when testing our classes we can mock dependent classes and pass them as parameters. Each class must focus on a specific task and should not be concerned with resolving their dependencies. This way, you'll have a more focused and maintainable application.

If you want to learn more about DI, Alejandro Gervassio has covered it extensively and expertly in this series of articles, so be sure to read them. So, what is IoC? IoC (Inversion of Control) does not require the use of dependency injection, but it can help you manage dependencies effectively.

Inversion of Control

Ioc is a simple component that makes it easier to resolve dependencies. You can describe the object as a container, and every time a class is resolved, dependencies are automatically injected.

Laravel Ioc

Laravel Ioc is a little special in the way it resolves dependencies when you request an object:

We use A simple example will improve it in this article. The
SimpleAuthclass depends onFileSessionStorage, so our code might look like this:

class FileSessionStorage{ public function __construct(){ session_start(); } public function get( $key ){ return $_SESSION[$key]; } public function set( $key, $value ){ $_SESSION[$key] = $value; } } class SimpleAuth{ protected $session; public function __construct(){ $this->session = new FileSessionStorage; } } //创建一个 SimpleAuth $auth = new SimpleAuth();

This is a classic approach, let's start with using the constructor Function injection begins.

class SimpleAuth{ protected $session; public function __construct( FileSessionStorage $session ){ $this->session = $session; } }

Now we create an object:

$auth = new SimpleAuth( new FileSessionStorage() );

Now I want to use Laravel Ioc to manage all this.

Because theApplicationclass inherits from theContainerclass, you can access the container through theAppfacade.

App::bind( 'FileSessionStorage', function(){ return new FileSessionStorage; });

bindThe first parameter of the method is the unique ID to be bound to the container, and the second parameter is a callback function that is executed whenever theFileSessionStorageclass is executed. , we can also pass a string representing the class name as shown below.

Note:If you look at the Laravel package, you will see that bindings are sometimes grouped, such as (view,view.finder...).

Assuming we convert the session store to Mysql storage, our class should look like:

class MysqlSessionStorage{ public function __construct(){ //... } public function get($key){ // do something } public function set( $key, $value ){ // do something } }

Now that we have changed the dependencies, we also need to change theSimpleAuthconstruct function and bind the new object to the container!

High-level modules should not depend on low-level modules, both should depend on abstract objects.
Abstraction should not depend on details, details should depend on abstraction.

Robert C. Martin

OurSimpleAuthclass should not care about how our storage is done, instead it should focus more on consuming the service.

Therefore, we can abstractly implement our storage:

interface SessionStorage{ public function get( $key ); public function set( $key, $value ); }

so that we can implement and request an instance of theSessionStorageinterface:

class FileSessionStorage implements SessionStorage{ public function __construct(){ //... } public function get( $key ){ //... } public function set( $key, $value ){ //... } } class MysqlSessionStorage implements SessionStorage{ public function __construct(){ //... } public function get( $key ){ //... } public function set( $key, $value ){ //... } } class SimpleAuth{ protected $session; public function __construct( SessionStorage $session ){ $this->session = $session; } }

If we UseApp::make('SimpleAuth')to resolve theSimpleAuth
class through the container, the container will throwBindingResolutionExceptiontrying to resolve the class from the binding After that, go back to the reflection method and resolve all dependencies.

Uncaught exception 'Illuminate\Container\BindingResolutionException' with message 'Target [SessionStorage] is not instantiable.'

The container is trying to instantiate the interface. We can make a specific binding for this interface.

App:bind( 'SessionStorage', 'MysqlSessionStorage' );

Now every time we try to resolve this interface from the container, we will get aMysqlSessionStorageinstance. If we want to switch our storage service, we just change this binding.

Note:If you want to check whether a class has been bound in the container, you can useApp::bound('ClassName'), or you can useApp::bindIf('ClassName')To register a binding that has not yet been registered.

Laravel Ioc also providesApp::singleton('ClassName', 'resolver')to handle singleton binding.
You can also useApp::instance('ClassName', 'instance')to create a singleton binding.
If the container cannot resolve the dependency, it will throwReflectionException, but we can use theApp::resolvingAny(Closure)method to resolve any specified type in the form of a callback function .

Note:If you have registered a resolving method for a certain type, theresolvingAnymethod will still be called, but it will return directlybindThe return value of the method.

Tips

Where to write these bindings:

If it is just a small application, you can write it in a global start fileglobal/start.php, but if the project becomes larger and larger, it will be necessary to use Service Provider.

Testing:

When you need quick and easy testing, you can consider using php artisan tinker. It is very powerful and can help you improve your Laravel testing process.

Reflection API:

PHP’s Reflection API is very powerful. If you want to go deep into Laravel Ioc, you need to be familiar with the Reflection API. You can first read this tutorial to get more information. [Related recommendations: PHP video tutorial]

The above is the detailed content of Detailed introduction to dependency injection and IoC in Laravel (with examples). For more information, please follow other related articles on the PHP Chinese website!