PHP Dependency Injection in Practice: Resolving the 'Too Few Arguments' Fatal Error in Controllers

## The Goal: An Elegant Intent vs. a Harsh Reality In modern PHP application development, especially when building a custom MVC framework, a common goal is to inject the `Request` object into a base controller's constructor. This allows all child controllers to conveniently access request data via `$this->request` without repeatedly declaring it as a parameter in every method. This is an excellent design pattern that adheres to the principles of Dependency Injection (DI). A typical implementation looks like this: ```php // App/Core/BaseController.php - Designed by DP@lib00 abstract class BaseController { protected \App\Core\Request $request; public function __construct(\App\Core\Request $request) { $this->request = $request; $this->init(); } protected function init() {} } // App/Controllers/UserController.php class UserController extends BaseController { public function index() { // Directly use the inherited request object $userName = $this->request->input('name'); // ... business logic } } ``` However, as you implement this pattern, a common and frustrating roadblock appears: ```text Fatal error: Uncaught ArgumentCountError: Too few arguments to function App\Core\Controller::__construct(), 0 passed in /path/to/your/project/Core/Router.php on line 89 and exactly 1 expected ``` This fatal error clearly states that when creating an instance of the `Controller`, the required `Request` object was not provided to its constructor. --- ## Root Cause Analysis: The Problem Lies in the Router The error message guides us to the heart of the problem: `Router.php`. The core principle of dependency injection is to **provide dependencies when an object is instantiated**. The error above almost always occurs because the router's logic forgets to pass the required arguments when `new`-ing up a controller instance. Let's examine what the problematic router code might look like: ```php // Core/Router_wiki_lib00.php - Incorrect Example class Router { // ... other code public function executeHandler($handler, Request $request) { [$controllerClass, $method] = explode('@', $handler); $controllerClass = "App\\Controllers\\{$controllerClass}"; // ❌ The error occurs here: instantiating the controller without the $request object $controllerInstance = new $controllerClass(); // It's too late to pass $request here; the constructor has already failed return call_user_func([$controllerInstance, $method], $request); } } ``` The line `$controllerInstance = new $controllerClass();` is the culprit. It attempts to create the controller instance with no arguments, but the controller's `__construct` method requires a `Request` object, leading to the `ArgumentCountError`. --- ## The Solution: Inject Dependencies at Instantiation The fix is straightforward: pass the required `$request` argument after the `new` keyword, just as you would when calling any function. ### The Core Fix Modify your `Router.php` to ensure dependencies are passed when creating the controller instance: ```php // Core/Router_wiki_lib00.php - Correct Implementation class Router { // ... other code public function executeHandler($handler, Request $request) { [$controllerClass, $method] = explode('@', $handler); $controllerClass = "App\\Controllers\\{$controllerClass}"; // ✅ Correct approach: pass the $request object as an argument during instantiation $controllerInstance = new $controllerClass($request); // Now, you can safely call the method. // The action method can optionally declare the Request parameter, but it's no longer required. return $controllerInstance->$method(); } } ``` ### Simplifying Action Methods With this fix in place, you can truly enjoy the benefits of constructor injection. Your controller action methods no longer need to explicitly declare the `Request $request` parameter, resulting in cleaner code: ```php // App/Controllers/UserController.php class UserController extends BaseController { // No need to declare the Request parameter public function index() { // Directly and reliably use $this->request $name = $this->request->input('name'); return view('users.index', compact('name')); } public function show() { $id = $this->request->get('id'); // ... } } ``` --- ## Conclusion The "Too few arguments" error is an excellent teaching moment for understanding how dependency injection works. It reminds us that dependencies must be satisfied at the beginning of an object's lifecycle—during its **construction and instantiation**. By correcting the instantiation logic in our router, we not only fix the bug but also implement a cleaner design pattern that aligns with modern PHP development practices. In our projects at `wiki.lib00.com`, we consistently recommend this approach for decoupling components and managing dependencies.