☕ Java 后端场景决策

// 📁 config/ThreadPoolConfig.java @Configuration public class ThreadPoolConfig { // ❌ 用了默认 AbortPolicy，秒杀高峰直接 500！ @Bean public ThreadPoolExecutor seckillThreadPool() { return new ThreadPoolExecutor( 8, // 核心线程 16, // 最大线程 60, TimeUnit.SECONDS, // 空闲存活 new ArrayBlockingQueue<>(200) // 队列200 // ❌ 没指定拒绝策略 → 默认 AbortPolicy // 当并发 > 224 (16+200+8) 时，submit() 抛异常 ); } } // 📁 controller/SeckillController.java @RestController public class SeckillController { @Autowired private ThreadPoolExecutor seckillThreadPool; @Autowired private SeckillOrderService seckillOrderService; @PostMapping("/seckill/{goodsId}") public Result<String> seckill(@PathVariable Long goodsId, Long userId) { seckillThreadPool.submit(() -> { seckillOrderService.executeSeckill(goodsId, userId); }); return Result.ok("秒杀成功，订单创建中"); } // ❌ 秒杀高峰时，submit() 抛 RejectedExecutionException // → Controller 没有catch → 全局异常处理器返回500 // → 用户看到"系统繁忙"，以为是系统挂了，疯狂重试！ } // 📁 service/SeckillOrderService.java @Service public class SeckillOrderService { @Autowired private StringRedisTemplate redisTemplate; @Autowired private OrderMapper orderMapper; public void executeSeckill(Long goodsId, Long userId) { // 1. Redis 原子扣库存 Long stock = redisTemplate.opsForValue().decrement("seckill:stock:" + goodsId); if (stock == null || stock < 0) { throw new BizException("库存不足"); } // 2. 写入 DB 订单 Order order = new Order(goodsId, userId, "PAID"); orderMapper.insert(order); } }

// 📁 handler/OrderRejectHandler.java — 自定义拒绝策略 @Component public class OrderRejectHandler implements RejectedExecutionHandler { @Autowired private OrderRetryMapper orderRetryMapper; // 重试队列表 @Override public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) { // 1. 记录日志（知道丢了什么、什么时候、线程池什么状态） log.warn("秒杀任务被拒绝! 活跃={}, 队列={}, 已完成={}", executor.getActiveCount(), executor.getQueue().size(), executor.getCompletedTaskCount()); // 2. 从 Runnable 中提取订单信息，存入DB重试队列 if (r instanceof SeckillTask) { SeckillTask task = (SeckillTask) r; OrderRetry retry = new OrderRetry(task.getGoodsId(), task.getUserId()); orderRetryMapper.insert(retry); // 定时任务稍后重试 } // 3. 注意：不抛异常！Controller 层不会 500 // 用户体验：返回"排队中，请稍后查看订单" } } // 📁 config/ThreadPoolConfig.java — 正确配置 @Configuration public class ThreadPoolConfig { @Autowired private OrderRejectHandler orderRejectHandler; @Bean("seckillThreadPool") public ThreadPoolExecutor seckillThreadPool() { return new ThreadPoolExecutor( 8, // 核心线程：CPU核心数 16, // 最大线程：2倍核心 60, TimeUnit.SECONDS, // 空闲线程60s回收 new ArrayBlockingQueue<>(200), // 有界队列！不要用无界 new ThreadFactoryBuilder() // 命名线程，方便排查 .setNameFormat("seckill-pool-%d").build(), orderRejectHandler // ✅ 自定义拒绝策略 ); } } // 📁 controller/SeckillController.java — 正确写法 @RestController public class SeckillController { @Autowired @Qualifier("seckillThreadPool") private ThreadPoolExecutor seckillThreadPool; @Autowired private SeckillOrderService seckillOrderService; @PostMapping("/seckill/{goodsId}") public Result<String> seckill(@PathVariable Long goodsId, Long userId) { try { seckillThreadPool.submit( new SeckillTask(goodsId, userId, seckillOrderService) ); return Result.ok("秒杀成功，订单创建中"); } catch (Exception e) { // submit() 内部会把拒绝异常包装成 ExecutionException // 但自定义Handler不抛异常，这里不会进来 log.error("秒杀提交失败", e); return Result.fail("系统繁忙，请重试"); } } } // SeckillTask：可序列化的任务包装类（方便拒绝时提取参数） @AllArgsConstructor public class SeckillTask implements Runnable { private final Long goodsId; private final Long userId; private final SeckillOrderService service; @Override public void run() { service.executeSeckill(goodsId, userId); } // getter 省略，供 RejectHandler 提取参数用 }

