add grpc client autowired

dapr-spring/dapr-spring-boot-autoconfigure/pom.xml

@@ -21,6 +21,12 @@
       <version>${project.parent.version}</version>
       <optional>true</optional>
     </dependency>
+    <dependency>
+      <groupId>io.dapr.spring</groupId>
+      <artifactId>dapr-spring-invoke</artifactId>
+      <version>${project.parent.version}</version>
+      <optional>true</optional>
+    </dependency>
     <dependency>
       <groupId>io.dapr.spring</groupId>
       <artifactId>dapr-spring-messaging</artifactId>

dapr-spring/dapr-spring-boot-autoconfigure/src/main/java/io/dapr/spring/boot/autoconfigure/client/DaprInvokeAutoConfiguration.java

@@ -0,0 +1,21 @@
+package io.dapr.spring.boot.autoconfigure.client;
+
+import io.dapr.spring.invoke.grpc.client.DaprGrpcBeanPostProcessor;
+import org.springframework.boot.autoconfigure.AutoConfiguration;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.annotation.Bean;
+
+@AutoConfiguration
+@AutoConfigureAfter(DaprClientAutoConfiguration.class)
+public class DaprInvokeAutoConfiguration {
+
+  @Bean
+  @ConditionalOnProperty(name = "dapr.invoke.grpc.client.daprGrpcClient.enabled", havingValue = "true",
+      matchIfMissing = true)
+  static DaprGrpcBeanPostProcessor daprGrpcClientBeanPostProcessor(
+      final ApplicationContext applicationContext) {
+    return new DaprGrpcBeanPostProcessor(applicationContext);
+  }
+}

dapr-spring/dapr-spring-boot-autoconfigure/src/main/resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports

@@ -1 +1,2 @@
 io.dapr.spring.boot.autoconfigure.client.DaprClientAutoConfiguration
+io.dapr.spring.boot.autoconfigure.client.DaprInvokeAutoConfiguration

dapr-spring/dapr-spring-boot-starters/dapr-spring-boot-starter/pom.xml

@@ -35,6 +35,11 @@
       <artifactId>dapr-spring-data</artifactId>
       <version>${project.parent.version}</version>
     </dependency>
+    <dependency>
+      <groupId>io.dapr.spring</groupId>
+      <artifactId>dapr-spring-invoke</artifactId>
+      <version>${project.parent.version}</version>
+    </dependency>
     <dependency>
       <groupId>io.dapr.spring</groupId>
       <artifactId>dapr-spring-messaging</artifactId>

dapr-spring/dapr-spring-invoke/pom.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <parent>
+    <groupId>io.dapr.spring</groupId>
+    <artifactId>dapr-spring-parent</artifactId>
+    <version>0.15.0-SNAPSHOT</version>
+  </parent>
+
+  <artifactId>dapr-spring-invoke</artifactId>
+  <name>dapr-spring-invoke</name>
+  <description>Dapr Spring Invoke</description>
+  <packaging>jar</packaging>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.sonatype.plugins</groupId>
+        <artifactId>nexus-staging-maven-plugin</artifactId>
+      </plugin>
+    </plugins>
+  </build>
+</project>

dapr-spring/dapr-spring-invoke/src/main/java/io/dapr/spring/invoke/grpc/client/DaprGrpcBeanPostProcessor.java

