Spring Boot: Scaling

Spring Boot Scaling

Spring-Boot
Scaling
Spring Boot Scaling
Author

albertprofe

Published

Tuesday, June 1, 2021

Modified

Tuesday, October 14, 2025

📘 JPA Scaling

Key strategies for scaling Spring Boot applications.

Each approach addresses different aspects of application scaling, from data management to processing efficiency and API design, providing us with a comprehensive toolkit for building robust, scalable Spring Boot applications:

  • DTOs optimize data transmission between layers, reducing network overhead and decoupling models.
  • Auditing tracks and logs data changes, enhancing integrity and traceability.
  • Pagination efficiently handles large datasets, improving performance and reducing memory usage.
  • Spring Batch provides a framework for robust batch processing, ideal for ETL operations and data migrations.
  • Caching improves application performance by storing frequently accessed data in memory, easily implemented with Spring Boot’s annotations.
  • Wrappers encapsulate or extend object functionality for various purposes, such as standardizing API responses or implementing lazy loading.

These strategies, when implemented correctly, can significantly enhance the scalability, performance, and maintainability of Spring Boot applications.


1 Scaling Spring Boot

1.1 DTO: Data Transfer Object

Data Transfer Objects (DTOs) are crucial for efficient data transmission between different layers of an application. They help reduce network overhead and decouple the internal data model from the external API representation.

In Spring Boot, DTOs are often used with RESTful APIs to control what data is exposed to clients. Here’s a simple example:

public class UserDTO {
    private Long id;
    private String username;
    private String email;

    // Constructors, getters, and setters
}

To map between entities and DTOs, you can use libraries like ModelMapper or MapStruct. For instance, with MapStruct:

@Mapper(componentModel = "spring")
public interface UserMapper {
    UserDTO userToUserDTO(User user);
    User userDTOToUser(UserDTO userDTO);
}

DTOs are particularly useful when working with complex domain models or when you need to aggregate data from multiple entities.

1.2 Auditing

Auditing is the process of tracking and logging changes to data over time. Spring Data JPA provides built-in support for auditing through annotations and interfaces.

To enable auditing, add the @EnableJpaAuditing annotation to a configuration class:

@Configuration
@EnableJpaAuditing
public class JpaConfig {
}

Then, use auditing annotations in your entity classes:

@Entity
@EntityListeners(AuditingEntityListener.class)
public class User {
    @CreatedDate
    private Instant createdDate;

    @LastModifiedDate
    private Instant lastModifiedDate;

    @CreatedBy
    private String createdBy;

    @LastModifiedBy
    private String lastModifiedBy;

    // Other fields, getters, and setters
}

To provide the current user for @CreatedBy and @LastModifiedBy, implement the AuditorAware interface.

For more details on auditing, refer to the Spring Data JPA Auditing documentation.

1.3 Pagination

Pagination is essential for handling large datasets efficiently.

Spring Data JPA provides built-in support for pagination through the Pageable interface and Page object.

To use pagination in a repository method:

public interface UserRepository extends JpaRepository<User, Long> {
    Page<User> findByLastName(String lastName, Pageable pageable);
}

In your service or controller:

@GetMapping("/users")
public Page<User> getUsers(@RequestParam(defaultValue = "0") int page,
                           @RequestParam(defaultValue = "10") int size) {
    Pageable pageable = PageRequest.of(page, size);
    return userRepository.findAll(pageable);
}

This approach allows clients to request specific pages of data, improving performance and reducing memory usage.

For more information on pagination and sorting, see the Spring Data JPA documentation on Paging and Sorting.

1.3.1 Interfaces

classDiagram
    class Pageable {
        +int getPageNumber()
        +int getPageSize()
        +Sort getSort()
        +boolean hasPrevious()
        +Pageable next()
        +Pageable previousOrFirst()
    }
    
    class PageRequest {
        +static PageRequest of(int page, int size, Sort sort)
    }
    
    class Slice {
        +List<T> getContent()
        +boolean hasNext()
        +Pageable nextPageable()
    }
    
    class Page {
        +long getTotalElements()
        +int getTotalPages()
    }
    
    Pageable <|-- PageRequest
    Slice <|-- Page