// ❌ 用了 DiscardPolicy，但没加监控 — 丢了多少日志完全不知道 @Bean("logPool") public ThreadPoolExecutor logThreadPool() { return new ThreadPoolExecutor( 2, 4, 30, TimeUnit.SECONDS, new LinkedBlockingQueue<>(500), new ThreadPoolExecutor.DiscardPolicy() // 静默丢弃 ); // ❌ 队列满后，日志静默消失 // 线上出问题排查时，发现关键日志完全缺失！ } // ✅ 改进：即使用 DiscardPolicy，也要加监控 @Bean("logPool") public ThreadPoolExecutor logThreadPool() { ThreadPoolExecutor pool = new ThreadPoolExecutor( 2, 4, 30, TimeUnit.SECONDS, new LinkedBlockingQueue<>(500), (r, executor) -> { // ✅ 自定义策略 // 不阻塞，不抛异常，但记录丢弃次数 logRejectedCounter.increment(); // Prometheus 计数器 log.warn("日志丢弃，当前队列={}，累计丢弃={}", executor.getQueue().size(), logRejectedCounter.count()); } ); return pool; }

// 📁 service/UserService.java — 注册主逻辑 @Service public class UserService { @Autowired private UserMapper userMapper; @Autowired private ProfileService profileService; // RPC查画像 @Autowired private EmailService emailService; // RPC发邮件 @Autowired private CouponService couponService; // RPC发优惠券 public User register(UserReq req) { // ① 写入数据库（50ms） User user = new User(req.getPhone(), req.getName()); userMapper.insert(user); // ② 查用户画像（100ms）—— 必须等①完成 Profile profile = profileService.getProfile(user.getId()); // ③ 发欢迎邮件（100ms）—— 必须等②完成，但其实跟②没有依赖关系！ emailService.sendWelcome(user.getEmail()); // ④ 发新人优惠券（100ms）—— 必须等③完成，但其实跟③也没有依赖关系！ couponService.grantNewUserCoupon(user.getId()); return user; } }

// 📁 config/AsyncConfig.java — 先配一个线程池给CF用 @Configuration public class AsyncConfig { // 给 CompletableFuture.supplyAsync / runAsync 传的线程池 @Bean("taskExecutor") public Executor taskExecutor() { ThreadPoolTaskExecutor exec = new ThreadPoolTaskExecutor(); exec.setCorePoolSize(8); // 核心线程数 exec.setMaxPoolSize(16); // 最大线程数 exec.setQueueCapacity(200); // 等待队列容量 exec.setThreadNamePrefix("cf-pool-"); // 线程名前缀（排查用） exec.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 满了让调用者自己跑 exec.initialize(); return exec; } }

// 📁 service/UserService.java — 用 CompletableFuture 重写 @Service public class UserService { @Autowired private UserMapper userMapper; @Autowired private ProfileService profileService; @Autowired private EmailService emailService; @Autowired private CouponService couponService; @Autowired @Qualifier("taskExecutor") private Executor taskExecutor; // ← 注入上面配的线程池 public User register(UserReq req) { // ① 同步写DB（必须先完成，后续步骤依赖user.getId()） User user = new User(req.getPhone(), req.getName()); userMapper.insert(user); // 50ms // ②③④ 三个不互相依赖的RPC → 并行执行 CompletableFuture<Profile> profileFuture = CompletableFuture .supplyAsync(() -> profileService.getProfile(user.getId()), taskExecutor); CompletableFuture<Void> emailFuture = CompletableFuture .runAsync(() -> emailService.sendWelcome(user.getEmail()), taskExecutor); CompletableFuture<Void> couponFuture = CompletableFuture .runAsync(() -> couponService.grantNewUserCoupon(user.getId()), taskExecutor); // 等三个全部完成，带3秒超时（防止某个RPC卡死） CompletableFuture.allOf(profileFuture, emailFuture, couponFuture) .orTimeout(3, TimeUnit.SECONDS) .join(); // 阻塞等待全部完成 // 把画像结果塞进user返回 user.setProfile(profileFuture.join()); return user; } }

// 📁 service/ProfileService.java — 被调用的RPC（供参考，看清调用关系） @Service public class ProfileService { @Autowired private ProfileFeignClient profileFeignClient; // Feign调用用户中心 // 普通同步方法，耗时约100ms（网络往返+远端处理） public Profile getProfile(Long userId) { return profileFeignClient.getById(userId); } } // 📁 service/EmailService.java @Service public class EmailService { @Autowired private EmailFeignClient emailFeignClient; public void sendWelcome(String email) { emailFeignClient.sendTemplate(email, "WELCOME"); } } // 📁 service/CouponService.java @Service public class CouponService { @Autowired private CouponFeignClient couponFeignClient; public void grantNewUserCoupon(Long userId) { couponFeignClient.grant(userId, "NEW_USER_100"); } }

// 📁 controller/UserController.java — 入口，看清完整调用链 @RestController @RequestMapping("/api/users") public class UserController { @Autowired private UserService userService; @PostMapping("/register") public Result<User> register(@RequestBody @Valid UserReq req) { User user = userService.register(req); // ← 调用上面的register方法 return Result.success(user); } } /* 完整调用链： * 前端POST /api/users/register * → UserController.register() * → UserService.register() * → userMapper.insert() （同步, 50ms） * → CompletableFuture 并行: * ├→ ProfileService.getProfile() （100ms） * ├→ EmailService.sendWelcome() （100ms） * └→ CouponService.grantNewUserCoupon() （100ms） * → allOf().join() 等全部完成 * ← 返回User * ← 返回Result */

