fixes #28

Author: Alexander Furer

grpc-spring-boot-starter-demo/build.gradle

@@ -7,8 +7,11 @@ dependencies {
     compile "io.grpc:grpc-netty:${grpcVersion}"
     compile "org.springframework.boot:spring-boot-starter-actuator"
     compile 'org.springframework.boot:spring-boot-starter-web'
+
+
     compile project(':grpc-spring-boot-starter')
 
+    testCompile 'org.springframework.boot:spring-boot-starter-aop'
     testCompile('org.springframework.boot:spring-boot-starter-test')
 }
 sourceSets {

grpc-spring-boot-starter-demo/src/main/protoGen/io/grpc/examples/GreeterGrpc.java

@@ -1,19 +1,9 @@
 package io.grpc.examples;
 
-import static io.grpc.stub.ClientCalls.asyncUnaryCall;
-import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
-import static io.grpc.stub.ClientCalls.blockingUnaryCall;
-import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
-import static io.grpc.stub.ClientCalls.futureUnaryCall;
 import static io.grpc.MethodDescriptor.generateFullMethodName;
+import static io.grpc.stub.ClientCalls.*;
 import static io.grpc.stub.ServerCalls.asyncUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
-import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
 import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;
-import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
 
 /**
  * <pre>

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

@@ -0,0 +1,47 @@
+package org.lognet.springboot.grpc;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.lognet.springboot.grpc.demo.DemoApp;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.junit4.SpringRunner;
+
+import java.util.concurrent.ExecutionException;
+
+import static org.junit.Assert.assertTrue;
+import static org.springframework.boot.test.context.SpringBootTest.WebEnvironment.DEFINED_PORT;
+
+/**
+ * Created by alexf on 28-Jan-16.
+ */
+@RunWith(SpringRunner.class)
+@SpringBootTest(classes = {DemoApp.class },webEnvironment = DEFINED_PORT
+        ,properties = {"spring.aop.proxy-target-class=true"}
+)
+@ActiveProfiles(profiles = {"aopTest"})
+public class DemoAppTestAop {
+
+
+    @Autowired
+    private DemoApp.GreeterService greeterService;
+
+    @Autowired
+    private DemoApp.CalculatorService calculatorService;
+
+
+
+    @Test
+    public void simpleGreeting() throws ExecutionException, InterruptedException {
+
+        assertTrue(AopUtils.isAopProxy(greeterService));
+        assertTrue(AopUtils.isAopProxy(calculatorService));
+
+    }
+
+
+
+
+}

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

@@ -0,0 +1,30 @@
+package org.lognet.springboot.grpc.demo;
+
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.Aspect;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Component;
+
+/**
+ * Created by 310242212 on 01-Nov-16.
+ */
+
+@Aspect
+@Component
+@Profile(value = {"aopTest"})
+public class AopServiceMonitor {
+
+    public AopServiceMonitor() {
+    }
+
+    @AfterReturning("execution(* org.lognet..*Service.*(..))")
+    public void logServiceAccess( ) {
+        System.out.println("Completed: ");
+    }
+
+
+
+
+
+
+}

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

@@ -5,21 +5,16 @@
 import org.lognet.springboot.grpc.autoconfigure.GRpcServerProperties;
 import org.springframework.beans.factory.BeanCreationException;
 import org.springframework.beans.factory.DisposableBean;
-import org.springframework.beans.factory.InitializingBean;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.boot.CommandLineRunner;
-import org.springframework.context.ApplicationContext;
 import org.springframework.context.support.AbstractApplicationContext;
 import org.springframework.core.type.StandardMethodMetadata;
-import org.springframework.util.StreamUtils;
 
 import java.lang.annotation.Annotation;
 import java.util.Collection;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
-import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -29,6 +24,32 @@
 @Slf4j
 public class GRpcServerRunner implements CommandLineRunner,DisposableBean  {
 
+    private class   NamedBeanWrapper<T>{
+        private  T bean;
+        private String beanName;
+
+        public NamedBeanWrapper( String beanName,T bean) {
+            this.bean = bean;
+            this.beanName = beanName;
+        }
+
+        public T getBean() {
+            return bean;
+        }
+
+        public void setBean(T bean) {
+            this.bean = bean;
+        }
+
+        public String getBeanName() {
+            return beanName;
+        }
+
+        public void setBeanName(String beanName) {
+            this.beanName = beanName;
+        }
+    }
+
     @Autowired
     private AbstractApplicationContext applicationContext;
 
@@ -41,14 +62,17 @@ public class GRpcServerRunner implements CommandLineRunner,DisposableBean  {
     public void run(String... args) throws Exception {
         log.info("Starting gRPC Server ...");
 
-        Collection<ServerInterceptor> globalInterceptors = getTypedBeansWithAnnotation(GRpcGlobalInterceptor.class,ServerInterceptor.class);
+        Collection<ServerInterceptor> globalInterceptors = getTypedBeansWithAnnotation(GRpcGlobalInterceptor.class,ServerInterceptor.class)
+                .stream()
+                .map(NamedBeanWrapper::getBean)
+                .collect(Collectors.toList());
         final ServerBuilder<?> serverBuilder = ServerBuilder.forPort(gRpcServerProperties.getPort());
 
         // find and register all GRpcService-enabled beans
-        for(BindableService bindableService : getTypedBeansWithAnnotation(GRpcService.class,BindableService.class)) {
+        for(NamedBeanWrapper<BindableService> bindableService : getTypedBeansWithAnnotation(GRpcService.class,BindableService.class)) {
 
-                ServerServiceDefinition serviceDefinition = bindableService.bindService();
-                GRpcService gRpcServiceAnn = bindableService.getClass().getAnnotation(GRpcService.class);
+                ServerServiceDefinition serviceDefinition = bindableService.getBean().bindService();
+                GRpcService gRpcServiceAnn = applicationContext.findAnnotationOnBean(bindableService.getBeanName(),GRpcService.class);
                 serviceDefinition  = bindInterceptors(serviceDefinition,gRpcServiceAnn,globalInterceptors);
                 serverBuilder.addService(serviceDefinition);
                 log.info("'{}' service has been registered.", bindableService.getClass().getName());
@@ -107,7 +131,7 @@ public void destroy() throws Exception {
         log.info("gRPC server stopped.");
     }
 
-    private <T> Collection<T> getTypedBeansWithAnnotation(Class<? extends Annotation> annotationType, Class<T> beanType) throws Exception{
+    private <T> Collection<NamedBeanWrapper<T>> getTypedBeansWithAnnotation(Class<? extends Annotation> annotationType, Class<T> beanType) throws Exception{
 
 
        return Stream.of(applicationContext.getBeanNamesForType(beanType))
@@ -119,7 +143,7 @@ private <T> Collection<T> getTypedBeansWithAnnotation(Class<? extends Annotation
                     }
                     return null!= applicationContext.getBeanFactory().findAnnotationOnBean(name,annotationType);
                 })
-               .map(name -> applicationContext.getBeanFactory().getBean(name,beanType))
+               .map(name -> new NamedBeanWrapper<T>(name,applicationContext.getBeanFactory().getBean(name,beanType)) )
                .collect(Collectors.toList());
 
     }