Laravel：不同控制器实现相同功能的最佳编程实践？

Hey there! Great question—reusing code across controllers is a key part of keeping your codebase clean and maintainable, especially for auth-related logic that often overlaps between login and registration flows. Let’s break down the best practices tailored for this scenario, with concrete, code-compliant implementations:

1. Traits: For Lightweight, Single-Responsibility Reuse #

Traits are perfect when you have small, self-contained functions that don’t need heavy dependencies. They let you "inject" code into multiple controllers without inheritance overhead.

Step 1: Create a Reusable Trait #

Make a dedicated trait file for your shared auth helpers:

// app/Traits/AuthHelpers.php
namespace App\Traits;

use Illuminate\Support\Facades\Cache;

trait AuthHelpers {
    // Validate phone number format (example shared logic)
    protected function validatePhoneNumber(string $phone): bool {
        return preg_match('/^\+?[1-9]\d{1,14}$/', $phone);
    }

    // Generate and cache a verification code
    protected function generateVerificationCode(string $phone): string {
        $code = rand(1000, 9999);
        Cache::put("verification_code_{$phone}", $code, 300); // Cache for 5 mins
        return $code;
    }
}

Step 2: Use the Trait in Controllers #

Import and use the trait in both your login and registration controllers:

// app/Http/Controllers/Auth/LoginController.php
namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Traits\AuthHelpers;
use Illuminate\Http\Request;

class LoginController extends Controller {
    use AuthHelpers;

    public function login(Request $request) {
        // Reuse the trait's validation method
        if (!$this->validatePhoneNumber($request->phone)) {
            return response()->json(['error' => 'Invalid phone number'], 422);
        }

        // Rest of your login logic...
    }
}

Do the same in RegisterController—just add use AuthHelpers; and call the shared methods.

2. Service Classes: For Complex, Business-Focused Logic #

If your shared code involves multiple steps, external dependencies (like SMS services, databases), or needs unit testing, a service class is the way to go. It follows the Single Responsibility Principle and makes your code more testable.

Step 1: Build an Auth Service #

Create a service class to encapsulate all shared auth logic:

// app/Services/AuthService.php
namespace App\Services;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Mail;
use App\Mail\VerificationCodeMail;

class AuthService {
    public function validatePhoneNumber(string $phone): bool {
        return preg_match('/^\+?[1-9]\d{1,14}$/', $phone);
    }

    public function sendVerificationCode(string $phone): void {
        $code = rand(1000, 9999);
        Cache::put("verification_code_{$phone}", $code, 300);
        Mail::to($phone)->send(new VerificationCodeMail($code));
    }

    public function verifyCode(string $phone, string $code): bool {
        return Cache::get("verification_code_{$phone}") === $code;
    }
}

Step 2: Inject the Service into Controllers #

Use dependency injection to access the service in your controllers (this is Laravel-friendly and makes testing easier):

// app/Http/Controllers/Auth/RegisterController.php
namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Services\AuthService;
use Illuminate\Http\Request;

class RegisterController extends Controller {
    protected $authService;

    // Inject the service via constructor
    public function __construct(AuthService $authService) {
        $this->authService = $authService;
    }

    public function register(Request $request) {
        if (!$this->authService->validatePhoneNumber($request->phone)) {
            return response()->json(['error' => 'Invalid phone number'], 422);
        }

        $this->authService->sendVerificationCode($request->phone);
        // Rest of your registration logic...
    }
}

3. Base Controller: For Shared Controller Foundation #

If your login and registration controllers share more than just helper functions (like middleware setup, response formatting), create a base auth controller for them to inherit from.

Step 1: Create a Base Auth Controller #

// app/Http/Controllers/Auth/BaseAuthController.php
namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;

class BaseAuthController extends Controller {
    protected function validatePhoneNumber(string $phone): bool {
        return preg_match('/^\+?[1-9]\d{1,14}$/', $phone);
    }

    protected function formatAuthResponse($user) {
        return [
            'id' => $user->id,
            'name' => $user->name,
            'token' => $user->createToken('auth_token')->plainTextToken
        ];
    }

    // Shared middleware, if needed
    public function __construct() {
        $this->middleware('guest')->except('logout');
    }
}

Step 2: Inherit from the Base Controller #

// app/Http/Controllers/Auth/LoginController.php
namespace App\Http\Controllers\Auth;

use Illuminate\Http\Request;

class LoginController extends BaseAuthController {
    public function login(Request $request) {
        if (!$this->validatePhoneNumber($request->phone)) {
            return response()->json(['error' => 'Invalid phone number'], 422);
        }

        // Login logic...
        return response()->json($this->formatAuthResponse($user));
    }
}

How to Choose the Right Approach? #

• Traits: Use for small, independent helper functions that don’t need external dependencies. Keep traits focused—avoid stuffing unrelated logic into one trait.
• Service Classes: Use for complex business logic, code that needs testing, or logic that relies on external services (like mailers or APIs).
• Base Controllers: Use when multiple controllers share core controller functionality (middleware, response formatting) alongside helper functions.

Quick Coding Tips #

• Keep functions single-responsibility: One function should do one thing (e.g., don’t mix validation and code sending in the same method).
• Name functions clearly: validatePhoneNumber is better than checkPhone—readability matters!
• Avoid hardcoding dependencies: Use dependency injection (like with service classes) instead of new AuthService() directly in controllers.

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