肇新合同

二、数据库优化

MySQL深度调优与分库分表策略：

2.1 优化策略矩阵

2.2 分库分表实现

ShardingSphere分片配置：

# 按企业ID分库+按时间分表
spring:
  shardingsphere:
    datasource:
      names: ds0,ds1,ds2
      ds0: ...
      ds1: ...
      ds2: ...
    sharding:
      tables:
        contract:
          actual-data-nodes: ds$->{0..2}.contract_$->{2020..2023}
          database-strategy:
            standard:
              precise-algorithm-class-name: com.example.DbShardingAlgorithm
              sharding-column: enterprise_id
          table-strategy:
            standard:
              precise-algorithm-class-name: com.example.TableShardingAlgorithm
              sharding-column: create_time
          key-generator:
            column: id
            type: SNOWFLAKE

# 自定义分片算法
public class DbShardingAlgorithm implements PreciseShardingAlgorithm<Long> {
    @Override
    public String doSharding(Collection<String> dbNames, PreciseShardingValue<Long> shardingValue) {
        long enterpriseId = shardingValue.getValue();
        return "ds" + (enterpriseId % dbNames.size());
    }
}

public class TableShardingAlgorithm implements PreciseShardingAlgorithm<Date> {
    @Override
    public String doSharding(Collection<String> tableNames, PreciseShardingValue<Date> shardingValue) {
        Date createTime = shardingValue.getValue();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
        return "contract_" + sdf.format(createTime);
    }
}

慢SQL优化案例：

-- 优化前（执行时间2.3s）
SELECT * FROM contracts 
WHERE status = 'SIGNED' 
AND create_time > '2023-01-01'
ORDER BY amount DESC
LIMIT 1000;

-- 优化后（执行时间280ms）
CREATE INDEX idx_status_create_amount ON contracts(status, create_time, amount);

SELECT * FROM contracts FORCE INDEX(idx_status_create_amount)
WHERE status = 'SIGNED' 
AND create_time > '2023-01-01'
ORDER BY amount DESC
LIMIT 1000;

-- 终极方案（执行时间15ms）
SELECT * FROM contracts c
JOIN (
    SELECT id FROM contracts
    WHERE status = 'SIGNED' 
    AND create_time > '2023-01-01'
    ORDER BY amount DESC
    LIMIT 1000
) tmp ON c.id = tmp.id;

三、缓存设计

多级缓存架构与一致性保障：

3.1 缓存策略矩阵

3.2 Redis高级用法

热点合同缓存方案：

// 多级缓存加载策略
public ContractDTO getContract(String id) {
    // 1. 查询本地缓存
    ContractDTO contract = caffeineCache.getIfPresent(id);
    if (contract != null) {
        return contract;
    }
    
    // 2. 查询Redis集群
    String redisKey = "contract:" + id;
    String json = redisCluster.get(redisKey);
    if (json != null) {
        contract = JSON.parseObject(json, ContractDTO.class);
        caffeineCache.put(id, contract); // 回填本地缓存
        return contract;
    }
    
    // 3. 查询数据库（防穿透）
    contract = contractMapper.selectById(id);
    if (contract != null) {
        // 双写缓存（设置不同过期时间）
        redisCluster.setex(redisKey, 3600, JSON.toJSONString(contract));
        caffeineCache.put(id, contract);
    } else {
        // 空值缓存防击穿
        redisCluster.setex(redisKey, 300, "NULL");
    }
    
    return contract;
}

// 使用Redis Lua保证原子性
String luaScript = "local key = KEYS[1] " +
    "local newStatus = ARGV[1] " +
    "local oldStatus = redis.call('HGET', key, 'status') " +
    "if oldStatus == ARGV[2] then " +
    "   redis.call('HSET', key, 'status', newStatus) " +
    "   return 1 " +
    "end " +
    "return 0";

// 签署状态变更
public boolean updateSignStatus(String id, String newStatus, String expectedOldStatus) {
    String scriptHash = redisCluster.scriptLoad(luaScript);
    return redisCluster.evalsha(
        scriptHash, 
        Collections.singletonList("contract:" + id), 
        Arrays.asList(newStatus, expectedOldStatus)) == 1L;
}

缓存一致性方案：

// 基于Binlog的缓存同步
@EventListener
public void onContractUpdate(ContractUpdateEvent event) {
    String redisKey = "contract:" + event.getContractId();
    
    // 1. 删除本地缓存
    caffeineCache.invalidate(event.getContractId());
    
    // 2. Redis删除+设置异步刷新任务
    redisCluster.del(redisKey);
    refreshQueue.add(new RefreshTask(event.getContractId()));
}

// 使用Canal监听数据库变更
public class CanalEventListener implements EntryListener {
    @Override
    public void onUpdate(Entry entry) {
        if (entry.getTableName().equals("contracts")) {
            String id = entry.getColumn("id").getValue();
            String redisKey = "contract:" + id;
            
            // 延迟双删策略
            redisCluster.del(redisKey);
            threadPool.schedule(() -> redisCluster.del(redisKey), 1, TimeUnit.SECONDS);
        }
    }
}

四、高性能编码

合同系统的Java最佳实践：

4.1 优化技巧对比

4.2 代码优化实例

合同导出优化：

// 优化前（内存溢出风险）
public byte[] exportContracts(List<String> ids) {
    List<Contract> contracts = ids.stream()
        .map(id -> contractMapper.selectById(id))
        .collect(Collectors.toList());
    
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    ExcelWriter writer = new ExcelWriter(out);
    writer.write(contracts);
    writer.finish();
    return out.toByteArray();
}

// 优化后（流式处理）
public void exportContracts(List<String> ids, OutputStream out) {
    ExcelWriter writer = new ExcelWriter(out);
    
    // 分批次查询
    int batchSize = 1000;
    for (int i = 0; i < ids.size(); i += batchSize) {
        List<String> batchIds = ids.subList(i, Math.min(i + batchSize, ids.size()));
        
        // 流式查询
        try (Cursor<Contract> cursor = contractMapper.selectStreamByIds(batchIds)) {
            writer.write(cursor, 
                new WriteConfig().setAutoTrim(true));
        }
    }
    
    writer.finish();
}

// MyBatis流式查询配置
@Select("SELECT * FROM contracts WHERE id IN (#{ids})")
@Options(resultSetType = ResultSetType.FORWARD_ONLY, fetchSize = 100)
Cursor<Contract> selectStreamByIds(@Param("ids") List<String> ids);

并发控制优化：

// 合同签署计数器
public class SignCounter {
    // 优化前
    private final AtomicInteger count = new AtomicInteger();
    
    // 优化后（高并发场景）
    private final LongAdder adder = new LongAdder();
    
    public void increment() {
        adder.increment();
    }
    
    public long get() {
        return adder.sum();
    }
}

// 合同锁优化
public class ContractLock {
    // 优化前（粗粒度锁）
    private static final Object globalLock = new Object();
    
    // 优化后（分段锁）
    private static final Striped<Lock> stripedLocks = Striped.lock(32);
    
    public void updateContract(String id) {
        Lock lock = stripedLocks.get(id);
        lock.lock();
        try {
            // 业务逻辑
        } finally {
            lock.unlock();
        }
    }
}

五、性能工具包

开箱即用的性能优化资源集合：

5.1 推荐工具集

5.2 开发资源包

▶ 免费获取资源：

关注「高性能架构」公众号领取：
               • 《数据库优化指南》
               • Redis配置模板
               • 合同压测场景集