The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Spring Boot Configuration

Next ►
►

In this section, we will explore how to configure a Spring Boot application. Configuration is a crucial aspect of any application as it allows you to customize the behavior of your application without changing the code. Spring Boot provides several ways to configure your application, making it flexible and easy to manage.

Key Concepts

  1. Application Properties and YAML Files
  2. Externalized Configuration
  3. Profiles
  4. Configuration Classes
  5. Environment Variables

  1. Application Properties and YAML Files

Spring Boot allows you to define configuration properties in two main formats: application.properties and application.yml.

application.properties

This is the default configuration file format in Spring Boot. It uses key-value pairs to define properties.

# application.properties
server.port=8081
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret

application.yml

YAML is a more readable format, especially for hierarchical data.

# application.yml
server:
  port: 8081

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mydb
    username: root
    password: secret

  1. Externalized Configuration

Spring Boot allows you to externalize your configuration so that you can work with the same code in different environments. You can place your configuration files in different locations:

  • Inside your project (src/main/resources)
  • Outside your project (e.g., /config directory)
  • As environment variables
  • As command-line arguments

Example

java -jar myapp.jar --server.port=8081

  1. Profiles

Profiles allow you to define different configurations for different environments (e.g., development, testing, production).

Defining Profiles

You can define profiles in your application.properties or application.yml files.

# application.properties
spring.profiles.active=dev
# application-dev.yml
server:
  port: 8081

# application-prod.yml
server:
  port: 80

Activating Profiles

You can activate profiles using environment variables or command-line arguments.

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

  1. Configuration Classes

Spring Boot allows you to use Java classes to define your configuration. This is useful for more complex configurations.

Example

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

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
}

  1. Environment Variables

Spring Boot can read configuration properties from environment variables. This is particularly useful for cloud-based deployments.

Example

export SPRING_DATASOURCE_URL=jdbc:mysql://localhost:3306/mydb
export SPRING_DATASOURCE_USERNAME=root
export SPRING_DATASOURCE_PASSWORD=secret

Practical Example

Let's create a simple Spring Boot application that uses different configurations for development and production environments.

Step 1: Create a Spring Boot Application

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

Step 2: Define Configuration Files

application.yml

spring:
  profiles:
    active: dev

application-dev.yml

server:
  port: 8081

application-prod.yml

server:
  port: 80

Step 3: Run the Application

# For development
java -jar myapp.jar

# For production
java -jar myapp.jar --spring.profiles.active=prod

Exercises

Exercise 1: Create a Custom Configuration

  1. Create a new Spring Boot application.
  2. Define a custom configuration property in application.properties.
  3. Create a configuration class to read this property.
  4. Print the property value in the main application class.

Solution

Step 1: Create a Spring Boot Application

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

Step 2: Define a Custom Configuration Property

# application.properties
myapp.custom.message=Hello, Spring Boot!

Step 3: Create a Configuration Class

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CustomConfig {

    @Value("${myapp.custom.message}")
    private String customMessage;

    public String getCustomMessage() {
        return customMessage;
    }
}

Step 4: Print the Property Value

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyAppRunner implements CommandLineRunner {

    @Autowired
    private CustomConfig customConfig;

    @Override
    public void run(String... args) throws Exception {
        System.out.println(customConfig.getCustomMessage());
    }
}

Conclusion

In this section, we covered the basics of configuring a Spring Boot application. We explored different ways to define and manage configuration properties, including using properties and YAML files, externalized configuration, profiles, configuration classes, and environment variables. We also provided a practical example and an exercise to reinforce the concepts. Understanding these configuration options will help you build flexible and maintainable Spring Boot applications.

◄ Previous
◄
Next ►
►

Spring Boot Course

Module 1: Introduction to Spring Boot

Module 2: Spring Boot Basics

Module 3: Building RESTful Web Services

Module 4: Data Access with Spring Boot

Module 5: Spring Boot Security

Module 6: Testing in Spring Boot

Module 7: Advanced Spring Boot Features

Module 8: Deploying Spring Boot Applications

Module 9: Performance and Monitoring

Module 10: Best Practices and Tips

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved