Partner – Microsoft – NPI (cat= Spring)
announcement - icon

Azure Spring Apps is a fully managed service from Microsoft (built in collaboration with VMware), focused on building and deploying Spring Boot applications on Azure Cloud without worrying about Kubernetes.

And, the Enterprise plan comes with some interesting features, such as commercial Spring runtime support, a 99.95% SLA and some deep discounts (up to 47%) when you are ready for production.

>> Learn more and deploy your first Spring Boot app to Azure.

You can also ask questions and leave feedback on the Azure Spring Apps GitHub page.

1. Overview

Spring, by default, manages beans’ lifecycle and arranges their initialization order.

But, we can still customize it based on our needs. We can choose either the SmartLifeCycle interface or the @DependsOn annotation for managing initialization order.

This tutorial explores the @DependsOn annotation and its behavior in case of a missing bean or circular dependency. Or in case of simply needing one bean initialized before another.

2. @DependsOn

We should use this annotation for specifying bean dependencies. Spring guarantees that the defined beans will be initialized before attempting an initialization of the current bean.

Let’s say we have a FileProcessor which depends on a FileReader and FileWriter. In this case, FileReader and FileWriter should be initialized before the FileProcessor.

3. Configuration

The configuration file is a pure Java class with @Configuration annotation:

public class Config {
    public FileProcessor fileProcessor(){
        return new FileProcessor();
    public FileReader fileReader() {
        return new FileReader();
    public FileWriter fileWriter() {
        return new FileWriter();

FileProcessor specifies its dependencies with @DependsOn. We can also annotate a Component with @DependsOn:

@DependsOn({"filereader", "fileWriter"})
public class FileProcessor {}

4. Usage

Let us create one class File. Each of the beans updates the text within File. FileReader updates it as read. FileWriter updates it as write and FileProcessor updates the text as processed:

public void WhenFileProcessorIsCreated_FileTextContains_Processed() {
    FileProcessor processor = context.getBean(FileProcessor.class);

4.1. Missing Dependency

In case of missing dependency, Spring throws a BeanCreationException with a base exception of NoSuchBeanDefinitionException. Read more about NoSuchBeanDefinitionException here.

For example, dummyFileProcessor bean depends on a dummyFileWriter bean. Since dummyFileWriter doesn’t exist, it throws BeanCreationException:

public void whenDependentBeanNotAvailable_ThrowsNosuchBeanDefinitionException(){

4.2. Circular Dependency

Also, in this case, it throws BeanCreationException and highlights that the beans have a circular dependency:

public FileProcessor dummyFileProcessorCircular() {
    return new FileProcessor(file);

Circular dependencies can happen if a bean has an eventual dependency on itself, creating a circle:

Bean1 -> Bean4 -> Bean6 -> Bean1

5. Key Points

Finally, there are few points which we should take care of while using @DependsOn annotation:

  • While using @DependsOn, we must use component-scanning
  • If a DependsOn-annotated class is declared via XML, DependsOn annotation metadata is ignored

6. Conclusion

@DependsOn becomes especially useful when building systems with complex dependency requirements.

It facilitates the Dependency Injection, ensuring that Spring will have handled all of the initialization of those required Beans before loading our dependent class.

As always, the code can be found over on GitHub.

Course – LS (cat=Spring)

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

res – REST with Spring (eBook) (everywhere)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.