Common Backend Interface Performance Optimization Strategies

1. Background

For legacy projects, many cost‑reduction and efficiency‑boosting measures were taken last year, and the most frequent issue discovered was excessively long interface response times, prompting a focused effort on interface performance optimization.

2. Summary of Interface Optimization Solutions

1. Batch Processing

Batch thinking: perform bulk database operations. In loops that insert records, execute a single batch insert or update after processing to avoid multiple I/O.

// batch insert
batchInsert();

2. Asynchronous Processing

Asynchronous thinking: for time‑consuming logic that does not need an immediate result, move it to asynchronous execution to lower interface latency.

Example: a financial purchase interface where accounting and file writing are not required instantly; these can be handled asynchronously.

Implementation can use thread pools, message queues, or scheduling frameworks.

3. Space‑for‑Time (Caching)

Reasonably use caches for frequently accessed, rarely changed data to avoid repeated database queries or calculations.

Be aware that caching introduces consistency challenges and must be applied judiciously.

Caches can be Redis, Memcached, local maps, etc.

4. Pre‑Processing

Pre‑fetching: compute data in advance and store it in cache or a dedicated column, so the interface can retrieve it directly.

Example: pre‑calculate annualized returns for financial products based on net asset value.

5. Pooling

Reuse objects such as database connections or thread pools to avoid the overhead of repeated creation and destruction.

The essence is pre‑allocation and cyclic reuse, applicable to various business scenarios.

6. Serial to Parallel

Convert sequential dependent calls into parallel ones when there is no result dependency, greatly reducing total latency.

Example: fetching user account, product info, and banner data for a portfolio page in parallel.

7. Indexing

Adding appropriate indexes dramatically improves query efficiency; the article notes common scenarios where indexes may not work.

8. Avoid Large Transactions

Long‑running transactions hold database connections and degrade performance. Example code shows a typical @Transactional method.

@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;
}

Mitigation: keep RPC calls out of transactions, place read‑only queries outside, and limit data processed within a transaction.

9. Optimize Program Structure

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

10. Deep Pagination Issues

Standard LIMIT pagination can be slow; using an indexed column (e.g., auto‑increment ID) with a condition can improve performance.

select * from purchase_record where productCode = 'PA9044' and status=4 and id > 100000 limit 200

11. SQL Optimization

SQL tuning (indexes, pagination, etc.) can greatly boost query performance; specific examples are omitted.

12. Lock Granularity

Overly coarse locks (e.g., synchronized on large scopes) hurt concurrency. Use fine‑grained locks only around critical sections.

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

3. Final Thoughts

Root Causes of Interface Performance Issues

Performance problems often accumulate over multiple iterations as quick feature delivery leads to code piling up.

Adopting a higher‑level design mindset and considering interface design from the start can effectively reduce such issues.

All the best!