Using DTOs is helpful when building applications that hold sensitive data like financial or health records. When used properly, DTOs can prevent sensitive fields from being exposed to the client side. In critical systems, they can further tighten security and reduce failure conditions by ensuring that only valid and required fields are accepted.

In this article, you’ll learn what DTOs are, why they’re important, and the best ways to create them for your Spring-based applications.

Prerequisites

This is a slightly more advanced tutorial. So to understand it better, you should have a sound knowledge of Java concepts like objects, getters and setters, and Spring/Spring Boot. You should also have a solid understanding of how software works in general.

Table of Contents

• What is a DTO?

• How to Create a DTO for a Spring-Based Application

• How to Create DTOs From Two or Multiple Objects

• Conclusion

What is a DTO?

DTOs stand for Data Transfer Objects. It is a software design pattern that ensures the transfer of tailored/streamlined data objects between different layers of a software system.

Image source | Fabio Ribeiro

The direction of data transfer with DTOs across the various layers of software is bi-directional. DTOs are either used to carry data in an inbound direction from an external client/user to the software or are constructed and used to carry data in an outbound direction from the software.

DTOs only hold field data, constructors, and necessary getter and setter methods. So they are Plain Old Java Objects (POJOs).

You can see the bi-directional flow in the image below:

Image source | Fabio Ribeiro

Why Use DTOs?

1. Data Privacy

In Spring Boot, entities serve as the blueprint for creating data objects. These entities are classes annotated with @Entity and map to a database table. An instance of the entity class represents a database row or record, while a field in the entity class represents a database column.

When registering for a software service or product, the user might be asked to provide both sensitive and non-sensitive data for the proper functioning of the application. These data are held as fields by the entity class and finally mapped and persisted to the database.

When we need to retrieve data from the database and expose it through an API endpoint based on the query provided – say, a query to retrieve a user record or entity, Jackson (the serializer dependency commonly used in Spring-based applications) serialises all the data fields contained in the retrieved user entity. Now, imagine you have a User entity that contains fields like password, credit card details, date of birth, home address, and other sensitive data you wouldn’t want to reveal when the User entity is being serialised. Well, this is where DTOs come in.

With DTOs, you can retrieve the complete entity (containing both sensitive and insensitive data) from the database, create a custom class (say UserDTO.java) that only holds the insensitive fields that you feel are safe to expose, and finally, map the database-retrieved entity to the safe-to-expose UserDTO object. This way, the UserDTO is what gets serialised and exposed through the API endpoint and not the complete entity – keeping the sensitive data confidential.

2. Improved Software Performance

DTOs can improve the performance of your software application by reducing the number of API calls for data retrieval. With DTOs, you can return serialized data from more than one entity in just one API call.

Let’s say that in your Spring Boot application, there are User and Follower entities, and you want to return user data as well as their followers. Typically, Jackson can only serialize one entity at a time, either User or Follower. But with a DTO, you can combine these two entities into one and eventually serialize and return all the data in a single request, instead of building two endpoints to return user and follower data.

In the next section, I’ll show you the various ways you can create DTOs for your Spring Boot project with code implementations.

How to Create a DTO for a Spring-Based Application

There are two main approaches to creating DTOs in Spring/Spring Boot:

1. Creating Custom Objects and Handling Mapping Manually

This approach requires you to handle the mapping/transforming of your existing entity to the custom object (DTO) by yourself – that is to say, you write the code that creates the DTO and sets the DTO fields to the values present in the existing entity. This is common for developers who prefer fine-grained control, but it can be tedious for large-scale projects.

Follow the steps below to create a UserDTO from a User entity:

Step 1: Create the DTO class

Create a new file named UserDTO.java and write the code below into it:

public class UserDTO {
    private Long id;
    private String firstName;
    private String lastName;
    private String email;


    // No-args Constructor
    public UserDTO() {}

    // All-args constructor
    public UserDTO(Long id, String firstName, String lastName, String email) {
        this.id = id;
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }


    // Getters and Setters
    public Long getId() {
        return id;
    }


    public void setId(Long id) {
        this.id = id;
    }


    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }


    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

}

The defined UserDTO class can only hold four (4) fields: id, firstName, lastName, and email. It’s not capable of exposing or receiving more than this number of fields. The class also contains getter and setter methods for retrieving and assigning data to the fields.

