check for superclass of thrown exception

Author: anjeyy

grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/service/exceptionhandling/GrpcExceptionAspect.java

@@ -75,9 +75,12 @@ public <E extends Throwable> void handleExceptionInsideGrpcService(JoinPoint joi
         log.error("Exception caught during gRPC service execution: ", exception);
         this.exception = exception;
 
-        if (!grpcExceptionHandlerMethodResolver.isMethodMappedForException(exception.getClass())) {
+        boolean exceptionIsMapped =
+                grpcExceptionHandlerMethodResolver.isMethodMappedForException(exception.getClass());
+        if (!exceptionIsMapped) {
             return;
         }
+
         extractNecessaryInformation();
         Throwable throwable = invokeMappedMethodSafely();
         closeStreamObserverOnError(joinPoint.getArgs(), throwable);
@@ -118,7 +121,7 @@ private Object[] determineInstancedParameters(Method mappedMethod) {
 
         for (int i = 0; i < parameters.length; i++) {
             Class<?> parameterClass = convertToClass(parameters[i]);
-            if (parameterClass.equals(exception.getClass())) {
+            if (parameterClass.isAssignableFrom(exception.getClass())) {
                 instancedParams[i] = exception;
                 break;
             }
@@ -139,7 +142,7 @@ private Throwable castToThrowable(Object statusThrowable) {
                 .filter(thrbl -> thrbl instanceof Throwable)
                 .map(thrbl -> (Throwable) thrbl)
                 .orElseThrow(() -> new IllegalStateException(
-                        "Return type has to beo f type java.lang.Throable: " + statusThrowable));
+                        "Return type has to be of type java.lang.Throwable: " + statusThrowable));
     }
 
     private void closeStreamObserverOnError(Object[] joinPointParams, Throwable throwable) {

grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/service/exceptionhandling/GrpcExceptionHandlerMethodResolver.java

@@ -22,7 +22,6 @@
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -98,7 +97,7 @@ private void checkParamTypesAreAlignedToExceptionTypes(Method method) {
     private Class<? extends Throwable>[] checkForExceptionType(Class<?>[] methodParamTypes) {
 
         for (Class<?> methodParamType : methodParamTypes) {
-            if (!RuntimeException.class.isAssignableFrom(methodParamType)) {
+            if (!Throwable.class.isAssignableFrom(methodParamType)) {
                 throw new IllegalStateException("Annotated Class is not of Type Throwable: " + methodParamType);
             }
         }
@@ -135,22 +134,34 @@ private void addExceptionMapping(Class<? extends Throwable> exceptionType, Metho
         }
     }
 
-    <E extends Throwable> boolean isMethodMappedForException(Class<E> exception) {
-        return mappedMethods.get(exception) != null;
-    }
 
-    Map.Entry<Object, Method> resolveMethodWithInstance(Class<? extends Throwable> exceptionType) {
+    public <E extends Throwable> Map.Entry<Object, Method> resolveMethodWithInstance(Class<E> exceptionType) {
+
+        Method value = extractExtendedThrowable(exceptionType);
+        if (value == null) {
+            return new SimpleImmutableEntry<>(null, null);
+        }
 
-        Method value = mappedMethods.get(exceptionType);
-        Class<?> methodClass = Optional.ofNullable(value).map(Method::getDeclaringClass).orElse(null);
+        Class<?> methodClass = value.getDeclaringClass();
         Object key = annotatedBeans.values()
                 .stream()
-                .filter(obj -> obj.getClass().equals(methodClass))
+                .filter(obj -> methodClass.isAssignableFrom(obj.getClass()))
                 .findFirst()
                 .orElse(null);
-
         return new SimpleImmutableEntry<>(key, value);
     }
 
+    public <E extends Throwable> boolean isMethodMappedForException(Class<E> exception) {
+        return extractExtendedThrowable(exception) != null;
+    }
+
+    private <E extends Throwable> Method extractExtendedThrowable(Class<E> exception) {
+        return mappedMethods.keySet()
+                .stream().filter(clazz -> clazz.isAssignableFrom(exception))
+                .findAny()
+                .map(mappedMethods::get)
+                .orElse(null);
+    }
+
 
 }

grpc-server-spring-boot-autoconfigure/src/main/java/net/devh/boot/grpc/server/service/exceptionhandling/MethodExecutionException.java

@@ -1,3 +1,19 @@
+/*
+ * 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.service.exceptionhandling;