tessl/maven-org-springframework-boot--spring-boot-autoconfigure

Spring Boot AutoConfigure provides auto-configuration capabilities that automatically configure Spring applications based on jar dependencies present on the classpath

—

Pending

Overview

Eval results

Files

Data Repository Configuration

Name: tessl/maven-org-springframework-boot--spring-boot-autoconfigure
Author: tessl

Spring Boot AutoConfigure provides configuration support for Spring Data repositories with type-based conditional registration and base package management. This enables automatic configuration of JPA, MongoDB, Redis, and other Spring Data repositories.

Imports

import org.springframework.boot.autoconfigure.data.*;
import org.springframework.data.repository.config.BootstrapMode;
import org.springframework.data.util.Streamable;

Conditional Repository Configuration

ConditionalOnRepositoryType

Conditional annotation that matches when a particular type of Spring Data repository has been enabled.

@Target({ ElementType.TYPE, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(OnRepositoryTypeCondition.class)
public @interface ConditionalOnRepositoryType {
    /**
     * The data store type (e.g., JDBC, JPA, MongoDB, Redis).
     * Use RepositoryType.AUTO to automatically detect based on available dependencies.
     * 
     * @return data store type (never null)
     */
    RepositoryType store();

    /**
     * The repository type (imperative, reactive, or auto-detect).
     * Use RepositoryType.IMPERATIVE for traditional blocking repositories.
     * Use RepositoryType.REACTIVE for non-blocking reactive repositories.
     * Use RepositoryType.AUTO to auto-detect based on classpath.
     * 
     * @return repository implementation type (never null)
     */
    RepositoryType type();
}

RepositoryType Enum

Enum defining types of Spring Data repositories to enable.

public enum RepositoryType {
    /**
     * Automatically detect repository type based on dependencies.
     */
    AUTO,

    /**
     * Traditional blocking/imperative repositories.
     */
    IMPERATIVE,

    /**
     * Reactive non-blocking repositories.
     */
    REACTIVE,

    /**
     * No repositories should be enabled.
     */
    NONE
}

Base Configuration Support

AbstractRepositoryConfigurationSourceSupport

Abstract base class for ImportBeanDefinitionRegistrar implementations that provide repository configuration support.

public abstract class AbstractRepositoryConfigurationSourceSupport
        implements ImportBeanDefinitionRegistrar,
                   BeanFactoryAware,
                   ResourceLoaderAware,
                   EnvironmentAware {

    /**
     * Register bean definitions with optional custom bean name generator.
     */
    public void registerBeanDefinitions(
        AnnotationMetadata importingClassMetadata,
        BeanDefinitionRegistry registry,
        BeanNameGenerator importBeanNameGenerator
    );

    /**
     * Register bean definitions.
     */
    public void registerBeanDefinitions(
        AnnotationMetadata importingClassMetadata,
        BeanDefinitionRegistry registry
    );

    /**
     * Set the resource loader.
     */
    public void setResourceLoader(ResourceLoader resourceLoader);

    /**
     * Set the bean factory.
     */
    public void setBeanFactory(BeanFactory beanFactory);

    /**
     * Set the environment.
     */
    public void setEnvironment(Environment environment);

    /**
     * Get the base packages to scan for repositories.
     * Subclasses must implement this method to specify which packages contain repositories.
     * These packages and their sub-packages will be scanned for repository interfaces.
     *
     * @return streamable of base package names (never null, may be empty)
     */
    public Streamable<String> getBasePackages();

    /**
     * Get the bootstrap mode for repository initialization.
     * Subclasses must implement this method to control when repositories are initialized.
     * 
     * Bootstrap modes:
     * - DEFAULT: Eager initialization of repositories at startup
     * - LAZY: Lazy initialization on first use (faster startup)
     * - DEFERRED: Background initialization (fastest startup)
     *
     * @return the bootstrap mode (never null, default: BootstrapMode.DEFAULT)
     */
    public BootstrapMode getBootstrapMode();
}

Configuration Examples

Conditional Repository Configuration

# JPA Repository Configuration
spring:
  data:
    jpa:
      repositories:
        enabled: true
        bootstrap-mode: default  # or 'lazy', 'deferred'

# MongoDB Repository Configuration
spring:
  data:
    mongodb:
      repositories:
        type: auto  # or 'imperative', 'reactive', 'none'

Usage Examples

Custom Repository Configuration

import org.springframework.boot.autoconfigure.data.AbstractRepositoryConfigurationSourceSupport;
import org.springframework.data.repository.config.BootstrapMode;
import org.springframework.data.repository.config.RepositoryConfigurationDelegate;
import org.springframework.data.util.Streamable;

public class CustomRepositoryConfigurationSourceSupport
        extends AbstractRepositoryConfigurationSourceSupport {

    @Override
    public Streamable<String> getBasePackages() {
        // Return base packages to scan
        return Streamable.of(
            "com.example.repositories",
            "com.example.data"
        );
    }

    @Override
    public BootstrapMode getBootstrapMode() {
        // Return bootstrap mode for repository initialization
        return BootstrapMode.DEFAULT;
    }

    @Override
    protected RepositoryConfigurationDelegate createDelegate(
            AnnotationMetadata metadata,
            BeanDefinitionRegistry registry) {
        // Implement configuration delegate creation
        return super.createDelegate(metadata, registry);
    }
}

Conditional Repository Auto-Configuration

import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.data.ConditionalOnRepositoryType;
import org.springframework.boot.autoconfigure.data.RepositoryType;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@AutoConfiguration
@ConditionalOnClass(JpaRepository.class)
@ConditionalOnRepositoryType(
    store = RepositoryType.AUTO,
    type = RepositoryType.IMPERATIVE
)
public class CustomJpaRepositoriesAutoConfiguration {

    @Configuration
    @EnableJpaRepositories(basePackages = "com.example.repositories")
    static class JpaRepositoriesConfiguration {
        // JPA repositories configuration
    }
}

Reactive Repository Configuration

import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.data.ConditionalOnRepositoryType;
import org.springframework.boot.autoconfigure.data.RepositoryType;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
import org.springframework.data.mongodb.repository.config.EnableReactiveMongoRepositories;

@AutoConfiguration
@ConditionalOnClass(ReactiveMongoRepository.class)
@ConditionalOnRepositoryType(
    store = RepositoryType.AUTO,
    type = RepositoryType.REACTIVE
)
public class ReactiveMongoRepositoriesAutoConfiguration {

    @Configuration
    @EnableReactiveMongoRepositories(
        basePackages = "com.example.repositories.reactive"
    )
    static class ReactiveRepositoriesConfiguration {
        // Reactive MongoDB repositories configuration
    }
}

Bootstrap Mode Configuration

import org.springframework.boot.autoconfigure.data.AbstractRepositoryConfigurationSourceSupport;
import org.springframework.data.repository.config.BootstrapMode;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("spring.data.custom")
public class CustomRepositoryProperties {
    private BootstrapMode bootstrapMode = BootstrapMode.DEFAULT;

    public BootstrapMode getBootstrapMode() {
        return bootstrapMode;
    }

    public void setBootstrapMode(BootstrapMode bootstrapMode) {
        this.bootstrapMode = bootstrapMode;
    }
}

public class CustomRepositoryConfiguration
        extends AbstractRepositoryConfigurationSourceSupport {

    private final CustomRepositoryProperties properties;

    public CustomRepositoryConfiguration(CustomRepositoryProperties properties) {
        this.properties = properties;
    }

    @Override
    public BootstrapMode getBootstrapMode() {
        return properties.getBootstrapMode();
    }

    @Override
    public Streamable<String> getBasePackages() {
        return Streamable.of("com.example.repositories");
    }
}

Multi-Module Repository Configuration

import org.springframework.boot.autoconfigure.AutoConfiguration;
import org.springframework.boot.autoconfigure.data.ConditionalOnRepositoryType;
import org.springframework.boot.autoconfigure.data.RepositoryType;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;

@AutoConfiguration
public class MultiStoreRepositoriesAutoConfiguration {

    @Configuration
    @ConditionalOnRepositoryType(
        store = RepositoryType.AUTO,
        type = RepositoryType.IMPERATIVE
    )
    @EnableJpaRepositories(
        basePackages = "com.example.repositories.jpa",
        entityManagerFactoryRef = "entityManagerFactory",
        transactionManagerRef = "transactionManager"
    )
    static class JpaRepositoriesConfiguration {
    }

    @Configuration
    @ConditionalOnRepositoryType(
        store = RepositoryType.AUTO,
        type = RepositoryType.IMPERATIVE
    )
    @EnableMongoRepositories(
        basePackages = "com.example.repositories.mongo",
        mongoTemplateRef = "mongoTemplate"
    )
    static class MongoRepositoriesConfiguration {
    }
}

Best Practices

Package Organization: Keep repositories in separate packages by data store type
Bootstrap Mode: Use DEFERRED or LAZY for faster application startup
Type Safety: Use ConditionalOnRepositoryType for type-safe repository detection
Base Packages: Specify explicit base packages to avoid unnecessary scanning
Multi-Store: Use separate configurations for different data store types
Testing: Test repository configurations with different bootstrap modes

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework-boot--spring-boot-autoconfigure

tessl/maven-org-springframework-boot--spring-boot-autoconfigure

data-configuration.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/reference/

Data Repository Configuration

Imports

Conditional Repository Configuration

ConditionalOnRepositoryType

RepositoryType Enum

Base Configuration Support

AbstractRepositoryConfigurationSourceSupport

Configuration Examples

Conditional Repository Configuration

Usage Examples

Custom Repository Configuration

Conditional Repository Auto-Configuration

Reactive Repository Configuration

Bootstrap Mode Configuration

Multi-Module Repository Configuration

Best Practices

data-configuration.mddocs/reference/