Last Updated on February 29th, 2024

After knowing about ‘What is Spring Boot?‘ in detail in a separate article, it’s time to talk about the features of Spring Boot. Needless to say, Spring Boot is full of features, that’s why it is being used in the majority of Java projects now-a-days. In this article, we are going to discuss features of Spring Boot in detail.

If you are attending any interview of Java/Spring Boot, there are high chances that you may be asked to tell about some important features of Spring Boot.

Spring-Boot comes with a lot of handy features that make the developer’s life easier. Below are some of the important features of Spring Boot.

Features of Spring Boot

Spring Boot offers a variety of features that simplify the development, deployment, and management of applications. Spring Boot’s approach spins around the “convention over configuration” idea, which minimizes the need for boilerplate code. It allows developers to focus on building robust and feature-rich applications. In this article, we will discuss some of the key features that make Spring Boot a go-to choice for developers when it comes to creating modern and scalable Java applications. From embedded web servers to automatic configuration and a vast ecosystem of libraries, Spring Boot simplifies the development process and enables the creation of production-ready applications with minimal effort. Let’s dig into the prominent features of Spring Boot one by one.

CommandLineRunner

CommandLineRunner is a one of the very handy features of Spring Boot while testing a functionality just like the thread’s run() method in Core Java. If we want to run some specific code once the Spring Boot Application has started, we can implement the CommandLineRunner interface. This interface provides a single run() method which is called just before SpringApplication.run() completes. Similarly, we have one more interface ApplicationRunner that we can also use. For example, the following code demonstrates the use of CommandLineRunner with the run() method.

@Component 
public class MyCommandLineRunner implements CommandLineRunner {
    
    @Override 
    public void run(String... args) {
       // code that you want to run only once 
    } 
}

If there are several CommandLineRunner or ApplicationRunner beans defined that must be called in a specific order, you can additionally use the @Order annotation or implement the org.springframework.core.Ordered interface.

Note: Don’t forget to apply the @Component annotation on the top of your custom runner class, otherwise you will not see any result on the console. Many developers make this mistake, especially beginners in this field.

Externalized Configuration

Spring Boot offers you to externalize your configuration so that you can work with the same application code in different environments. You can use a variety of external configuration sources, including Java properties files, YAML files, environment variables, and command-line arguments. However, the two formats : ‘.properties’ & ‘.yml’ are the most popular in Spring Boot. Moreover, it is recommended to stick with one format for your entire application. If you have configuration files with both ‘.properties’ and ‘.yml’ format in the same location, ‘.properties’ takes precedence.

YAML

YAML is a superset of JSON and, as such, is a convenient format for specifying hierarchical configuration data. If you have SnakeYAML library on your class path, Spring Boot automatically supports YAML as an alternative to ‘.properties’ file. However, If you use “Starters”, SnakeYAML automatically comes with spring-boot-starter. YAML format files takes extension as ‘.yml’.

Mapping YAML to Properties

As aforementioned, YAML files are known for their hierarchical structure. Here will will take an example of YAML file in order to know how it looks. Further, we will convert it to a properties file. For example, consider the following ‘.yml’ file.

environments: 
  prod: 
    url: https://prod.example.com
    name: Production Setup
    host: 10.10.10.40 
  dev: 
    url: https://dev.example.com 
    name: Development Setup
    host: 10.10.10.30

it’s equivalent ‘.properties’ file will look like below:

environments.prod.url=https://prod.example.com 
environments.prod.name=Production Setup
environments.prod.host=10.10.10.40
environments.dev.url=https://dev.example.com
environments.dev.name=Development Setup 
environments.dev.host=10.10.10.30

Furthermore, let’s take an example of properties with index. For example, consider the following ‘.yml’ file.

prod: 
  servers:
  - prod1.example.com
  - prod2.example.com
dev: 
 servers:
 - dev1.example.com
 - dev2.example.com

it’s equivalent ‘.properties’ file will look like :

prod.servers[0]=prod1.example.com
prod.servers[1]=prod2.example.com
dev.servers[0]=dev1.example.com
dev.servers[1]=dev2.example.com

Hence, Properties that use the [index] notation can be bound to Java List or Set objects easily. However, YAML files cannot be loaded by using the @PropertySource or @TestPropertySource annotations. So, in that case, you need to use a ‘.properties’ file. Moreover, Spring Framework provides two convenient classes that we can use to load YAML documents. The YamlPropertiesFactoryBean loads YAML as Properties and the YamlMapFactoryBean loads YAML as a Map. We can also use the YamlPropertySourceLoader class if we want to load YAML as a Spring PropertySource.

In order to learn more complicated examples of ‘.properties’/’.yml’ file, kindly visit our separate article on Spring Boot Application Properties.

Profiles

Spring Profiles offer a way to separate out parts of your application configuration and make it be available only in particular environments. We can mark @Profile on top of any class annotated with @Component, @Configuration or @ConfigurationProperties to limit when it is loaded. For example, below code demonstrates the concept.

@Profile("production") 
@Configuration 
public class ProductionConfig { 
        // ... 
}

Moreover, we can use a ‘spring.profiles.active’ Environment property to describe which profiles are active. For example, we could include it in our ‘application.properties’, as shown in the following example:

spring.profiles.active=prod

Profile Groups

Sometimes we could need to create multiple profiles to separate artifacts. For example, we might have db profiles and security profiles that we use to enable database and security features separately. In order to help with this, Spring Boot offers us to define profile groups. A profile group allows us to define a logical name for a related group of profiles. For example, we can create a production group that consists of our proddb and prodsecurity profiles. For instance, we will need below entry in our application.properties file.

spring.profiles.group.production[0]=proddb 
spring.profiles.group.production[1]=prodsecurity

Consequently, our application can now be started using ‘–spring.profiles.active=production‘ to activate the production, proddb and prodsecurity profiles in one hit.

In order to learn more about profiles in Spring Boot, kindly visit our separate article on How to Write Spring Boot Application Profiles?.

JSON Support

spring.r2dbc.url=r2dbc:postgresql://localhost/test
spring.r2dbc.username=dbuser
spring.r2dbc.password=dbpass

@Component 
public class MyMathService {
    @Cacheable("piDecimals") 
    public int computePiDecimal(int precision) {
           ... 
    }
}