Common Interface Performance Optimization Techniques

1. Background

For an existing project, many cost‑saving and efficiency‑improving measures were taken last year, and the most frequent issue discovered was excessively long interface response time. This article shares a generic solution for interface performance optimization.

2. Interface Optimization Summary

1. Batch Processing

Batch operations on the database can dramatically reduce I/O by inserting or updating records in bulk after processing is complete.

// Batch insert
batchInsert();

2. Asynchronous Processing

Time‑consuming logic that does not affect the immediate result can be moved to asynchronous execution, lowering interface latency. This can be implemented with thread pools, message queues, or scheduling frameworks.

3. Space‑for‑Time (Caching)

Cache frequently accessed, rarely changed data to avoid repeated database queries or calculations. Caches may be in‑memory (e.g., Map, memcached) or external (e.g., Redis).

4. Pre‑Processing

Pre‑compute data and store it in a cache or a dedicated column so that the interface can retrieve ready‑made results quickly, similar to caching but focused on computed values such as annualized returns.

5. Pooling

Reuse resources like database connections or thread pools instead of creating and destroying them repeatedly, which saves time and reduces overhead.

6. Serial to Parallel

When independent tasks have no data dependency, execute them in parallel rather than sequentially to cut total execution time.

7. Indexing

Adding appropriate indexes greatly improves query efficiency; the article notes common scenarios where indexes may not be effective.

8. Avoid Large Transactions

@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);
    result.setInfo(ResultInfoEnum.SUCCESS);
    return result;
}

Large, long‑running transactions hold database connections and degrade performance. Recommendations include moving RPC calls out of transactions, keeping read‑only queries outside transactions, and limiting the amount of data processed within a transaction.

9. Optimize Program Structure

Repeated iterations can cause code bloat, redundant queries, and unnecessary object creation. Refactor the overall interface flow, evaluate each code block’s purpose, and reorder execution for efficiency.

10. Deep Pagination

Deep pagination using LIMIT can be slow; using a continuously increasing primary key for pagination can improve performance, but it requires appropriate data design.

11. SQL Optimization

General SQL tuning—combined with proper indexing and pagination—can significantly boost query performance.

12. Lock Granularity

Use fine‑grained locks only on truly shared resources; avoid coarse locks that block unrelated operations. Example of incorrect locking is shown below:

// Non‑shared resource
private void notShare() {}
// Shared resource
private void share() {}
private int right() {
    notShare();
    synchronized (this) {
        share();
    }
}

3. Conclusion

Interface performance issues usually accumulate over multiple development cycles due to rapid feature delivery without proper refactoring. By adopting higher‑level design thinking and systematic optimization, developers can achieve cost reduction and efficiency gains.