refactor from AOP to interceptor & change javadoc

Author: anjeyy

grpc-server-spring-boot-autoconfigure/build.gradle

@@ -16,16 +16,12 @@ dependencies {
     api project(':grpc-common-spring-boot')
     api 'org.springframework.boot:spring-boot-starter'
     optionalSupportImplementation 'org.springframework.boot:spring-boot-starter-actuator'
-    optionalSupportImplementation 'org.springframework.boot:spring-boot-starter-aop'
     optionalSupportImplementation 'org.springframework.security:spring-security-core'
     optionalSupportImplementation 'org.springframework.cloud:spring-cloud-starter-sleuth'
     optionalSupportImplementation 'org.springframework.cloud:spring-cloud-starter-consul-discovery'
     optionalSupportImplementation 'org.springframework.cloud:spring-cloud-starter-netflix-eureka-client'
     optionalSupportImplementation "com.alibaba.cloud:spring-cloud-starter-alibaba-nacos-discovery:${springCloudAlibabaNacosVersion}"
-    // Only needed to avoid some warnings during compilation (for eureka)
-    optionalSupportImplementation 'com.google.inject:guice:4.2.3'
-    optionalSupportImplementation 'io.zipkin.brave:brave-instrumentation-grpc'
-    optionalSupportApi 'io.grpc:grpc-netty'
+    optionalSupportImplementation 'com.google.inject:guice:4.2.3' // Only needed to avoid some warnings during compilation (for eureka)
     api 'io.grpc:grpc-netty-shaded'
     api 'io.grpc:grpc-protobuf'
     api 'io.grpc:grpc-stub'
@@ -39,6 +35,5 @@ dependencies {
         exclude module: 'junit'
     }
 
-    runtimeOnly 'org.aspectj:aspectjweaver'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
 }

grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/service/exceptionhandling/GrpcServiceAdvice.java renamed to grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/advice/GrpcAdvice.java

@@ -15,7 +15,7 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package net.devh.boot.grpc.server.service.exceptionhandling;
+package net.devh.boot.grpc.server.advice;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
@@ -26,19 +26,19 @@
 import org.springframework.stereotype.Component;
 
 /**
- * Special {@link Component @Component} to declare {@link GrpcExceptionHandler GrpcException Handling}.
+ * Special {@link Component @Component} to declare global gRPC exception handling.
  * 
- * Every class annotated with {@link GrpcServiceAdvice @GrpcServiceAdvice} is marked to be scanned for
+ * Every class annotated with {@link GrpcAdvice @GrpcAdvice} is marked to be scanned for
  * {@link GrpcExceptionHandler @GrpcExceptionHandler} annotations.
+ * <p>
  * 
  * @author Andjelko Perisic ([email protected])
- * 
  * @see GrpcExceptionHandler
  */
 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Component
