Laravel实现函数自动执行前后置逻辑的方案咨询

方案1：利用PHP魔术方法__call/__callStatic（适合自定义可控类） #

如果你的业务类是自己可控的，PHP魔术方法是低成本实现方式。原理是接管公共方法调用，在原方法执行前后注入逻辑——注意需要把原方法（包括Trait中的方法）设为非公共，因为魔术方法仅在调用不存在的公共方法时触发。

示例代码 #

// 基类，所有需要拦截的业务类继承此类
class BaseService
{
    public function __call($method, $arguments)
    {
        // 执行前置逻辑
        $this->beforeEveryFunctionCore($method, $arguments);
        
        // 调用原方法
        $result = $this->$method(...$arguments);
        
        // 执行后置逻辑
        $this->afterEveryFunctionCore($method, $arguments, $result);
        
        return $result;
    }

    public static function __callStatic($method, $arguments)
    {
        // 静态方法前置逻辑
        static::beforeEveryFunctionCore($method, $arguments);
        
        // 调用原静态方法
        $result = static::$method(...$arguments);
        
        // 静态方法后置逻辑
        static::afterEveryFunctionCore($method, $arguments, $result);
        
        return $result;
    }

    protected function beforeEveryFunctionCore(string $method, array $args)
    {
        // 自定义前置逻辑：比如日志记录、参数校验
        \Illuminate\Support\Facades\Log::info("执行方法前：{$method}，参数：" . json_encode($args));
    }

    protected function afterEveryFunctionCore(string $method, array $args, $result)
    {
        // 自定义后置逻辑：比如返回值记录、资源清理
        \Illuminate\Support\Facades\Log::info("执行方法后：{$method}，返回值：" . json_encode($result));
    }
}

// 业务类，继承基类并将原方法设为protected
class UserService extends BaseService
{
    protected function getUser(int $id)
    {
        return \App\Models\User::find($id);
    }

    protected static function getUserName(int $id)
    {
        return \App\Models\User::find($id)?->name;
    }
}

// 使用时直接调用「伪公共方法」，实际由魔术方法接管
$userService = new UserService();
$userService->getUser(1); // 自动触发前后置逻辑
UserService::getUserName(1); // 静态方法同样生效

Trait方法的适配 #

如果要拦截Trait中的方法，只需在使用Trait的类里，将Trait方法重命名为非公共：

trait UserTrait
{
    public function getFullName()
    {
        return $this->first_name . ' ' . $this->last_name;
    }
}

class User extends BaseService
{
    // 将Trait的getFullName方法重命名为protected
    use UserTrait {
        getFullName as protected;
    }
}

// 调用时自动触发前后置逻辑
$user = new User();
$user->getFullName();

方案2：使用AOP面向切面编程（最灵活，支持Trait/第三方类） #

如果需要拦截任意类（包括Trait、第三方包的类）的方法，AOP是最直接的方案。Laravel生态中常用spatie/laravel-aop包，通过注解或配置定义切面，自动织入前后置逻辑。

步骤实现 #

1. 安装扩展包

composer require spatie/laravel-aop

2. 发布配置文件

php artisan vendor:publish --provider="Spatie\Aop\AopServiceProvider"

3. 定义切面类

namespace App\Aspects;

use Spatie\Aop\Contracts\Aspect;
use Spatie\Aop\Intercepts\MethodInvocation;
use Illuminate\Support\Facades\Log;

class FunctionInterceptorAspect implements Aspect
{
    public function handle(MethodInvocation $invocation)
    {
        // 前置逻辑
        $method = $invocation->getMethod()->getName();
        $args = $invocation->getArguments();
        $this->beforeEveryFunctionCore($method, $args);
        
        // 执行原方法
        $result = $invocation->proceed();
        
        // 后置逻辑
        $this->afterEveryFunctionCore($method, $args, $result);
        
        return $result;
    }

    protected function beforeEveryFunctionCore(string $method, array $args)
    {
        Log::info("[AOP前置] 方法：{$method}，参数：" . json_encode($args));
    }

    protected function afterEveryFunctionCore(string $method, array $args, $result)
    {
        Log::info("[AOP后置] 方法：{$method}，返回值：" . json_encode($result));
    }
}

4. 配置拦截目标
   在config/aop.php中指定需要拦截的类/方法：

return [
    'aspects' => [
        App\Aspects\FunctionInterceptorAspect::class => [
            // 拦截UserTrait的所有公共方法
            'targets' => [
                'App\Traits\UserTrait->*',
                // 可扩展：拦截某个类的所有方法 App\Services\*->*
                // 可扩展：拦截特定方法 App\Services\UserService->getUser
            ],
        ],
    ],
];

5. 启用AOP
   在.env中设置AOP_ENABLED=true，重启应用（AOP为编译时织入，修改配置后需重启生效）。

方案3：自定义装饰器（适合特定服务类） #

如果仅需给特定服务类添加前后置逻辑，可使用装饰器模式，将原类实例包装后注入逻辑。

示例代码 #

// 定义服务接口
interface UserServiceInterface
{
    public function getUser(int $id);
}

// 原服务类
class UserService implements UserServiceInterface
{
    public function getUser(int $id)
    {
        return \App\Models\User::find($id);
    }
}

// 装饰器类，实现相同接口并包装原服务
class UserServiceDecorator implements UserServiceInterface
{
    public function __construct(protected UserServiceInterface $userService)
    {
    }

    public function getUser(int $id)
    {
        // 前置逻辑
        $this->beforeEveryFunctionCore(__FUNCTION__, func_get_args());
        
        $result = $this->userService->getUser($id);
        
        // 后置逻辑
        $this->afterEveryFunctionCore(__FUNCTION__, func_get_args(), $result);
        
        return $result;
    }

    protected function beforeEveryFunctionCore(string $method, array $args)
    {
        // 自定义前置逻辑
    }

    protected function afterEveryFunctionCore(string $method, array $args, $result)
    {
        // 自定义后置逻辑
    }
}

// 在AppServiceProvider的register方法中绑定装饰器
$this->app->bind(UserServiceInterface::class, function ($app) {
    $originalService = $app->make(UserService::class);
    return new UserServiceDecorator($originalService);
});

之后通过接口获取实例时，会自动使用装饰器，触发前后置逻辑。

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