Spring Boot Interview Questions

In a Spring Boot application, the application.properties or application.yml file plays a crucial role in configuring the application. These files allow you to externalize configuration settings, making it easy to manage and change application behavior without modifying the code. They support various configuration options, including database settings, server ports, logging levels, and custom application properties.

Key Roles of application.properties or application.yml

1. Externalized Configuration:

   • These files enable you to externalize configuration, making it easy to manage different environments (development, testing, production) without changing the application code.
   • You can define properties specific to each environment and activate them using profiles.

2. Default Configuration Source:

   • application.properties or application.yml is the default location for application configuration.
   • Spring Boot automatically loads these files and applies the configurations when the application starts.

3. Centralized Configuration Management:

   • They provide a centralized place to manage configuration settings, improving maintainability and reducing the risk of hardcoding values in the application code.

4. Support for Hierarchical Configuration:

   • The application.yml file supports hierarchical data structures, which can be more readable and organized compared to the flat structure of application.properties.

5. Profiles and Environment-Specific Configurations:

   • You can define profiles and environment-specific configurations using these files, making it easy to manage different settings for different environments.

Example Usage

Example application.properties

# Server Configuration
server.port=8080

# Database Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA Configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

# Logging Configuration
logging.level.org.springframework=INFO
logging.level.com.example=DEBUG

Example application.yml

server:
  port: 8080

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: root
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

logging:
  level:
    org.springframework: INFO
    com.example: DEBUG

Profiles and Environment-Specific Configurations

You can use profiles to define environment-specific configurations. For example, you might have different database configurations for development and production environments.

Example application-dev.properties

spring.datasource.url=jdbc:mysql://localhost:3306/devdb
spring.datasource.username=devuser
spring.datasource.password=devpassword

Example application-prod.properties

spring.datasource.url=jdbc:mysql://localhost:3306/proddb
spring.datasource.username=produser
spring.datasource.password=prodpassword

Activating Profiles

You can activate profiles using the spring.profiles.active property in the main application.properties file or via command line arguments.

Activating Profile in application.properties

spring.profiles.active=dev

Activating Profile via Command Line

java -jar myapp.jar --spring.profiles.active=prod

Custom Application Properties

You can define custom properties in these files and access them in your application using the @Value annotation or the @ConfigurationProperties class.

Example Custom Properties

In application.properties

myapp.feature.enabled=true
myapp.feature.name=MyFeature

Accessing Custom Properties Using @Value

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

@Component
public class MyAppConfig {
    
    @Value("${myapp.feature.enabled}")
    private boolean featureEnabled;

    @Value("${myapp.feature.name}")
    private String featureName;

    // Getters and other methods
}

Accessing Custom Properties Using @ConfigurationProperties

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "myapp.feature")
public class MyAppFeatureConfig {

    private boolean enabled;
    private String name;

    // Getters and setters
}

Summary

• Externalized Configuration: Allows you to manage application settings outside the code, making it easier to change configurations across different environments.
• Default Configuration Source: Spring Boot automatically loads configurations from application.properties or application.yml.
• Centralized Management: Provides a centralized place for managing configuration settings.
• Support for Hierarchical Data: application.yml supports hierarchical configurations, which can be more readable.
• Profiles: Define and activate environment-specific configurations easily.
• Custom Properties: Define and access custom properties using @Value or @ConfigurationProperties.

Using application.properties or application.yml, Spring Boot applications can be easily configured and managed, promoting best practices for application configuration and environment management.