Comprehensive Interface Performance Optimization Strategies

Recently I came across a sharing from a senior engineer at JD Cloud about an interface optimization plan that can be applied directly. Below is a detailed guide.

1. Background

In legacy projects, many cost‑saving and efficiency‑improving efforts revealed that excessive interface latency was the most common issue, prompting a focused performance‑optimization effort.

2. Summary of Interface Optimization Solutions

2.1 Batch Processing

Batch operations reduce repeated I/O by inserting or updating data in bulk after processing a collection.

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

2.2 Asynchronous Processing

Long‑running, non‑essential logic can be offloaded to asynchronous execution (thread pools, message queues, or scheduling frameworks) to lower request latency.

2.3 Space‑for‑Time (Caching)

Cache frequently accessed, rarely changed data (e.g., using Redis, Memcached, local maps) to avoid repeated database queries or calculations, while being mindful of consistency concerns.

2.4 Pre‑Processing

Pre‑compute results and store them (in cache or a dedicated column) so that API calls can retrieve ready‑made values, such as pre‑calculated annualized returns for financial products.

2.5 Pooling

Reuse resources like database connections or threads via pools to avoid the overhead of repeated creation and destruction.

2.6 Serial‑to‑Parallel Conversion

Execute independent tasks concurrently (e.g., fetching user account, product info, and banner data in parallel) to significantly cut total response time.

2.7 Indexing

Proper indexing dramatically speeds up data retrieval; the article notes common scenarios where indexes may become ineffective.

2.8 Avoid Large Transactions

Long‑running transactions hold database connections and can cause timeouts, deadlocks, and replication lag. Recommendations include moving RPC calls out of transactions, limiting data processed within a transaction, and keeping queries outside the transaction when possible.

@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 account task
    taskMapper.insert(ManagerParamUtil.buildTask(record, TaskEnum.Task_type.pension_account.type(), TaskEnum.Account_bizType.purchase_request.type()));
    // insert sync task
    taskMapper.insert(ManagerParamUtil.buildTask(record, TaskEnum.Task_type.pension_sync.type(), TaskEnum.Sync_bizType.purchase.type()));
    // insert image upload task
    taskMapper.insert(ManagerParamUtil.buildTask(record, TaskEnum.Task_type.pension_sync.type(), TaskEnum.Sync_bizType.cert.type()));
    result.setInfo(ResultInfoEnum.SUCCESS);
    return result;
}

2.9 Program Structure Optimization

Refactor accumulated code after multiple iterations to eliminate redundant queries and object creations, ensuring a clean execution flow.

2.10 Deep Pagination Issues

Using LIMIT offset, count scans unnecessary rows; replace with key‑set pagination (e.g., WHERE id > lastId LIMIT count ) to leverage primary‑key indexes.

SELECT * FROM purchase_record WHERE productCode = 'PA9044' AND status = 4 AND id > 100000 LIMIT 200;

2.11 SQL Optimization

General SQL tuning—leveraging indexes, efficient pagination, and selective column retrieval—further improves query performance.

2.12 Lock Granularity

Apply locks only to truly shared resources; avoid coarse‑grained synchronization that blocks unrelated operations.

// Incorrect: locking non‑shared code
synchronized(this) {
    share();
    notShare();
}

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

Conclusion

Interface performance problems usually stem from incremental development without holistic design. By adopting the above strategies—batching, async, caching, pre‑processing, pooling, parallelism, indexing, transaction hygiene, code refactoring, pagination, SQL tuning, and fine‑grained locking—developers can achieve significant cost reduction and efficiency gains.