Step 2: Create Mapper Methods Inside a Utility Class

Create a new file named UserMapper.java and put this piece of code into it:

public class UserMapper {

    // Convert Entity to DTO

    public static UserDTO toDTO(UserEntity user) {

        if (user == null) return null;

        UserDTO dto = new UserDTO();
        dto.setId(user.getId());
        dto.setFirstName(user.getFirstName());
        dto.setLastName(user.getLastName());
        dto.setEmail(user.getEmail());
        return dto;
    }


    // Convert DTO to Entity

    public static UserEntity toEntity(UserDTO dto) {

        if (dto == null) return null;
       UserEntity user = new UserEntity(); 
        user.setFirstName(dto.getFirstName());
        user.setLastName(dto.getLastName());
        user.setEmail(dto.getEmail());

        return user;
    }

The UserMapper class is a utility class that maps the UserEntity to a DTO and the DTO to an entity. This is where the bi-directional data transfer I talked about earlier comes into play. First, the UserEntity-DTO-direction involves retrieving the complete record from the database and transforming it into a streamlined object (void of unnecessary information) before it’s serialized and exposed to the client side through an API endpoint.

The DTO-UserEntity-direction involves taking the object from the client side as input into the system, but this time, to limit the client in terms of the number of data fields they can pass to the system. This object is received, mapped to an entity, and saved in the system. This is important when you don’t want the client to have access to certain critical fields (that would make your application vulnerable). That’s why software engineers always say, “Don’t trust the user”.

Let me give you a peek into what our UserEntity looks like:

import jakarta.persistence.*;

import java.time.LocalDate;


@Entity

@Table(name = "users")

public class UserEntity {


    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)

    private Long id;
    private String firstName;
    private String lastName;

    @Column(unique = true)
    private String email;
    private String password;
    private String phoneNumber;
    private String gender;
    private LocalDate dateOfBirth;
    private String address;
    private String city;
    private String state;
    private String country;
    private String profilePictureUrl;
    private boolean isVerified;
    private LocalDate createdAt;
    private LocalDate updatedAt;

    // Constructors
    public UserEntity() {}

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public LocalDate getDateOfBirth() {
        return dateOfBirth;
    }

    public void setDateOfBirth(LocalDate dateOfBirth) {
        this.dateOfBirth = dateOfBirth;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getCountry() {
       return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    public String getProfilePictureUrl() {
        return profilePictureUrl;
    }

    public void setProfilePictureUrl(String profilePictureUrl) {
        this.profilePictureUrl = profilePictureUrl;
    }

    public boolean isVerified() {
        return isVerified;
    }

    public void setVerified(boolean verified) {
        isVerified = verified;
    }

    public LocalDate getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(LocalDate createdAt) {
        this.createdAt = createdAt;
    }

    public LocalDate getUpdatedAt() {
        return updatedAt;
    }

    public void setUpdatedAt(LocalDate updatedAt) {
        this.updatedAt = updatedAt;
    }

}

In the code snippet above, you can see that the UserDTO holds just four (4) fields, which are insensitive and safe to expose upon serialization. These fields are id, firstName, lastName, and email – unlike the UserEntity, which contains both the sensitive and insensitive fields. So, the not-safe-to-expose UserEntity maps to the safe-to-expose UserDTO. With that being done, the UserDTO object can be serialized and returned through an endpoint. You can now see why DTOs help us prevent exposing confidential information.

2. Creating Custom Objects and Handling Mapping Through an External Library

Using an external library means adding a layer of abstraction to the mapping process. The library handles the stressful parts of the job for you, and it’s often a preferred choice for large-scale projects. In this article, we’re using MapStruct because it’s popular and easy to use. Maven will be our build tool.

Step 1: Add the dependency to your project

Since you are using Maven as your build tool, open your pom.xml file and add this code:

<dependencies>
    <!-- MapStruct API -->
    <dependency>
        <groupId>org.mapstruct</groupId>
        <artifactId>mapstruct</artifactId>
        <version>1.5.5.Final</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <!-- Annotation processor plugin -->
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.10.1</version>
            <configuration>
                <annotationProcessorPaths>
                    <path>
                        <groupId>org.mapstruct</groupId>
                        <artifactId>mapstruct-processor</artifactId>
                        <version>1.5.5.Final</version>
                    </path>
                </annotationProcessorPaths>
            </configuration>
        </plugin>
    </plugins>
</build>

This will help download the dependency during the project build.

Step 2: Define your DTO

Use the UserDTO.java file given in step 1 of the first approach.

Step 3: Create the MapStruct Mapper Interface

Create a file and name it UserMapper.java, and add the code below to it:

import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

@Mapper(componentModel = "spring")
public interface UserMapper {
    UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);
    UserDTO toDTO(UserEntity user);
    UserEntity toEntity(UserDTO userDTO);
}

The UserMapper interface contains the INSTANCE field and two methods, namely toDTO and toEntity, that take in objects of types UserEntity and UserDTO, respectively, as arguments. The implementations of these methods are abstracted and handled by the library for us.

You can now use the mapper methods (toDTO and toEntity) in your Service or Controller.

How to Create DTOs From Two or Multiple Objects

This is one of the most important ways to use DTOs: creating DTOs from more than one entity and combining them as one, so that they can be returned in one API call or request.

There are many ways you can apply this technique and create complex response DTOs, based on the requirements of your project. The form or structure of your API response object might not be the same as the example given in this tutorial – but the same principle applies, which is simply creating individual DTOs and combining them into one DTO, which eventually serves as the response DTO.

The example below isn’t super complex, but it’s sufficient to help you understand how this works so you can leverage the technique in creating more complex API response objects. This example will combine DTOs of a doctor and their appointments.

Step 1: Create the DTO Classes

Create a file named DoctorDto.java and add this code to it:

public class DoctorProfileDTO {
    private String doctorId;
    private String fullName;
    private String email;
    private String specialization;

