Java千万级别接口优化方案总结

这是一个关于接口优化方案总结的思维导图，包含了12个关键方面：

1.批处理

2.异步处理

3.空间换时间

4.预处理

5.池化思想

6.串行改并行

7.索引

8.避免大事务

9.优化程序结构

10.深分页问题

11.SQL优化

12.锁粒度避免过粗

这个思维导图展示了一个全面的接口优化策略框架，涵盖了从数据库层面（如SQL优化、索引）到应用层面（如批处理、异步处理）的多个优化维度。每个方面都是提升接口性能的重要考虑因素。

这些优化方案可以根据具体场景组合使用，比如：

对于高并发场景，可以重点考虑异步处理和串行改并行

对于数据库访问密集型接口，可以着重于SQL优化和索引设计

对于大数据量处理，可以采用批处理和预处理策略

这个框架可以作为接口优化的检查清单，帮助开发人员系统地思考和实施优化方案。

继续补充，并案例说明，代码写出来，并写出架构图

让我为每个优化方向提供详细说明和代码示例。

1. 批处理优化

场景

当需要处理大量数据插入或更新时，逐条处理会导致性能问题。

代码示例

// 优化前

publicvoidinsertUsers(List users){

for(Useruser :users){

userMapper.insert(user);

}

}

// 优化后

publicvoidbatchInsertUsers(List users){

intbatchSize = 1000;

for(inti = 0; i < users.size(); i += batchSize){

List batch = users.subList(

i,

Math.min(i + batchSize, users.size())

);

userMapper.batchInsert(batch);

}

}

-- 对应的 Mapper XML

INSERT INTOuser (name, age, email)VALUES

