Add client interceptors to channel factory

This commit adds support for global and channel-specific client
interceptors.

Resolves #52

Signed-off-by: Chris Bono <[email protected]>

Author: onobc

spring-grpc-core/src/main/java/org/springframework/grpc/client/ClientInterceptorsConfigurer.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2024-2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * */
+
+package org.springframework.grpc.client;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.context.ApplicationContext;
+import org.springframework.grpc.internal.ApplicationContextBeanLookupUtils;
+
+import io.grpc.ClientInterceptor;
+import io.grpc.ManagedChannelBuilder;
+
+/**
+ * Configure a {@link ManagedChannelBuilder} with client interceptors.
+ *
+ * @author Chris Bono
+ */
+public class ClientInterceptorsConfigurer implements InitializingBean {
+
+	private final ApplicationContext applicationContext;
+
+	private List<ClientInterceptor> globalInterceptors;
+
+	public ClientInterceptorsConfigurer(ApplicationContext applicationContext) {
+		this.applicationContext = applicationContext;
+	}
+
+	/**
+	 * Configure a {@link ManagedChannelBuilder} with client interceptors.
+	 * @param builder the builder to configure
+	 * @param interceptors the non-null list of interceptors to be applied to the channel
+	 * @param mergeWithGlobalInterceptors whether the provided interceptors should be
+	 * blended with the global interceptors.
+	 */
+	protected void configureInterceptors(ManagedChannelBuilder<?> builder, List<ClientInterceptor> interceptors,
+			boolean mergeWithGlobalInterceptors) {
+		// Add global interceptors first
+		List<ClientInterceptor> allInterceptors = new ArrayList<>(this.globalInterceptors);
+		// Add specific interceptors
+		allInterceptors.addAll(interceptors);
+		if (mergeWithGlobalInterceptors) {
+			ApplicationContextBeanLookupUtils.sortBeansIncludingOrderAnnotation(this.applicationContext,
+					ClientInterceptor.class, allInterceptors);
+		}
+		Collections.reverse(allInterceptors);
+		builder.intercept(allInterceptors);
+	}
+
+	@Override
+	public void afterPropertiesSet() {
+		this.globalInterceptors = findGlobalInterceptors();
+	}
+
+	private List<ClientInterceptor> findGlobalInterceptors() {
+		return ApplicationContextBeanLookupUtils.getBeansWithAnnotation(this.applicationContext,
+				ClientInterceptor.class, GlobalClientInterceptor.class);
+	}
+
+}

spring-grpc-core/src/main/java/org/springframework/grpc/client/DefaultGrpcChannelFactory.java

@@ -25,6 +25,7 @@
 import org.springframework.util.Assert;
 
 import io.grpc.ChannelCredentials;
+import io.grpc.ClientInterceptor;
 import io.grpc.ForwardingChannelBuilder2;
 import io.grpc.Grpc;
 import io.grpc.ManagedChannel;
@@ -47,17 +48,18 @@ public class DefaultGrpcChannelFactory implements GrpcChannelFactory, Disposable
 
 	private final List<GrpcChannelBuilderCustomizer> customizers = new ArrayList<>();
 
+	private final ClientInterceptorsConfigurer interceptorsConfigurer;
+
 	private ChannelCredentialsProvider credentials = ChannelCredentialsProvider.INSECURE;
 
 	private VirtualTargets targets = VirtualTargets.DEFAULT;
 