// ❌ 没有加 @EnableAsync → @Async 注解就是摆设！ @SpringBootApplication public class OrderApplication { public static void main(String[] args) { SpringApplication.run(OrderApplication.class, args); } } // ✅ 正确：加 @EnableAsync @SpringBootApplication @EnableAsync // ← 必须加！ public class OrderApplication { public static void main(String[] args) { SpringApplication.run(OrderApplication.class, args); } }

// ❌ 错误：this.sendEmail() 绕过Spring代理，@Async不生效！ // 📁 service/UserService.java @Service public class UserService { @Autowired private UserMapper userMapper; public User register(UserReq req) { User user = new User(req.getPhone(), req.getName()); userMapper.insert(user); // ❌ this. 调用 → 绕过代理 → @Async 不生效 → 同步执行！ this.sendWelcomeEmail(user.getEmail()); return user; } @Async // 这里想要异步，但被 this. 调用时完全无效 public void sendWelcomeEmail(String email) { emailFeignClient.send(email, "WELCOME"); } } // ────────────────────────────────────────────── // ✅ 正确：@Async方法拆到独立Bean，通过注入调用 // 📁 service/EmailService.java（独立类） @Service public class EmailService { @Autowired private EmailFeignClient emailFeignClient; @Async("asyncExecutor") // ← 指定线程池名 public void sendWelcomeEmail(String email) { emailFeignClient.send(email, "WELCOME"); } } // 📁 service/UserService.java（调用方） @Service public class UserService { @Autowired private EmailService emailService; // ← 注入独立Bean public User register(UserReq req) { User user = new User(req.getPhone(), req.getName()); userMapper.insert(user); // ✅ 通过注入的emailService调用 → 走代理 → 真正异步！ emailService.sendWelcomeEmail(user.getEmail()); return user; } }

// ❌ 不指定线程池 → SimpleAsyncTaskExecutor → 每次new线程！ @Service public class EmailService { @Async // ← 没有指定线程池名 public void sendEmail(String email) { emailFeignClient.send(email, "WELCOME"); } } // 结果：1000个请求 = 1000个线程 = 线程爆炸 / OOM // ────────────────────────────────────────────── // ✅ 正确：定义线程池 + @Async 指定名称 // 📁 config/AsyncConfig.java @Configuration @EnableAsync public class AsyncConfig { @Bean("asyncExecutor") public Executor asyncExecutor() { ThreadPoolTaskExecutor exec = new ThreadPoolTaskExecutor(); exec.setCorePoolSize(4); // 平时保持4个线程 exec.setMaxPoolSize(8); // 最多8个线程 exec.setQueueCapacity(100); // 排队最多100个任务 exec.setThreadNamePrefix("async-"); // 看日志好排查 exec.setRejectedExecutionHandler( new ThreadPoolExecutor.CallerRunsPolicy()); exec.initialize(); return exec; } } // 📁 service/EmailService.java（指定线程池） @Service public class EmailService { @Async("asyncExecutor") // ← 指定用上面定义的线程池 public void sendEmail(String email) { emailFeignClient.send(email, "WELCOME"); } }

// 🔗 调用链（集群部署 = 2个以上实例）： // OrderController.createOrder() // → InventoryService.deductStock(goodsId, quantity) // → [方案A] synchronized(this) ← 单JVM有效，集群下无效！ // → [方案B] Redis SET NX EX 分布式锁 ← 集群下有效 // 📁 service/InventoryService.java @Service public class InventoryService { @Autowired private InventoryMapper inventoryMapper; // ❌ synchronized 只锁当前 JVM！ // 部署2个实例后：实例A和实例B各有自己的锁，互不感知 // 同一商品的两个请求分别打到 A 和 B → 两个synchronized各自通过 → 超卖！ public synchronized boolean deductStock(Long goodsId, int quantity) { Inventory inv = inventoryMapper.selectByGoodsId(goodsId); if (inv.getStock() < quantity) { return false; // 库存不足 } // 💥 集群环境下：两个实例同时读到 stock=1，各自扣减，stock变-1 inv.setStock(inv.getStock() - quantity); inventoryMapper.update(inv); return true; } }

