如何在Laravel中使用服務容器和依賴注入？

Laravel的依賴注入與服務容器通過自動解析類型提示的依賴實現解耦，1. 使用構造函數注入將依賴外部化；2. 在服務提供者中通過bind綁定接口到具體實現；3. 使用singleton確保單例；4. 通過needs()->give()注入標量值；5. 利用when()->needs()->give()實現上下文綁定；6. 在控制器、中間件、任務等中直接類型提示依賴；7. 可使用app()或resolve()手動解析實例，最終實現靈活、可測試的應用架構。

In Laravel, service containers and dependency injection are core concepts that help you build flexible, testable, and maintainable applications. Let's break down how to use them effectively.

What is the Service Container?

The service container is Laravel's powerful inversion of control (IoC) container. It manages class dependencies and automatically resolves them when needed. This means you don't have to manually create objects — Laravel does it for you.

1. Understanding Dependency Injection

Dependency injection is a design pattern where a class receives its dependencies from the outside, rather than creating them internally.

Example Without Injection

 class OrderController extends Controller
{
    public function store()
    {
        $logger = new FileLogger(); // Hardcoded dependency
        $logger->log('Order created');
    }
}

This is inflexible — you can't easily switch loggers.

With Constructor Injection

 class OrderController extends Controller
{
    protected $logger;

    public function __construct(FileLogger $logger)
    {
        $this->logger = $logger;
    }

    public function store()
    {
        $this->logger->log('Order created');
    }
}

Now, the controller doesn't care how FileLogger is built — the container handles it.

2. How Laravel Resolves Dependencies

When Laravel sees a type-hinted class in a constructor or method, it tries to resolve it from the container.

 public function __construct(UserRepository $repo)
{
    $this->repo = $repo;
}

If UserRepository has its own dependencies (eg User model, Cache ), Laravel recursively resolves them — as long as they're type-hinted.

3. Binding Interfaces to Implementations

This is where the container shines. You can bind an interface to a concrete class, allowing easy swapping.

Example:

 // In a service provider (like AppServiceProvider)
public function register()
{
    $this->app->bind(
        PaymentGatewayInterface::class,
        StripePaymentGateway::class
    );
}

Now, anywhere you type-hint PaymentGatewayInterface , Laravel injects StripePaymentGateway .

 public function pay(PaymentGatewayInterface $gateway)
{
    $gateway->charge(100);
}

You can later change the binding to PayPalPaymentGateway without touching the controller.

4. Contextual Bindings

Sometimes you want different implementations based on the consumer.

 $this->app->when(InvoiceController::class)
          ->needs(PaymentGatewayInterface::class)
          ->give(StripePaymentGateway::class);

$this->app->when(ReceiptController::class)
          ->needs(PaymentGatewayInterface::class)
          ->give(PayPalPaymentGateway::class);

5. Singleton Bindings

Use singleton() if you want the same instance returned every time:

 $this->app->singleton(ReportGenerator::class, function ($app) {
    return new ReportGenerator();
});

Now, every time ReportGenerator is resolved, the same instance is used.

6. Binding Primitives (Scalar Values)

You can inject configuration values or strings using contextual binding:

 $this->app->when(StripePaymentGateway::class)
          ->needs('$apiKey')
          ->give(config('services.stripe.key'));

Then in your class:

 class StripePaymentGateway
{
    public function __construct(string $apiKey)
    {
        $this->apiKey = $apiKey;
    }
}

7. Using Dependency Injection in Different Contexts

In Controllers

Laravel automatically resolves type-hinted dependencies in controller constructors or methods.

 public function index(UserRepository $users)
{
    return $users->all();
}

In Middleware

 public function handle($request, Closure $next, UserService $service)
{
    // $service is auto-injected
    return $next($request);
}

In Jobs, Listeners, and Commands

Same rules apply — type-hint dependencies in the constructor.

8. Service Providers: Where Bindings Live

Create custom service providers to organize your bindings:

 php artisan make:provider PaymentServiceProvider

Then register it in config/app.php or use Laravel 5.5 auto-discovery.

 // PaymentServiceProvider.php
public function register()
{
    $this->app->bind(PaymentProcessor::class, function ($app) {
        return new PaymentProcessor(
            config('services.payment.secret')
        );
    });
}

9. Resolving Instances Manually

You can pull instances from the container using app() or resolve() :

 $logger = app()->make(LoggerInterface::class);
// or
$logger = resolve(LoggerInterface::class);

Even simpler:

 $logger = app(LoggerInterface::class);

Summary of Key Points

• Laravel's service container automatically resolves dependencies via type hints.
• Use bind() to map interfaces to implementations.
• Use singleton() for single instance sharing.
• Inject scalar values with needs()->give() .
• Define bindings in service providers.
• Dependency injection works in controllers, middleware, jobs, and more.

Basically, just type-hint your dependencies — Laravel handles the rest, as long as things are properly bound. It keeps your code decoupled and easier to test.

以上是如何在Laravel中使用服務容器和依賴注入？的詳細內容。更多資訊請關注PHP中文網其他相關文章！