How to optimize Spring Boot Application Performance with just few steps

Published on 2024-05-08, by Javed Shaikh

Subscribe for new article

*No spam. unsubscribe at anytime

Spring Boot applications are known for their ease of development and rapid deployment, but as your application scales, performance optimization becomes crucial. This guide covers proven strategies to enhance your Spring Boot application's performance, complete with practical code examples and detailed explanations.

1. Database Optimization

Connection Pooling Configuration

Database connections are expensive resources. Proper connection pooling significantly reduces connection overhead and improves response times.

bash
# application.yml
spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      idle-timeout: 300000
      connection-timeout: 20000
      max-lifetime: 1200000
      leak-detection-threshold: 60000

Why it helps: HikariCP is the default connection pool in Spring Boot 2.x+. These settings ensure optimal connection reuse while preventing connection leaks and timeouts.

JPA Query Optimization

Lazy loading and query optimization prevent unnecessary database hits.

java
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    
    // Use LAZY loading for collections
    @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
    private List<Order> orders;
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    
    // Use @Query for optimized queries
    @Query("SELECT u FROM User u WHERE u.name = :name")
    List<User> findByNameOptimized(@Param("name") String name);
    
    // Use JOIN FETCH to avoid N+1 problem
    @Query("SELECT u FROM User u JOIN FETCH u.orders WHERE u.id = :id")
    Optional<User> findByIdWithOrders(@Param("id") Long id);
}

Performance impact: Lazy loading reduces initial query time by 30-70%, while JOIN FETCH eliminates N+1 queries that can cause exponential performance degradation.

2. Caching Strategies

Enable Spring Cache

Caching frequently accessed data dramatically reduces database load and improves response times.

java
@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(10, TimeUnit.MINUTES)
            .recordStats());
        return cacheManager;
    }
}

@Service
public class UserService {
    
    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        // This method will be cached
        return userRepository.findById(id).orElse(null);
    }
    
    @CacheEvict(value = "users", key = "#user.id")
    public User updateUser(User user) {
        return userRepository.save(user);
    }
    
    @Cacheable(value = "userStats", key = "#userId")
    public UserStats getUserStats(Long userId) {
        // Expensive calculation cached for 10 minutes
        return calculateUserStats(userId);
    }
}

Performance gain: Properly implemented caching can reduce response times by 80-95% for frequently accessed data and reduce database load significantly.

Redis for Distributed Caching

For multi-instance applications, use Redis for shared caching.

bash
# application.yml
spring:
  redis:
    host: localhost
    port: 6379
    timeout: 2000ms
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0

java
@Configuration
public class RedisConfig {
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

3. Asynchronous Processing

Enable Async Methods

Move time-consuming operations to background threads to improve response times.

java
@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    @Bean(name = "taskExecutor")
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-");
        executor.initialize();
        return executor;
    }
}

@Service
public class NotificationService {
    
    @Async("taskExecutor")
    public CompletableFuture<Void> sendEmailNotification(String email, String message) {
        // Simulate email sending
        try {
            Thread.sleep(2000); // Email sending delay
            log.info("Email sent to: {}", email);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture(null);
    }
    
    @Async
    public void processLargeDataSet(List<Data> dataList) {
        // Process large dataset asynchronously
        dataList.parallelStream()
            .forEach(this::processData);
    }
}

Impact: Async processing can improve perceived response times by 60-90% for operations involving external services or heavy computations.

4. JVM Optimization

Memory Configuration

Proper JVM tuning prevents garbage collection bottlenecks.

bash
# Production JVM settings
java -jar myapp.jar \
  -Xms2g \
  -Xmx4g \
  -XX:+UseG1GC \
  -XX:MaxGCPauseMillis=200 \
  -XX:+HeapDumpOnOutOfMemoryError \
  -XX:HeapDumpPath=/logs/heapdump.hprof

text

# application.yml
server:
  # Optimize embedded Tomcat
  tomcat:
    threads:
      max: 200
      min-spare: 10
    connection-timeout: 20000
    max-connections: 8192
    accept-count: 100

spring:
  jpa:
    hibernate:
      # Disable in production
      ddl-auto: none
    # Optimize SQL logging
    show-sql: false
    properties:
      hibernate:
        # Enable batch processing
        jdbc.batch_size: 20
        order_inserts: true
        order_updates: true
        # Second-level cache
        cache.use_second_level_cache: true
        cache.region.factory_class: org.hibernate.cache.jcache.JCacheRegionFactory

5. HTTP Response Optimization

Enable Compression

Reduce payload size with GZIP compression.

text

# application.yml
server:
  compression:
    enabled: true
    mime-types: text/html,text/xml,text/plain,text/css,text/javascript,application/javascript,application/json
    min-response-size: 1024

java
@RestController
public class ApiController {
    