// 📁 service/DistributedLockService.java @Service public class DistributedLockService { @Autowired private StringRedisTemplate redisTemplate; // ❌ 问题1：没设过期时间 → 如果程序崩溃，锁永远不释放 → 死锁 // ❌ 问题2：没 try-finally → 如果业务异常，锁不释放 → 下一个请求永远等 public boolean tryLockBad(String key) { Boolean locked = redisTemplate.opsForValue() .setIfAbsent(key, "locked"); // ❌ 没设过期！ return locked != null && locked; } public void unlockBad(String key) { redisTemplate.delete(key); // ❌ 无论谁加的锁都能删 → 可能删别人的锁 } } // 📁 service/InventoryService.java — 用了上面的坏锁 public boolean deductStockBad(Long goodsId, int quantity) { String lockKey = "lock:inventory:" + goodsId; if (!lockService.tryLockBad(lockKey)) { throw new BizException("系统繁忙，请重试"); } // ❌ 如果这里抛异常，unlockBad 不会被调用 → 锁泄漏！ Inventory inv = inventoryMapper.selectByGoodsId(goodsId); if (inv.getStock() < quantity) { lockService.unlockBad(lockKey); // 每个return前都要手动解锁，容易漏 return false; } inv.setStock(inv.getStock() - quantity); inventoryMapper.update(inv); lockService.unlockBad(lockKey); // ❌ 删的可能是别人的锁（锁已过期被别人抢到） return true; }

// 📁 service/DistributedLockService.java — 生产级实现 @Service public class DistributedLockService { @Autowired private StringRedisTemplate redisTemplate; private static final String UNLOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then " + " return redis.call('del', KEYS[1]) " + "else return 0 end"; // ✅ SET key value NX EX seconds → 原子操作，不存在才设置+自动过期 public String tryLock(String key, long expireSeconds) { String lockValue = UUID.randomUUID().toString(); // 唯一标识，防止删别人的锁 Boolean locked = redisTemplate.opsForValue() .setIfAbsent(key, lockValue, expireSeconds, TimeUnit.SECONDS); return locked != null && locked ? lockValue : null; } // ✅ Lua脚本解锁：先验证值再删除，保证原子性 public boolean unlock(String key, String lockValue) { Long result = redisTemplate.execute( new DefaultRedisCallback<>(connection -> connection.eval(UNLOCK_SCRIPT.getBytes(), ReturnType.INTEGER, 1, key.getBytes(), lockValue.getBytes())), true); return result != null && result == 1; } } // 📁 service/InventoryService.java — 正确使用 @Service public class InventoryService { @Autowired private DistributedLockService lockService; @Autowired private InventoryMapper inventoryMapper; public boolean deductStock(Long goodsId, int quantity) { String lockKey = "lock:inventory:" + goodsId; String lockValue = lockService.tryLock(lockKey, 10); // 10秒自动过期 if (lockValue == null) { throw new BizException("系统繁忙，请重试"); } try { // ✅ 必须 try-finally Inventory inv = inventoryMapper.selectByGoodsId(goodsId); if (inv.getStock() < quantity) { return false; // 不需要在这里手动解锁 } inv.setStock(inv.getStock() - quantity); inventoryMapper.update(inv); return true; } finally { lockService.unlock(lockKey, lockValue); // ✅ 不管成功失败，都会解锁 } } } // 📁 controller/OrderController.java @RestController public class OrderController { @Autowired private InventoryService inventoryService; @PostMapping("/order") public Result<String> createOrder(Long goodsId, int quantity) { boolean ok = inventoryService.deductStock(goodsId, quantity); if (!ok) { return Result.fail("库存不足"); } // 创建订单... return Result.ok("下单成功"); } }

// 📁 config/RedissonConfig.java — Redisson 配置 @Configuration public class RedissonConfig { @Bean(destroyMethod = "shutdown") public RedissonClient redissonClient() { Config config = new Config(); config.useSingleServer() .setAddress("redis://127.0.0.1:6379") .setConnectionPoolSize(32); return Redisson.create(config); } } // 📁 service/RedissonLockService.java — Redisson 分布式锁 @Service public class RedissonLockService { @Autowired private RedissonClient redissonClient; // ✅ Redisson 方式：tryLock 不传 leaseTime → 启动看门狗(watchdog)！ // 看门狗默认 30 秒过期，每 10 秒自动续期一次（= 30s / 3） // 业务执行多久都不会提前过期，直到 unlock 后看门狗自动停止 public boolean deductStockWithRedisson(Long goodsId, int quantity) { RLock lock = redissonClient.getLock("lock:inventory:" + goodsId); try { // 参数1: waitTime=0（拿不到锁立刻返回，不等待） // 参数2: 不传 leaseTime → 启动看门狗自动续期！ if (!lock.tryLock(0, TimeUnit.SECONDS)) { throw new BizException("系统繁忙，请重试"); } // ===== 业务逻辑 ===== // 不管这里执行多久（GC停顿、网络超时）， // 看门狗都在后台自动续期，锁不会提前过期！ Inventory inv = inventoryMapper.selectByGoodsId(goodsId); if (inv.getStock() < quantity) return false; inv.setStock(inv.getStock() - quantity); inventoryMapper.update(inv); return true; } finally { // ✅ 先检查是否还持有锁，再 unlock // 防止业务超时后锁被 Redis 自动释放，此时 unlock 会报错 if (lock.isHeldByCurrentThread()) { lock.unlock(); // unlock 后看门狗自动停止 } } } } // ═══════════════════════════════════════════════════════ // 🔍 Redisson 看门狗内部原理（源码简化版，框架帮你做的） // ═══════════════════════════════════════════════════════ // // 1. tryLock() 成功后，Redisson 内部启动一个 Netty 定时任务 // 2. 每隔 10 秒（= 过期时间 30s / 3）执行续期逻辑： // IF Redis 中 key 还属于当前线程 THEN // EXPIRE key 30 ← 续期到 30 秒！ // ELSE // 停止看门狗 ← 锁已不属于我，停止续期 // END IF // 3. lock.unlock() → 看门狗任务自动取消 // // ⚠️ 坑1：tryLock(waitTime, leaseTime, unit) 指定了 leaseTime // → 看门狗不会启动！只有不传 leaseTime 才启动 // ⚠️ 坑2：unlock 前必须 isHeldByCurrentThread() 检查 // → 否则锁过期后被别人抢走，你 unlock 会报异常

