Master Spring 7 BeanRegistrar: Dynamic Bean Registration Made Simple

Introduction

Starting with Spring Framework 7, Spring offers first‑class programmatic bean registration support via the BeanRegistrar interface, allowing flexible and efficient dynamic bean management within the application context.

BeanRegistrar Interface

Basic Usage

Bean registrar implementations are typically imported into a @Configuration class using the @Import annotation.

@Configuration
@Import(MyBeanRegistrar.class)
class MyConfiguration {
}

Conditional annotations such as @Conditional (and its variants) can be used to import bean registrars conditionally.

Implementation Example

The bean registrar uses the BeanRegistry and Environment APIs to register beans with concise, flexible code, supporting if expressions, for loops, and custom registration logic.

class MyBeanRegistrar implements BeanRegistrar {
    @Override
    public void register(BeanRegistry registry, Environment env) {
        // Basic bean registration
        registry.registerBean("foo", Foo.class);

        // Advanced bean registration with options
        registry.registerBean("bar", Bar.class, spec -> spec
                .prototype()
                .lazyInit()
                .description("Custom description")
                .supplier(context -> new Bar(context.bean(Foo.class))));

        // Conditional bean registration
        if (env.matchesProfiles("baz")) {
            registry.registerBean(Baz.class, spec -> spec
                    .supplier(context -> new Baz("Hello, World!")));
        }
    }
}

The bean registrar supports AOT optimization for both JVM and GraalVM native images; this feature may evolve in future releases.

Comparison with Traditional Methods

Limitations of @Conditional Annotation

While the @Conditional family is crucial for conditional bean registration, it has drawbacks in complex scenarios:

Limited expressive power – cannot directly use programming constructs such as loops, branches, or exception handling.

Debugging difficulty – the matching process is opaque, making issue diagnosis costly.

These constraints become evident when dynamic decisions, complex condition combinations, or deep runtime environment interactions are required.

Programmatic Registration before Spring 7

Developers who explore Spring’s source code will notice that the BeanDefinitionRegistry based registration is widely used across the Spring ecosystem (auto‑configuration, starters, etc.). It offers high flexibility but comes with a steep learning curve and complexity.

Main Methods

Using BeanDefinitionRegistry

Implement BeanDefinitionRegistryPostProcessor (Spring 3.0+).

Manually create and configure BeanDefinition objects.

More verbose and complex.

Using SingletonBeanRegistry

Access via ConfigurableListableBeanFactory.

Simpler but limited to already‑created singleton instances.

Limited control over bean definition attributes.

public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry bdr) {
    BeanDefinition definition = new RootBeanDefinition(MyClass.class);
    bdr.registerBeanDefinition("myId", definition);
}

ConfigurableListableBeanFactory beanFactory = ((ConfigurableApplicationContext) applicationContext).getBeanFactory();
beanFactory.registerSingleton(bean.getClass().getCanonicalName(), bean);

Advantages and Outlook

Spring Framework 7’s new programmatic bean registration represents a significant improvement over previous approaches. It simplifies common registration patterns, follows Spring’s trend toward more modern and developer‑friendly APIs, and maintains backward compatibility with existing methods.