small refactoring

Author: anjeyy

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

@@ -108,8 +108,6 @@ public GrpcServiceDiscoverer defaultGrpcServiceDiscoverer() {
         return new AnnotationGrpcServiceDiscoverer();
     }
 
-    // TODO eventually insert @Conditional
-
     @ConditionalOnMissingBean
     @Bean
     public HealthStatusManager healthStatusManager() {

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

@@ -32,12 +32,14 @@
 import org.springframework.stereotype.Component;
 
 import io.grpc.stub.StreamObserver;
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
 /**
- * Exception handling for thrown {@link RuntimeException} inside gRPC service classes, which implements
- * {@link io.grpc.BindableService}.
+ * Exception handling for thrown {@link RuntimeException} inside annotated CLasses with
+ * {@link net.devh.boot.grpc.server.service.GrpcService @GrpcService}, which implement {@link io.grpc.BindableService}.
+ * <p>
+ * After calling the mapped Methods to the corresponding Exception, the returned {@link Throwable} is beeing send to the
+ * {@link io.grpc.stub.StreamObserver#onError(Throwable)}.
  * 
  * TODO...
  *
@@ -46,16 +48,19 @@
 @Slf4j
 @Aspect
 @Component
-@RequiredArgsConstructor
 @ConditionalOnBean(annotation = GrpcServiceAdvice.class)
 public class GrpcExceptionAspect {
 
-    private final GrpcExceptionHandlerMethodResolver exceptionHandlerMethodResolver;
+    private final GrpcExceptionHandlerMethodResolver grpcExceptionHandlerMethodResolver;
 
     private Throwable exception;
     private Method mappedMethod;
     private Object instanceOfMappedMethod;
 
+    public GrpcExceptionAspect(final GrpcExceptionHandlerMethodResolver grpcExceptionHandlerMethodResolver) {
+        this.grpcExceptionHandlerMethodResolver = grpcExceptionHandlerMethodResolver;
+    }
+
 
     @Pointcut("within(@net.devh.boot.grpc.server.service.GrpcService *)")
     void grpcServiceAnnotatedPointcut() {}
@@ -67,9 +72,12 @@ void implementedBindableServicePointcut() {}
             pointcut = "grpcServiceAnnotatedPointcut() && implementedBindableServicePointcut()",
             throwing = "exception")
     public <E extends Throwable> void handleExceptionInsideGrpcService(JoinPoint joinPoint, E exception) {
-        log.error("Runtimeexception caught during gRPC service execution: ", exception);
+        log.error("Exception caught during gRPC service execution: ", exception);
         this.exception = exception;
 
+        if (!grpcExceptionHandlerMethodResolver.isMethodMappedForException(exception.getClass())) {
+            return;
+        }
         extractNecessaryInformation();
         Throwable throwable = invokeMappedMethodSafely();
         closeStreamObserverOnError(joinPoint.getArgs(), throwable);
@@ -80,7 +88,7 @@ private void extractNecessaryInformation() {
         final Class<? extends Throwable> exceptionClass = exception.getClass();
 
         Entry<Object, Method> methodWithInstance =
-                exceptionHandlerMethodResolver.resolveMethodWithInstance(exceptionClass);
+                grpcExceptionHandlerMethodResolver.resolveMethodWithInstance(exceptionClass);
         mappedMethod =
                 Optional.of(methodWithInstance)
                         .map(Entry::getValue)
@@ -99,7 +107,7 @@ private Throwable invokeMappedMethodSafely() {
             Object statusThrowable = mappedMethod.invoke(instanceOfMappedMethod, instancedParams);
             return castToThrowable(statusThrowable);
         } catch (InvocationTargetException | IllegalAccessException e) {
-            throw new IllegalStateException("No mapped instance found for Exception " + exception);
+            throw new MethodExecutionException("Error during mapped exception method execution: ", e.getCause());
         }
     }
 

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

@@ -22,6 +22,7 @@
 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;
@@ -30,10 +31,9 @@
 import org.springframework.beans.factory.InitializingBean;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
 import org.springframework.context.ApplicationContext;
-import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Component;
 import org.springframework.util.Assert;
 
-import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 
 /**
@@ -42,19 +42,21 @@
  * @author Andjelko ([email protected])
  */
 @Slf4j
-@Configuration
-@RequiredArgsConstructor
+@Component
 @ConditionalOnBean(annotation = GrpcServiceAdvice.class)
-public class GrpcExceptionHandlerMethodResolver implements InitializingBean {
-
-    // TODO remove lombok
+class GrpcExceptionHandlerMethodResolver implements InitializingBean {
 
     private final Map<Class<? extends Throwable>, Method> mappedMethods = new HashMap<>(16);
     private final ApplicationContext applicationContext;
 
     private Class<? extends Throwable>[] annotatedExceptions;
     private Map<String, Object> annotatedBeans;
 
+
+    GrpcExceptionHandlerMethodResolver(final ApplicationContext applicationContext) {
+        this.applicationContext = applicationContext;
+    }
+
     @Override
     public void afterPropertiesSet() throws Exception {
         Set<Class<?>> annotatedClasses = findAllAnnotatedClasses();
@@ -100,6 +102,7 @@ private Class<? extends Throwable>[] checkForExceptionType(Class<?>[] methodPara
                 throw new IllegalStateException("Annotated Class is not of Type Throwable: " + methodParamType);
             }
         }
+        // safe to call, prior to the check above
         @SuppressWarnings("unchecked")
         Class<? extends Throwable>[] paramExceptionTypes = (Class<? extends Throwable>[]) methodParamTypes;
         return paramExceptionTypes;
@@ -132,12 +135,17 @@ 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 Map.Entry<Object, Method> resolveMethodWithInstance(Class<? extends Throwable> exceptionType) {
         Method value = mappedMethods.get(exceptionType);
+        Class<?> methodClass = Optional.ofNullable(value).map(Method::getDeclaringClass).orElse(null);
         Object key = annotatedBeans.values()
                 .stream()
-                .filter(obj -> obj.getClass().equals(value.getDeclaringClass()))
+                .filter(obj -> obj.getClass().equals(methodClass))
                 .findFirst()
                 .orElse(null);
 

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

@@ -0,0 +1,14 @@
+
+package net.devh.boot.grpc.server.service.exceptionhandling;
+
+/**
+ * TODO..
+ *
+ * @author Andjelko ([email protected])
+ */
+class MethodExecutionException extends RuntimeException {
+
+    MethodExecutionException(String msg, Throwable e) {
+        super(msg, e);
+    }
+}