利用注解实现 Grpc 数据验证 #4821

huangdijia · 2022-06-10T03:02:34Z

huangdijia
Jun 10, 2022
Collaborator

Hyperf 对提供了好用的表单验证组件，使得表单验证更简单，不再是各种 if-else。

最近项目组使用到了 Grpc Server，从源码和实例代码看，Grpc Server 是继承了 Http Server。

public function sayHello(HiUser $user) 
{
    $message = new HiReply();
    $message->setMessage("Hello World");
    $message->setUser($user);
    return $message;
}

于是我开始思考，Grpc 的请求是不是也可以跟 HTTP 请求一样。后来发现注入的 HiUser 不是一个标准的 Request，而是 Google/Protobuf/Message。

前面提到，Grpc Server 是继承了 Http Server，于是我把思路转向了中间件。经过测试，思路没毛病，但是遇到一个问题，怎么把标准的 Request 转为 Validator 能识别的 data （array 类型）？

经过源码分析，让我看到了一点希望（Hyperf/Grpc/Parser），1 分钟之后又让我彻底放弃了。原因是我在中间件这个环节无法知道 Message 的类名，无法通过 Hyperf/Grpc/Parser::deserializeMessage() 反向序列化出我需要的 message。

最后把希望寄托到了“万能的 AOP”，对控制器的方法做拦截，结合注解实现：

#[Validation(rules: [
        'user' => 'required|string',
        'message' => 'required|string',
    ], messages: [
        'user.required' => 'User 不能为空',
    ], resolve: true)]
public function sayHello(HiUser $user) 
{
    $message = new HiReply();
    $message->setMessage("Hello World");
    $message->setUser($user);
    return $message;
}

或者复用已有的 fromRequest

#[Validation(formRequest: 'App\Request\FooRequest', scene: 'sayHello')]
public function sayHello(HiUser $user) 
{
    $message = new HiReply();
    $message->setMessage("Hello World");
    $message->setUser($user);
    return $message;
}

下面分享一下我的实现代码：

注解

// app/Annotation/Grpc/Validation.php

namespace App\Annotation\Grpc;

use Attribute;
use Hyperf\Di\Annotation\AbstractAnnotation;

#[Attribute(Attribute::TARGET_METHOD)]
class Validation extends AbstractAnnotation
{
    public function __construct(public array $rules = [], public array $messages = [], public string $formRequest = '', public string $scene = '', public bool $resolve = true)
    {
    }
}

切面

// app/Annotation/Grpc/ValidationAspect.php

namespace App\Annotation\Grpc;

use Google\Protobuf\Internal\Message;
use Hyperf\Context\Context;
use Hyperf\Contract\ValidatorInterface;
use Hyperf\Di\Annotation\Aspect;
use Hyperf\Di\Aop\AbstractAspect;
use Hyperf\Di\Aop\ProceedingJoinPoint;
use Hyperf\Validation\Contract\ValidatorFactoryInterface;
use Hyperf\Validation\Request\FormRequest;
use Psr\Container\ContainerInterface;
use ReflectionProperty;

#[Aspect()]
class ValidationAspect extends AbstractAspect
{
    public array $annotations = [
        Validation::class,
    ];

    public function __construct(protected ContainerInterface $container, protected ValidatorFactoryInterface $validatorFactory)
    {
    }

    public function process(ProceedingJoinPoint $proceedingJoinPoint)
    {
        [$rules, $messages, $resolve] = $this->getValidationRules($proceedingJoinPoint);
        $protobufMessage = $this->getProtobufMessage($proceedingJoinPoint);

        if (
            $rules
            && $protobufMessage
            && $data = $this->convertProtobufMessageToArray($protobufMessage)
        ) {
            Context::set(get_class($protobufMessage), $data);
            $validator = $this->validatorFactory->make($data, $rules, $messages);
            Context::set(ValidatorInterface::class, $validator);

            if ($resolve && $validator->fails()) {
                throw new ValidationException($validator->errors()->first());
            }
        }

        return $proceedingJoinPoint->process();
    }

    protected function getValidationRules(ProceedingJoinPoint $proceedingJoinPoint): array
    {
        $metadata = $proceedingJoinPoint->getAnnotationMetadata();
        /** @var Validation $annotation */
        $annotation = $metadata->method[Validation::class] ?? null;

        if (! $annotation) {
            return [null, null, false];
        }

        if ($annotation->formRequest && $this->container->has($annotation->formRequest)) {
            $scene = $annotation->scene ?: $proceedingJoinPoint->methodName;
            /** @var FormRequest $formRequest */
            $formRequest = $this->container->get($annotation->formRequest)->scene($scene);
            $rules = $formRequest->rules();
            $messages = $formRequest->messages();
        } else {
            $rules = $annotation->rules;
            $messages = $annotation->messages;
        }

        return [$rules, $messages, $annotation->resolve];
    }

    protected function getProtobufMessage(ProceedingJoinPoint $proceedingJoinPoint): ?Message
    {
        foreach ($proceedingJoinPoint->getArguments() as $argument) {
            if ($argument instanceof Message) {
                return $argument;
            }
        }

        return null;
    }

    protected function convertProtobufMessageToArray(Message $message): array
    {
        $array = [];
        $reflect = new \ReflectionObject($message);
        $props = $reflect->getProperties(ReflectionProperty::IS_PROTECTED);

        foreach ($props as $prop) {
            $prop->setAccessible(true);

            $name = $prop->getName();
            $value = $prop->getValue($message);

            if ($value instanceof Message) {
                $array[$name] = $this->convertProtobufMessageToArray($value);
            } else {
                $array[$name] = $value;
            }
        }

        return $array;
    }
}

异常类

// app/Annotation/Grpc/ValidationException.php

namespace App\Annotation\Grpc;

class ValidationException extends \Exception
{
    public function __construct(string $message, int $code = 422, \Throwable $previous = null)
    {
        parent::__construct($message, $code, $previous);
    }
}