10 Proven Strategies to Supercharge API Performance in Spring Boot

Background

Many legacy projects suffer from excessively long API response times, prompting a focused effort on interface performance optimization.

Interface Optimization Summary

1. Batch Processing

Batch database operations reduce I/O by inserting or updating records in bulk after processing completes.

//for loop single insert
list.stream().forEach(msg->{
    insert();
});
//batch insert
batchInsert();

2. Asynchronous Processing

Long‑running, non‑essential logic can be moved to asynchronous execution using thread pools, message queues, or scheduling frameworks, reducing perceived latency.

For example, a financial purchase interface can handle accounting and file writing asynchronously.

3. Space‑for‑Time (Caching)

Cache frequently accessed, rarely changed data to avoid repeated database queries or calculations, while being mindful of consistency challenges.

4. Pre‑processing

Pre‑compute and store results (e.g., annualized return rates) so that API calls can retrieve ready‑made values directly.

5. Pooling

Reuse resources such as database connections or threads via pooling to avoid the overhead of repeated creation and destruction.

6. Serial to Parallel

Convert sequential calls into parallel ones when there are no result dependencies, dramatically reducing total latency.

7. Indexing

Proper indexing can greatly improve query efficiency; the article notes common pitfalls where indexes may not be effective.

8. Avoid Large Transactions

Long‑running transactions hold database connections, harming concurrency. Solutions include moving RPC calls out of transactions, limiting data processed within a transaction, and keeping queries outside transactional scopes.

@Transactional(value = "taskTransactionManager", propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, rollbackFor ={RuntimeException.class, Exception.class})
public BasicResult purchaseRequest(PurchaseRecord record){
    BasicResult result = new BasicResult();
    // insert tasks
    taskMapper.insert(...);
    // other logic
    return result;
}

@Transactional(value = "taskTransactionManager", propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, rollbackFor ={RuntimeException.class, Exception.class})
public BasicResult purchaseRequest(PurchaseRecord record){
    BasicResult result = new BasicResult();
    // ...
    pushRpc.doPush(record);
    return result;
}

9. Optimize Program Structure

Refactor code to eliminate redundant queries and object creations, especially after multiple feature iterations.

10. Deep Pagination

Replace offset‑based pagination (e.g., limit 100000,200) with keyset pagination using a continuously increasing primary key to leverage index scans.

select * from purchase_record where productCode='PA9044' and status=4 and id > 100000 limit 200;

11. SQL Optimization

General SQL tuning—leveraging indexes, appropriate pagination, and query simplification—can significantly boost API query performance.

12. Lock Granularity

Use fine‑grained locks only around truly shared resources; avoid locking unrelated code paths to prevent unnecessary contention.

// Incorrect: lock non‑shared resources
synchronized(this){
    share();
    notShare();
}

// Correct: lock only shared part
private void right(){
    notShare();
    synchronized(this){
        share();
    }
}

Conclusion

Performance issues often accumulate over iterative development; adopting higher‑level design thinking and applying the above strategies can effectively reduce latency and improve overall system efficiency.