   // No-args constructor
   public DoctorProfileDTO(){
    }

    // Getter and Setter for doctorId
    public String getDoctorId() {
        return doctorId;
    }

    public void setDoctorId(String doctorId) {
        this.doctorId = doctorId;
    }

    // Getter and Setter for fullName
    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    // Getter and Setter for email
    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    // Getter and Setter for specialization
    public String getSpecialization() {
        return specialization;
    }

    public void setSpecialization(String specialization) {
        this.specialization = specialization;
    }
}

Create another one called AppointmentDto.java and include this code:

public class AppointmentDTO {
    private String appointmentId;
    private String appointmentDate;
    private String status;
    private String patientName;
    private String patientEmail;

   // No-args constructor
   public AppointmentDTO(){
    }

    // Getter and Setter for appointmentId
    public String getAppointmentId() {
        return appointmentId;
    }

    public void setAppointmentId(String appointmentId) {
        this.appointmentId = appointmentId;
    }

    // Getter and Setter for appointmentDate
    public String getAppointmentDate() {
        return appointmentDate;
    }

    public void setAppointmentDate(String appointmentDate) {
        this.appointmentDate = appointmentDate;
    }

    // Getter and Setter for status
    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    // Getter and Setter for patientName
    public String getPatientName() {
        return patientName;
    }

    public void setPatientName(String patientName) {
        this.patientName = patientName;
    }

    // Getter and Setter for patientEmail
    public String getPatientEmail() {
        return patientEmail;
    }

    public void setPatientEmail(String patientEmail) {
        this.patientEmail = patientEmail;
    }
}

Step 2: Create a Composite DTO Combining both Entities

Create a file named DoctorWithAppointmentsDTO.java:

import java.util.List;

public class DoctorWithAppointmentsDTO {
    private DoctorProfileDTO doctorProfile;
    private List<AppointmentDTO> appointments;

    // No-args constructor
    public DoctorWithAppointmentsDTO() {
    }

    // Getter and Setter for doctorProfile
    public DoctorProfileDTO getDoctorProfile() {
        return doctorProfile;
    }

    public void setDoctorProfile(DoctorProfileDTO doctorProfile) {
        this.doctorProfile = doctorProfile;
    }

    // Getter and Setter for appointments
    public List<AppointmentDTO> getAppointments() {
        return appointments;
    }

    public void setAppointments(List<AppointmentDTO> appointments) {
        this.appointments = appointments;
    }
}

Step 3: Create a Mapper Class

Create a mapper class DoctorMapper.java containing the logic to map to the DoctorWithAppointmentsDTO class:

public class MapperClass {

