What are the ways to configure a Spring application…

There are three main approaches:

XML Configuration:

Uses an XML file to define beans and their relationships.
The main file is applicationContext.xml.
Suitable for large and complex configurations.
Considered an outdated approach compared to annotations and JavaConfig.

<!-- applicationContext.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="myBean" class="com.example.MyBean">
        <property name="message" value="Hello from XML!"/>
    </bean>

</beans>

Annotation-based Configuration:

Uses annotations directly in Java code to define beans and dependency injection.
Main annotations: @Component, @Service, @Repository, @Controller, @Autowired, @Qualifier, @Value.
Requires enabling <context:component-scan> in XML or using @ComponentScan in JavaConfig.
Makes the code more compact and readable.

// com.example.MyBean.java
package com.example;

import org.springframework.stereotype.Component;
import org.springframework.beans.factory.annotation.Value;

@Component // Annotation to define a bean
public class MyBean {

    @Value("${my.property}") // Injects value from properties file
    private String message;

    public String getMessage() {
        return message;
    }
}

<!-- applicationContext.xml (for enabling component scanning) -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.example"/> <!-- Package scanning -->

</beans>

JavaConfig:

Uses Java classes annotated with @Configuration to define beans and their configuration.
Methods annotated with @Bean return bean instances.
Provides full flexibility of Java language for creating complex configurations.
The recommended approach in modern Spring applications.

// com.example.AppConfig.java
package com.example;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration // Declares the class as a configuration
public class AppConfig {

    @Bean // Declares the method as a bean factory
    public MyBean myBean() {
        MyBean bean = new MyBean();
        bean.setMessage("Hello from JavaConfig!"); // Example of setting a property
        return bean;
    }
}

Often, in real applications, a combination of these approaches is used, where JavaConfig and annotations are preferred. Properties files (.properties or .yml) are also used to externalize configuration parameters.

What are the ways to configure a Spring application?