// 📁 service/BoundedBuffer.java — 内部消息队列缓冲区 // 场景：订单服务往缓冲区放消息，物流服务从中取消息 public class BoundedBuffer<T> { private final ReentrantLock lock = new ReentrantLock(); private final Condition notFull = lock.newCondition(); // 生产者等 private final Condition notEmpty = lock.newCondition(); // 消费者等 private final Object[] items = new Object[100]; private int putIdx, takeIdx, count; // 生产者：放数据 public void put(T item) throws InterruptedException { lock.lock(); try { while (count == items.length) notFull.await(); // 满了：生产者等待 items[putIdx] = item; if (++putIdx == items.length) putIdx = 0; count++; notEmpty.signal(); // ✅ 精确唤醒消费者（不是所有线程） } finally { lock.unlock(); // ✅ try-finally 保证解锁 } } // 消费者：取数据 @SuppressWarnings("unchecked") public T take() throws InterruptedException { lock.lock(); try { while (count == 0) notEmpty.await(); // 空了：消费者等 T item = (T) items[takeIdx]; if (++takeIdx == items.length) takeIdx = 0; count--; notFull.signal(); // ✅ 精确唤醒生产者 return item; } finally { lock.unlock(); } } }

// 📁 service/PermissionService.java @Service public class PermissionService { @Autowired private RoleMapper roleMapper; // ❌ 每次请求都查DB + 用List判断 public boolean hasPermission(Long userId, String resource) { // 1. 每次请求都查DB（应该缓存） List<String> roles = roleMapper.findRolesByUserId(userId); // 2. ❌ List.contains() 是 O(n) 遍历！ // 如果用户有50个角色，最坏情况遍历50次 if (roles.contains("ADMIN")) { return true; } // 3. ❌ 再遍历一次检查权限资源 for (String role : roles) { List<String> perms = roleMapper.findPermsByRole(role); // 每个角色又查DB！ if (perms.contains(resource)) { return true; } } return false; // 💥 结果：一个请求 N 次DB查询 + N 次 O(n) 遍历 // 1000 QPS 下 = 1000 * 50 * DB查询 → 接口耗时 500ms+ } }

// 📁 service/PermissionService.java — 正确实现 @Service public class PermissionService { @Autowired private RoleMapper roleMapper; // ✅ 本地缓存：userId → 权限Set，5分钟过期 private final Cache<Long, Set<String>> permCache = Caffeine.newBuilder() .expireAfterWrite(5, TimeUnit.MINUTES) .maximumSize(10000) .build(); public boolean hasPermission(Long userId, String resource) { // 1. 从缓存获取权限集合（Hit率99%+ → 不查DB） Set<String> permissions = permCache.get(userId, this::loadPermissionsFromDB); // 2. ✅ HashSet.contains() 是 O(1)！ return permissions.contains(resource); } // 从DB加载，存入HashSet private Set<String> loadPermissionsFromDB(Long userId) { List<String> roles = roleMapper.findRolesByUserId(userId); if (roles.contains("ADMIN")) { return Set.of("*"); // ADMIN 拥有所有权限 } List<String> perms = roleMapper.findPermsByRoleIds(roles); // ✅ 批量查，一次DB return new HashSet<>(perms); // ✅ 转成HashSet } } // 效果：缓存命中时 → 1次HashSet.contains() → O(1) → 耗时 <1ms

// 📁 service/UserRoleCache.java — 多线程并发读写角色缓存 // ❌ 用 HashMap：多线程put可能导致数据丢失（HashMap扩容时链表成环 → 死循环） @Service public class UserRoleCacheBad { private final Map<Long, String> cache = new HashMap<>(); // ❌ 非线程安全！ // 定时刷新线程 → 写；请求线程 → 读 → 并发修改 → JDK7 死循环 / JDK8 数据丢失 @Scheduled(fixedRate = 60000) public void refresh() { cache.clear(); cache.putAll(loadFromDB()); // ❌ 多线程同时put → 可能丢数据 } public String getRole(Long userId) { return cache.get(userId); // ❌ 可能读到不一致状态 } } // ❌ 用 synchronized 包装：虽然线程安全，但锁粒度太粗，读写互斥 private final Map<Long, String> cache = Collections.synchronizedMap(new HashMap<>()); // ❌ 读也要锁 → 并发吞吐量低 // ✅ 用 ConcurrentHashMap：分段锁/CAS，读写不互斥 @Service public class UserRoleCache { private final ConcurrentHashMap<Long, String> cache = new ConcurrentHashMap<>(); @Scheduled(fixedRate = 60000) public void refresh() { cache.clear(); // ✅ 线程安全 loadFromDB().forEach(cache::put); // ✅ 多线程put不丢数据 } public String getRole(Long userId) { return cache.get(userId); // ✅ 无锁读，不影响写入 } }