For official documentation on Pageable, Page, Slice, and PageRequest in Spring Boot, you can refer to the following links:

Pagination is managed using the Pageable, Page, Slice, and PageRequest interfaces:

  • Pageable: This interface defines pagination parameters such as page number, page size, and sorting options. It is commonly instantiated using PageRequest.

  • PageRequest: A concrete implementation of Pageable that allows you to specify the page index (zero-based), size, and sorting.

  • Page: Extends Slice and provides additional metadata like total number of pages and total elements. It is used when you need complete pagination details.

  • Slice: Represents a subset of data without total count information, useful for simple “next” and “previous” navigation.

1.4 Spring Batch

Spring Batch is a lightweight, comprehensive framework designed for robust batch processing. It’s particularly useful for ETL operations, data migrations, and periodic data processing tasks.

A basic Spring Batch job consists of one or more steps, each with a reader, processor, and writer:

@Configuration
@EnableBatchProcessing
public class BatchConfig {

    @Bean
    public Job importUserJob(JobBuilderFactory jobBuilderFactory,
                             Step step1) {
        return jobBuilderFactory.get("importUserJob")
                .incrementer(new RunIdIncrementer())
                .flow(step1)
                .end()
                .build();
    }

    @Bean
    public Step step1(StepBuilderFactory stepBuilderFactory,
                      ItemReader<User> reader,
                      ItemProcessor<User, User> processor,
                      ItemWriter<User> writer) {
        return stepBuilderFactory.get("step1")
                .<User, User>chunk(10)
                .reader(reader)
                .processor(processor)
                .writer(writer)
                .build();
    }
}

Spring Batch provides robust error handling, restart capability, and parallel processing options, making it ideal for large-scale data operations.

1.5 Caching

Caching is a powerful technique to improve application performance by storing frequently accessed data in memory. Spring Boot provides easy integration with various caching providers.

To enable caching, add the @EnableCaching annotation to a configuration class:

@Configuration
@EnableCaching
public class CacheConfig {
}

Then, use caching annotations in your service methods:

@Service
public class UserService {

    @Cacheable("users")
    public User getUserById(Long id) {
        // Method implementation
    }

    @CachePut(value = "users", key = "#user.id")
    public User updateUser(User user) {
        // Method implementation
    }

    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(Long id) {
        // Method implementation
    }
}

Spring Boot auto-configures a suitable CacheManager based on the classpath dependencies. You can customize the caching behavior using properties in application.properties or application.yml.

For more advanced caching scenarios, consider using distributed caches like Redis or Hazelcast.

1.6 Wrappers

Wrappers in Spring Boot often refer to classes that encapsulate or extend the functionality of other objects. They can be used for various purposes, such as adding cross-cutting concerns, adapting interfaces, or providing additional functionality.

One common use of wrappers is in the context of response entities. For example, you might create a wrapper class to standardize API responses:

public class ApiResponse<T> {
    private T data;
    private String message;
    private boolean success;

    // Constructors, getters, and setters
}

You can then use this wrapper in your controllers:

@GetMapping("/users/{id}")
public ResponseEntity<ApiResponse<User>> getUser(@PathVariable Long id) {
    User user = userService.getUserById(id);
    ApiResponse<User> response = new ApiResponse<>(user, "User retrieved successfully", true);
    return ResponseEntity.ok(response);
}

Another example is using wrappers for lazy loading in JPA:

@Entity
public class User {
    @OneToMany(fetch = FetchType.LAZY)
    private List<Order> orders;

    // Other fields and methods
}

Here, orders is wrapped in a proxy object that loads the actual data only when accessed, improving performance for large datasets.

Wrappers can also be used for decorating beans, implementing the decorator pattern, or creating custom type converters in Spring Boot applications.

Back to top