Common Interface Performance Optimization Strategies

Background: The author observed long interface response times in legacy projects and decided to consolidate performance improvements.

1. Batch Processing

Batch database operations reduce I/O by inserting or updating records in a single transaction.

//批量入库
batchInsert();

2. Asynchronous Processing

Time‑consuming, non‑essential logic can be moved to asynchronous execution, using thread pools, message queues, or scheduling frameworks, e.g., handling accounting and file writing for a financial purchase request.

3. Space‑Time Trade‑off (Caching)

Cache frequently accessed, rarely changed data to avoid repeated database queries; examples include using Redis, Memcached, or in‑memory maps.

4. Pre‑processing

Pre‑compute data and store it for fast retrieval, similar to caching.

5. Pooling

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

6. Serial to Parallel

Execute independent tasks concurrently to reduce overall latency, e.g., fetching account, product, and banner data in parallel for a portfolio page.

7. Indexing

Proper indexes dramatically speed up queries; the article notes common pitfalls when indexes are ineffective.

8. Avoid Large Transactions

Long‑running transactions hold database connections; move RPC calls and heavy queries outside the 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 code to eliminate redundant queries and object creation, adjusting execution order.

10. Deep Pagination

Use primary‑key based pagination to maintain performance on large offsets.

11. SQL Optimization

Combine indexing, pagination, and other techniques to improve query efficiency.

12. Lock Granularity

Apply locks only to truly shared resources; avoid coarse‑grained locking that degrades performance.

//非共享资源
private void notShare(){
}
//共享资源
private void share(){
}
private int right(){
    notShare();
    synchronized (this) {
        share();
    }
}

Overall, the author encourages developers to adopt a higher‑level design mindset to prevent performance degradation during rapid feature iteration.