    public DoctorWithAppointmentsDTO toDTO(Doctor doctor, List<Appointment> appointments) {

        DoctorProfileDTO doctorProfile = new DoctorProfileDTO();
        doctorProfile.setDoctorId(doctor.getId());
        doctorProfile.setFullName(doctor.getFullName());
        doctorProfile.setEmail(doctor.getEmail());
        doctorProfile.setSpecialization(doctor.getSpecialization());

        List<AppointmentDTO> appointmentDTOs = appointments.stream().map(appt -> {
            AppointmentDTO dto = new AppointmentDTO();
            dto.setAppointmentId(appt.getId());
            dto.setAppointmentDate(appt.getDate().toString()); 
            dto.setStatus(appt.getStatus().name());
            dto.setPatientName(appt.getPatient().getName());
            dto.setPatientEmail(appt.getPatient().getEmail());
            return dto;
        }).toList();

        DoctorWithAppointmentsDTO doctorWithAppointment = new DoctorWithAppointmentsDTO();
        doctorWithAppointment.setDoctorProfile(doctorProfile);
        doctorWithAppointment.setAppointments(appointmentDTOs);

        return doctorWithAppointment;
    }
}

From the example above, you can see that two separate DTOs (AppointmentDTO and DoctorProfileDTO) were created before the composite DTO, DoctorWithAppointmentsDTO was created. The composite DTO class (DoctorWithAppointmentsDTO) contains fields that hold the instances of the Appointment and DoctorProfile DTOs. The mapper class takes in the Doctor and a list of Appointment entities as arguments, maps them to DoctorProfileDTO and AppointmentDTO, respectively. Finally, the fields for the composite DTO class are set using the DTO objects mapped from the entities.

The DoctorWithAppointmentsDTO, when serialised and returned through an endpoint, should give you an output like this:

{
  "doctorProfile": {
    "doctorId": "abc123",
    "fullName": "Dr. Susan Emeka",
    "email": "suzan.emeka@example.com",
    "specialisation": "Cardiology"
  },
  "appointments": [
    {
      "appointmentId": "appt001",
      "appointmentDate": "2025-07-10T09:00:00",
      "status": "CONFIRMED",
      "patientName": "James Agaji",
      "patientEmail": "james.agaji@example.com"
    },
 {
      "appointmentId": "appt002",
      "appointmentDate": "2025-08-12T07:05:08",
      "status": "CONFIRMED",
      "patientName": "Jane Augustine",
      "patientEmail": "jane.augustine@example.com"
    }
  ]
}

Conclusion

If you’re a software engineer who’s concerned with privacy and efficiency, using DTOs in your applications is a must.

In this article, you’ve learned what DTOs are as well as the main approaches for creating and using them. Take the time to go through the code snippets given in this article and practice with them until you’re comfortable implementing them yourself. Thanks for reading.

If you’re learning Java with the end goal of building applications, you’ll need to be able to choose a suitable Java framework (a collection of necessary pre-built tools and libraries) to make development easier once you know the fundamentals.

There are many Java frameworks out there that help you complete different tasks, such as Jakarta EE (formerly Java EE, an enterprise-level framework, used for large-scale applications), JSF (or JavaServer Faces, a UI framework for developing Java web interfaces), Spring, Spring Boot, and others.

You may have heard of Spring and Spring Boot by now, as they are very popular and commonly used by Java devs. In this article, you will learn:

• What the Spring and Spring Boot frameworks are.

• Their real-world use cases and how to get started building with them.

• The key differences between Spring and Spring Boot.

Prerequisites

To fully understand the content of this article, you should have a good working knowledge of the Java programming language, be familiar with the concept of APIs (Application Programming Interfaces), and know how to use Java project build tools – especially Maven, as it’s the build tool we’ll use for this article’s code examples.

Table of Contents

• What is the Spring Framework?

• What is the Spring Boot Framework?

• Core Differences Between Spring and Spring Boot

• Real World Example

• How to Choose Between Spring and Spring Boot

• Conclusion

What is the Spring Framework?

Spring is a framework used for building modern enterprise-grade applications. It’s primarily used for Java, but it’s also compatible with the Kotlin and Groovy programming languages, too. This means that you can use Kotlin and Groovy to develop applications in Spring.

Spring provides a clear paradigm you can follow for building and configuring applications for easy deployment on any platform you choose.

At the core of the Spring framework is its robust infrastructure support. It internally handles implementing key components that are required for the safety and overall functionality of enterprise applications. It does this using modules such as:

• Spring JDBC

• Spring MVC

• Spring Security

• Spring AOP

• Spring ORM and

• Spring Test

These let developers focus on the business logic of the application instead of worrying about implementing or writing the code for the components/modules from scratch. This saves significant development time.

Why use Spring?

Spring does a lot of heavy lifting in terms of reducing excessive infrastructure code through its modules compared to legacy Java frameworks. This is one of the reasons it’s so popular.

For instance, when it comes to handling dependencies in Spring, you just have to define the dependency using the @Bean annotation in a configuration class, replacing the older approach of adding the dependency in an XML file.

Spring then adds the bean to an IoC (Inversion of Control) container, and makes the bean available to be utilised during runtime, also handling the lifecycle and wiring automatically.

Here is a simple code illustration of the configuration class below:

@Configuration

public class AppConfig{

@Bean

public DataSource dataSource() {

    DriverManagerDataSource ds = new DriverManagerDataSource();

    ds.setUrl("jdbc:mysql://localhost:3306/mydb");

    ds.setUsername("user");

    ds.setPassword("pass");

    return ds;

  }


}

Here’s the class where the resource/dependency is utilised:

@Component

public class UserRepository {

private DataSource dataSource;

public UserRepository(DataSource dataSource){

      this.dataSource = dataSource;

}

