Exploring Spring Boot 3: Most Used and Undervalued Features

Spring Boot 3 has made significant waves in the Java development community with its powerful features and improvements. It offers simplicity, speed, and flexibility to build enterprise-grade applications. In this blog post, we’ll dive into three of the most used features and explore some undervalued, yet powerful functionalities that often get overlooked.

Most Used Features in Spring Boot 3

1. Auto-Configuration

What is it?

Spring Boot’s auto-configuration is perhaps the most popular feature, automating many tedious setup tasks. When you add dependencies (like for a database or a messaging queue), Spring Boot automatically configures them based on best practices without manual configuration.

Why is it used?

This is a huge time-saver because developers don’t have to manually configure complex systems like data sources, messaging brokers, or security. Spring Boot does most of the heavy lifting for you.

Example:

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

When you include the dependency for a database (like H2 or MySQL), Spring Boot automatically configures a DataSource without you writing extra configuration files like application.properties.

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

In Action:

If you add a JPA dependency (for example, with Hibernate), Spring Boot will automatically configure JPA with Hibernate as the default provider. All you need to focus on is your code—no need to write XML files or tons of configuration!

2. Spring Boot Actuator

What is it?

Actuator is a tool in Spring Boot that helps you monitor and manage your application in production by exposing endpoints to check the health, metrics, and other operational data of your application.

Why is it used?

Actuator is indispensable in production systems. It provides insights into the application’s current state, metrics like memory usage, uptime, and even custom health checks. This can be integrated with monitoring tools like Prometheus or Micrometer to help in better observability.

Example:

Adding the Spring Boot Actuator dependency:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

By default, some endpoints like /actuator/health and /actuator/info are enabled:

GET /actuator/health

Response:

{
    "status": "UP"
}

In Action:

You can enable metrics and monitoring endpoints for tracking memory, CPU usage, or even database connections. Actuator helps your team identify potential issues in real time by integrating with monitoring platforms.

3. Spring Data JPA

What is it?

Spring Data JPA is a powerful abstraction over JPA, allowing you to interact with databases easily without writing a lot of boilerplate code.

Why is it used?

It simplifies database interactions by reducing the complexity of writing SQL queries and provides an easy way to perform CRUD operations through repository interfaces.

Example:

Creating a repository to interact with a database:

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;
}

public interface UserRepository extends JpaRepository<User, Long> {
    List<User> findByName(String name);
}

Now, using UserRepository, you can perform database operations like saving, retrieving, and searching for User objects with minimal code.

In Action:

Spring Data JPA can automatically generate methods like findByName() or even complex queries based on method names, reducing the need for manually writing queries.

Most Undervalued Features in Spring Boot 3

While some features in Spring Boot 3 are widely used, others remain undervalued or underutilized despite being incredibly useful. Let’s highlight a few of these hidden gems.

1. Spring Boot DevTools

What is it?

Spring Boot DevTools is a set of tools designed to speed up the development process by enabling live reload and automatic application restarts when code changes.

Why is it undervalued?

Many developers don’t take full advantage of DevTools during development, not realizing how it can improve productivity by avoiding constant manual restarts.

Example:

Simply add DevTools as a dependency in your pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

In Action:

With DevTools, changes made to the code are automatically reflected in your running application, without having to restart the application manually every time. This feature can save valuable development time, especially in large projects.

2. Profiles and Configuration Properties

What is it?

Spring Boot profiles allow you to define different configurations for different environments (development, testing, production, etc.). Configuration properties make it easy to externalize configuration, allowing for environment-specific values.

Why is it undervalued?

Developers often overlook how powerful and flexible profiles can be, especially when deploying the same codebase across multiple environments. Using configuration properties and profiles smartly can lead to better code organization and easier deployments.

Example:

Define properties for different environments in separate files like:

# application-dev.properties
spring.datasource.url=jdbc:h2:mem:testdb

# application-prod.properties
spring.datasource.url=jdbc:mysql://prod-db:3306/proddb

You can specify which profile to use at runtime by setting the environment variable:

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

In Action:

This allows you to seamlessly switch between different environments without changing the code. You can also define custom profiles (like “staging”) to fine-tune how your application behaves in each environment.

3. Custom Error Pages and Exception Handling

What is it?

Spring Boot provides easy mechanisms for customizing error pages and handling exceptions in a user-friendly manner.

Why is it undervalued?

Many developers rely on default error pages and don’t realize how easy it is to give users a better experience when something goes wrong.

Example:

You can define a @ControllerAdvice class to handle specific exceptions globally:

@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ResponseEntity<String> handleNotFoundException(ResourceNotFoundException ex) {
        return new ResponseEntity<>("Resource not found: " + ex.getMessage(), HttpStatus.NOT_FOUND);
    }
}

You can also create a custom error page for specific HTTP errors by placing an error.html file in the resources/templates directory:

<html>
<body>
    <h1>Oops! Something went wrong</h1>
    <p>The page you are looking for does not exist.</p>
</body>
</html>

In Action:

By handling errors gracefully, you provide users with a better experience and maintain a professional look even when things go wrong. It’s also easy to implement custom error responses in JSON format for APIs, which makes debugging and client-side handling more efficient.

Conclusion

Spring Boot 3 offers a rich set of features that can significantly boost productivity and simplify development. While the most used features like Auto-Configuration, Actuator, and Spring Data JPA are well-known, undervalued features like DevTools, Profiles, and custom error handling can also elevate your projects if leveraged properly.

By understanding and utilizing both popular and underrated features, you can make the most of Spring Boot 3 and build more robust, efficient, and user-friendly applications. Happy coding!