How is autowired deciding which context/configuration file to use

Scenario: Spring Mvc application with xml configuration file (auto scanning and setting mvc dispatcher - standard config). Also there is Java configuration file (within autoscanned package) with one bean, let's call it A. Then we have RestController which uses @autowired annotation to inject bean A and then use this object iside the controller in some way.

Question: How does autowired annotation knows where to look for bean in java annotated configuration file?
If my understanding is correct, the context that is being used for autowired in the controller should be created from xml file and all autoscanned classes (anotated with Component) - so how does this work and how does it access bean from java configuration file?

From javadoc of @Configuration:

> lang-java
> @Target(value=TYPE)
> @Retention(value=RUNTIME)
> @Documented
> @Component
> public @interface Configuration
>
>
Indicates that a class declares one or
> more @Bean methods and may be processed by the Spring container to
> generate bean definitions and service requests for those beans at
> runtime.

So your @Configuration class will be scanned as a @Component when it is in one of the base-packages defined with <context:component-scan/> in your XML configuration.

If you want the @Configuration class to work without XML configuration, you need to initialize the context using AnnotationConfigApplicationContext.

Example web.xml:

<web-app>
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>
            org.springframework.web.context.support.AnnotationConfigWebApplicationContext
        </param-value>
    </context-param>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>com.acme.AppConfig</param-value>
    </context-param>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- Declare a Spring MVC DispatcherServlet as usual -->
    <servlet>
        <!-- Configuration goes here -->
    </servlet>

    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>

<br/>
Note:

From Spring Framework Reference:

> Annotation injection is performed before XML injection. Thus, the XML
> configuration overrides the annotations for properties wired through
> both approaches.

<br/>
Further Reading:

• Instantiating the Spring Container by Using AnnotationConfigApplicationContext in Spring Framework Reference.

It's on-demand bean injection.

Spring looks for all the configuration classes, from these classes it starts scanning packages and XML files to create beans.

While scanning if it founds that a particular bean has to be created then it will try to create that bean, while creating it may encounter that this bean is depending on other beans, now it will try to create other dependents beans. Once dependent beans are created they can now be autowired either using Field injection or construction injection. While creating it needs to also consider lazy and optional beans. Spring follows the bean creation path as they require, if you give package name in the scanner then this can create a cycle as well.

For XML things become more complex, for example, a XML bean might be depending on package scanner based and vice-versa then spring has to go through each XML file to see how to create that bean.