+ * Example usage: + *
+ * {@code
+ * public class MyRequestValidator implements BaseValidator {
+ * public void validateMyRequest(MyRequest request) {
+ * // Business validation
+ * }
+ * }
+ * }
+ *
+ *
+ */
+public interface BaseValidator {
+
+ /**
+ * Validates the provided request object using the Envoy Proxy Protoc-Gen-Validate library.
+ * + * This method uses the {@link ValidatorIndex} (specifically the {@link ReflectiveValidatorIndex}) to look up + * the appropriate validator for the request's class and performs validation. If the request is invalid, a + * {@link StatusRuntimeException} with a {@link Status} status is thrown, including details + * of the validation failure. + *
+ * + * @param request the request object to validate + * @param+ * Usage Example: + *
+ * + *
+ * {@code @GrpcValidator(requestClass = MyRequest.class, validatorClass = MyRequestValidator.class, validatorMethod = "validateRequest")
+ * public void myGrpcMethod(MyRequest request) {
+ * // Your gRPC method implementation
+ * }
+ * }
+ *
+ *
+ * + * In this example, the annotation tells the system to use the {@code MyRequestValidator} class and call its + * {@code validateRequest} method to validate the incoming {@code MyRequest}. + *
+ */ +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +@Documented +@Component +public @interface GrpcValidator { + + /** + * The request class that will be validated. + * + *+ * This represents the type of the gRPC request that needs validation. The validator will perform checks based on + * this class. + *
+ * + * @return the class type of the gRPC request + */ + Class requestClass(); + + /** + * The validator class that contains the validation logic. + * + *+ * This class is responsible for validating the request class. It should provide the validation method specified by + * {@link #validatorMethod()}. + *
+ * + * @return the class type of the validator + */ + Class validatorClass(); + + /** + * The name of the method in the validator class that performs the validation. + * + *+ * This method is invoked at runtime to perform the validation logic on the request class. It should take the + * request class type as an argument and return a validation result, typically a boolean or a validation exception. + *
+ * + * @return the name of the validation method + */ + String validatorMethod(); +} diff --git a/grpc-server-spring-boot-starter/src/main/java/net/devh/boot/grpc/server/validator/GrpcValidatorDiscoverer.java b/grpc-server-spring-boot-starter/src/main/java/net/devh/boot/grpc/server/validator/GrpcValidatorDiscoverer.java new file mode 100644 index 000000000..52a7a748e --- /dev/null +++ b/grpc-server-spring-boot-starter/src/main/java/net/devh/boot/grpc/server/validator/GrpcValidatorDiscoverer.java @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2016-2025 The gRPC-Spring Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.devh.boot.grpc.server.validator; + +import java.util.Arrays; +import java.util.Map; +import java.util.stream.Collectors; + +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationContextAware; +import org.springframework.stereotype.Component; +import org.springframework.stereotype.Service; + +import com.netflix.discovery.shared.Pair; + +import jakarta.annotation.PostConstruct; +import lombok.Getter; +import lombok.extern.slf4j.Slf4j; + +/** + * The {@code GrpcValidatorDiscoverer} class is responsible for discovering and registering gRPC validators + * in the Spring application context based on custom annotations. + * + * @author Pritesh (priteshdpawar53@gmail.com) + * @since 02/10/25 + * + *+ * Example usage: If a service contains a method annotated with {@link GrpcValidator} for a specific request class, + * the {@code GrpcValidatorDiscoverer} will discover this method and register it in the map so that it can later be + * used for validation during gRPC request processing. + *
+ */ +@Slf4j +@Component +public class GrpcValidatorDiscoverer implements ApplicationContextAware { + + private ApplicationContext applicationContext; + + /** + * A map of request classes to their corresponding validator bean and method. + * The map is populated during the initialization phase using the {@link GrpcValidator} annotation. + * The key is the request class, and the value is a {@link Pair} containing the validator bean and method name. + */ + @Getter + private Map+ * It collects the mapping between request classes and their corresponding validator beans and methods, + * storing it in the {@link #requestValidatorMethodMap} field. + *
+ *+ * This method is executed after the bean has been initialized (as indicated by the {@link PostConstruct} annotation), + * and it logs the initialization status and the resulting map of validators. + *
+ */ + @PostConstruct + public void init() { + log.info("Initializing registration of GrpcValidator annotation"); + + // Discover beans annotated with @Service and their methods annotated with @GrpcValidator + requestValidatorMethodMap = applicationContext.getBeansWithAnnotation(Service.class).values().stream() + .flatMap(bean -> Arrays.stream(bean.getClass().getDeclaredMethods())) // Flatten the methods in the bean + .filter(method -> method.isAnnotationPresent(GrpcValidator.class)) // Filter methods annotated with @GrpcValidator + .map(method -> { + GrpcValidator validator = method.getAnnotation(GrpcValidator.class); + Object validatorBean = applicationContext.getBean(validator.validatorClass()); // Retrieve the validator bean from the context + return new Pair<>(validator.requestClass(), new Pair<>(validatorBean, validator.validatorMethod())); // Return a pair of the request class and the validator info + }) + .collect(Collectors.toMap(Pair::first, Pair::second)); // Collect into a map: request class -> (validator bean, method name) + + log.info("Request to validator map instantiated: {}", requestValidatorMethodMap); + } +} diff --git a/grpc-server-spring-boot-starter/src/main/java/net/devh/boot/grpc/server/validator/RequestValidatingInterceptor.java b/grpc-server-spring-boot-starter/src/main/java/net/devh/boot/grpc/server/validator/RequestValidatingInterceptor.java new file mode 100644 index 000000000..2af944e16 --- /dev/null +++ b/grpc-server-spring-boot-starter/src/main/java/net/devh/boot/grpc/server/validator/RequestValidatingInterceptor.java @@ -0,0 +1,132 @@ +/* + * Copyright (c) 2016-2025 The gRPC-Spring Authors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package net.devh.boot.grpc.server.validator; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.Map; + +import com.alibaba.nacos.common.utils.MapUtil; +import com.netflix.discovery.shared.Pair; + +import io.grpc.*; +import lombok.extern.slf4j.Slf4j; +import net.devh.boot.grpc.common.util.InterceptorOrder; +import net.devh.boot.grpc.server.interceptor.GrpcGlobalServerInterceptor; +import org.springframework.core.annotation.Order; + +/** + * {@code RequestValidatingInterceptor} is a gRPC server interceptor that validates incoming requests using the + * {@link BaseValidator} interface and performs custom validations as defined by {@link GrpcValidator}. + *+ * This interceptor is registered globally using the {@link GrpcGlobalServerInterceptor} annotation and is invoked + * for every gRPC call on the server. It first validates the request using the base validation logic provided + * by the {@link BaseValidator} interface, and then it performs additional custom validation based on the + * {@link GrpcValidator} annotations discovered by the {@link GrpcValidatorDiscoverer}. + *
+ * + * @author Pritesh (priteshdpawar53@gmail.com) + * @since 02/10/25 + */ +@GrpcGlobalServerInterceptor +@Order(InterceptorOrder.REQUEST_VALIDATION) +@Slf4j +public class RequestValidatingInterceptor implements ServerInterceptor, BaseValidator { + + private final GrpcValidatorDiscoverer validatorDiscoverer; + + /** + * Constructs a new {@code RequestValidatingInterceptor} with the given {@link GrpcValidatorDiscoverer}. + * The {@link GrpcValidatorDiscoverer} is used to discover and retrieve custom validators for request classes. + * + * @param validatorDiscoverer the {@link GrpcValidatorDiscoverer} used for discovering validators + */ + public RequestValidatingInterceptor(GrpcValidatorDiscoverer validatorDiscoverer) { + this.validatorDiscoverer = validatorDiscoverer; + } + + /** + * Intercepts an incoming gRPC request and performs validation on the message. + *+ * This method is called when a request is received. It first validates the request using the base validation + * provided by {@link BaseValidator}, and then it performs custom validation as defined by the + * {@link GrpcValidator} annotations on methods in service beans. + *
+ * + * @param+ * If a custom validation method is found for the given message's class, it invokes the validator method on the + * corresponding validator bean. + *
+ * + * @param message the request message to validate + * @param