    public void connectToDb() throws SQLException {

        Connection conn = dataSource.getConnection();

        System.out.println("Connected to DB via Spring!");

        conn.close();

    }

}

These code snippets demonstrate how dependency injection is implemented using Spring’s @Bean and @Component annotations. In the code is a configuration class and a second class where the DataSource is injected and used. This shows a simplistic approach to dependency management in Spring.

Key Components of the Spring Framework

Spring is made up of several components, each serving distinct roles (as shown in the image below):

Image source | Overview of the Spring Framework

These components collectively provide useful functionalities that make Spring a robust framework. Think of them as parts that make up a whole. Let me briefly explain each of the components and their various roles for easy understanding.

Data Access/Integration:

This component enables easy interaction with databases and other data sources. It contains several modules (JDBC, ORM, OXM, JMS and Transaction Management), each performing unique functions.

These modules provide fine-grained abstraction for tasks like executing SQL queries, integrating with ORM frameworks (for example, Hibernate), handling XML data binding, messaging, and managing transactions, while working in a Spring-based application.

Web:

The Web component makes interaction between the client side (through HTTP request) and the core business logic possible in a Spring application. It consists of four modules (Web, Web-Servlet, Web-Struts, and Web-Portlet), each serving a specific function:

• The Web module enables multipart file upload functionality and initialization of the IoC container.

• Web-Servlet module provides an MVC (Model View Controller) Implementation for web applications.

• The Web-Struts module integrates Struts into Spring by using support classes.

• The Web-Portlet module supports MVC implementation for use in a portlet environment.

AOP and Instrumentation:

AOP provides the implementation that makes it possible to ensure the separation of “cross-cutting concerns” in your application from the business logic, leading to cleaner and more organized code that’s free from clutter and repetition.

Instead of writing these concerns everywhere in your classes, you just define them in aspects and they are injected for you by Spring when the program needs them. These concerns could be logging, security, or transactions.

Instrumentation:

This enables class instrumentation support, which ensures class bytecode modification.

Core Container:

Core Container as the name implies, is a crucial part of Spring. It is responsible for some of the unique features that make the Spring Framework desired and popular: IoC (Inversion of Control) and dependency injection.

Core Container is made of Beans, Core, Context and Expression Language modules. These modules all have unique, yet complementary properties.

Test:

The Test component provides a suitable approach to testing Spring applications, and it integrates smoothly with JUnit or TestNG. It goes as far as providing mock objects that can be used to test different components of your application in either an isolated or Spring-managed environment, helping you achieve a robust and reliable software application.

What is the Spring Boot Framework?

Spring Boot is an open-source framework built on top of Spring for developing robust stand-alone applications that you can “easily run”. The major purpose for which Spring Boot was created was to further simplify the process of configuring and running Spring applications.

Spring Boot enforces an opinionated approach to development and provides extra useful features not contained in Spring. Let’s learn a bit more about how it works.

Key Features of the Spring Boot Framework

Spring Boot, being part of the Spring ecosystem, inherits most Spring functionalities, but contains additional features not included in Spring. Let me explain these unique features briefly:

Auto-configuration

Spring Boot automatically configures dependencies present in the classpath (location where the Java runtime looks for classes/resources during compilation) through the @SpringBootApplication annotation. This is a combination of @EnableAutoConfiguration, @Configuration, and @ComponentScan. This auto-configuration saves effort in writing boilerplate code for configuring dependencies/beans (as you have to do with Spring).

Here’s how you can use the @SpringBootApplication annotation for auto-configuration in Spring Boot applications:

