Comprehensive Interface Performance Optimization Strategies

Background: In legacy projects, prolonged API latency was identified as a major bottleneck, prompting a focused effort on interface performance optimization.

1. Batch Processing

Batch operations reduce repeated I/O by aggregating database writes after processing a collection of records.

list.stream().forEach(msg -> {
    insert();
});
// Batch insert
batchInsert();

2. Asynchronous Execution

Time‑consuming, non‑essential logic can be offloaded to asynchronous tasks using thread pools, message queues, or scheduling frameworks, thereby lowering request latency.

Example: In a financial purchase API, accounting and file‑writing steps are moved to asynchronous processing.

3. Space‑for‑Time (Caching)

Frequently accessed, rarely changed data should be cached (e.g., Redis, local cache, Memcached, or in‑memory maps) to avoid repeated database queries.

4. Pre‑Processing

Pre‑compute results (such as annualized returns from net asset values) and store them, so the API can return ready‑made values instantly.

5. Pooling

Reuse resources like database connections and threads through pooling to eliminate the overhead of repeated creation and destruction.

6. Serial to Parallel

Independent operations (e.g., fetching user, product, and banner data) should be executed in parallel to reduce cumulative latency.

7. Indexing

Proper indexes dramatically speed up data retrieval; the article notes common scenarios where indexes may be ineffective.

8. Avoid Large Transactions

Long‑running transactions hold database connections, causing contention. Recommendations include keeping RPC calls and heavy queries outside transactions and limiting the amount of data processed within a transaction.

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

When adding push notifications, avoid placing RPC calls inside the transaction to prevent large‑transaction issues.

@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. Refactor Program Structure

Iterative development can lead to duplicated queries and object creation; a systematic refactor evaluates each code block’s purpose and reorders execution for efficiency.

10. Deep Pagination

Using LIMIT offset, count scans unnecessary rows. Replace it with a primary‑key‑based pagination (e.g., WHERE id > lastId LIMIT count ) to leverage index scans.

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

11. SQL Optimization

Combine indexing, pagination, and query rewriting to improve query performance; specific SQL tweaks are left to the reader.

12. Lock Granularity

Use fine‑grained locks only around truly shared resources; avoid over‑locking (e.g., synchronizing non‑shared code) to prevent unnecessary contention.

// Incorrect locking
synchronized(this) {
    share();
    notShare();
}

// Correct locking
notShare();
synchronized(this) {
    share();
}

Conclusion

Interface performance issues accumulate over multiple iterations; adopting higher‑level design thinking and the above optimization techniques can significantly reduce latency and improve overall system efficiency.