(#{user.name}, #{user.age}, #{user.email})

2. 异步处理

场景

对于一些非实时性要求的操作，可以采用异步处理提高响应速度。

代码示例

@Service

publicclassOrderService{

@Autowired

privateAsyncTaskExecutortaskExecutor;

publicvoidprocessOrder(Orderorder){

// 主流程快速返回

saveOrder(order);

// 异步处理非核心逻辑

taskExecutor.execute(()->{

sendNotification(order);

updateInventory(order);

generateReport(order);

});

}

}

配置异步线程池：

@Configuration

public class AsyncConfig {

@Bean

public AsyncTaskExecutor taskExecutor() {

ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

executor.setCorePoolSize(5);

executor.setMaxPoolSize(10);

executor.setQueueCapacity(25);

executor.setThreadNamePrefix("AsyncTask-");

return executor;

}

}

3. 空间换时间

场景

使用缓存来提升读取性能。

代码示例

@Service

publicclassProductService{

@Autowired

privateRedisTemplate redisTemplate;

@Cacheable(value = "products", key = "#productId")

publicProductgetProduct(LongproductId){

// 从数据库查询

returnproductMapper.selectById(productId);

}

@CachePut(value = "products", key = "#product.id")

publicProductupdateProduct(Productproduct){

productMapper.updateById(product);

returnproduct;

}

@CacheEvict(value = "products", key = "#productId")

publicvoiddeleteProduct(LongproductId){

productMapper.deleteById(productId);

}

}

4.预处理

场景

对于复杂的统计分析，可以提前计算并存储结果。

@Service

public class StatisticsService {

@Scheduled(cron = "0 0 1 * * ?") // 每天凌晨1点执行

public void preCalculateStatistics() {

List stats = calculateDailyStats();

statsRepository.saveAll(stats);

}

public DailyStats getStatistics(String date) {

// 直接返回预计算的结果

return statsRepository.findByDate(date);

}

}

架构图

graph TD

A[客户端请求] --> B[API网关]

B --> C[负载均衡]

C --> D[服务层]

D --> E[缓存层/Redis]

D --> F[数据库]

D --> G[消息队列]

G --> H[异步处理服务]

H --> F

D --> I[批处理服务]

I --> F

5. 池化思想

场景

对于需要频繁创建和销毁的资源，使用对象池来提升性能。

public class ConnectionPool {

private BlockingQueue pool;

public ConnectionPool(int poolSize) {

pool = new ArrayBlockingQueue<>(poolSize);

for (int i = 0; i < poolSize; i++) {

pool.offer(createConnection());

}

}

public Connection getConnection() throws InterruptedException {

return pool.take();

}

public void releaseConnection(Connection conn) {

pool.offer(conn);

}

}

6. 串行改并行

场景

将可以并行处理的任务改为并行执行。

@Service

public class DataProcessService {

@Autowired

private ExecutorService executorService;

public List processData(List tasks) {

List<CompletableFuture> futures = tasks.stream()

.map(task -> CompletableFuture.supplyAsync(

() -> processTask(task),

executorService

))

.collect(Collectors.toList());

return futures.stream()

.map(CompletableFuture::join)

.collect(Collectors.toList());

}

}

7. 索引优化

SQL示例

-- 创建复合索引

CREATEINDEXidx_user_name_emailONusers(name, email);

-- 创建部分索引

CREATEINDEXidx_orders_statusONorders(status)WHEREstatus!= 'completed';

-- 创建函数索引

CREATEINDEXidx_lower_emailONusers(LOWER(email));

8. 避免大事务

代码示例

@Service

publicclassOrderService{

@Transactional(propagation = Propagation.REQUIRED)

publicvoidprocessOrders(List orders){

for(Orderorder :orders){

try{

// 每个订单单独事务

processOrderInNewTransaction(order);

}catch(Exceptione){

log.error("处理订单失败: "+ order.getId(), e);

}

}

}

@Transactional(propagation = Propagation.REQUIRES_NEW)

publicvoidprocessOrderInNewTransaction(Orderorder){

// 处理单个订单

}

}

9. 深分页优化

代码示例

@Service

publicclassProductService{

publicPagegetProductPage(StringlastId, intsize){

returnproductMapper.selectPage(

newPage<>(1, size),

newQueryWrapper()

.gt("id", lastId)

.orderByAsc("id")

);

}

}

-- 优化后的SQL

SELECT* FROMproducts

WHEREid > :lastId

ORDER BYid ASC

LIMIT:size

完整架构图

graph TB

Client[客户端] --> Gateway[API网关/负载均衡]

Gateway --> ServiceLayer[服务层]

subgraph 性能优化策略

ServiceLayer --> Cache[缓存层]

ServiceLayer --> AsyncProcess[异步处理]

ServiceLayer --> BatchProcess[批处理]

ServiceLayer --> Pool[资源池]

ServiceLayer --> ParallelProcess[并行处理]

end

Cache --> Redis[(Redis)]

AsyncProcess --> MQ[(消息队列)]

BatchProcess --> DB[(数据库)]

Pool --> Resources[连接池/线程池]

ParallelProcess --> Workers[工作线程]

MQ --> AsyncWorkers[异步工作者]

AsyncWorkers --> DB

这些优化方案可以根据具体业务场景选择性使用，通常需要:

进行性能测试

监控系统指标

分析瓶颈所在

选择合适的优化方案

验证优化效果

同时要注意：

过度优化可能带来代码复杂度提升

要在性能和可维护性之间找到平衡

优化方案要考虑系统规模和团队能力

建立性能监控和告警机制

继续

让我们继续深入探讨其他优化方案和最佳实践。

10. SQL优化详解

10.1 执行计划优化

-- 使用 EXPLAIN 分析SQL执行计划

EXPLAIN SELECT* FROMusers u

JOINorders o ONu.id = o.user_id

WHEREu.status = 'active';

-- 优化后，添加适当索引

CREATEINDEXidx_user_statusONusers(status);

CREATEINDEXidx_order_userONorders(user_id);

10.2 SQL改写优化

-- 优化前

SELECT* FROMorders

WHEREDATE_FORMAT(create_time, '%Y-%m-%d')= '2024-03-20';

-- 优化后

SELECT* FROMorders

WHEREcreate_time >= '2024-03-20 00:00:00'

ANDcreate_time < '2024-03-21 00:00:00';

11.接口限流实现

11.1令牌桶算法实现

@Service

publicclassRateLimiter{

privatefinallongcapacity; // 桶的容量

privatefinaldoublerate; // 令牌产生速率

privatedoubletokens; // 当前令牌数量

privatelonglastTimestamp; // 上次更新时间

publicRateLimiter(longcapacity, doublerate){

this.capacity = capacity;

this.rate = rate;

this.tokens = capacity;

this.lastTimestamp = System.currentTimeMillis();

}

publicsynchronizedbooleantryAcquire(){

longnow = System.currentTimeMillis();

// 计算新增令牌数

doublenewTokens = (now - lastTimestamp)/ 1000.0* rate;

tokens = Math.min(capacity, tokens + newTokens);

lastTimestamp = now;

if(tokens < 1){

returnfalse;

}

tokens--;

returntrue;

}

}

11.2 使用SpringCloud Gateway实现限流

spring:

cloud:

gateway:

routes:

- id: rate_limit_route

uri: lb://service-name

predicates:

- Path=/api/**

filters:

- name: RequestRateLimiter

args:

redis-rate-limiter.replenishRate: 10

redis-rate-limiter.burstCapacity: 20

key-resolver: "#{@userKeyResolver}"

@Configuration

publicclassRateLimiterConfig{

@Bean

KeyResolveruserKeyResolver(){

returnexchange ->Mono.just(

exchange.getRequest()

.getHeaders()

.getFirst("user-id")

);

}

}

12.分布式锁实现

12.1 Redis分布式锁

@Service

publicclassDistributedLockService{

@Autowired

privateStringRedisTemplateredisTemplate;

publicbooleanlock(Stringkey, Stringvalue, longtimeout){

returnredisTemplate.opsForValue()

.setIfAbsent(key, value, timeout, TimeUnit.SECONDS);

}

publicbooleanunlock(Stringkey, Stringvalue){

Stringscript = "if redis.call('get',KEYS[1]) == ARGV[1] then "+

"return redis.call('del',KEYS[1]) else return 0 end";

returnredisTemplate.execute(newDefaultRedisScript<>(script, Boolean.class),

Collections.singletonList(key), value);

}

}

12.2 使用Redisson实现可重入锁

@Service

publicclassRedissonLockService{

@Autowired

privateRedissonClientredisson;

publicvoidprocessWithLock(StringlockKey, Runnabletask){

RLocklock = redisson.getLock(lockKey);

try{

// 尝试加锁，最多等待100秒，锁定后10秒自动解锁

booleanisLocked = lock.tryLock(100, 10, TimeUnit.SECONDS);

if(isLocked){

task.run();

}

}catch(InterruptedExceptione){

Thread.currentThread().interrupt();

}finally{

lock.unlock();

}

}

}

13.缓存架构设计

13.1多级缓存实现

@Service

publicclassMultiLevelCache{

@Autowired

privateCaffeineCacheManagerlocalCache;

@Autowired

privateRedisTemplate redisCache;

@Autowired

privateDataServicedataService;

publicObjectget(Stringkey){

// 查询本地缓存

Objectvalue = localCache.getCache("local").get(key);

if(value != null){

returnvalue;

}

// 查询Redis缓存

value = redisCache.opsForValue().get(key);

if(value != null){

// 回填本地缓存

localCache.getCache("local").put(key, value);

returnvalue;

}

// 查询数据库

value = dataService.query(key);

if(value != null){

// 更新Redis缓存

redisCache.opsForValue().set(key, value, 1, TimeUnit.HOURS);

// 更新本地缓存

localCache.getCache("local").put(key, value);

}

returnvalue;

}

}

13.2 缓存更新策略

@Service

publicclassCacheUpdateStrategy{

@Autowired

privateRedisTemplate redisTemplate;

@Autowired

privateCacheManagercacheManager;

publicvoidupdateThroughStrategy(Stringkey, Objectvalue){

// 先更新数据库

dataService.update(key, value);

// 再更新缓存

redisTemplate.opsForValue().set(key, value);

}

publicvoidwriteBackStrategy(Stringkey, Objectvalue){

// 更新缓存

redisTemplate.opsForValue().set(key, value);

// 异步更新数据库

CompletableFuture.runAsync(()->{

dataService.update(key, value);

});

}

}

14.系统监控方案

14.1性能指标收集

@Aspect

@Component

publicclassPerformanceMonitorAspect{

privatefinalMeterRegistryregistry;

publicPerformanceMonitorAspect(MeterRegistryregistry){

this.registry = registry;

}

@Around("@annotation(Monitor)")

publicObjectmonitorPerformance(ProceedingJoinPointpjp)throwsThrowable{

Timer.Samplesample = Timer.start(registry);

try{

returnpjp.proceed();

}finally{

sample.stop(Timer.builder("method.execution.time")

.tag("class", pjp.getSignature().getDeclaringTypeName())

.tag("method", pjp.getSignature().getName())

.register(registry));

}

}

}

14.2链路追踪

@Configuration

publicclassTracingConfig{

@Bean

publicTracertracer(){

returnTracing.newBuilder()

.localServiceName("my-service")

.spanReporter(spanReporter())

.build()

.tracer();

}

@Bean

publicReporterspanReporter(){

returnAsyncReporter.builder(URLConnectionSender.create("http://zipkin:9411/api/v2/spans"))

.build();

}

}

完整系统架构图

graph TB

Client[客户端] --> LB[负载均衡]

LB --> Gateway[API网关]

subgraph 应用层

Gateway --> Auth[认证授权]

Auth --> RateLimit[限流]

RateLimit --> Cache[多级缓存]

Cache --> Service[业务服务]

end

subgraph 数据层

Service --> LocalCache[本地缓存]

Service --> Redis[(Redis集群)]

Service --> DB[(数据库集群)]

Service --> MQ[(消息队列)]

end

subgraph 监控层

Monitor[监控系统] --> Metrics[指标收集]

Monitor --> Trace[链路追踪]

Monitor --> Log[日志系统]

Monitor --> Alert[告警系统]

end

15. 性能优化建议

1. 系统层面

使用CDN加速静态资源

实现服务降级和熔断

采用微服务架构提高扩展性

实现灰度发布机制

应用层面

使用连接池管理资源

采用异步编程模型

实现请求合并

使用本地缓存

数据库层面

合理设计索引

优化SQL语句

实现分库分表

读写分离

缓存层面

建立多级缓存

防止缓存穿透

解决缓存雪崩

合理设置过期时间

代码层面

使用性能更好的数据结构

避免创建不必要的对象

减少锁的使用范围

优化循环结构

这些优化方案需要根据实际业务场景和性能瓶颈来选择性使用，同时要注意监控优化效果，确保系统的稳定性和可维护性