Spring @Configuration Annotation with Example

In this article, we will discuss a very important Spring Java-based configuration annotation which is a @Configuration annotation with examples.

@Configuration Annotation Overview

Spring @Configuration annotation is part of the spring core framework. 
Spring @Configuration annotation indicates that the class has @Bean definition methods. So Spring container can process the class and generate Spring Beans to be used in the application.
Calls to @Bean methods on @Configuration classes can also be used to define inter-bean dependencies.

Importing Additional Configuration Classes

You need not put all your @Configuration into a single class. The @Import annotation can be used to import additional configuration classes. Alternatively, you can use @ComponentScan to automatically pick up all Spring components, including @Configuration classes.
Read more about @Import annotation on Spring @Import Annotation with Example

Refer below diagram shows an internal implementation for your reference:

@Configuration Annotation Example

The simplest possible @Configuration class would read as follows:
import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.companyname.projectname.customer.CustomerService;
import com.companyname.projectname.order.OrderService;

public class Application {

     public CustomerService customerService() {
         return new CustomerService();
     public OrderService orderService() {
         return new OrderService();
The AppConfig class above would be equivalent to the following Spring XML:
        <bean id="customerService" class="com.companyname.projectname.CustomerService"/>
        <bean id="orderService" class="com.companyname.projectname.OrderService"/>

Injecting inter-bean dependencies

When @Bean have dependencies on one another, expressing that dependency is as simple as having one bean method call another:
public class AppConfig {

    public Foo foo() {
        return new Foo(bar());

    public Bar bar() {
        return new Bar();
In the example above, the foo bean receives a reference to the bar via constructor injection. 

Related Spring and Spring Boot Annotations