// 📁 service/DataCleanService.java — 定时清理无效数据 // ❌ 遍历时删除 → ConcurrentModificationException public void cleanBad(List<User> users) { for (User u : users) { // 增强 for 循环底层用 Iterator if (u.getStatus() == 0) { users.remove(u); // ❌ Iterator检测到modCount变化 → 抛异常！ } } } // ✅ 写法1：Iterator.remove() public void cleanGood1(List<User> users) { Iterator<User> it = users.iterator(); while (it.hasNext()) { if (it.next().getStatus() == 0) { it.remove(); // ✅ Iterator自己的remove，同步更新modCount } } } // ✅ 写法2：Java 8 removeIf（最简洁） public void cleanGood2(List<User> users) { users.removeIf(u -> u.getStatus() == 0); // ✅ 一行搞定 }

// ❌ subList 返回的是视图（view），不是副本！ List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C", "D")); List<String> sub = list.subList(0, 2); // 返回的是原List的视图 sub.clear(); // 清除子列表 System.out.println(list); // ["C", "D"] ← 原列表也被改了！ // ✅ 需要独立副本时：new ArrayList(list.subList(0, 2)) // 📁 config/CacheConfig.java — LinkedHashMap 实现 LRU 缓存 public class LRUCache<K, V> extends LinkedHashMap<K, V> { private final int maxSize; public LRUCache(int maxSize) { super(maxSize, 0.75f, true); // accessOrder=true → 访问后移到末尾 this.maxSize = maxSize; } @Override protected boolean removeEldestEntry(Map.Entry<K, V> eldest) { return size() > maxSize; // 超过容量自动删除头部（最老的） } } // 使用示例 LRUCache<String, String> cache = new LRUCache<>(3); cache.put("a", "1"); cache.put("b", "2"); cache.put("c", "3"); cache.get("a"); // 访问"a"，"a"移到最新 cache.put("d", "4"); // 超过容量3，删除最老的"b" System.out.println(cache); // {c=3, a=1, d=4}

// 📁 service/OrderService.java @Service public class OrderService { @Autowired private OrderMapper orderMapper; @Autowired private OrderService self; // 注入自己，解决同类调用 // ❌ 失效1：同类内部调用 public void createOrderBad(Order order) { orderMapper.insert(order); // 无事务 this.deductStock(order); // ❌ this调用不走代理！ } @Transactional public void deductStock(Order order) { ... } // ✅ 修复1：通过注入的代理对象调用 public void createOrderGood(Order order) { orderMapper.insert(order); self.deductStock(order); // ✅ 走代理！ } // ❌ 失效2：catch 吞异常 @Transactional public void transferBad() { try { accountMapper.deduct(fromId, amount); accountMapper.add(toId, amount); } catch (Exception e) { log.error("转账失败", e); // ❌ 异常被吞了，代理不知道！不会回滚！ } } // ✅ 修复2：catch 后再 throw @Transactional public void transferGood() { try { accountMapper.deduct(fromId, amount); accountMapper.add(toId, amount); } catch (Exception e) { log.error("转账失败", e); throw new RuntimeException(e); // ✅ 重新抛出 } } // ❌ 失效3：checked 异常默认不回滚 @Transactional // 默认只回滚 RuntimeException public void importBad() throws IOException { fileService.process(); // 抛 IOException → 不回滚！ } // ✅ 修复3：rollbackFor = Exception.class @Transactional(rollbackFor = Exception.class) public void importGood() throws IOException { fileService.process(); // ✅ 任何异常都回滚 } }