    @GetMapping("/users/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.getUserById(id);
        
        return ResponseEntity.ok()
            .cacheControl(CacheControl.maxAge(30, TimeUnit.MINUTES))
            .eTag(String.valueOf(user.getVersion()))
            .body(user);
    }
    
    @GetMapping("/static-data")
    public ResponseEntity<StaticData> getStaticData() {
        StaticData data = dataService.getStaticData();
        
        return ResponseEntity.ok()
            .cacheControl(CacheControl.maxAge(1, TimeUnit.HOURS)
                .cachePublic())
            .body(data);
    }
}

Bandwidth savings: Compression typically reduces payload size by 60-80%, significantly improving load times for clients with slower connections.

6. Monitoring and Profiling

Enable Actuator for Monitoring

text

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: health,metrics,prometheus
  endpoint:
    health:
      show-details: always
  metrics:
    export:
      prometheus:
        enabled: true

Custom Performance Metrics

java
@Component
public class PerformanceMetrics {
    
    private final MeterRegistry meterRegistry;
    private final Timer.Sample sample;
    
    public PerformanceMetrics(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    @EventListener
    public void handleRequest(RequestEvent event) {
        Timer.Sample sample = Timer.start(meterRegistry);
        sample.stop(Timer.builder("request.duration")
            .tag("endpoint", event.getEndpoint())
            .register(meterRegistry));
    }
}

Best Practices

Always measure before optimizing - Use profiling tools to identify actual bottlenecks
Implement caching strategically - Cache expensive operations, not everything
Optimize database queries - Use appropriate fetch strategies and avoid N+1 problems
Configure connection pools properly - Match pool sizes to your application's needs
Use async processing - For operations that don't need immediate responses
Monitor continuously - Set up proper monitoring and alerting
Test under load - Performance testing should simulate real-world conditions

Conclusion

Performance optimization is an iterative process that requires careful measurement and testing. The first step for optimization is understanding your application's specific usage patterns and optimizing accordingly. These above techniques provide a solid foundation, but the specific implementation may require additional customization based on the application's unique requirements.

About the Author

I am a Backend System Engineer at a credit card company, specializing in C/C++ and assembler on IBM's TPF OS. I have a passion for web development and enjoy working with Node.js and Python in my free time.

Connect with author

Java Records vs Traditional Classes: When and how to use Java Records

Java Records significantly reduce boilerplate code. With records, we don’t need to write getters, toString(), equals(), or hashCode() methods.

2024-10-09

Java

Spring Boot Actuator for Performance Monitoring

Spring Boot Actuator is a crucial tool for monitoring and managing Spring Boot applications in production. It provides ready-to-use endpoints that help track application health, metrics, and performance.

2024-02-05

Java

Building a TCP Server with Reactor Netty and Spring Boot: A Step-by-Step Guide

When it comes to building high-performance, scalable TCP servers, the combination of Reactor Netty and Spring Boot offers a powerful solution. Reactor Netty provides a non-blocking and reactive approach to network programming, while Spring Boot simplifies the setup and configuration process

2024-01-02

Java

Optimizing Memory Configuration in Java Applications

Understanding how to optimize memory configuration can dramatically improve your application's throughput, reduce latency, and prevent dreaded OutOfMemoryError exceptions

2024-07-17

Java

How to optimize Spring Boot Application Performance with just few steps

1. Database Optimization

Connection Pooling Configuration

JPA Query Optimization

2. Caching Strategies

Enable Spring Cache

Redis for Distributed Caching

3. Asynchronous Processing

Enable Async Methods

4. JVM Optimization

Memory Configuration

5. HTTP Response Optimization

Enable Compression

6. Monitoring and Profiling

Enable Actuator for Monitoring

Custom Performance Metrics

Best Practices

Conclusion

Related articles ...

Java Records vs Traditional Classes: When and how to use Java Records

Spring Boot Actuator for Performance Monitoring

Building a TCP Server with Reactor Netty and Spring Boot: A Step-by-Step Guide

Optimizing Memory Configuration in Java Applications