Common Interface Performance Optimization Strategies

When legacy projects suffer from long API response times, a systematic performance tuning approach can dramatically improve efficiency. The following tenable strategies are presented with explanations and code examples.

1. Batch Processing

Group database writes into a single batch to avoid repeated I/O operations.

batchInsert();

2. Asynchronous Processing

Offload non‑critical, time‑consuming tasks to background threads, thread pools, message queues, or scheduled jobs.

3. Space‑for‑Time (Caching)

Cache frequently accessed, rarely changed data (e.g., using Redis, Memcached, or in‑memory maps) to eliminate redundant database queries.

4. Pre‑processing

Pre‑compute results or store derived values in a cache or dedicated column so that API calls can retrieve them instantly.

5. Pooling

Reuse expensive resources such as database connections or threads via connection pools and thread pools.

6. Serial to Parallel

Execute independent sub‑tasks concurrently when there are no data dependencies, reducing overall latency.

7. Indexing

Apply appropriate indexes to accelerate query execution; be aware of scenarios where indexes may become ineffective.

8. Avoid Large Transactions

Split lengthy transactional work, keep RPC calls outside transactions, and limit the amount of data processed within a single 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();
    // ...
    pushRpc.doPush(record);
    result.setInfo(ResultInfoEnum.SUCCESS);
    return result;
}

9. Optimize Program Structure

Refactor accumulated code after multiple iterations to eliminate redundant queries and object creations, and reorder execution for better performance.

10. Deep Pagination

Use key‑based pagination (e.g., "WHERE id > lastId LIMIT 200") instead of offset‑based LIMIT to keep queries fast on large tables.

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

11. SQL Optimization

Combine indexing, proper pagination, and query rewriting to improve database access speed.

12. Lock Granularity

Apply locks only to the minimal critical section (e.g., synchronized(this) around shared resources) to avoid unnecessary contention.

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