@@ -0,0 +1,233 @@
+package io.dapr.spring.invoke.grpc.client;
+
+import com.google.common.collect.Lists;
+import io.dapr.client.DaprClient;
+import io.grpc.CallOptions;
+import io.grpc.Channel;
+import io.grpc.ClientInterceptor;
+import io.grpc.ClientInterceptors;
+import io.grpc.stub.AbstractAsyncStub;
+import io.grpc.stub.AbstractStub;
+import org.springframework.beans.BeanInstantiationException;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.InvalidPropertyException;
+import org.springframework.beans.factory.BeanCreationException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.context.ApplicationContext;
+import org.springframework.core.annotation.AnnotationAwareOrderComparator;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.util.ReflectionUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Parameter;
+import java.util.List;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Handlers Dapr gRPC client in spring boot.
+ * Searches for fields and methods in beans that are annotated with {@link DaprGrpcClient} and sets them.
+ *
+ */
+public class DaprGrpcBeanPostProcessor implements BeanPostProcessor {
+
+  private final ApplicationContext applicationContext;
+
+  private DaprClient daprClient;
+
+  public DaprGrpcBeanPostProcessor(ApplicationContext applicationContext) {
+    this.applicationContext =  requireNonNull(applicationContext, "applicationContext");
+  }
+
+  @Override
+  public Object postProcessBeforeInitialization(final Object bean, final String beanName) throws BeansException {
+    processDaprGprcClients(bean);
+
+    return bean;
+  }
+
+  /**
+   * Process Dapr gRPC client in bean.
+   * @param bean The bean to process.
+   */
+  private void processDaprGprcClients(final Object bean) {
+    Class<?> clazz = bean.getClass();
+    do {
+      processDaprGprcClientFields(clazz, bean);
+      clazz = clazz.getSuperclass();
+    } while (clazz != null);
+  }
+
+  /**
+   * Process DaprGrpcClient annotation in bean.
+   * @param clazz The class to process.
+   * @param bean The bean to process.
+   */
+  private void processDaprGprcClientFields(final Class<?> clazz, final Object bean) {
+    for (final Field field : clazz.getDeclaredFields()) {
+      final DaprGrpcClient annotation = AnnotationUtils.findAnnotation(field, DaprGrpcClient.class);
+      if (annotation != null) {
+        ReflectionUtils.makeAccessible(field);
+        ReflectionUtils.setField(field, bean, processDaprGrpcClientPoint(field, field.getType(), annotation));
+      }
+    }
+  }
+
+  /**
+   * Processes DaprGrpcClient announce and computes the appropriate value for the injection.
+   *
+   * @param <T> The type to be injected for the given injection point.
+   * @param injectionTarget The target member for the injection.
+   * @param injectionType The class that should injected type.
+   * @param annotation The DaprGrpcClient annotation instance.
+   * @return The value to be injected for the given injection point.
+   */
+  private <T> T processDaprGrpcClientPoint(final Member injectionTarget, final Class<T> injectionType,
+                                           final DaprGrpcClient annotation) {
+    final String name = annotation.value();
+
+    final List<ClientInterceptor> interceptors = interceptorsFromAnnotation(annotation);
+    if (annotation.sortInterceptors()) {
+      interceptors.sort(AnnotationAwareOrderComparator.INSTANCE);
+    }
+
+    return valueForMember(name, injectionTarget, injectionType, interceptors);
+  }
+
+  /**
+   * Processes DaprGrpcClient announce with Channel or AbstractStub type.
+   *
+   * @param <T> The type of the instance to be injected.
+   * @param <ST> The type of the AbstractStub implement class.
+   * @param name The name of target service name.
+   * @param injectionTarget The target member for the injection.
+   * @param injectionType The class that should injected type.
+   * @param interceptors The interceptors defined on DaprGrpcClient.
+   * @return The value that matches the type of the given field.
+   * @throws BeansException If the value of the field could not be created or the type of the field is unsupported.
+   */
+  protected <T, ST extends AbstractStub<ST>> T valueForMember(final String name, final Member injectionTarget,
+                                                              final Class<T> injectionType,
+                                                              final List<ClientInterceptor> interceptors)
+      throws BeansException {
+    if (Channel.class.equals(injectionType)) {
+      Channel channel = getDaprClient().newGrpcStub(name, DaprGrpcBeanPostProcessor::newStub).getChannel();
+      channel = ClientInterceptors.interceptForward(channel, interceptors);
+      return injectionType.cast(channel);
+    } else if (AbstractStub.class.isAssignableFrom(injectionType)) {
+      @SuppressWarnings("unchecked")
+      ST stub = getDaprClient().newGrpcStub(name, (daprChannel ->
+          createStub((Class<ST>)injectionType.asSubclass(AbstractStub.class), daprChannel)));
+      stub = stub.withInterceptors(interceptors.toArray(new ClientInterceptor[0]));
+      return injectionType.cast(stub);
+    } else {
+      if (injectionTarget != null) {
+        throw new InvalidPropertyException(injectionTarget.getDeclaringClass(), injectionTarget.getName(),
+            "Unsupported type " + injectionType.getName());
+      } else {
+        throw new BeanInstantiationException(injectionType, "Unsupported grpc stub or channel type");
+      }
+    }
+  }
+
+  /**
+   * Create a new stub by stubType and channel.
+   *
+   * @param stubClass The stub class that needs to be created.
+   * @param channel The gRPC channel associated with the created stub, passed as a parameter to the stub factory.
+   * @return A newly created gRPC stub.
+   */
+  private <T extends AbstractStub<T>> T createStub(final Class<T> stubClass, final Channel channel) {
+    try {
+      // Search for public static *Grpc#new*Stub(Channel)
+      final Class<?> declaringClass = stubClass.getDeclaringClass();
+      if (declaringClass != null) {
+        for (final Method method : declaringClass.getMethods()) {
+          final String name = method.getName();
+          final int modifiers = method.getModifiers();
+          final Parameter[] parameters = method.getParameters();
+          if (name.startsWith("new") && name.endsWith("Stub")
+              && Modifier.isStatic(modifiers) && Modifier.isPublic(modifiers)
+              && method.getReturnType().isAssignableFrom(stubClass)
+              && parameters.length == 1
+              && Channel.class.equals(parameters[0].getType())) {
+            return stubClass.cast(method.invoke(null, channel));
+          }
+        }
+      }
+
+      // Search for a public constructor *Stub(Channel)
+      final Constructor<T> constructor = stubClass.getConstructor(Channel.class);
+      return constructor.newInstance(channel);
+    } catch (final Exception e) {
+      throw new BeanInstantiationException(stubClass, "Failed to create gRPC client", e);
+    }
+  }
+
+  /**
+   * Create a new stub by stubType and channel.
+   *
+   * @param channel The grpc channel.
+   * @return The transparent stub instance.
+   */
+  private static DaprTransparentStub newStub(final Channel channel) {
+    AbstractStub.StubFactory<DaprTransparentStub> factory = new AbstractStub.StubFactory<DaprTransparentStub>() {
+      public DaprTransparentStub newStub(final Channel channel, final CallOptions callOptions) {
+        return new DaprTransparentStub(channel, callOptions);
+      }
+    };
+    return DaprTransparentStub.newStub(factory, channel);
+  }
+
+  /**
+   * A transparent stub that for DaprClient get channel.
+   */
+  private static class DaprTransparentStub extends AbstractAsyncStub<DaprTransparentStub> {
+    private DaprTransparentStub(final Channel channel, final CallOptions callOptions) {
+      super(channel, callOptions);
+    }
+
+    protected DaprTransparentStub build(final Channel channel, final CallOptions callOptions) {
+      return new DaprTransparentStub(channel, callOptions);
+    }
+  }
+
+  /**
+   * Gets or creates the {@link ClientInterceptor}s that are referenced in the given annotation.
+   *
+   * @param annotation The annotation to get the interceptors for.
+   * @return A list containing the interceptors for the given annotation.
+   * @throws BeansException If the referenced interceptors weren't found or could not be created.
+   */
+  protected List<ClientInterceptor> interceptorsFromAnnotation(final DaprGrpcClient annotation) throws BeansException {
+    final List<ClientInterceptor> list = Lists.newArrayList();
+    for (final Class<? extends ClientInterceptor> interceptorClass : annotation.interceptors()) {
+      final ClientInterceptor clientInterceptor;
+      if (this.applicationContext.getBeanNamesForType(interceptorClass).length > 0) {
+        clientInterceptor = this.applicationContext.getBean(interceptorClass);
+      } else {
+        try {
+          clientInterceptor = interceptorClass.getConstructor().newInstance();
+        } catch (final Exception e) {
+          throw new BeanCreationException("Failed to create interceptor instance", e);
+        }
+      }
+      list.add(clientInterceptor);
+    }
+    for (final String interceptorName : annotation.interceptorNames()) {
+      list.add(this.applicationContext.getBean(interceptorName, ClientInterceptor.class));
+    }
+    return list;
+  }
+
+  private DaprClient getDaprClient() {
+    if (this.daprClient == null) {
+      this.daprClient = this.applicationContext.getBean(DaprClient.class);
+    }
+    return this.daprClient;
+  }
+}

