Fix dependencies. Fix naming. Fix exception handling.

OlgaMaciaszek · OlgaMaciaszek · commit db379caf2cc3 · 2024-07-30T23:06:11.000+02:00
diff --git a/spring-boot-project/spring-boot-autoconfigure/build.gradle b/spring-boot-project/spring-boot-autoconfigure/build.gradle
@@ -23,6 +23,10 @@ configurations.all {
 dependencies {
 	api(project(":spring-boot-project:spring-boot"))
 
+//	TODO: Have added it to be able to use CaseUtils and avoid rewriting the code;
+//	 can remove it and duplicate the required method instead
+	implementation("org.apache.commons:commons-text")
+
 	dockerTestImplementation(project(":spring-boot-project:spring-boot-test"))
 	dockerTestImplementation(project(":spring-boot-project:spring-boot-tools:spring-boot-test-support-docker"))
 	dockerTestImplementation("org.assertj:assertj-core")
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/InterfaceClientsAdapter.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/InterfaceClientsAdapter.java
@@ -23,10 +23,10 @@
  * @author Olga Maciaszek-Sharma
  */
 // TODO: remove abstract supertype or move to a shared package
-public interface InterfaceClientAdapter extends Ordered {
+public interface InterfaceClientsAdapter extends Ordered {
 
 	String DEFAULT_QUALIFIER = "interfaceClients";
 
-	<T> T createClient(ListableBeanFactory beanFactory, String clientName, Class<T> type);
+	<T> T createClient(ListableBeanFactory beanFactory, String clientId, Class<T> type);
 
 }
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpExchangeAdapterProvider.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpExchangeAdapterProvider.java
@@ -26,6 +26,6 @@
 public interface HttpExchangeAdapterProvider {
 
 	// TODO: try a less specific type for the beanFactory
-	HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientName);
+	HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientId);
 
 }
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpInterfaceClientsAdapter.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpInterfaceClientsAdapter.java
@@ -20,41 +20,41 @@
 import org.apache.commons.logging.LogFactory;
 
 import org.springframework.beans.factory.ListableBeanFactory;
-import org.springframework.boot.autoconfigure.interfaceclients.InterfaceClientAdapter;
+import org.springframework.boot.autoconfigure.interfaceclients.InterfaceClientsAdapter;
 import org.springframework.web.service.invoker.HttpExchangeAdapter;
 import org.springframework.web.service.invoker.HttpServiceProxyFactory;
 
 /**
  * @author Olga Maciaszek-Sharma
  */
-public class HttpInterfaceClientAdapter implements InterfaceClientAdapter {
+public class HttpInterfaceClientsAdapter implements InterfaceClientsAdapter {
 
-	private static final Log logger = LogFactory.getLog(HttpInterfaceClientAdapter.class);
+	private static final Log logger = LogFactory.getLog(HttpInterfaceClientsAdapter.class);
 
 	private final HttpExchangeAdapterProvider adapterProvider;
 
-	public HttpInterfaceClientAdapter(HttpExchangeAdapterProvider adapterProvider) {
+	public HttpInterfaceClientsAdapter(HttpExchangeAdapterProvider adapterProvider) {
 		this.adapterProvider = adapterProvider;
 	}
 
 	@Override
-	public <T> T createClient(ListableBeanFactory beanFactory, String clientName, Class<T> type) {
-		HttpServiceProxyFactory proxyFactory = proxyFactory(beanFactory, clientName);
+	public <T> T createClient(ListableBeanFactory beanFactory, String clientId, Class<T> type) {
+		HttpServiceProxyFactory proxyFactory = proxyFactory(beanFactory, clientId);
 
 		return proxyFactory.createClient(type);
 	}
 
-	private HttpServiceProxyFactory proxyFactory(ListableBeanFactory beanFactory, String clientName) {
+	private HttpServiceProxyFactory proxyFactory(ListableBeanFactory beanFactory, String clientId) {
 		HttpServiceProxyFactory userProvidedProxyFactory = QualifiedBeanProvider.qualifiedBean(beanFactory,
-				HttpServiceProxyFactory.class, clientName);
+				HttpServiceProxyFactory.class, clientId);
 		if (userProvidedProxyFactory != null) {
 			return userProvidedProxyFactory;
 		}
 		// create an HttpServiceProxyFactory bean with default implementation
 		if (logger.isDebugEnabled()) {
-			logger.debug("Creating HttpServiceProxyFactory for '" + clientName + "'");
+			logger.debug("Creating HttpServiceProxyFactory for '" + clientId + "'");
 		}
-		HttpExchangeAdapter adapter = this.adapterProvider.get(beanFactory, clientName);
+		HttpExchangeAdapter adapter = this.adapterProvider.get(beanFactory, clientId);
 		return HttpServiceProxyFactory.builderFor(adapter).build();
 	}
 
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpInterfaceClientsAutoConfiguration.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpInterfaceClientsAutoConfiguration.java
@@ -44,14 +44,14 @@
  * @author Olga Maciaszek-Sharma
  */
 @AutoConfiguration(after = { RestTemplateAutoConfiguration.class, RestClientAutoConfiguration.class,
-		WebClientAutoConfiguration.class })
+		WebClientAutoConfiguration.class})
 @Import(HttpInterfaceClientsImportRegistrar.class)
 @EnableConfigurationProperties(HttpInterfaceClientsProperties.class)
 public class HttpInterfaceClientsAutoConfiguration {
 
 	@Bean
-	HttpInterfaceClientAdapter httpInterfaceClientAdapter(HttpExchangeAdapterProvider adapterProvider) {
-		return new HttpInterfaceClientAdapter(adapterProvider);
+	HttpInterfaceClientsAdapter httpInterfaceClientAdapter(HttpExchangeAdapterProvider adapterProvider) {
+		return new HttpInterfaceClientsAdapter(adapterProvider);
 	}
 
 	@Configuration(proxyBeanMethods = false)
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpInterfaceClientsImportRegistrar.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpInterfaceClientsImportRegistrar.java
@@ -42,6 +42,8 @@
 // TODO: Handle AOT
 public class HttpInterfaceClientsImportRegistrar extends AbstractInterfaceClientsImportRegistrar {
 
+	// TODO: work on IntelliJ plugin /other plugins/ to show that the client beans are
+	//  autoconfigured
 	private static final Log logger = LogFactory.getLog(HttpInterfaceClientsImportRegistrar.class);
 
 	private static final String INTERFACE_CLIENT_SUFFIX = "InterfaceClient";
@@ -76,23 +78,23 @@ public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionR
 				// qualifier to look for related beans
 				// TODO: while the actual beanName corresponds to the simple class name
 				// suffixed with InterfaceClient
-				String clientQualifier = annotation.getString(MergedAnnotation.VALUE);
+				String clientId = annotation.getString(MergedAnnotation.VALUE);
 				String beanName = !ObjectUtils.isEmpty(annotation.getString(BEAN_NAME_ATTRIBUTE_NAME))
-						? annotation.getString(BEAN_NAME_ATTRIBUTE_NAME) : buildBeanName(clientQualifier);
-				HttpInterfaceClientAdapter adapter = beanFactory.getBean(HttpInterfaceClientAdapter.class);
+						? annotation.getString(BEAN_NAME_ATTRIBUTE_NAME) : buildBeanName(clientId);
+				HttpInterfaceClientsAdapter adapter = beanFactory.getBean(HttpInterfaceClientsAdapter.class);
 				BeanDefinition definition = BeanDefinitionBuilder
 					.rootBeanDefinition(ResolvableType.forClass(beanClass),
-							() -> adapter.createClient(beanFactory, clientQualifier, beanClass))
+							() -> adapter.createClient(beanFactory, clientId, beanClass))
 					.getBeanDefinition();
 				registry.registerBeanDefinition(beanName, definition);
 
 			}
 		}
 	}
 
-	private String buildBeanName(String clientQualifier) {
+	private String buildBeanName(String clientId) {
 		// TODO: research Normalizer form types
-		String normalised = Normalizer.normalize(clientQualifier, Normalizer.Form.NFD);
+		String normalised = Normalizer.normalize(clientId, Normalizer.Form.NFD);
 		String camelCased = CaseUtils.toCamelCase(normalised, false, '-', '_');
 		return camelCased + INTERFACE_CLIENT_SUFFIX;
 	}
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpInterfaceClientsProperties.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/HttpInterfaceClientsProperties.java
@@ -39,14 +39,14 @@ public Map<String, HttpInterfaceClientsBaseProperties> getClients() {
 		return this.clients;
 	}
 
-	public HttpInterfaceClientsBaseProperties getProperties(String clientName) {
-		if (clientName == null || !this.getClients().containsKey(clientName)) {
+	public HttpInterfaceClientsBaseProperties getProperties(String clientId) {
+		if (clientId == null || !this.getClients().containsKey(clientId)) {
 			// no specific client properties, return default
 			return this;
 		}
 		// because specifics are overlaid on top of defaults, everything in `properties`,
 		// unless overridden, is in `clientsProperties`
-		return this.getClients().get(clientName);
+		return this.getClients().get(clientId);
 	}
 
 }
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/QualifiedBeanProvider.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/QualifiedBeanProvider.java
@@ -22,7 +22,7 @@
 import org.springframework.beans.factory.ListableBeanFactory;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.annotation.BeanFactoryAnnotationUtils;
-import org.springframework.boot.autoconfigure.interfaceclients.InterfaceClientAdapter;
+import org.springframework.boot.autoconfigure.interfaceclients.InterfaceClientsAdapter;
 
 /**
  * @author Olga Maciaszek-Sharma
@@ -31,24 +31,23 @@ final class QualifiedBeanProvider {
 
 	private static final Log logger = LogFactory.getLog(QualifiedBeanProvider.class);
 
-	static <T> T qualifiedBean(ListableBeanFactory beanFactory, Class<T> type, String clientName) {
+	static <T> T qualifiedBean(ListableBeanFactory beanFactory, Class<T> type, String clientId) {
 		try {
-			return BeanFactoryAnnotationUtils.qualifiedBeanOfType(beanFactory, type, clientName);
+			return BeanFactoryAnnotationUtils.qualifiedBeanOfType(beanFactory, type, clientId);
 		}
-		catch (NoSuchBeanDefinitionException ex) {
+		catch (NoSuchBeanDefinitionException ignored) {
 			if (logger.isDebugEnabled()) {
-				logger.debug("No qualified bean of type " + type + " found for " + clientName, ex);
+				logger.debug("No qualified bean of type " + type + " found for " + clientId);
 			}
 		}
 		// Get default-qualified bean
 		try {
 			return BeanFactoryAnnotationUtils.qualifiedBeanOfType(beanFactory, type,
-					InterfaceClientAdapter.DEFAULT_QUALIFIER);
+					InterfaceClientsAdapter.DEFAULT_QUALIFIER);
 		}
-		catch (NoSuchBeanDefinitionException ex) {
+		catch (NoSuchBeanDefinitionException ignored) {
 			if (logger.isDebugEnabled()) {
-				logger.debug("No qualified of type " + type + "found for " + InterfaceClientAdapter.DEFAULT_QUALIFIER,
-						ex);
+				logger.debug("No qualified of type " + type + "found for " + InterfaceClientsAdapter.DEFAULT_QUALIFIER);
 			}
 		}
 		return null;
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/RestClientAdapterProvider.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/RestClientAdapterProvider.java
@@ -41,24 +41,24 @@ public RestClientAdapterProvider(RestClient.Builder builder, HttpInterfaceClient
 	}
 
 	@Override
-	public HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientName) {
+	public HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientId) {
 		RestClient userProvidedRestClient = QualifiedBeanProvider.qualifiedBean(beanFactory, RestClient.class,
-				clientName);
+				clientId);
 		if (userProvidedRestClient != null) {
 			return RestClientAdapter.create(userProvidedRestClient);
 		}
 		RestClient.Builder userProvidedRestClientBuilder = QualifiedBeanProvider.qualifiedBean(beanFactory,
-				RestClient.Builder.class, clientName);
+				RestClient.Builder.class, clientId);
 		if (userProvidedRestClientBuilder != null) {
 			// TODO: should we do this or get it from the user?
-			userProvidedRestClientBuilder.baseUrl(this.properties.getProperties(clientName).getBaseUrl());
+			userProvidedRestClientBuilder.baseUrl(this.properties.getProperties(clientId).getBaseUrl());
 			return RestClientAdapter.create(userProvidedRestClientBuilder.build());
 		}
 		// create a RestClientAdapter bean with default implementation
 		if (logger.isDebugEnabled()) {
-			logger.debug("Creating RestClientAdapter for '" + clientName + "'");
+			logger.debug("Creating RestClientAdapter for '" + clientId + "'");
 		}
-		RestClient restClient = this.builder.baseUrl(this.properties.getProperties(clientName).getBaseUrl()).build();
+		RestClient restClient = this.builder.baseUrl(this.properties.getProperties(clientId).getBaseUrl()).build();
 		return RestClientAdapter.create(restClient);
 	}
 
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/RestTemplateAdapterProvider.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/RestTemplateAdapterProvider.java
@@ -43,25 +43,25 @@ public RestTemplateAdapterProvider(RestTemplateBuilder restTemplateBuilder,
 	}
 
 	@Override
-	public HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientName) {
+	public HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientId) {
 		RestTemplate userProvidedRestTemplate = QualifiedBeanProvider.qualifiedBean(beanFactory, RestTemplate.class,
-				clientName);
+				clientId);
 		if (userProvidedRestTemplate != null) {
 			return RestTemplateAdapter.create(userProvidedRestTemplate);
 		}
 		RestTemplateBuilder userProvidedRestTemplateBuilder = QualifiedBeanProvider.qualifiedBean(beanFactory,
-				RestTemplateBuilder.class, clientName);
+				RestTemplateBuilder.class, clientId);
 		if (userProvidedRestTemplateBuilder != null) {
 			// TODO: should we do this or get it from the user?
-			userProvidedRestTemplateBuilder.rootUri(this.properties.getProperties(clientName).getBaseUrl());
+			userProvidedRestTemplateBuilder.rootUri(this.properties.getProperties(clientId).getBaseUrl());
 			return RestTemplateAdapter.create(userProvidedRestTemplateBuilder.build());
 		}
 		// create a RestTemplateAdapter bean with default implementation
 		if (logger.isDebugEnabled()) {
-			logger.debug("Creating RestTemplateAdapter for '" + clientName + "'");
+			logger.debug("Creating RestTemplateAdapter for '" + clientId + "'");
 		}
 		RestTemplate restTemplate = this.restTemplateBuilder
-			.rootUri(this.properties.getProperties(clientName).getBaseUrl())
+			.rootUri(this.properties.getProperties(clientId).getBaseUrl())
 			.build();
 		return RestTemplateAdapter.create(restTemplate);
 	}
diff --git a/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/WebClientAdapterProvider.java b/spring-boot-project/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/interfaceclients/http/WebClientAdapterProvider.java
@@ -41,23 +41,23 @@ public WebClientAdapterProvider(WebClient.Builder builder, HttpInterfaceClientsP
 	}
 
 	@Override
-	public HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientName) {
-		WebClient userProvidedWebClient = QualifiedBeanProvider.qualifiedBean(beanFactory, WebClient.class, clientName);
+	public HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientId) {
+		WebClient userProvidedWebClient = QualifiedBeanProvider.qualifiedBean(beanFactory, WebClient.class, clientId);
 		if (userProvidedWebClient != null) {
 			return WebClientAdapter.create(userProvidedWebClient);
 		}
 		WebClient.Builder userProvidedWebClientBuilder = QualifiedBeanProvider.qualifiedBean(beanFactory,
-				WebClient.Builder.class, clientName);
+				WebClient.Builder.class, clientId);
 		if (userProvidedWebClientBuilder != null) {
 			// TODO: should we do this or get it from the user?
-			userProvidedWebClientBuilder.baseUrl(this.properties.getProperties(clientName).getBaseUrl());
+			userProvidedWebClientBuilder.baseUrl(this.properties.getProperties(clientId).getBaseUrl());
 			return WebClientAdapter.create(userProvidedWebClientBuilder.build());
 		}
 		// create a WebClientAdapter bean with default implementation
 		if (logger.isDebugEnabled()) {
-			logger.debug("Creating WebClientAdapter for '" + clientName + "'");
+			logger.debug("Creating WebClientAdapter for '" + clientId + "'");
 		}
-		WebClient webClient = this.builder.baseUrl(this.properties.getProperties(clientName).getBaseUrl()).build();
+		WebClient webClient = this.builder.baseUrl(this.properties.getProperties(clientId).getBaseUrl()).build();
 		return WebClientAdapter.create(webClient);
 	}
 
diff --git a/spring-boot-project/spring-boot-dependencies/build.gradle b/spring-boot-project/spring-boot-dependencies/build.gradle
@@ -275,6 +275,16 @@ bom {
 			site("https://commons.apache.org/proper/commons-pool")
 		}
 	}
+	library("Commons Text", "1.12.0") {
+		group("org.apache.commons") {
+			modules = [
+					"commons-text"
+			]
+		}
+		links {
+			site("https://commons.apache.org/proper/commons-text")
+		}
+	}
 	library("Couchbase Client", "3.6.2") {
 		group("com.couchbase.client") {
 			modules = [

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,6 @@`
`26`	`26`	`public interface HttpExchangeAdapterProvider {`
`27`	`27`
`28`	`28`	`// TODO: try a less specific type for the beanFactory`
`29`		`- HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientName);`
	`29`	`+ HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientId);`
`30`	`30`
`31`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,14 +39,14 @@ public Map<String, HttpInterfaceClientsBaseProperties> getClients() {`
`39`	`39`	`return this.clients;`
`40`	`40`	`}`
`41`	`41`
`42`		`- public HttpInterfaceClientsBaseProperties getProperties(String clientName) {`
`43`		`- if (clientName == null \|\| !this.getClients().containsKey(clientName)) {`
	`42`	`+ public HttpInterfaceClientsBaseProperties getProperties(String clientId) {`
	`43`	`+ if (clientId == null \|\| !this.getClients().containsKey(clientId)) {`
`44`	`44`	`// no specific client properties, return default`
`45`	`45`	`return this;`
`46`	`46`	`}`
`47`	`47`	// because specifics are overlaid on top of defaults, everything in `properties`,
`48`	`48`	// unless overridden, is in `clientsProperties`
`49`		`- return this.getClients().get(clientName);`
	`49`	`+ return this.getClients().get(clientId);`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,24 +41,24 @@ public RestClientAdapterProvider(RestClient.Builder builder, HttpInterfaceClient`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`@Override`
`44`		`- public HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientName) {`
	`44`	`+ public HttpExchangeAdapter get(ListableBeanFactory beanFactory, String clientId) {`
`45`	`45`	`RestClient userProvidedRestClient = QualifiedBeanProvider.qualifiedBean(beanFactory, RestClient.class,`
`46`		`- clientName);`
	`46`	`+ clientId);`
`47`	`47`	`if (userProvidedRestClient != null) {`
`48`	`48`	`return RestClientAdapter.create(userProvidedRestClient);`
`49`	`49`	`}`
`50`	`50`	`RestClient.Builder userProvidedRestClientBuilder = QualifiedBeanProvider.qualifiedBean(beanFactory,`
`51`		`- RestClient.Builder.class, clientName);`
	`51`	`+ RestClient.Builder.class, clientId);`
`52`	`52`	`if (userProvidedRestClientBuilder != null) {`
`53`	`53`	`// TODO: should we do this or get it from the user?`
`54`		`- userProvidedRestClientBuilder.baseUrl(this.properties.getProperties(clientName).getBaseUrl());`
	`54`	`+ userProvidedRestClientBuilder.baseUrl(this.properties.getProperties(clientId).getBaseUrl());`
`55`	`55`	`return RestClientAdapter.create(userProvidedRestClientBuilder.build());`
`56`	`56`	`}`
`57`	`57`	`// create a RestClientAdapter bean with default implementation`
`58`	`58`	`if (logger.isDebugEnabled()) {`
`59`		`- logger.debug("Creating RestClientAdapter for '" + clientName + "'");`
	`59`	`+ logger.debug("Creating RestClientAdapter for '" + clientId + "'");`
`60`	`60`	`}`
`61`		`- RestClient restClient = this.builder.baseUrl(this.properties.getProperties(clientName).getBaseUrl()).build();`
	`61`	`+ RestClient restClient = this.builder.baseUrl(this.properties.getProperties(clientId).getBaseUrl()).build();`
`62`	`62`	`return RestClientAdapter.create(restClient);`
`63`	`63`	`}`
`64`	`64`