      @SpringBootApplication

public class MyApp {

    public static void main(String[] args) {

        SpringApplication.run(MyApp.class, args);

    }

}

Starter dependencies

Starter dependencies provide a cleaner and less verbose way of managing dependencies in Spring Boot. Essentially, it bundles a set of complementary dependencies that perform a common task into one, meaning you don’t need to manually declare every single dependency that is part of the starter bundle.

Starter dependencies in Spring Boot follow the naming convention spring-boot-starter-*, where the asterisk represents the name of the particular dependency.

Some common starter dependencies in Spring Boot are:

• spring-boot-starter-web

• spring-boot-starter-aop

• spring-boot-starter-data-jdbc

• spring-boot-starter-data-jpa

• spring-boot-starter-data-rest

Actuator

Actuator is a module in the Spring Boot framework that lets you monitor Spring Boot applications after/during development. It provides both inbuilt and customizable endpoints you can use for application health checks, metrics, and diagnostics.

These are some of the commonly used endpoints:

• /actuator/health: Provides health status.

• /actuator/metrics: Displays various application metrics.

• /actuator/info: Shows general application information.

• /actuator/env: Exposes environment properties.

• /actuator/beans: Lists all Spring beans.

• /actuator/threaddump: Performs a thread dump.

• /actuator/shutdown: Allows graceful shutdown (disabled by default).

Command line tool

The Spring Boot command line tool is an interface that helps you rapidly develop and test your Spring Boot applications. It contains commands you can use to:

• Run Spring Boot applications from the terminal directly (spring run).

• Manage application dependencies and versions

• Initialize a new Spring Boot project

• Compile and test Java/Groovy scripts.

Additional configuration (through application.properties and application.yml files)

application.properties and application.yml files are two formats you can use to configure your Spring Boot application settings. They are in key-value and YAML formats, respectively. They let you configure ports, data source, logging, caching, and so on.

