What are the ways to configure a Spring application…

XML Configuration: Using XML files to define beans, dependencies, and other settings.

<!-- 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="myService" class="com.example.MyService">
        <property name="dependency" ref="myDependency"/>
    </bean>

    <bean id="myDependency" class="com.example.MyDependency"/>

</beans>

Java Configuration (Config Classes): Using Java classes with the @Configuration annotation and methods marked with @Bean to define beans.

// AppConfig.java
package com.example;

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

@Configuration // Indicates this is a configuration class
public class AppConfig {

    @Bean // Declares the method as a bean provider
    public MyService myService() {
        return new MyService();
    }

    @Bean
    public MyDependency myDependency() {
        return new MyDependency();
    }
}

Annotation-based Configuration: Using annotations such as @Component, @Service, @Repository, @Controller, @Autowired, and @Qualifier for automatic bean creation and injection.

// MyService.java
package com.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service // Marks the class as a service component
public class MyService {

    private final MyDependency myDependency;

    @Autowired // Injects the dependency
    public MyService(MyDependency myDependency) {
        this.myDependency = myDependency;
    }

    // ... other methods
}

Hibernate/JPA Second Level Cache: (If applicable) Configuring entity caching for performance enhancement. Usually configured via properties in application.properties or application.yml.

# application.properties
spring.jpa.properties.hibernate.cache.use_second_level_cache=true
spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

Configuration via application.properties or application.yml: Files for external application configuration, allowing setting property values (ports, DB settings, timeout values, etc.).

# application.yml
server:
  port: 8080

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydatabase
    username: myuser
    password: mypassword

Profile-based Configuration (@Profile): Allows activating different configuration sets depending on the active profile (e.g., dev, test, prod).

// DataSourceConfig.java
package com.example;

import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

@Configuration
public class DataSourceConfig {

    @Bean
    @Profile("dev") // Active only in "dev" profile
    public DataSource devDataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("org.postgresql.Driver");
        dataSource.setUrl("jdbc:postgresql://localhost:5432/devdb");
        dataSource.setUsername("devuser");
        dataSource.setPassword("devpassword");
        return dataSource;
    }

    @Bean
    @Profile("prod") // Active only in "prod" profile
    public DataSource prodDataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("org.postgresql.Driver");
        dataSource.setUrl("jdbc:postgresql://localhost:5432/proddb");
        dataSource.setUsername("produser");
        dataSource.setPassword("prodpassword");
        return dataSource;
    }
}

External Configuration Sources: Using external systems like Spring Cloud Config Server, HashiCorp Consul, Kubernetes ConfigMaps for centralized configuration management.

These methods can be used separately or in combination. Modern practice aims to maximize the use of Java configuration and annotations, combined with property files for external settings.

What are the ways to configure a Spring application?