Fix issue 593:When the project depends on spring-retry, executing restTemplate to call microservice and reporting NPE error (#594)

CHANGELOG.md

@@ -1,4 +1,5 @@
 # Change Log
 ---
 
+- [Fix issue 593:When the project depends on spring-retry, executing restTemplate to call microservice and reporting NPE error](https://github.com/Tencent/spring-cloud-tencent/pull/594)
 - [Optimize: remove discovery module useless code](https://github.com/Tencent/spring-cloud-tencent/pull/595)

spring-cloud-starter-tencent-polaris-router/src/main/java/com/tencent/cloud/polaris/router/config/RouterAutoConfiguration.java

@@ -18,6 +18,11 @@
 
 package com.tencent.cloud.polaris.router.config;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import com.tencent.cloud.common.metadata.StaticMetadataManager;
 import com.tencent.cloud.polaris.context.ServiceRuleManager;
 import com.tencent.cloud.polaris.router.RouterRuleLabelResolver;
 import com.tencent.cloud.polaris.router.beanprocessor.LoadBalancerInterceptorBeanPostProcessor;
@@ -28,7 +33,11 @@ import com.tencent.cloud.polaris.router.config.properties.PolarisRuleBasedRouter
 import com.tencent.cloud.polaris.router.interceptor.MetadataRouterRequestInterceptor;
 import com.tencent.cloud.polaris.router.interceptor.NearbyRouterRequestInterceptor;
 import com.tencent.cloud.polaris.router.interceptor.RuleBasedRouterRequestInterceptor;
+import com.tencent.cloud.polaris.router.resttemplate.RouterLabelRestTemplateInterceptor;
+import com.tencent.cloud.polaris.router.spi.SpringWebRouterLabelResolver;
 
+import org.springframework.beans.factory.SmartInitializingSingleton;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClients;
@@ -36,6 +45,8 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Import;
 import org.springframework.core.annotation.Order;
+import org.springframework.http.client.ClientHttpRequestInterceptor;
+import org.springframework.web.client.RestTemplate;
 
 import static org.springframework.core.Ordered.HIGHEST_PRECEDENCE;
 
@@ -85,4 +96,34 @@ public class RouterAutoConfiguration {
 	public RuleBasedRouterRequestInterceptor ruleBasedRouterRequestInterceptor(PolarisRuleBasedRouterProperties polarisRuleBasedRouterProperties) {
 		return new RuleBasedRouterRequestInterceptor(polarisRuleBasedRouterProperties);
 	}
+
+	/**
+	 * Create when RestTemplate exists.
+	 * @author liuye 2022-09-14
+	 */
+	@Configuration(proxyBeanMethods = false)
+	@ConditionalOnClass(name = "org.springframework.web.client.RestTemplate")
+	@ConditionalOnProperty(value = "spring.cloud.polaris.router.rule-router.enabled", matchIfMissing = true)
+	protected static class RouterLabelRestTemplateConfig {
+
+		@Autowired(required = false)
+		private List<RestTemplate> restTemplates = Collections.emptyList();
+
+		@Bean
+		public RouterLabelRestTemplateInterceptor routerLabelRestTemplateInterceptor(
+				List<SpringWebRouterLabelResolver> routerLabelResolvers,
+				StaticMetadataManager staticMetadataManager,
+				RouterRuleLabelResolver routerRuleLabelResolver) {
+			return new RouterLabelRestTemplateInterceptor(routerLabelResolvers, staticMetadataManager, routerRuleLabelResolver);
+		}
+
+		@Bean
+		public SmartInitializingSingleton addRouterLabelInterceptorForRestTemplate(RouterLabelRestTemplateInterceptor interceptor) {
+			return () -> restTemplates.forEach(restTemplate -> {
+				List<ClientHttpRequestInterceptor> list = new ArrayList<>(restTemplate.getInterceptors());
+				list.add(interceptor);
+				restTemplate.setInterceptors(list);
+			});
+		}
+	}
 }

spring-cloud-starter-tencent-polaris-router/src/main/java/com/tencent/cloud/polaris/router/resttemplate/RouterLabelRestTemplateInterceptor.java

@@ -0,0 +1,151 @@
+/*
+ * Tencent is pleased to support the open source community by making Spring Cloud Tencent available.
+ *
+ * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://opensource.org/licenses/BSD-3-Clause
+ *
+ * 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 com.tencent.cloud.polaris.router.resttemplate;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.URI;
+import java.net.URLEncoder;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import com.tencent.cloud.common.constant.RouterConstants;
+import com.tencent.cloud.common.metadata.MetadataContext;
+import com.tencent.cloud.common.metadata.MetadataContextHolder;
+import com.tencent.cloud.common.metadata.StaticMetadataManager;
+import com.tencent.cloud.common.util.JacksonUtils;
+import com.tencent.cloud.common.util.expresstion.SpringWebExpressionLabelUtils;
+import com.tencent.cloud.polaris.router.RouterRuleLabelResolver;
+import com.tencent.cloud.polaris.router.spi.SpringWebRouterLabelResolver;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.springframework.core.Ordered;
+import org.springframework.http.HttpRequest;
+import org.springframework.http.client.ClientHttpRequestExecution;
+import org.springframework.http.client.ClientHttpRequestInterceptor;
+import org.springframework.http.client.ClientHttpResponse;
+import org.springframework.lang.NonNull;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+
+import static com.tencent.cloud.common.constant.ContextConstant.UTF_8;
+
+/**
+ * Interceptor used for adding the route label in http headers from context when web client
+ * is RestTemplate.
+ *
+ * @author liuye 2022-09-14
+ */
+public class RouterLabelRestTemplateInterceptor implements ClientHttpRequestInterceptor, Ordered {
+	private static final Logger LOGGER = LoggerFactory.getLogger(RouterLabelRestTemplateInterceptor.class);
+
+	private final List<SpringWebRouterLabelResolver> routerLabelResolvers;
+	private final StaticMetadataManager staticMetadataManager;
+	private final RouterRuleLabelResolver routerRuleLabelResolver;
+
+	public RouterLabelRestTemplateInterceptor(List<SpringWebRouterLabelResolver> routerLabelResolvers,
+			StaticMetadataManager staticMetadataManager,
+			RouterRuleLabelResolver routerRuleLabelResolver) {
+		this.staticMetadataManager = staticMetadataManager;
+		this.routerRuleLabelResolver = routerRuleLabelResolver;
+
+		if (!CollectionUtils.isEmpty(routerLabelResolvers)) {
+			routerLabelResolvers.sort(Comparator.comparingInt(Ordered::getOrder));
+			this.routerLabelResolvers = routerLabelResolvers;
+		}
+		else {
+			this.routerLabelResolvers = null;
+		}
+	}
+
+	@Override
+	public int getOrder() {
+		return Ordered.LOWEST_PRECEDENCE;
+	}
+
+	@Override
+	public ClientHttpResponse intercept(@NonNull HttpRequest request, @NonNull byte[] body,
+			@NonNull ClientHttpRequestExecution clientHttpRequestExecution) throws IOException {
+		final URI originalUri = request.getURI();
+		String peerServiceName = originalUri.getHost();
+		Assert.state(peerServiceName != null,
+				"Request URI does not contain a valid hostname: " + originalUri);
+
+		setLabelsToHeaders(request, body, peerServiceName);
+
+		return clientHttpRequestExecution.execute(request, body);
+	}
+
+	void setLabelsToHeaders(HttpRequest request, byte[] body, String peerServiceName) {
+		// local service labels
+		Map<String, String> labels = new HashMap<>(staticMetadataManager.getMergedStaticMetadata());
+
+		// labels from rule expression
+		Set<String> expressionLabelKeys = routerRuleLabelResolver.getExpressionLabelKeys(MetadataContext.LOCAL_NAMESPACE,
+				MetadataContext.LOCAL_SERVICE, peerServiceName);
+
+		Map<String, String> ruleExpressionLabels = getExpressionLabels(request, expressionLabelKeys);
+		if (!CollectionUtils.isEmpty(ruleExpressionLabels)) {
+			labels.putAll(ruleExpressionLabels);
+		}
+
+		// labels from request
+		if (!CollectionUtils.isEmpty(routerLabelResolvers)) {
+			routerLabelResolvers.forEach(resolver -> {
+				try {
+					Map<String, String> customResolvedLabels = resolver.resolve(request, body, expressionLabelKeys);
+					if (!CollectionUtils.isEmpty(customResolvedLabels)) {
+						labels.putAll(customResolvedLabels);
+					}
+				}
+				catch (Throwable t) {
+					LOGGER.error("[SCT][Router] revoke RouterLabelResolver occur some exception. ", t);
+				}
+			});
+		}
+
+		// labels from downstream
+		Map<String, String> transitiveLabels = MetadataContextHolder.get()
+				.getFragmentContext(MetadataContext.FRAGMENT_TRANSITIVE);
+		labels.putAll(transitiveLabels);
+
+		// pass label by header
+		String encodedLabelsContent;
+		try {
+			encodedLabelsContent = URLEncoder.encode(JacksonUtils.serialize2Json(labels), UTF_8);
+		}
+		catch (UnsupportedEncodingException e) {
+			throw new RuntimeException("unsupported charset exception " + UTF_8);
+		}
+		request.getHeaders().set(RouterConstants.ROUTER_LABEL_HEADER, encodedLabelsContent);
+	}
+
+	private Map<String, String> getExpressionLabels(HttpRequest request, Set<String> labelKeys) {
+		if (CollectionUtils.isEmpty(labelKeys)) {
+			return Collections.emptyMap();
+		}
+
+		return SpringWebExpressionLabelUtils.resolve(request, labelKeys);
+	}
+}

spring-cloud-starter-tencent-polaris-router/src/test/java/com/tencent/cloud/polaris/router/resttemplate/RouterLabelRestTemplateInterceptorTest.java

@@ -0,0 +1,167 @@
+/*
+ * Tencent is pleased to support the open source community by making Spring Cloud Tencent available.
+ *
+ * Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://opensource.org/licenses/BSD-3-Clause
+ *
+ * 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 com.tencent.cloud.polaris.router.resttemplate;
+
+
+import java.net.URI;
+import java.net.URLDecoder;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import com.tencent.cloud.common.constant.RouterConstants;
+import com.tencent.cloud.common.metadata.MetadataContext;
+import com.tencent.cloud.common.metadata.MetadataContextHolder;
+import com.tencent.cloud.common.metadata.StaticMetadataManager;
+import com.tencent.cloud.common.util.ApplicationContextAwareUtils;
+import com.tencent.cloud.common.util.JacksonUtils;
+import com.tencent.cloud.polaris.router.RouterRuleLabelResolver;
+import com.tencent.cloud.polaris.router.spi.SpringWebRouterLabelResolver;
+import org.assertj.core.api.Assertions;
+import org.junit.AfterClass;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpRequest;
+
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+/**
+ * test for {@link RouterLabelRestTemplateInterceptor}
+ * @author liuye 2022-09-16
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class RouterLabelRestTemplateInterceptorTest {
+
+	private static MockedStatic<ApplicationContextAwareUtils> mockedApplicationContextAwareUtils;
+	private static MockedStatic<MetadataContextHolder> mockedMetadataContextHolder;
+	@Mock
+	private SpringWebRouterLabelResolver routerLabelResolver;
+	@Mock
+	private StaticMetadataManager staticMetadataManager;
+	@Mock
+	private RouterRuleLabelResolver routerRuleLabelResolver;
+
+	@BeforeClass
+	public static void beforeClass() {
+		mockedApplicationContextAwareUtils = Mockito.mockStatic(ApplicationContextAwareUtils.class);
+		mockedApplicationContextAwareUtils.when(() -> ApplicationContextAwareUtils.getProperties(anyString()))
+				.thenReturn("callerService");
+
+		mockedMetadataContextHolder = Mockito.mockStatic(MetadataContextHolder.class);
+	}
+
+	@AfterClass
+	public static void afterClass() {
+		mockedApplicationContextAwareUtils.close();
+		mockedMetadataContextHolder.close();
+	}
+
+	@Test
+	public void testRouterContext() throws Exception {
+		String callerService = "callerService";
+		String calleeService = "calleeService";
+		HttpRequest request = new MockedHttpRequest("http://" + calleeService + "/user/get");
+
+		// mock local metadata
+		Map<String, String> localMetadata = new HashMap<>();
+		localMetadata.put("k1", "v1");
+		localMetadata.put("k2", "v2");
+		when(staticMetadataManager.getMergedStaticMetadata()).thenReturn(localMetadata);
+
+		// mock expression rule labels
+
+		Set<String> expressionKeys = new HashSet<>();
+		expressionKeys.add("${http.method}");
+		expressionKeys.add("${http.uri}");
+		when(routerRuleLabelResolver.getExpressionLabelKeys(callerService, callerService, calleeService)).thenReturn(expressionKeys);
+
+		// mock custom resolved from request
+		Map<String, String> customResolvedLabels = new HashMap<>();
+		customResolvedLabels.put("k2", "v22");
+		customResolvedLabels.put("k4", "v4");
+		when(routerLabelResolver.resolve(request, null, expressionKeys)).thenReturn(customResolvedLabels);
+
+		MetadataContext metadataContext = Mockito.mock(MetadataContext.class);
+
+		// mock transitive metadata
+		Map<String, String> transitiveLabels = new HashMap<>();
+		transitiveLabels.put("k1", "v1");
+		transitiveLabels.put("k2", "v22");
+		when(metadataContext.getFragmentContext(MetadataContext.FRAGMENT_TRANSITIVE)).thenReturn(transitiveLabels);
+
+		mockedMetadataContextHolder.when(MetadataContextHolder::get).thenReturn(metadataContext);
+
+		RouterLabelRestTemplateInterceptor routerLabelRestTemplateInterceptor = new RouterLabelRestTemplateInterceptor(
+				Collections.singletonList(routerLabelResolver), staticMetadataManager, routerRuleLabelResolver);
+
+		routerLabelRestTemplateInterceptor.setLabelsToHeaders(request, null, calleeService);
+
+		verify(staticMetadataManager).getMergedStaticMetadata();
+		verify(routerRuleLabelResolver).getExpressionLabelKeys(callerService, callerService, calleeService);
+		verify(routerLabelResolver).resolve(request, null, expressionKeys);
+
+
+		Map<String, String> headers = JacksonUtils.deserialize2Map(URLDecoder.decode(request.getHeaders()
+				.get(RouterConstants.ROUTER_LABEL_HEADER).get(0), "UTF-8"));
+		Assertions.assertThat("v1").isEqualTo(headers.get("k1"));
+		Assertions.assertThat("v22").isEqualTo(headers.get("k2"));
+		Assertions.assertThat("v4").isEqualTo(headers.get("k4"));
+		Assertions.assertThat("GET").isEqualTo(headers.get("${http.method}"));
+		Assertions.assertThat("/user/get").isEqualTo(headers.get("${http.uri}"));
+	}
+
+	static class MockedHttpRequest implements HttpRequest {
+
+		private URI uri;
+
+		private HttpHeaders httpHeaders = new HttpHeaders();
+
+		MockedHttpRequest(String url) {
+			this.uri = URI.create(url);
+		}
+
+		@Override
+		public String getMethodValue() {
+			return HttpMethod.GET.name();
+		}
+
+		@Override
+		public URI getURI() {
+			return uri;
+		}
+
+		@Override
+		public HttpHeaders getHeaders() {
+			return httpHeaders;
+		}
+	}
+}