Laravel控制器类中构造函数的作用与使用场景咨询

Awesome question—this is one of those Laravel nuances that feels confusing at first because we never manually write new UserController() ourselves, right? Let me break this down clearly:

First, quick background: Laravel’s service container automatically instantiates controllers for you when a request matches a route tied to that controller. So even though you don’t see the instantiation code, the constructor still runs as soon as the controller object is created under the hood.

1. Centralize Dependency Injection #

The constructor is the best place to inject dependencies that multiple controller methods need. Instead of resolving a service (like a repository, auth helper, or custom business class) in every single method, you inject it once in the constructor, store it as a class property, and reuse it everywhere:

class UserController extends Controller
{
    protected $userRepository;

    // Inject the dependency via constructor
    public function __construct(UserRepository $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function index()
    {
        // No need to inject again—just use the property
        $users = $this->userRepository->getAllUsers();
        return view('users.index', compact('users'));
    }

    public function show($id)
    {
        $user = $this->userRepository->findUserById($id);
        return view('users.show', compact('user'));
    }
}

This keeps your code DRY, follows dependency injection principles, and makes testing way easier (you can pass mock objects during tests instead of real services).

2. Apply Global Middleware/Logic #

If you want a piece of logic to run for every method in a controller, the constructor is your go-to spot. The most common use case is applying middleware—like restricting an entire controller to admins only:

class AdminDashboardController extends Controller
{
    public function __construct()
    {
        // Apply auth + admin middleware to all controller methods
        $this->middleware('auth');
        $this->middleware('role:admin');
    }

    public function overview()
    {
        // Only authenticated admins can access this
        return view('admin.overview');
    }

    public function manageUsers()
    {
        // Same middleware applies here too
        $users = User::all();
        return view('admin.users', compact('users'));
    }
}

You can also use this for other global setup—like setting the current user’s timezone, loading site-wide config, or initializing shared data that all methods need.

3. Custom Initialization Logic #

Sometimes you need to run code the moment the controller is created, before any method executes. For example, preloading a resource based on a request parameter:

class BlogController extends Controller
{
    protected $currentCategory;

    public function __construct(Request $request)
    {
        // Preload the category if a category ID is in the request
        if ($request->has('category')) {
            $this->currentCategory = Category::findOrFail($request->category);
        }
    }

    public function index()
    {
        // Use the preloaded category to filter posts
        $posts = $this->currentCategory 
            ? $this->currentCategory->posts 
            : Post::latest()->get();
        
        return view('blog.index', compact('posts'));
    }
}

When Should You Define a Controller Constructor? #

• When multiple methods share the same dependency (cuts down on repetition).
• When you need to apply middleware or logic to all controller methods (no need to add it to every route or method).
• When you have custom setup that needs to run before any controller method executes (preloading data, setting global properties, etc.).

At the end of the day, Laravel controllers are just regular PHP classes—their constructors work exactly like any other OOP constructor. The only difference is Laravel handles the instantiation for you, so you don’t have to write the new keyword yourself.

内容的提问来源于stack exchange，提问作者Matrix