Is @Configuration mandatory?

For some circumstances I've got an Spring configuration class that can not be annotated with @Configuration. At the beginning I thought that it couldn't work because Spring configuration must have @Configuration annotation. However, after doing some tests, I've just realized @Configuration is not mandatory.

For example, this is a configuration Java class without @Configuration:

public class NotAnnotatedConfiguration {

    @Bean
    public DemoService demoService() {
        return new DemoService();
    }

}

I've tried to load this configuration in the following test:

@ContextConfiguration(classes = NotAnnotatedConfiguration.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class NotAnnotatedConfigurationTest {

    @Autowired DemoService demoService;

    @Test
    public void load() {
        assertNotNull(this.demoService);
    }

}

And it works! I've got the same result in real applications, not only in tests.

Based on my tests, I think that @Configuration is necessary only when you want the class to be scanned by Spring, otherwise you can give a not annotated configuration to Spring and it will load and scan all the beans defined inside it. However, the AnnotationConfigApplicationContext's javadoc doesn't seem so clear to me (probably I'm misunderstanding something):

/**
 * Create a new AnnotationConfigApplicationContext, deriving bean definitions
 * from the given annotated classes and automatically refreshing the context.
 * @param annotatedClasses one or more annotated classes,
 * e.g. {@link Configuration @Configuration} classes
 */
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
    this();
    register(annotatedClasses);
    refresh();
}

I've created a github repository with my tests to share my conclusions: https://github.com/itelleria/configuration-annotation

The question is, despite working my tests, is it allowed not annotating with @Configuration the java configuration class in Spring?

Thanks in advance.

Solution

I think you are right that Spring will load the config class and also create instances but will not treat the instances as beans. Meaning: other service which uses the DemoService will create several instances for each usage and not as a singleton which would be the default scope when created as a bean.

public class DemoServiceUsage {

    DemoService demoService;

    public DemoServiceUsage(DemoService demoService) {
        this.demoService = demoService;
    }
}

public class NotAnnotatedConfiguration {
    @Bean
    public DemoService demoService() {
        DemoService demoService = new DemoService();
        System.out.println("demoService " + demoService.hashCode());
        return demoService;
    }

    @Bean
    public DemoServiceUsage demoServiceUsage1() {
        return new DemoServiceUsage(demoService());
    }

    @Bean
    public DemoServiceUsage demoServiceUsage2() {
        return new DemoServiceUsage(demoService());
    }
}

@Configuration
@Import({
    NotAnnotatedConfiguration.class
})
public class ApplicationConfig {
}

@ContextConfiguration(classes = ApplicationConfiguration.class)
@RunWith(SpringJUnit4ClassRunner.class)
public class NotAnnotatedConfigurationTest {

    @Autowired
    DemoServiceUsage demoServiceUsage1;

    @Autowired
    DemoServiceUsage demoServiceUsage2;

    @Test
    public void load() {
        assertNotNull(this.demoServiceUsage1);
        assertNotNull(this.demoServiceUsage2);
    }
}

Here you will see that you get multiple demoService outputs with different hashCodes. If demoService would be a bean we should only see one instance as it should have a singleton scope.