dapr-spring/dapr-spring-invoke/src/main/java/io/dapr/spring/invoke/grpc/client/DaprGrpcClient.java

@@ -0,0 +1,71 @@
+package io.dapr.spring.invoke.grpc.client;
+
+import io.grpc.Channel;
+import io.grpc.ClientInterceptor;
+import io.grpc.stub.AbstractStub;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * An annotation for fields of type {@link Channel} or subclasses of {@link AbstractStub}/gRPC client services.
+ *
+ * <p>
+ * <b>Note:</b> Fields that are annotated with this annotation should NOT be annotated with
+ * {@link Autowired} (conflict).
+ * </p>
+ *
+ */
+@Target({ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+@Inherited
+public @interface DaprGrpcClient {
+
+  /**
+   * The name of the target service. The channel use DaprClient's grpc channel.
+   *
+   * <p>
+   * <b>Example:</b> <code>@DaprGrpcClient("exampleService")</code> &lt;-&gt;
+   * {@code headers.put(Metadata.Key.of("dapr-app-id", Metadata.ASCII_STRING_MARSHALLER), name); }
+   * </p>
+   *
+   * @return The name of the target service.
+   */
+  String value();
+
+  /**
+   * A list of {@link ClientInterceptor} classes that should be used with this client in addition to the globally
+   * defined ones. If a bean of the given type exists, it will be used; otherwise a new instance of that class will be
+   * created via no-args constructor.
+   *
+   * @return A list of ClientInterceptor classes that should be used.
+   */
+  Class<? extends ClientInterceptor>[] interceptors() default {};
+
+  /**
+   * A list of {@link ClientInterceptor} beans that should be used with this client in addition to the globally
+   * defined ones.
+   *
+   * @return A list of ClientInterceptor beans that should be used.
+   */
+  String[] interceptorNames() default {};
+
+  /**
+   * Whether the custom ClientInterceptor defined by interceptors and interceptorNames should be sorted.
+   *
+   * <p>
+   * Sorted by
+   * {@code interceptors.sort(AnnotationAwareOrderComparator.INSTANCE)}
+   * </p>
+   *
+   *
+   * @return True, if the custom interceptors will be sorted. False otherwise.
+   */
+  boolean sortInterceptors() default false;
+}

dapr-spring/pom.xml

@@ -19,6 +19,7 @@
 
   <modules>
     <module>dapr-spring-data</module>
+    <module>dapr-spring-invoke</module>
     <module>dapr-spring-messaging</module>
     <module>dapr-spring-workflows</module>
     <module>dapr-spring-boot-autoconfigure</module>