Dependency injection in controllers in Laravel - Mini Project: Build & Apply

Dependency Injection in Laravel Controllers

📖 Scenario: You are building a simple Laravel web application that manages books. You want to use dependency injection in a controller to get a service that handles book data.

🎯 Goal: Create a Laravel controller that uses dependency injection to receive a BookService instance. This service will provide a method to get all books. You will set up the service, inject it into the controller, and call its method.

📋 What You'll Learn

Create a BookService class with a method getAllBooks() that returns an array of book titles.

Create a controller named BookController.

Inject the BookService into the BookController constructor using dependency injection.

Use the injected BookService inside a method index() in the controller to get all books.

💡 Why This Matters

🌍 Real World

Dependency injection is a common pattern in Laravel to manage class dependencies cleanly. It helps you write modular and testable code.

💼 Career

Understanding dependency injection in controllers is essential for Laravel developers. It is widely used in professional Laravel projects to manage services and repositories.

1

Create the BookService class

Create a class called BookService with a public method getAllBooks() that returns an array with these exact book titles: 'The Hobbit', '1984', and 'Pride and Prejudice'.

Laravel

# Create the BookService class with getAllBooks method
# Your code here

Hint

Define a class named BookService inside the App\Services namespace. Add a public method getAllBooks() that returns the array of book titles.

2

Create the BookController with constructor injection

Create a controller class called BookController inside the App\Http\Controllers namespace. Add a constructor that accepts a BookService parameter and stores it in a private property called bookService.

Laravel

<?php

namespace App\Services;

class BookService
{
    public function getAllBooks(): array
    {
        return ['The Hobbit', '1984', 'Pride and Prejudice'];
    }
}

// Create BookController with constructor injection
# Your code here

Hint

Remember to import BookService with a use statement. Define a private property bookService and assign the injected service to it in the constructor.

3

Add the index method to use the injected service

Inside the BookController class, add a public method called index(). Inside this method, call $this->bookService->getAllBooks() and store the result in a variable called books.

Laravel

bookService = $bookService;
    }

    // Add index method here
    # Your code here
}

Hint

Define the index() method to call the service method and return the list of books.

4

Complete the controller with namespace and use statements

Ensure the BookController class has the correct namespace App\Http\Controllers and includes the use App\Services\BookService; statement at the top. Confirm the full controller code includes the constructor and index() method using dependency injection.

Laravel

<?php

namespace App\Services;

class BookService
{
    public function getAllBooks(): array
    {
        return ['The Hobbit', '1984', 'Pride and Prejudice'];
    }
}

// Confirm the full BookController code with namespace and use statements
# Your code here

Hint

Make sure the controller file starts with the correct namespace and imports the BookService. The class should have the constructor and index() method as before.

Practice

1. What is the main purpose of dependency injection in Laravel controllers?

easy

A. To automatically provide required objects to the controller

B. To manually create objects inside controller methods

C. To make controllers dependent on global variables

D. To avoid using any external classes in controllers

Solution

1. Step 1: Understand dependency injection concept

   Dependency injection means Laravel automatically gives the controller the objects it needs without manual creation.

2. Step 2: Identify the purpose in Laravel controllers

   This keeps controllers clean and easy to test by providing dependencies automatically.

3. Final Answer:

   To automatically provide required objects to the controller -> Option A

4. Quick Check:

   Dependency injection = automatic object provision [OK]

Hint: Dependency injection means Laravel gives needed objects automatically [OK]

Common Mistakes:

• Thinking you must create objects manually inside controllers
• Confusing dependency injection with global variables
• Believing dependency injection removes use of external classes

2. Which of the following is the correct way to inject a service into a Laravel controller constructor?

easy

A. public function __construct($service) { $this->service = new Service(); }

B. public function __construct(Service $service) { $this->service = $service; }

C. public function __construct() { $this->service = Service::class; }

D. public function __construct(Service $service) { $service = new Service(); }

Solution

