Single action controllers in Laravel - Step-by-Step Execution

Concept Flow - Single action controllers

Route receives request

↓

Invoke Single Action Controller

↓

__invoke() method runs

↓

Process request logic

↓

Return response

↓

Send response to browser

The route calls a controller with one __invoke method that handles the request and returns a response.

Execution Sample

Laravel

class ShowProfileController extends Controller {
  public function __invoke($id) {
    return "User profile: $id";
  }
}

Route::get('/profile/{id}', ShowProfileController::class);

This code defines a single action controller that returns a user profile string for a given id.

Execution Table

Step	Action	Input	Method Called	Output/Response
1	Route matches GET /profile/5	/profile/5	ShowProfileController::__invoke	Called with id=5
2	Controller __invoke runs	id=5	__invoke	Returns 'User profile: 5'
3	Response sent to browser	User profile: 5	N/A	Browser displays 'User profile: 5'
4	End	N/A	N/A	Request complete

💡 Request completes after __invoke returns response and it is sent to browser

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
id	N/A	5	5	5
response	N/A	N/A	'User profile: 5'	'User profile: 5'

Key Moments - 2 Insights

Why does the controller only have one method named __invoke?

Because single action controllers use the __invoke method to handle the request, so no other methods are needed. See execution_table step 2 where __invoke runs.

How does Laravel know to call __invoke automatically?

When the controller class is passed to the route without specifying a method, Laravel calls __invoke by default. This is shown in execution_table step 1 where the route calls ShowProfileController::__invoke.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'id' when __invoke runs?

A 5

B null

C 0

D undefined

💡 Hint

Check execution_table row 2 under Input column shows id=5

At which step does the response get sent to the browser?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at execution_table row 3 where response is sent to browser

If the route was changed to call a controller with multiple methods, what would change in the execution flow?

A Route would still call __invoke automatically

B Route would specify which method to call instead of __invoke

C Controller would not run any method

D Response would be sent before method runs

💡 Hint

Refer to concept_flow where route calls __invoke only if no method specified

Concept Snapshot

Single action controllers have one __invoke method.
Routes call the controller class directly.
Laravel runs __invoke automatically.
Simplifies controllers for single tasks.
Response returned from __invoke is sent to browser.

Full Transcript

Single action controllers in Laravel use a special method called __invoke to handle requests. When a route points to a controller class without specifying a method, Laravel calls the __invoke method automatically. This method receives any route parameters and returns a response. The flow starts when the route matches the request URL, then Laravel creates the controller and runs __invoke with parameters. The method processes the request and returns a response string or view. Finally, Laravel sends this response back to the browser. This pattern simplifies controllers that only need to do one thing, like showing a user profile. The example shows a controller returning a string with the user id. The execution table traces each step from route matching to response delivery. Variables like id and response are tracked to show their values during execution. Key points include understanding why __invoke is used and how Laravel calls it automatically. The visual quiz tests understanding of variable values and flow steps. The snapshot summarizes the concept in a few lines for quick review.

Practice

1. What is the main purpose of a single action controller in Laravel?

easy

A. To replace middleware functionality

B. To manage multiple actions in one controller

C. To handle exactly one action using the __invoke method

D. To handle database migrations

Solution

1. Step 1: Understand the role of single action controllers

   Single action controllers are designed to handle only one action, making code simpler and focused.

2. Step 2: Identify the method used

   They use the special __invoke method to handle that single action.

3. Final Answer:

   To handle exactly one action using the __invoke method -> Option C

4. Quick Check:

   Single action controller = __invoke method [OK]

Hint: Single action controllers always use __invoke method [OK]

Common Mistakes:

• Thinking they handle multiple actions
• Confusing with middleware or migrations
• Assuming they require multiple methods

2. Which of the following is the correct syntax to define a single action controller in Laravel?

easy

A. class MyController { public function __invoke() {} }

B. class MyController { public function handle() {} }

C. class MyController { public function index() {} }

D. class MyController { public function action() {} }

Solution

1. Step 1: Recall the special method for single action controllers

   Single action controllers use the __invoke() method to handle the action.

2. Step 2: Match the syntax

   The correct syntax defines a class with a public function __invoke() method.

3. Final Answer:

   class MyController { public function __invoke() {} } -> Option A

4. Quick Check:

   __invoke method syntax = class MyController { public function __invoke() {} } [OK]

Hint: Look for __invoke method in the class [OK]

Common Mistakes:

• Using index() or handle() instead of __invoke()
• Forgetting the public visibility
• Confusing method names with other controller types

3. Given this single action controller code, what will be the output when accessed?

class WelcomeController {
    public function __invoke() {
        return 'Hello, Laravel!';
    }
}

medium

A. Hello, Laravel!

B. Error: Method not found

C. Empty response

D. 404 Not Found

Solution

1. Step 1: Understand __invoke method behavior

   The __invoke method runs when the controller is called as a single action, returning the string 'Hello, Laravel!'.

2. Step 2: Predict the output

   Since the method returns a string, the response will be that string displayed.

3. Final Answer:

   Hello, Laravel! -> Option A

4. Quick Check:

   __invoke returns string = 'Hello, Laravel!' [OK]

Hint: __invoke returns output directly as response [OK]

Common Mistakes:

• Expecting an error due to missing method name
• Thinking it returns empty or 404
• Confusing with multi-method controllers

4. Identify the error in this single action controller code:

class TestController {
    public function invoke() {
        return 'Test';
    }
}

medium

A. Return statement is invalid

B. Method should be private, not public

C. Class name must be TestActionController

D. Missing __invoke method name with double underscores

Solution

1. Step 1: Check method name for single action controller

   The method must be named __invoke with two underscores, not invoke.

2. Step 2: Verify method visibility and return

   Method should be public and return a value, which is correct here.

3. Final Answer:

   Missing __invoke method name with double underscores -> Option D

4. Quick Check:

   Method name must be __invoke [OK]

Hint: Method must be named __invoke with double underscores [OK]

Common Mistakes:

• Using invoke instead of __invoke
• Changing method visibility incorrectly
• Assuming class name affects single action controller

5. You want to create a single action controller that returns a JSON response with a message 'Success'. Which code snippet correctly implements this?

hard

A. class JsonResponseController {
public function __invoke() {
return json_encode(['message' => 'Success']);
}
}

B. class JsonResponseController {
public function __invoke() {
return response()->json(['message' => 'Success']);
}
}

C. class JsonResponseController {
private function __invoke() {
return ['message' => 'Success'];
}
}

D. class JsonResponseController {
public function handle() {
return json(['message' => 'Success']);
}
}

Solution

1. Step 1: Use __invoke method for single action controller

   The controller must have a public __invoke() method to be a single action controller.

2. Step 2: Return a proper JSON response in Laravel

   Use Laravel's response()->json() helper to return a JSON response correctly.

3. Final Answer:

   class JsonResponseController { public function __invoke() { return response()->json(['message' => 'Success']); } } -> Option B

4. Quick Check:

   __invoke + response()->json() = class JsonResponseController { public function __invoke() { return response()->json(['message' => 'Success']); } } [OK]

Hint: Use response()->json() inside __invoke method [OK]

Common Mistakes:

• Using handle() instead of __invoke()
• Returning raw arrays without response helper
• Using json() function which doesn't exist in Laravel