Simplified configuration injection in EclipseStoreRepositoryFactoryBean

Author: JohannesRabauer

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 2.5.1
+
+* Simplified configuration injection in ``EclipseStoreRepositoryFactoryBean``.
+
 # 2.5.0
 
 * Updated org.springframework.boot.version to v3.4.1

spring-data-eclipse-store-demo/src/main/java/software/xdev/spring/data/eclipse/store/demo/dual/storage/invoice/PersistenceInvoiceConfiguration.java

@@ -11,13 +11,14 @@
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Configuration;
 
+import software.xdev.spring.data.eclipse.store.demo.dual.storage.person.PersistencePersonConfiguration;
 import software.xdev.spring.data.eclipse.store.repository.config.EclipseStoreClientConfiguration;
 import software.xdev.spring.data.eclipse.store.repository.config.EnableEclipseStoreRepositories;
 
 
 /**
- * To set this configuration for the package we use the {@link EnableEclipseStoreRepositories#clientConfiguration()}
- * ()}. Another example:
+ * To set this configuration for the package we use the {@link EnableEclipseStoreRepositories#clientConfiguration()}.
+ * Another example:
  * {@link software.xdev.spring.data.eclipse.store.demo.dual.storage.person.PersistencePersonConfiguration}
  */
 @Configuration
@@ -49,7 +50,7 @@ public EmbeddedStorageFoundation<?> createEmbeddedStorageFoundation()
 		final EmbeddedStorageFoundation<?> storageFoundation =
 			EmbeddedStorage.Foundation(Storage.Configuration(Storage.FileProvider(Path.of(STORAGE_PATH))));
 		// This is only needed, if a different ClassLoader is used (e.g. when using spring-dev-tools)
-		storageFoundation.getConnectionFoundation().setClassLoaderProvider(getClassLoaderProvider());
+		storageFoundation.getConnectionFoundation().setClassLoaderProvider(this.getClassLoaderProvider());
 		return storageFoundation;
 	}
 }

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/config/EclipseStoreRepositoryConfigurationExtension.java

@@ -81,6 +81,7 @@ public String getRepositoryFactoryBeanClassName()
 	 * This is surely not the perfect way to get the correct configuration of that context, but it works with multiple
 	 * configurations, with no configuration and with a single configuration.
 	 */