-public @interface GrpcServiceAdvice {
+public @interface GrpcAdvice {
 
 }

grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/service/exceptionhandling/GrpcServiceAdviceDiscoverer.java renamed to grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/advice/GrpcAdviceDiscoverer.java

@@ -15,7 +15,7 @@
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-package net.devh.boot.grpc.server.service.exceptionhandling;
+package net.devh.boot.grpc.server.advice;
 
 import java.lang.reflect.Method;
 import java.util.Arrays;
@@ -28,66 +28,70 @@
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
+import org.springframework.util.Assert;
 
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * A discovery class to find all Beans annotated with {@link GrpcServiceAdvice @GrpcServiceAdvice} and for all found
- * beans a second search is performed looking for methods with {@link GrpcExceptionHandler @GrpcExceptionHandler}.<br>
- * <br>
+ * A discovery class to find all Beans annotated with {@link GrpcAdvice @GrpcAdvice} and for all found beans a second
+ * search is performed looking for methods with {@link GrpcExceptionHandler @GrpcExceptionHandler}.<br>
+ * <p>
  * 
  * @author Andjelko Perisic ([email protected])
- * @see GrpcServiceAdvice
+ * @see GrpcAdvice
  * @see GrpcExceptionHandler
  */
 @Slf4j
-public class GrpcServiceAdviceDiscoverer implements InitializingBean, ApplicationContextAware {
+public class GrpcAdviceDiscoverer implements InitializingBean, ApplicationContextAware {
 
     private ApplicationContext applicationContext;
     private Map<String, Object> annotatedBeans;
     private Set<Class<?>> annotatedClasses;
     private Set<Method> annotatedMethods;
 
 
-    Map<String, Object> getAnnotatedBeans() {
-        return annotatedBeans;
-    }
-
-    Set<Method> getAnnotatedMethods() {
-        return annotatedMethods;
-    }
-
-
     @Override
     public void afterPropertiesSet() throws Exception {
 
-        annotatedBeans = applicationContext.getBeansWithAnnotation(GrpcServiceAdvice.class);
-        annotatedClasses = findAllAnnotatedClasses();
-        annotatedMethods = getAnnotatedMethods(annotatedClasses);
+        annotatedBeans = applicationContext.getBeansWithAnnotation(GrpcAdvice.class);
+        annotatedClasses = extractClassType();
+        annotatedMethods = findAnnotatedMethods();
     }
 
-    private Set<Class<?>> findAllAnnotatedClasses() {
+    private Set<Class<?>> extractClassType() {
         return annotatedBeans.values()
                 .stream()
                 .map(Object::getClass)
                 .collect(Collectors.toSet());
     }
 
-    private Set<Method> getAnnotatedMethods(Set<Class<?>> annotatedClasses) {
+    private Set<Method> findAnnotatedMethods() {
         Function<Class<?>, Stream<Method>> extractMethodsFromClass = clazz -> Arrays.stream(clazz.getDeclaredMethods());
         return annotatedClasses.stream()
                 .flatMap(extractMethodsFromClass)
                 .filter(method -> method.isAnnotationPresent(GrpcExceptionHandler.class))
                 .collect(Collectors.toSet());
     }
 
+    @Override
+    public void setApplicationContext(final ApplicationContext applicationContext) {
+        this.applicationContext = applicationContext;
+    }
+
     boolean isAnnotationPresent() {
 
         return !annotatedClasses.isEmpty() && !annotatedMethods.isEmpty();
     }
 
-    @Override
-    public void setApplicationContext(final ApplicationContext applicationContext) {
-        this.applicationContext = applicationContext;
+    Map<String, Object> getAnnotatedBeans() {
+        Assert.state(annotatedBeans != null, "@GrpcAdvice annotation scanning failed.");
+        return annotatedBeans;
     }
+
+    Set<Method> getAnnotatedMethods() {
+        Assert.state(annotatedMethods != null, "@GrpcExceptionHandler annotation scanning failed.");
+        return annotatedMethods;
+    }
+
+
 }

grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/advice/GrpcAdviceExceptionHandler.java

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2016-2020 Michael Zhang <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package net.devh.boot.grpc.server.advice;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.lang.reflect.Type;
+import java.util.Map.Entry;
+
+import org.aspectj.lang.annotation.Aspect;
+import org.springframework.lang.Nullable;
+
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * As part of {@link GrpcAdvice @GrpcAdvice}, when a thrown exception is caught during gRPC calls (via global
+ * interceptor {@link GrpcAdviceExceptionInterceptor}, then this thrown exception is being handled. By
+ * {@link GrpcExceptionHandlerMethodResolver} is a mapping between exception and the in case to be executed method
+ * provided. <br>
+ * Returned object is declared in {@link GrpcAdvice @GrpcAdvice} classes with annotated methods
+ * {@link GrpcExceptionHandler @GrpcExceptionHandler}.
+ * <p>
+ *
+ * @author Andjelko Perisic ([email protected])
+ * @see GrpcExceptionHandlerMethodResolver
+ * @see GrpcAdviceExceptionInterceptor
+ */
+@Slf4j
+@Aspect
+public class GrpcAdviceExceptionHandler {
+
+    private final GrpcExceptionHandlerMethodResolver grpcExceptionHandlerMethodResolver;
+
+    public GrpcAdviceExceptionHandler(
+            final GrpcExceptionHandlerMethodResolver grpcExceptionHandlerMethodResolver) {
+        this.grpcExceptionHandlerMethodResolver = grpcExceptionHandlerMethodResolver;
+    }
+
+    /**
+     * Given an exception, a lookup is performed to retrieve mapped method. <br>
+     * In case of successful returned method, and matching exception parameter type for given exception, the exception
+     * is handed over to retrieved method. Retrieved method is then being invoked.
+     * 
+     * @param exception exception to search for
+     * @param <E> type of exception
+     * @return result of invoked mapped method to given exception
+     * @throws Throwable rethrows exception if no mapping existent or exceptions raised by implementation
+     */
+    @Nullable
+    public <E extends Throwable> Object handleThrownException(E exception) throws Throwable {
+
+        final Class<? extends Throwable> exceptionClass = exception.getClass();
+        boolean exceptionIsMapped =
+                grpcExceptionHandlerMethodResolver.isMethodMappedForException(exceptionClass);
+        if (!exceptionIsMapped) {
+            throw exception;
+        }
+
+        Entry<Object, Method> methodWithInstance =
+                grpcExceptionHandlerMethodResolver.resolveMethodWithInstance(exceptionClass);
+        Method mappedMethod = methodWithInstance.getValue();
+        Object instanceOfMappedMethod = methodWithInstance.getKey();
+        Object[] instancedParams = determineInstancedParameters(mappedMethod, exception);
+
+        return invokeMappedMethodSafely(mappedMethod, instanceOfMappedMethod, instancedParams);
+    }
+
+    private <E extends Throwable> Object[] determineInstancedParameters(Method mappedMethod, E exception) {
+
+        Parameter[] parameters = mappedMethod.getParameters();
+        Object[] instancedParams = new Object[parameters.length];
+
+        for (int i = 0; i < parameters.length; i++) {
+            Class<?> parameterClass = convertToClass(parameters[i]);
+            if (parameterClass.isAssignableFrom(exception.getClass())) {
+                instancedParams[i] = exception;
+                break;
+            }
+        }
+        return instancedParams;
+    }
+
+    private Class<?> convertToClass(Parameter parameter) {
+        Type paramType = parameter.getParameterizedType();
+        if (paramType instanceof Class) {
+            return (Class<?>) paramType;
+        }
+        throw new IllegalStateException("Parameter type of method has to be from Class, it was: " + paramType);
+    }
+
+    private Object invokeMappedMethodSafely(
+            Method mappedMethod,
+            Object instanceOfMappedMethod,
+            Object[] instancedParams) throws Throwable {
+        Object statusThrowable = null;
+        try {
+            statusThrowable = mappedMethod.invoke(instanceOfMappedMethod, instancedParams);
+        } catch (InvocationTargetException | IllegalAccessException e) {
+            throw e.getCause(); // throw the exception thrown by implementation
+        }
+        return statusThrowable;
+    }
+
+}

grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/advice/GrpcAdviceExceptionInterceptor.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2016-2020 Michael Zhang <[email protected]>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+ * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package net.devh.boot.grpc.server.advice;
+
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCall.Listener;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+
+/**
+ * Interceptor to use for global exception handling. Every raised {@link Throwable} is caught and being processed.
+ * Actual processing of exception is in {@link GrpcAdviceExceptionListener}.
+ * <p>
+ * 
+ * @author Andjelko Perisic ([email protected])
+ * @see GrpcAdviceExceptionHandler
+ * @see GrpcAdviceExceptionListener
+ */
+public class GrpcAdviceExceptionInterceptor implements ServerInterceptor {
+
+    private final GrpcAdviceExceptionHandler grpcAdviceExceptionHandler;
+
+    public GrpcAdviceExceptionInterceptor(final GrpcAdviceExceptionHandler grpcAdviceExceptionHandler) {
+        this.grpcAdviceExceptionHandler = grpcAdviceExceptionHandler;
+    }
+
+    @Override
+    public <ReqT, RespT> Listener<ReqT> interceptCall(
+            ServerCall<ReqT, RespT> call,
+            Metadata headers,
+            ServerCallHandler<ReqT, RespT> next) {
+        Listener<ReqT> delegate = next.startCall(call, headers);
+        return new GrpcAdviceExceptionListener<>(delegate, call, grpcAdviceExceptionHandler);
+    }
+
+}