1. Step 1: Check constructor parameter type hinting

   public function __construct(Service $service) { $this->service = $service; } correctly type hints the Service class in the constructor parameter.

2. Step 2: Verify assignment to class property

   public function __construct(Service $service) { $this->service = $service; } assigns the injected service to a class property for later use, which is correct.

3. Final Answer:

   public function __construct(Service $service) { $this->service = $service; } -> Option B

4. Quick Check:

   Constructor injection = type hint + assign property [OK]

Hint: Type hint service in constructor and assign to property [OK]

Common Mistakes:

• Not type hinting the service class in constructor
• Creating new service instance inside constructor instead of injecting
• Assigning class name string instead of object

3. Given this controller method, what will be the output if the injected service returns 'Hello' from its greet() method?

public function show(Service $service) {
    return $service->greet();
}

medium

A. "Hello"

B. Error: Service not found

C. null

D. "greet"

Solution

1. Step 1: Understand method injection

   The Service object is injected automatically into the show method by Laravel.

2. Step 2: Call the greet() method on the injected service

   The greet() method returns the string "Hello", so the method returns "Hello".

3. Final Answer:

   "Hello" -> Option A

4. Quick Check:

   Injected service method output = "Hello" [OK]

Hint: Injected method returns service method result directly [OK]

Common Mistakes:

• Assuming service is not injected and causes error
• Expecting method name instead of method return value
• Confusing null with empty string output

4. What is wrong with this controller constructor for dependency injection?

public function __construct(Service $service) {
    $service = new Service();
    $this->service = $service;
}

medium

A. It lacks type hinting for the service parameter

B. It does not assign the service to a class property

C. It creates a new Service instance instead of using the injected one

D. It should not use $this keyword inside constructor

Solution

1. Step 1: Analyze the constructor parameter and assignment

   The constructor receives a Service object but immediately overwrites it by creating a new instance.

2. Step 2: Understand why this is wrong

   This defeats dependency injection because the injected object is ignored and a new one is created manually.

3. Final Answer:

   It creates a new Service instance instead of using the injected one -> Option C

4. Quick Check:

   Overwriting injected service = wrong [OK]

Hint: Do not create new instance; use injected object directly [OK]

Common Mistakes:

• Overwriting injected parameter with new instance
• Forgetting to assign injected object to property
• Confusing type hinting with variable assignment

5. You want to inject two services, Logger and Mailer, into a Laravel controller and use them in a method. Which constructor and method setup is correct?

hard

A. public function __construct() { $this->logger = new Logger(); $this->mailer = new Mailer(); } public function notify() { $this->logger->log('Notify'); $this->mailer->send(); }

B. public function __construct(Mailer $mailer) { $this->mailer = $mailer; } public function notify(Logger $logger) { $logger->log('Notify'); }

C. public function __construct(Logger $logger) { $this->logger = $logger; } public function notify(Mailer $mailer) { $mailer->send(); }

D. public function __construct(Logger $logger, Mailer $mailer) { $this->logger = $logger; $this->mailer = $mailer; } public function notify() { $this->logger->log('Notify'); $this->mailer->send(); }

Solution

1. Step 1: Check constructor injection of both services

   public function __construct(Logger $logger, Mailer $mailer) { $this->logger = $logger; $this->mailer = $mailer; } public function notify() { $this->logger->log('Notify'); $this->mailer->send(); } correctly injects both Logger and Mailer in the constructor and assigns them to properties.

2. Step 2: Verify method usage of injected services

   The notify method uses the injected properties to call log and send methods, which is correct.

3. Final Answer:

   public function __construct(Logger $logger, Mailer $mailer) { $this->logger = $logger; $this->mailer = $mailer; } public function notify() { $this->logger->log('Notify'); $this->mailer->send(); } -> Option D

4. Quick Check:

   Inject all services in constructor, use properties in methods [OK]

Hint: Inject all services in constructor, use $this->property in methods [OK]

Common Mistakes:

• Injecting services only in methods instead of constructor
• Creating new instances inside constructor instead of injecting
• Mixing constructor and method injection inconsistently