-	public DefaultGrpcChannelFactory() {
-		this(List.of());
-	}
-
-	public DefaultGrpcChannelFactory(List<GrpcChannelBuilderCustomizer> customizers) {
+	public DefaultGrpcChannelFactory(List<GrpcChannelBuilderCustomizer> customizers,
+			ClientInterceptorsConfigurer interceptorsConfigurer) {
 		Assert.notNull(customizers, () -> "customizers must not be null");
+		Assert.notNull(interceptorsConfigurer, () -> "interceptorsConfigurer must not be null");
 		this.customizers.addAll(customizers);
+		this.interceptorsConfigurer = interceptorsConfigurer;
 	}
 
 	public void setVirtualTargets(VirtualTargets targets) {
@@ -70,13 +72,20 @@ public void setCredentialsProvider(ChannelCredentialsProvider credentials) {
 
 	@Override
 	public ManagedChannelBuilder<?> createChannel(String authority) {
-		ManagedChannelBuilder<?> target = this.builders.computeIfAbsent(authority, path -> {
-			ManagedChannelBuilder<?> builder = newChannel(this.targets.getTarget(path),
+		return this.createChannel(authority, List.of(), false);
+	}
+
+	@Override
+	public ManagedChannelBuilder<?> createChannel(String authority, List<ClientInterceptor> interceptors,
+			boolean mergeWithGlobalInterceptors) {
+		Assert.notNull(interceptors, () -> "interceptors must not be null");
+		return this.builders.computeIfAbsent(authority, path -> {
+			ManagedChannelBuilder<?> builder = newChannelBuilder(this.targets.getTarget(path),
 					this.credentials.getChannelCredentials(path));
+			this.interceptorsConfigurer.configureInterceptors(builder, interceptors, mergeWithGlobalInterceptors);
 			this.customizers.forEach((c) -> c.customize(path, builder));
-			return builder;
+			return new DisposableChannelBuilder(authority, builder);
 		});
-		return new DisposableChannelBuilder(authority, target);
 	}
 
 	/**
@@ -86,15 +95,17 @@ public ManagedChannelBuilder<?> createChannel(String authority) {
 	 * @param creds the credentials for the channel
 	 * @return a new {@link ManagedChannelBuilder} for the given path and credentials
 	 */
-	protected ManagedChannelBuilder<?> newChannel(String path, ChannelCredentials creds) {
+	protected ManagedChannelBuilder<?> newChannelBuilder(String path, ChannelCredentials creds) {
 		return Grpc.newChannelBuilder(path, creds);
 	}
 
+	private ManagedChannel buildAndRegisterChannel(String channelName, ManagedChannelBuilder<?> channelBuilder) {
+		return this.channels.computeIfAbsent(channelName, (__) -> channelBuilder.build());
+	}
+
 	@Override
 	public void destroy() {
-		for (ManagedChannel channel : this.channels.values()) {
-			channel.shutdown();
-		}
+		this.channels.values().forEach(ManagedChannel::shutdown);
 	}
 
 	/**
@@ -103,10 +114,10 @@ public void destroy() {
 	 */
 	class DisposableChannelBuilder extends ForwardingChannelBuilder2<DisposableChannelBuilder> {
 
-		private final ManagedChannelBuilder<?> delegate;
-
 		private final String authority;
 
+		private final ManagedChannelBuilder<?> delegate;
+
 		DisposableChannelBuilder(String authority, ManagedChannelBuilder<?> delegate) {
 			this.authority = authority;
 			this.delegate = delegate;
@@ -119,7 +130,7 @@ protected ManagedChannelBuilder<?> delegate() {
 
 		@Override
 		public ManagedChannel build() {
-			return DefaultGrpcChannelFactory.this.channels.computeIfAbsent(this.authority, name -> super.build());
+			return DefaultGrpcChannelFactory.this.buildAndRegisterChannel(this.authority, this.delegate);
 		}
 
 	}

spring-grpc-core/src/main/java/org/springframework/grpc/client/GlobalClientInterceptor.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2024-2024 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Partial copy from net.devh:grpc-spring-boot-starter.
+ */
+
+package org.springframework.grpc.client;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import org.springframework.core.annotation.Order;
+
+import io.grpc.ClientInterceptor;
+
+/**
+ * Annotation that can be specified on a gRPC {@link ClientInterceptor} bean which will
+ * result in the interceptor being applied globally to channels.
+ * <p>
+ * The bean interceptor {@link Order} will be respected.
+ *
+ * @author Daniel Theuke ([email protected])
+ * @author Chris Bono
+ */
+@Target({ ElementType.TYPE, ElementType.METHOD })
+@Retention(RetentionPolicy.RUNTIME)
+@Documented
+public @interface GlobalClientInterceptor {
+
+}

spring-grpc-core/src/main/java/org/springframework/grpc/client/GrpcChannelFactory.java

@@ -16,6 +16,9 @@
 
 package org.springframework.grpc.client;
 
+import java.util.List;
+
+import io.grpc.ClientInterceptor;
 import io.grpc.ManagedChannelBuilder;
 
 /**
@@ -34,4 +37,16 @@ public interface GrpcChannelFactory {
 	 */
 	ManagedChannelBuilder<?> createChannel(String authority);
 
+	/**
+	 * Creates a {@link ManagedChannelBuilder} for the given authority and the provided
+	 * client interceptors.
+	 * @param authority the target authority for the channel
+	 * @param interceptors the non-null list of interceptors to be applied to the channel
+	 * @param mergeWithGlobalInterceptors whether the provided interceptors should be
+	 * blended with the global interceptors.
+	 * @return a channel builder conifgured with the provided values
+	 */
+	ManagedChannelBuilder<?> createChannel(String authority, List<ClientInterceptor> interceptors,
+			boolean mergeWithGlobalInterceptors);
+
 }