 server.port=8081
 spring.datasource.url=jdbc:mysql://localhost:3306/mydb

spring.datasource.username=root

spring.datasource.password=secret

logging.level.org.springframework=DEBUG

This is an example of an application.properties file for a Spring Boot project. You can see that the port, datasource and logging credentials have been configured.

Embedded Web Server

Spring Boot comes with embedded web servers (Tomcat, Jetty, and Undertow) that are used to easily serve compiled Spring Boot applications in the form of jar files without needing to deploy them to an external, dedicated web server. This simplifies deployment, especially in a microservice architecture and containerised environments, as applications can be easily run using the command:

java -jar my-springboot-app.jar

Note that Spring Boot cannot exist without Spring (but Spring can exist without Jakarta EE and other Java legacy frameworks created before it). Spring Boot is part of the Spring platform. It is like the extra icing on top of the cake that makes it sweeter.

Of course, you can still have your cake without the icing. Technically, you can say Spring Boot is an additional layer that still needs Spring to run as its underlying infrastructure.

Core Differences Between Spring and Spring Boot

You should now be familiar with the fundamentals of the Spring and Spring Boot frameworks. So let’s talk a bit more about how they differ, x-raying their strengths and areas of weakness.

Configuration

Configuration in Spring is more tedious when compared to Spring Boot, since you’ll need to manually add the configurations for your project in Spring. This requires more code for setting up the various components you need for a project.

Meanwhile, configuration in Spring Boot is easier as you can use the Spring Initializr website. There, you just have to select the dependencies for the project, add a little more setup, and then download the zip file that contains the configuration for the project. It requires minimal steps to do this, which improves your productivity and makes the learning curve easier.

External Server and Deployment

Spring requires that you deploy your applications to an external server like Tomcat in the form of a WAR (Web Application Archive or Web Application Resource) file.

Spring Boot, on the other hand, comes with an embedded server like Tomcat, which you can use for running/deploying stand-alone executable applications as JAR (or Java ARchive) files. This is why Spring Boot is highly preferred for developing microservices since it is relatively easy to build applications and run them.

Level of Control

Both Spring and Spring Boot utilise the Inversion of Control (or IoC) paradigm for managing dependencies. Spring gives you more control over the application because you have the flexibility to initiate configurations as needed. But Spring Boot handles more of the application management internally, giving you little room for control over the application configuration, as it auto-generates configurations that may not be needed for a particular project. This can lead to redundant code.

Suitability for Development

Spring, like Java EE, is preferred for large-scale enterprise applications due to its fine-grained configuration control that is invaluable, especially for complex and critical performance applications like banking, healthcare, and e-commerce. It provides great flexibility, which makes it suitable for integrating with Java EE components and other enterprise-grade technologies and legacy systems.

Spring Boot is not a common choice for large-scale monolithic applications, even though it can be used in these cases. It is more suitable for developing stand-alone applications or microservices where rapid development with embedded server support is prioritized over granular configuration and control.

Production-ready features

In Spring, extra effort is needed to manually set up health checks, metrics and monitoring of your application. Whereas, Spring Boot comes with the actuator, which is a built-in tool that is useful for metrics, application monitoring, and for carrying out health checks. You just need to add this dependency to your pom.xml file

<dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-actuator</artifactId>

</dependency>

After that, you can monitor your application by visiting the desired actuator endpoint that exposes the needed information. Find a list of the common actuator endpoints you can visit under the Actuator subsection of the What is Spring Boot section above.

Real World Example

Let’s look at an example of how to build a simple REST API endpoint in both Spring and Spring Boot frameworks:

Building with the Spring Framework

In this API example, the technologies/dependencies we’ll use are:

• Java (Programming Language)

• Maven (the build tool for the project)

• Tomcat (servlet container)

• Operating System (Mac/Linux/Windows)

• Core Spring framework with the Spring MVC module

• Jackson Databind: for JSON serialisation

Note that we’ll be using Maven here as our build tool (and for the Spring Boot example that follows, too) because of its simplicity and beginner friendliness.

Step 1: Create AppConfig.java file

This is the configuration class that sets on Spring MVC properties through the @EnableWebMvc annotation, scans for the controllers in their packages through the @ComponentScan annotation, and configures other needed defaults automatically.

@Configuration

@EnableWebMvc

@ComponentScan(basePackages = "com.example.controller")

public class AppConfig implements WebMvcConfigurer {

}

Step 2: Create WebAppInitializer.java

This is the class that replaces web.xml (That was used in older versions.) It creates the Spring application context and connects to the AppConfig file for configuration.

public class WebAppInitializer implements WebApplicationInitializer {  
  @Override
  public void onStartup(ServletContext servletContext) {

    // Create annotation-based web context

    AnnotationConfigWebApplicationContext context = 

      new AnnotationConfigWebApplicationContext();

    context.register(AppConfig.class);

    // Register DispatcherServlet

    DispatcherServlet servlet = new DispatcherServlet(context);

    ServletRegistration.Dynamic registration = 

      servletContext.addServlet("dispatcher", servlet);

    registration.setLoadOnStartup(1);

    registration.addMapping("/");

  }

}

Step 3: Add the controller logic

Create a HelloController.java file and add the controller logic. It receives a GET request and returns “Hello from Spring Framework!”

@RestController // Combines @Controller + @ResponseBody

public class HelloController {

  @GetMapping("/hello")

  public String hello() {

    return "Hello from Spring Framework!";

  }

}

Step 4: Add Dependencies

Include all the dependencies for the project in a pom.xml file, since we’re using Maven as the build tool.

<dependency>

  <groupId>org.springframework</groupId>

  <artifactId>spring-webmvc</artifactId>

  <version>6.1.6</version> <!-- Latest Spring 6.x -->

</dependency>

<dependency>

  <groupId>com.fasterxml.jackson.core</groupId>

  <artifactId>jackson-databind</artifactId>