// 1. 📁 enums/ErrorCode.java — 错误码枚举 public enum ErrorCode { USER_NOT_FOUND(40001, "用户不存在"), INSUFFICIENT_BALANCE(40002, "余额不足"), ORDER_EXPIRED(40003, "订单已过期"), PARAM_INVALID(40004, "参数校验失败"), SYSTEM_ERROR(50000, "系统繁忙"); private final int code; private final String message; // getter, constructor 省略 } // 2. 📁 exception/BizException.java — 自定义业务异常 public class BizException extends RuntimeException { private final ErrorCode errorCode; public BizException(ErrorCode errorCode) { super(errorCode.getMessage()); this.errorCode = errorCode; } } // 3. 📁 handler/GlobalExceptionHandler.java — 全局异常处理器 @RestControllerAdvice public class GlobalExceptionHandler { // 业务异常：返回具体错误码 @ExceptionHandler(BizException.class) public Result<?> handleBiz(BizException e) { log.warn("业务异常: code={}, msg={}", e.getErrorCode().getCode(), e.getMessage()); return Result.fail(e.getErrorCode().getCode(), e.getMessage()); } // 参数校验异常 @ExceptionHandler(MethodArgumentNotValidException.class) public Result<?> handleValidation(MethodArgumentNotValidException e) { String msg = e.getBindingResult().getFieldErrors().stream() .map(f -> f.getField() + ": " + f.getDefaultMessage()) .collect(Collectors.joining("; ")); return Result.fail(ErrorCode.PARAM_INVALID.getCode(), msg); } // 未知异常：返回通用错误（不暴露内部细节） @ExceptionHandler(Exception.class) public Result<?> handleUnknown(Exception e) { log.error("未知异常", e); // 带完整堆栈 return Result.fail(ErrorCode.SYSTEM_ERROR.getCode(), "系统繁忙"); } } // 4. 📁 service/UserService.java — 使用示例 @Service public class UserService { public User getUser(Long id) { User user = userMapper.selectById(id); if (user == null) { throw new BizException(ErrorCode.USER_NOT_FOUND); // ✅ } return user; } }

// 📁 service/PaymentService.java — 每加一种支付就要改这里 @Service public class PaymentService { @Autowired private WechatPayClient wechatClient; @Autowired private AlipayClient alipayClient; @Autowired private AccountMapper accountMapper; public PayResult processPayment(Order order, String payType) { // ❌ 第1种：微信支付 if ("WECHAT".equals(payType)) { WxPayRequest req = new WxPayRequest(); req.setAppId("wx123"); req.setOutTradeNo(order.getOrderNo()); req.setAmount(order.getAmount().multiply(new BigDecimal("100")).intValue()); WxPayResponse resp = wechatClient.unifiedOrder(req); return new PayResult(resp.getCodeUrl()); } // ❌ 第2种：支付宝 else if ("ALIPAY".equals(payType)) { AlipayTradeRequest req = new AlipayTradeRequest(); req.setSubject(order.getProductName()); req.setOutTradeNo(order.getOrderNo()); req.setTotalAmount(order.getAmount().toString()); AlipayTradeResponse resp = alipayClient.tradePay(req); return new PayResult(resp.getPayUrl()); } // ❌ 第3种：余额支付 else if ("BALANCE".equals(payType)) { Account acc = accountMapper.selectByUserId(order.getUserId()); if (acc.getBalance().compareTo(order.getAmount()) < 0) { throw new BizException("余额不足"); } acc.setBalance(acc.getBalance().subtract(order.getAmount())); accountMapper.update(acc); return new PayResult("SUCCESS"); } // ❌ 新增"银行卡支付" → 又要加一个 else if → 方法越来越长 // ❌ 修改微信支付参数 → 要在这个几百行方法里找 → 容易改错其他分支 throw new BizException("不支持的支付方式"); } } // 📁 controller/PaymentController.java @RestController public class PaymentController { @Autowired private PaymentService paymentService; @PostMapping("/pay") public Result<PayResult> pay(Long orderId, String payType) { return Result.ok(paymentService.processPayment(orderId, payType)); } }

// 📁 strategy/PaymentStrategy.java — 策略接口 public interface PaymentStrategy { String getPayType(); // 支持的支付类型 PayResult pay(Order order); // 执行支付 } // 📁 strategy/WechatPayStrategy.java — 微信支付策略 @Service public class WechatPayStrategy implements PaymentStrategy { @Autowired private WechatPayClient wechatClient; @Override public String getPayType() { return "WECHAT"; } @Override public PayResult pay(Order order) { WxPayRequest req = new WxPayRequest(); req.setAppId("wx123"); req.setOutTradeNo(order.getOrderNo()); req.setAmount(order.getAmount().multiply(new BigDecimal("100")).intValue()); WxPayResponse resp = wechatClient.unifiedOrder(req); return new PayResult(resp.getCodeUrl()); } } // 📁 strategy/AlipayStrategy.java — 支付宝策略 @Service public class AlipayStrategy implements PaymentStrategy { @Autowired private AlipayClient alipayClient; @Override public String getPayType() { return "ALIPAY"; } @Override public PayResult pay(Order order) { AlipayTradeRequest req = new AlipayTradeRequest(); req.setSubject(order.getProductName()); req.setOutTradeNo(order.getOrderNo()); req.setTotalAmount(order.getAmount().toString()); AlipayTradeResponse resp = alipayClient.tradePay(req); return new PayResult(resp.getPayUrl()); } } // 📁 strategy/BalancePayStrategy.java — 余额支付策略 @Service public class BalancePayStrategy implements PaymentStrategy { @Autowired private AccountMapper accountMapper; @Override public String getPayType() { return "BALANCE"; } @Override @Transactional(rollbackFor = Exception.class) // ✅ 每个策略可以有自己的事务需求 public PayResult pay(Order order) { Account acc = accountMapper.selectByUserId(order.getUserId()); if (acc.getBalance().compareTo(order.getAmount()) < 0) { throw new BizException("余额不足"); } acc.setBalance(acc.getBalance().subtract(order.getAmount())); accountMapper.update(acc); return new PayResult("SUCCESS"); } } // 📁 factory/PaymentStrategyFactory.java — 策略工厂 @Service public class PaymentStrategyFactory { private final Map<String, PaymentStrategy> strategyMap; // ✅ Spring启动时自动把所有PaymentStrategy实现注入List @Autowired public PaymentStrategyFactory(List<PaymentStrategy> strategies) { // 转 Map：getPayType() → 策略实例 this.strategyMap = strategies.stream() .collect(Collectors.toMap(PaymentStrategy::getPayType, s -> s)); // 新增支付方式时：只需新建一个 @Service 类，这里自动收录！ } public PaymentStrategy getStrategy(String payType) { PaymentStrategy strategy = strategyMap.get(payType); if (strategy == null) { throw new BizException("不支持的支付方式: " + payType); } return strategy; } } // 📁 service/PaymentService.java — 核心逻辑只此一行 @Service public class PaymentService { @Autowired private PaymentStrategyFactory strategyFactory; public PayResult processPayment(Order order, String payType) { PaymentStrategy strategy = strategyFactory.getStrategy(payType); // ✅ 一行搞定 return strategy.pay(order); } } // ✅ 新增"银行卡支付" = 新建 UnionPayStrategy.java，加@Service → 完事！ // 不需要改 PaymentService、PaymentController、Factory 中任何一行代码

