Dependency injection and service container for PHP functions

Answer: Dependency injection and service containers in PHP help to flexibly manage dependencies and improve code testability. Dependency injection: Pass dependencies through the container to avoid direct creation within the function, improving flexibility. Service container: Stores dependency instances for easy access in the program, further enhancing loose coupling. Practical case: The sample application demonstrates the practical application of dependency injection and service containers, injecting dependencies into the controller, reflecting the advantages of loose coupling.

Dependency Injection and Service Container for PHP Functions

Introduction
Dependency Injection (DI) is a design pattern that allows us to pass dependencies within a function instead of creating them directly within the function body. This makes our code more flexible and testable. A service container is a library that manages dependencies. It stores a single instance for each dependency and allows us to access them from anywhere in the application.

Dependency Injection
In order to use dependency injection in PHP functions, we can use a class called "container". This class will be responsible for creating and storing dependencies.

class Container {
  private $dependencies = [];

  public function get($dependency) {
    if (!isset($this->dependencies[$dependency])) {
      $this->dependencies[$dependency] = $this->create($dependency);
    }
    return $this->dependencies[$dependency];
  }

  private function create($dependency) {
    switch ($dependency) {
      case 'Database':
        return new Database();
      case 'Logger':
        return new Logger();
      default:
        throw new Exception('Unknown dependency: ' . $dependency);
    }
  }
}

Now, we can use the get() method in the function to get the dependencies:

function sendEmail(Container $container, string $to, string $subject, string $body) {
  $mailer = $container->get('Mailer');
  $mailer->send($to, $subject, $body);
}

Service Container
Service Container Is an extension library for managing dependencies. It stores a single instance for each dependency and allows us to access them from anywhere in the application.

In PHP, we recommend using Symfony’s ContainerInterface and ContainerBuilder classes.

// 配置服务容器
$container = new ContainerBuilder();
$container->register('database', Database::class);
$container->register('logger', Logger::class);

// 编译服务容器
$container->compile();

// 使用服务容器
$database = $container->get('database');
$logger = $container->get('logger');

Practical case
The following is a sample application using dependency injection and service containers:

// index.php
require 'vendor/autoload.php';
$container = new Container();
$controller = $container->get('Controller');
$controller->index();

// Controller.php
class Controller {
  private $database;
  private $logger;

  public function __construct(Container $container) {
    $this->database = $container->get('Database');
    $this->logger = $container->get('Logger');
  }

  public function index() {
    // ...
  }
}

// Database.php
class Database {
  // ...
}

// Logger.php
class Logger {
  // ...
}

In this application, we use dependency injection to The Database and Logger dependencies are passed to the Controller class. The service container is responsible for creating and managing these dependencies.

Conclusion
Dependency injection and service containers are powerful tools for improving the flexibility and testability of PHP applications. They allow us to manage dependencies in a loosely coupled way, making our code easier to maintain and extend.

The above is the detailed content of Dependency injection and service container for PHP functions. For more information, please follow other related articles on the PHP Chinese website!