  <version>2.17.0</version> <!-- For JSON support -->

</dependency>

Step 5: Build and Deploy the API

Lastly, you have to build the application into a WAR (Web Archive) file and deploy it to a servlet container (like Tomcat, Jetty, or whichever is suitable) before the application can be made accessible.

Follow the steps given below to deploy to a Tomcat server:

1. Package the app as a WAR file

If Maven is your build tool for the project, add this configuration code to your Pom.xml file:

<packaging>war</packaging>

Then, build using the command:

./mvnw clean package

After this, your WAR file will be created and stored in target/yourapp.war

2. Deploy your WAR file to a servlet container (in this case, Tomcat)

At this point, you can choose to either deploy your WAR file to a remote or local servlet container on your machine. Let’s deploy to a local servlet container since you can easily practice this on your own.

• Download and install Apache Tomcat from the official website https://tomcat.apache.org/

• Enter the webapps directory by entering the command cd path-to-tomcat/webapps/

• Copy your WAR file into the folder

cp /path-to-your/target/yourapp.war

• Start the Tomcat web server.

On Linux/Mac OS, run:

./bin/startup.sh

On Windows, do:

startup.bat.

You should see a link similar to this on your terminal window:

http://localhost:8080/yourapp

Go ahead and click on it. And there you go!

Building with the Spring Boot Framework

The different technologies from the Spring example that I will use are simply the Embedded Tomcat server over the Tomcat servlet container. And here, of course, we’ll be using Spring Boot as the development framework instead of Spring.

In Spring Boot, you can either go straight into your IDE and start creating the needed files and configurations for your project, or you can choose to use the Spring initializr to select dependencies and generate the base files and configurations for your project. The second option is preferred since it is less tedious.

Step 1: Choose Necessary Dependencies for Your Project and Download the Zip File

Open the Spring initializr website, choose the project as Maven, language as Java, and fill in the project metadata. For this project, fill in the Artifact as Hello.

Choose jar for packaging, and then select the dependencies for the project. For this article, we will use only the Spring Web. Then click on the generate button.

This downloads a zip file to your machine containing the boilerplate code with which you can build your application.

Step 2: Create the Controller (HelloController.java)

Unzip the downloaded file from step 1, and open it in your preferred IDE (or Integrated Development Environment). Navigate to the Hello/src/main/java/com/example/Hello directory, where you should already have the HelloApplication.java file, and add the HelloController.java file:

@RestController

public class HelloController {

  @GetMapping("/hello")

  public String hello() {

    return "Hello from Spring Boot!";

  }

}

Step 3: Build and run the application

On your terminal, run the following commands: mvn clean package && java -jar target/your-app.jar. You can then access the endpoint on http://localhost:8080/hello. When you click on the link, you should see Hello from Spring Boot! on your screen.

How to Choose Between Spring and Spring Boot

Spring and Spring Boot are both popular Java frameworks for building robust software solutions. And as you have learned from the earlier part of this tutorial, they have many common features (since Spring Boot is built atop Spring).

But there are a few key areas where they differ. First is the format of their packaged files: Spring is packaged to WAR, and Spring Boot to JAR. Also, Spring Boot comes with an embedded web server while Spring requires an external servlet container.

The embedded web server that comes with Spring Boot makes it easy to run Spring Boot applications during development and in production without needing an external servlet container. Meanwhile, traditional Spring requires developers to deploy to an external servlet container. This makes Spring Boot suitable for rapid development and deployment of stand-alone applications or microservices, as it not only saves time but also reduces setup complexity and infrastructure requirements.

Furthermore, Spring’s fine-grained configuration and ease of integration with legacy systems and tools make it the desired choice for developing highly customizable enterprise-grade applications. This is unlike Spring Boot, which relies on the convention-over-configuration philosophy, providing auto-configuration for reduced development time.

Conclusion

Building enterprise-grade and microservices applications with Java is much easier using the Spring and Spring Boot frameworks.

In this article, you’ve learned how these two frameworks work, along with their areas of strength and drawbacks.

This article doesn’t intend to favour one framework over the other, but rather to show in detail how they differ and their unique characteristics.

But to summarize:

• Use Spring when building highly customized legacy-integrated enterprise systems.

• Use Spring Boot for REST APIs, microservices, or cloud-native apps.

The next time you are faced with a project requiring you to choose a similar framework, it is imperative to carefully weigh your choices and select the framework that closely fits your task. Happy coding!

References

1. Spring Framework Official Documentation

2. Baeldung – Introduction to Spring Framework

3. Ellow. Spring vs Spring Boot: An In-depth Comparison