// 📁 service/DataImporter.java — 抽象模板 // 场景：系统支持Excel/CSV/JSON三种导入，流程一样：校验→解析→处理→保存→通知 public abstract class DataImporter { // 模板方法：固定流程（final 防止子类覆盖流程顺序） public final ImportResult importData(MultipartFile file) { validate(file); // 1. 校验（公共逻辑） List<Map<String, Object>> rows = parse(file); // 2. 解析（可变：Excel/CSV/JSON） List<Map<String, Object>> filtered = process(rows); // 3. 处理（可变：去重/转换） save(filtered); // 4. 保存（可变：不同表） notifyComplete(); // 5. 通知（公共逻辑） return new ImportResult(filtered.size()); } // 公共逻辑（子类不能改） private void validate(MultipartFile file) { if (file.isEmpty()) throw new BizException("文件为空"); if (file.getSize() > 10 * 1024 * 1024) throw new BizException("文件超过10MB"); } private void notifyComplete() { log.info("导入完成，发送通知..."); messageService.send("数据导入完成"); } // 可变步骤：由子类实现 protected abstract List<Map<String, Object>> parse(MultipartFile file); protected abstract List<Map<String, Object>> process(List<Map<String, Object>> rows); protected abstract void save(List<Map<String, Object>> rows); } // 📁 service/ExcelImporter.java — Excel导入 @Service public class ExcelImporter extends DataImporter { @Override protected List<Map<String, Object>> parse(MultipartFile file) { return EasyExcel.read(file.getInputStream()).sheet().doReadSync(); } @Override protected List<Map<String, Object>> process(List<Map<String, Object>> rows) { return rows.stream().filter(r -> r.get("name") != null).collect(Collectors.toList()); } @Override protected void save(List<Map<String, Object>> rows) { userMapper.batchInsert(rows); } }

// 📁 config/BadConfig.java // ❌ 用 @Component：每次调用 myBean() 都会 new 一个新对象！ @Component public class BadConfig { @Bean public DataSource dataSource() { return new HikariDataSource(...); } @Bean public JdbcTemplate jdbcTemplate() { return new JdbcTemplate(dataSource()); // ❌ 又调了一次 dataSource()！ // @Component 下会创建第二个 DataSource 实例！ } } // 📁 config/GoodConfig.java // ✅ 用 @Configuration：CGLIB代理保证单例 @Configuration public class GoodConfig { @Bean public DataSource dataSource() { return new HikariDataSource(...); } @Bean public JdbcTemplate jdbcTemplate() { return new JdbcTemplate(dataSource()); // ✅ 返回同一个实例 } }

// 📁 config/OssConfigBad.java — 对象存储配置 // ❌ @Value：多个配置项很痛苦 @Component public class OssConfigBad { @Value("${oss.endpoint}") private String endpoint; @Value("${oss.accessKey}") private String accessKey; @Value("${oss.secretKey}") private String secretKey; @Value("${oss.bucketName}") private String bucketName; // 每加一个配置就要加一行 @Value } // 📁 config/OssProperties.java // ✅ @ConfigurationProperties：批量绑定+校验 @ConfigurationProperties(prefix = "oss") @Validated public class OssProperties { @NotBlank private String endpoint; @NotBlank private String accessKey; @NotBlank private String secretKey; private String bucketName = "default"; // 默认值 // getter/setter }