1. Overview

In this tutorial, we’ll learn how to set beans in the Spring context to nulls. This might be useful in some cases, such as testing when we don’t want to provide mocks. Also, while using some optional features, we might want to avoid creating implementation and pass null instead.

Additionally, this way, we can create placeholders if we want to defer the decision of picking needed implementation outside of the beans’ lifecycle. Lastly, this technique might be the first step during the deprecation process, which involves removing specific beans from the context.

2. Components Setup

A couple of ways exist to set a bean to null, depending on how the context is configured. We’ll consider XML, annotation, and Java configurations. We’ll be using a simple setup with two classes:

@Component
public class MainComponent {
    private SubComponent subComponent;
    public MainComponent(final SubComponent subComponent) {
        this.subComponent = subComponent;
    }
    public SubComponent getSubComponent() {
        return subComponent;
    }
    public void setSubComponent(final SubComponent subComponent) {
        this.subComponent = subComponent;
    }
}

We’ll show how to set SubComponent to null in the Spring context:

@Component
public class SubComponent {}

3. XML Configuration Using Placeholder

In XML configuration, we can use a special placeholder to identify null values:

<beans>
    <bean class="com.baeldung.nullablebean.MainComponent" name="mainComponent">
        <constructor-arg>
            <null/>
        </constructor-arg>
    </bean>
</beans>

This configuration would provide the following result:

@Test
void givenNullableXMLContextWhenCreatingMainComponentThenSubComponentIsNull() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
      "nullable-application-context.xml");
    MainComponent bean = context.getBean(MainComponent.class);
    assertNull(bean.getSubComponent());
}

4. XML Configuration Using SpEL

We can achieve similar results using SpEL in XML. There will be a couple of differences from the previous configuration:

<beans>
    <bean class="com.baeldung.nullablebean.MainComponent" name="mainComponent">
        <constructor-arg value="#{null}"/>
    </bean>
</beans>

Similarly to the last test, we can identify that the SubComponent is null:

@Test
void givenNullableSpELXMLContextWhenCreatingMainComponentThenSubComponentIsNull() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
      "nullable-spel-application-context.xml");
    MainComponent bean = context.getBean(MainComponent.class);
    assertNull(bean.getSubComponent());
}

5. XML Configuration Using SpEL With Properties

One of the ways to improve the previous solution is to store the bean name in a property file. This way, we can pass a null value whenever needed without changing the configuration:

nullableBean = null

The XML configuration would use PropertyPlaceholderConfigurer to read the properties:

<beans>
    <bean id="propertyConfigurer"
      class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:nullable.properties"/>
    </bean>
    <bean class="com.baeldung.nullablebean.MainComponent" name="mainComponent">
        <constructor-arg value="#{ ${nullableBean} }"/>
    </bean>
    <bean class="com.baeldung.nullablebean.SubComponent" name="subComponent"/>
</beans>

However, we should use the property placeholder inside the SpEL expression so that the values would be read correctly. As a result, we’ll initialize the SubComponent to null:

@Test
void givenNullableSpELXMLContextWithNullablePropertiesWhenCreatingMainComponentThenSubComponentIsNull() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
      "nullable-configurable-spel-application-context.xml");
    MainComponent bean = context.getBean(MainComponent.class);
    assertNull(bean.getSubComponent());
}

To provide an implementation, we’ll have to change only the properties:

nullableBean = subComponent

6. Null Supplier in Java Configuration

It’s impossible to return null directly from a method annotated with @Bean. That’s why we need to wrap it in some way. We can use Supplier to do so:

@Bean
public Supplier<SubComponent> subComponentSupplier() {
    return () -> null;
}

Technically, we can use any class to wrap a null value, but using Supplier is more idiomatic. In the case of null, we don’t care that the Supplier might be called several times. However, if we want to implement a similar solution for the usual beans, we must ensure that the Supplier provides the same instance if a singleton is required.

This solution would also provide us with the correct behavior:

@Test
void givenNullableSupplierContextWhenCreatingMainComponentThenSubComponentIsNull() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
      NullableSupplierConfiguration.class);
    MainComponent bean = context.getBean(MainComponent.class);
    assertNull(bean.getSubComponent());
}

Note that simply returning null from @Bean might create problems:

@Bean
public SubComponent subComponent() {
    return null;
}

In this case, the context would fail with UnsatisfiedDependencyException:

@Test
void givenNullableContextWhenCreatingMainComponentThenSubComponentIsNull() {
    assertThrows(UnsatisfiedDependencyException.class, () ->  new AnnotationConfigApplicationContext(
      NullableConfiguration.class));
}

7. Using Optional

When using Optional, Spring automatically identifies that the bean can be absent from the context and passes null without any additional configuration:

@Bean
public MainComponent mainComponent(Optional<SubComponent> optionalSubComponent) {
    return new MainComponent(optionalSubComponent.orElse(null));
}

If Spring cannot find SubComponent in the context, it will pass an empty Optional:

@Test
void givenOptionableContextWhenCreatingMainComponentThenSubComponentIsNull() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
      OptionableConfiguration.class);
    MainComponent bean = context.getBean(MainComponent.class);
    assertNull(bean.getSubComponent());
}

8. Non-Required Autowiring

Another way to use null as a value for a bean is to declare it non-required. However, this method would work only with non-constructor injections:

@Component
public class NonRequiredMainComponent {
    @Autowired(required = false)
    private NonRequiredSubComponent subComponent;
    public NonRequiredSubComponent getSubComponent() {
        return subComponent;
    }
    public void setSubComponent(final NonRequiredSubComponent subComponent) {
        this.subComponent = subComponent;
    }
}

This dependency is not required for the proper functioning of the component:

@Test
void givenNonRequiredContextWhenCreatingMainComponentThenSubComponentIsNull() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
      NonRequiredConfiguration.class);
    NonRequiredMainComponent bean = context.getBean(NonRequiredMainComponent.class);
    assertNull(bean.getSubComponent());
}

9. Using @Nullable

Additionally, we can use @Nullable annotation to identify that we expect that the bean might be null. Both Spring and Jakarta annotations would work for this:

@Component
public class NullableMainComponent {
    private NullableSubComponent subComponent;
    public NullableMainComponent(final @Nullable NullableSubComponent subComponent) {
        this.subComponent = subComponent;
    }
    public NullableSubComponent getSubComponent() {
        return subComponent;
    }
    public void setSubComponent(final NullableSubComponent subComponent) {
        this.subComponent = subComponent;
    }
}

We don’t need to identify NullableSubComponent as a Spring component:

public class NullableSubComponent {}

Spring context will set it to null based on the @Nullable annotation:

@Test
void givenContextWhenCreatingNullableMainComponentThenSubComponentIsNull() {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
      NullableJavaConfiguration.class);
    NullableMainComponent bean = context.getBean(NullableMainComponent.class);
    assertNull(bean.getSubComponent());
}

10. Conclusion

Using nulls in a Spring context isn’t the most common practice, but it might be reasonable sometimes. However, the process of setting a bean to null might not be very intuitive.

In this article, we’ve learned how to address this issue in multiple ways.

As always, the code from the article is available over on GitHub.

Course – LS (cat=Spring)
announcement - icon

Get started with Spring Boot and with core Spring, through the Learn Spring course:

>> CHECK OUT THE COURSE

res – REST with Spring (eBook) (everywhere)