+	@SuppressWarnings("NullableProblems")
 	@Override
 	public void postProcess(final BeanDefinitionBuilder builder, final AnnotationRepositoryConfigurationSource config)
 	{

spring-data-eclipse-store/src/main/java/software/xdev/spring/data/eclipse/store/repository/support/EclipseStoreRepositoryFactoryBean.java

@@ -16,23 +16,24 @@
 package software.xdev.spring.data.eclipse.store.repository.support;
 
 import java.io.Serializable;
-import java.util.Objects;
+import java.util.List;
+import java.util.Optional;
 
 import jakarta.annotation.Nonnull;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.BeansException;
-import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.data.repository.Repository;
 import org.springframework.data.repository.config.AnnotationRepositoryConfigurationSource;
 import org.springframework.data.repository.core.support.RepositoryFactoryBeanSupport;
 import org.springframework.data.repository.core.support.RepositoryFactorySupport;
 import org.springframework.stereotype.Component;
+import org.springframework.util.ClassUtils;
 
-import software.xdev.spring.data.eclipse.store.repository.config.DefaultEclipseStoreClientConfiguration;
 import software.xdev.spring.data.eclipse.store.repository.config.EclipseStoreClientConfiguration;
 import software.xdev.spring.data.eclipse.store.repository.config.EclipseStoreRepositoryConfigurationExtension;
 
@@ -47,9 +48,9 @@ public class EclipseStoreRepositoryFactoryBean<T extends Repository<S, ID>, S, I
 	extends RepositoryFactoryBeanSupport<T, S, ID>
 {
 	private static final Logger LOG = LoggerFactory.getLogger(EclipseStoreRepositoryFactoryBean.class);
-	private EclipseStoreClientConfiguration configuration;
-	private BeanFactory beanFactory;
 	private Class<?> configurationClass;
+	@Autowired
+	private List<EclipseStoreClientConfiguration> configurations;
 
 	public EclipseStoreRepositoryFactoryBean(
 		final Class<? extends T> repositoryInterface)
@@ -67,66 +68,52 @@ public void setConfigurationClass(final Class<?> configurationClass)
 		this.configurationClass = configurationClass;
 	}
 
-	@Override
-	public void setBeanFactory(final BeanFactory beanFactory)
-	{
-		super.setBeanFactory(beanFactory);
-		this.beanFactory = beanFactory;
-	}
-	
 	@Override
 	@Nonnull
 	protected RepositoryFactorySupport createRepositoryFactory()
 	{
-		final EclipseStoreClientConfiguration ensuredConfiguration = this.ensureConfiguration();
+		final EclipseStoreClientConfiguration ensuredConfiguration = this.getSuitableConfiguration();
 		return new EclipseStoreRepositoryFactory(
 			ensuredConfiguration.getStorageInstance(),
 			ensuredConfiguration.getTransactionManagerInstance(),
 			ensuredConfiguration.getValidator()
 		);
 	}
 
-	private EclipseStoreClientConfiguration ensureConfiguration()
-	{
-		if(this.configuration == null)
-		{
-			this.configuration = this.createConfiguration();
-		}
-		return this.configuration;
-	}
-	
 	/**
 	 * This is surely not the perfect way to get the correct configuration of that context, but it works with multiple
 	 * configurations, with no configuration and with a single configuration.
 	 * <p>
-	 * It checks if there is a configuration class defined (through
-	 * {@link EclipseStoreRepositoryConfigurationExtension}) and then tries to get the bean for it. If no configuration
-	 * is set, the {@link DefaultEclipseStoreClientConfiguration} is used.
+	 * It checks if any of the available configurations are suitable from the {@link #configurationClass}
+	 * and if so, returns it. Otherwise the
+	 * {@link software.xdev.spring.data.eclipse.store.repository.config.DefaultEclipseStoreClientConfiguration}
+	 * should be injected into the {@link #configurations} and get returned.
 	 * </p>
 	 */
-	private EclipseStoreClientConfiguration createConfiguration()
+	private EclipseStoreClientConfiguration getSuitableConfiguration()
 	{
-		Objects.requireNonNull(this.beanFactory);
-		try
+		if(this.configurationClass == null && this.configurations.size() == 1)
 		{
-			if(this.configurationClass != null
-				&& this.beanFactory.getBean(this.configurationClass)
-				instanceof final EclipseStoreClientConfiguration eclipseStoreConfiguration
-			)
-			{
-				return eclipseStoreConfiguration;
-			}
+			return this.configurations.get(0);
 		}
-		catch(final BeansException ex)
+		final Optional<EclipseStoreClientConfiguration> definedConfiguration = this.configurations
+			.stream()
+			.filter(
+				configuration ->
+				{
+					if(this.configurationClass != null)
+					{
+						return this.configurationClass.getName()
+							.equals(ClassUtils.getUserClass(configuration).getName());
+					}
+					return false;
+				}
+			)
+			.findAny();
+		if(definedConfiguration.isEmpty())
 		{
-			LOG.warn(
-				"Could not initiate Bean %s. Using %s instead."
-					.formatted(
-						this.configurationClass.getSimpleName(),
-						DefaultEclipseStoreClientConfiguration.class.getSimpleName()
-					),
-				ex);
+			throw new NoSuchBeanDefinitionException(this.configurationClass);
 		}
-		return this.beanFactory.getBean(DefaultEclipseStoreClientConfiguration.class);
+		return definedConfiguration.get();
 	}
 }