dubbo参数校验ValidationFilter使用与说明

import com.alibaba.fastjson2.JSON;
import org.apache.dubbo.common.constants.CommonConstants;
import org.apache.dubbo.common.extension.Activate;
import org.apache.dubbo.rpc.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

// 使用@Activate注解指定Filter生效场景
// order属性控制执行顺序，值越小，优先级越高
@Activate(group = {CommonConstants.CONSUMER, CommonConstants.PROVIDER}, order = 10001)
public class CustomFilter implements Filter {
    private Logger logger = LoggerFactory.getLogger(CustomFilter.class);
    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        logger.info("invoker invoked method {} {} {} {}",
                invocation.getMethodName(),
                JSON.toJSONString(invocation.getObjectAttachments()),
                invocation.getAttributes(),
                JSON.toJSONString(invocation.getArguments()));
        Result result = invoker.invoke(invocation);
        logger.info("invoker invoked result {}", JSON.toJSONString(result));
        return result;
    }
}

consumer=com.doudou.demo.filter.CustomFilter

 <!-- Bean Validation API -->
<dependency>
    <groupId>javax.validation</groupId>
    <artifactId>validation-api</artifactId>
    <version>2.0.1.Final</version>
</dependency>
<!-- Hibernate Validator实现 -->
<dependency>
    <groupId>org.hibernate.validator</groupId>
    <artifactId>hibernate-validator</artifactId>
    <version>6.2.5.Final</version>
</dependency>
<dependency>
    <groupId>org.glassfish</groupId>
    <artifactId>jakarta.el</artifactId> <!-- 适配EL表达式 -->
    <version>5.0.0-M1</version>
</dependency>

@Setter
@Getter
public class UserDTO implements Serializable {
    @NotBlank(message = "用户名不能为空")
    private String username;

    @Min(value = 18, message = "年龄必须大于18岁")
    private Integer age;

    @Email(message = "邮箱格式不合法")
    private String email;
}

public class BaseResult<T> {
    // 处理是否正确结束
    private boolean success;
    // 异常编码
    private Integer errorCode;
    // 异常描述
    private String errorMsg;
    // dubbo接口返回的结果
    private T data;
}    

public interface UserService {
    BaseResult<String> registerUser(UserDTO userDTO);
}

@DubboService(validation = "true")
public class UserServiceImpl implements UserService {

    @Override
    public BaseResult<String> registerUser(UserDTO userDTO) {
        return BaseResult.success("用户注册成功：" + userDTO.getUsername());
    }
}

public class ParameterVerificationResultFilter implements Filter {
    private Logger logger = LoggerFactory.getLogger(ParameterVerificationResultFilter.class);

    @Override
    public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
        Result result = invoker.invoke(invocation);
        // 处理出现异常
        if (result.hasException()) {
            Throwable exception = result.getException();
            // 是由参数校验失败抛出的异常
            if (exception instanceof ConstraintViolationException) {
                List<String> errors = ((ConstraintViolationException) exception).getConstraintViolations().stream()
                        .map(v -> v.getPropertyPath() + ": " + v.getMessage())
                        .collect(Collectors.toList());
                logger.info("---------------2---------------");
                logger.error(errors.toString());
                logger.info("---------------3---------------");
                // 将错误信息封装到返回结果中
                return AsyncRpcResult.newDefaultAsyncResult(BaseResult.fail(400, errors.toString()), invocation);
            }
        }
        return result;
    }
}

# 参数校验过滤器
validation=org.apache.dubbo.validation.filter.ValidationFilter
# 校验结果处理过滤器
parameterVerification=com.doudou.filter.ParameterVerificationResultFilter

dubbo:
	provider:
		filter: validation,parameterVerification

@RestController
public class UserServiceController {
    @DubboReference(validation = "true")
    private UserService userService;

    @PostMapping("/test")
    public BaseResult<String> test(@RequestBody UserDTO userDTO) {
        return userService.registerUser(userDTO);
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 处理RpcException异常
    @ExceptionHandler(RpcException.class)
    public ResponseEntity<BaseResult> handleValidationException(RpcException rpcException) {
        return ResponseEntity.badRequest().body(BaseResult.fail(403, rpcException.getLocalizedMessage()));
    }
}

public Result invoke(Invoker<?> invoker, Invocation invocation) throws RpcException {
   // 判断是否需要进行参数验证
    if (needValidate(invoker.getUrl(), invocation.getMethodName())) {
        try {
            // 通过url中的validation属性值获取验证器
            Validator validator = validation.getValidator(invoker.getUrl());
            if (validator != null) {
                // 获取到验证器时，进行参数验证
                validator.validate(
                        invocation.getMethodName(), invocation.getParameterTypes(), invocation.getArguments());
            }
        } catch (RpcException e) {
            // RpcException 异常直接抛出
            throw e;
        } catch (Throwable t) {
            // 非RpcException，封装到结果中返回
            return AsyncRpcResult.newDefaultAsyncResult(t, invocation);
        }
    }
    // 执行下一个过滤器的处理
    return invoker.invoke(invocation);
}

 /**
  * 是否需要进行参数验证
  */
 private boolean needValidate(URL url, String methodName) {
     return validation != null
             && !methodName.startsWith("$")
             && ConfigUtils.isNotEmpty(url.getMethodParameter(methodName, VALIDATION_KEY))
             && !"false".equalsIgnoreCase(url.getParameter(VALIDATION_KEY));
 }

@Override
public Validator getValidator(URL url) {
    // 使用url作为存储验证器map集合的的key
    String key = url.toFullString();
    // 从容器中获取验证器
    Validator validator = validators.get(key);
    // 判断验证器是否已经存在
    if (validator == null) {
        // 如果不存在，则创建
        validators.put(key, createValidator(url));
        validator = validators.get(key);
    }
    return validator;
}

@Activate(onClass = "javax.validation.Validation")
public class JValidation extends AbstractValidation {

    /**
     * Return new instance of {@link JValidator}
     * @param url Valid URL instance
     * @return Instance of JValidator
     */
    @Override
    protected Validator createValidator(URL url) {
        // 创建一个Dubbo框架默认的校验器
        return new JValidator(url);
    }
}