fixes #117

Author: Alexander Furer

grpc-spring-boot-starter-demo/src/test/java/org/lognet/springboot/grpc/OrderedInterceptorsTest.java

@@ -14,8 +14,8 @@
 import org.lognet.springboot.grpc.demo.DemoApp;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.boot.test.context.TestConfiguration;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
 import org.springframework.core.Ordered;
 import org.springframework.core.annotation.Order;
 import org.springframework.test.context.junit4.SpringRunner;
@@ -55,12 +55,12 @@ protected GreeterGrpc.GreeterFutureStub beforeGreeting(GreeterGrpc.GreeterFuture
 
   @Override
   protected void afterGreeting() {
-    assertThat(calledInterceptors).containsExactly(1, 2, 3, 4,5,6, 10, 100);
+    assertThat(calledInterceptors).containsExactly(1, 2, 3, 4,5,6, 7,10,10, 100);
   }
 
 
 
-  @Configuration
+  @TestConfiguration
   public static class TheConfiguration {
 
 
@@ -155,6 +155,34 @@ public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
       }
     }
 
+    @Bean
+    @GRpcGlobalInterceptor
+    @Order(7)
+    public  ServerInterceptor mySeventhInterceptor(){
+      return  new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+            calledInterceptors.add(7);
+            return next.startCall(call, headers);
+
+        }
+      };
+    }
+
+    @Bean
+    @GRpcGlobalInterceptor
+    @Order
+    public  ServerInterceptor myOrderedMethodFactoryBeanInterceptor(){
+      return  new ServerInterceptor() {
+        @Override
+        public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
+          calledInterceptors.add(10);
+          return next.startCall(call, headers);
+
+        }
+      };
+    }
+
     @Bean
     @GRpcGlobalInterceptor
     public  ServerInterceptor myInterceptor(){

grpc-spring-boot-starter/src/main/java/org/lognet/springboot/grpc/GRpcServerRunner.java

@@ -1,6 +1,11 @@
 package org.lognet.springboot.grpc;
 
-import io.grpc.*;
+import io.grpc.BindableService;
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.ServerInterceptor;
+import io.grpc.ServerInterceptors;
+import io.grpc.ServerServiceDefinition;
 import io.grpc.health.v1.HealthCheckResponse;
 import io.grpc.protobuf.services.ProtoReflectionService;
 import io.grpc.services.HealthStatusManager;
@@ -11,20 +16,22 @@
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.RootBeanDefinition;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.context.support.AbstractApplicationContext;
 import org.springframework.core.annotation.AnnotationAwareOrderComparator;
-import org.springframework.core.annotation.AnnotationUtils;
-import org.springframework.core.annotation.Order;
 import org.springframework.core.type.AnnotatedTypeMetadata;
 
 import java.lang.annotation.Annotation;
-import java.lang.reflect.Method;
-import java.util.*;
-import java.util.concurrent.TimeUnit;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
-import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -90,7 +97,7 @@ public void run(String... args) throws Exception {
 
         configurator.accept(serverBuilder);
         server = serverBuilder.build().start();
-        applicationContext.publishEvent(new GRpcServerInitializedEvent(applicationContext,server));
+        applicationContext.publishEvent(new GRpcServerInitializedEvent(applicationContext, server));
 
         log.info("gRPC Server started, listening on port {}.", server.getPort());
         startDaemonAwaitThread();
@@ -103,8 +110,7 @@ private ServerServiceDefinition bindInterceptors(ServerServiceDefinition service
                 .map(interceptorClass -> {
                     try {
                         return 0 < applicationContext.getBeanNamesForType(interceptorClass).length ?
-                                applicationContext.getBean(interceptorClass) :
-                                interceptorClass.newInstance();
+                                applicationContext.getBean(interceptorClass) : interceptorClass.newInstance();
                     } catch (Exception e) {
                         throw new BeanCreationException("Failed to create interceptor instance.", e);
                     }
@@ -120,26 +126,34 @@ private ServerServiceDefinition bindInterceptors(ServerServiceDefinition service
     }
 
     private Comparator<Object> serverInterceptorOrderComparator() {
-        Function<Object,Boolean> isOrderAnnotated = obj->{
-            Order ann = obj instanceof Method ? AnnotationUtils.findAnnotation((Method) obj, Order.class) :
-                    AnnotationUtils.findAnnotation(obj.getClass(), Order.class);
-            return ann != null;
-        };
-        return AnnotationAwareOrderComparator.INSTANCE.thenComparing((o1, o2) -> {
-            boolean p1 = isOrderAnnotated.apply(o1);
-            boolean p2 = isOrderAnnotated.apply(o2);
-            return p1 && !p2 ? -1 : p2 && !p1 ? 1 : 0;
-        }).reversed();
+        return new AnnotationAwareOrderComparator()
+                .withSourceProvider(o -> {
+                    List<Object> sources = new ArrayList<>(2);
+                    final Optional<RootBeanDefinition> rootBeanDefinition = Stream.of(applicationContext.getBeanNamesForType(o.getClass()))
+                            .findFirst()
+                            .map(name -> applicationContext.getBeanFactory().getBeanDefinition(name))
+                            .filter(RootBeanDefinition.class::isInstance)
+                            .map(RootBeanDefinition.class::cast);
+
+                            rootBeanDefinition.map(RootBeanDefinition::getResolvedFactoryMethod)
+                                    .ifPresent(sources::add);
+
+                            rootBeanDefinition.map(RootBeanDefinition::getTargetType)
+                                    .filter(t -> t != o.getClass())
+                                    .ifPresent(sources::add);
+
+                    return sources.toArray();
+                }).reversed();
     }
 
     private void startDaemonAwaitThread() {
-        Thread awaitThread = new Thread(()->{
-                try {
-                    latch.await();
-                } catch (InterruptedException e) {
-                    log.error("gRPC server awaiter interrupted.", e);
-                }
-            });
+        Thread awaitThread = new Thread(() -> {
+            try {
+                latch.await();
+            } catch (InterruptedException e) {
+                log.error("gRPC server awaiter interrupted.", e);
+            }
+        });
         awaitThread.setName("grpc-server-awaiter");
         awaitThread.setDaemon(false);
         awaitThread.start();
@@ -148,9 +162,9 @@ private void startDaemonAwaitThread() {
     @Override
     public void destroy() throws Exception {
 
-        Optional.ofNullable(server).ifPresent(s->{
+        Optional.ofNullable(server).ifPresent(s -> {
             log.info("Shutting down gRPC server ...");
-            s.getServices().forEach(def->healthStatusManager.clearStatus(def.getServiceDescriptor().getName()));
+            s.getServices().forEach(def -> healthStatusManager.clearStatus(def.getServiceDescriptor().getName()));
             s.shutdown();
             int shutdownGrace = gRpcServerProperties.getShutdownGrace();
             try {