如何学编程之02.理论篇.如何写出具有良好健壮性的代码？

这是一套通用且可落地的代码健壮性规范，编写高可用、低故障代码的核心指导准则，能帮助在 Java 开发中从编码层面规避绝大多数常见 bug，结合 Java 语言特性和行业最佳实践，分为核心原则、通用编码规范、各场景专项规范、验证与保障四个部分，可直接作为团队编码规范参考。

---

（一）代码健壮性规范概述

一、核心原则（所有场景通用）

这是健壮性的底层逻辑，贯穿编码全流程：

1. 防御式编程：假设所有外部输入 / 依赖都是不可信的，先校验合法性，再执行业务逻辑；
2. 输入校验优先：所有外部输入（方法参数、接口传参、文件读取等）必须先校验合法性，再执行业务逻辑。
3. 最小意外原则：代码行为符合直觉，异常场景有明确提示，避免 "静默失败"；
4. 异常合理处理：捕获异常后要么修复问题、要么优雅降级，而非直接崩溃；避免空 catch 块，区分运行时异常（RuntimeException）和受检异常（Checked Exception），针对性捕获并处理。
5. 资源自动释放：占用的资源（连接、流、锁）必须有明确的释放逻辑；使用 try-with-resources 处理 IO 流、数据库连接等资源，避免内存泄漏。
6. 边界条件全覆盖：识别并处理所有数据 / 操作的临界点（如 null、空、越界、极值）明确识别并处理数据范围、集合操作、循环执行等场景的边界。
7. 避免空指针：对可能为 null 的对象做非空判断，或使用 Optional 类优雅处理。

---

二、通用编码规范

1. 输入校验规范

• 校验范围：所有外部输入（方法参数、接口传参、文件 / 数据库读取数据、用户输入）必须校验；
• 校验顺序：先判 null → 再判空（空字符串 / 空集合） → 最后判业务规则（长度、格式、范围）；
• 校验工具 ：优先复用成熟工具类，避免重复造轮子：
  • Java 原生：Objects.requireNonNull()、String.isBlank()；
  • 第三方：Apache Commons Lang3（StringUtils）、Guava（Preconditions）；
• 错误反馈 ：校验失败时抛出具体的异常类型 （如IllegalArgumentException），并携带清晰的错误信息（如 "用户名不能为空，当前值：null"）。

Java 示例：参数校验

import org.apache.commons.lang3.StringUtils;
import java.util.Objects;

public class InputCheckDemo {
    public void createUser(String username, Integer age) {
        // 1. 校验null
        Objects.requireNonNull(username, "用户名不能为null");
        Objects.requireNonNull(age, "年龄不能为null");
        
        // 2. 校验空/格式
        if (StringUtils.isBlank(username)) {
            throw new IllegalArgumentException("用户名不能为空白字符串");
        }
        
        // 3. 校验业务范围
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄必须在0-150之间，当前值：" + age);
        }
        
        // 执行业务逻辑...
    }
}

2. 异常处理规范

• 禁止空 catch 块 ：空 catch 会隐藏问题，至少记录日志（如log.error("读取文件失败", e)）；
• 区分异常类型 ：
  • 受检异常（Checked Exception）：如IOException，需显式处理（catch/throws）；
  • 运行时异常（RuntimeException）：如NullPointerException，优先通过编码规避（而非捕获）；
• 异常封装 ：底层异常（如 SQL 异常）需封装为业务异常（如UserNotFoundException），避免暴露底层实现；
• 避免过度捕获 ：不要捕获Exception/Throwable这类大范围异常，仅捕获明确可处理的异常；
• finally 慎用：finally 块仅用于释放资源，避免在 finally 中修改返回值 / 抛出新异常；
• try-with-resources ：处理 IO 流、数据库连接等资源时，必须使用try-with-resources自动释放（替代手动 close）。

Java 示例：异常处理

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.FileInputStream;
import java.io.IOException;

public class ExceptionHandleDemo {
    private static final Logger log = LoggerFactory.getLogger(ExceptionHandleDemo.class);

    public byte[] readFile(String filePath) {
        // try-with-resources自动释放流
        try (FileInputStream fis = new FileInputStream(filePath)) {
            byte[] buffer = new byte[fis.available()];
            fis.read(buffer);
            return buffer;
        } catch (FileNotFoundException e) {
            // 具体异常捕获 + 日志记录 + 封装业务异常
            log.error("文件不存在，路径：{}", filePath, e);
            throw new BusinessException("读取文件失败：文件不存在", e);
        } catch (IOException e) {
            log.error("读取文件IO异常，路径：{}", filePath, e);
            throw new BusinessException("读取文件失败：IO异常", e);
        }
        // 禁止捕获Exception后无处理：
        // catch (Exception e) { return null; } → 错误示例
    }

    // 自定义业务异常
    static class BusinessException extends RuntimeException {
        public BusinessException(String message, Throwable cause) {
            super(message, cause);
        }
    }
}

3. 空值处理规范

• 主动判空 ：对可能为 null 的对象，先判空再调用方法，避免NullPointerException；
• 优雅处理 ：Java 8 + 推荐使用Optional封装可能为 null 的返回值，替代直接返回 null；
• 禁止返回 null 集合 / 数组 ：方法返回集合 / 数组时，返回空集合（Collections.emptyList()）而非 null；
• 默认值兜底 ：对 null 值提供合理的默认值（如String name = Objects.requireNonNullElse(username, "未知用户")）。

Java 示例：空值处理

import java.util.Collections;
import java.util.List;
import java.util.Optional;

public class NullHandleDemo {
    // 返回空集合而非null
    public List<String> getUserList() {
        // 模拟查询无结果
        boolean hasData = false;
        if (!hasData) {
            return Collections.emptyList(); // 推荐
            // return null; // 禁止
        }
        return List.of("张三", "李四");
    }

    // 使用Optional封装可能为null的返回值
    public Optional<String> getUserName(Long userId) {
        // 模拟查询：userId=1返回"张三"，其他返回null
        if (userId == 1) {
            return Optional.of("张三");
        }
        return Optional.empty();
    }
}

4. 数据类型与运算规范

• 避免类型溢出 ：数值运算前校验范围（如Integer.MAX_VALUE），大数运算使用BigDecimal；
• 浮点数精度 ：金额 / 精度敏感场景使用BigDecimal（指定精度和舍入模式），避免float/double；
• 字符串拼接 ：大量字符串拼接使用StringBuilder/StringBuffer，避免+号拼接；
• 数组 / 集合操作 ：索引操作前校验范围（index >= 0 && index < size），遍历优先使用增强 for/stream。

Java 示例：数值运算安全

import java.math.BigDecimal;
import java.math.RoundingMode;

public class NumberSafeDemo {
    // 安全加法（避免Integer溢出）
    public static int safeAdd(int a, int b) {
        if (b > 0 && a > Integer.MAX_VALUE - b) {
            throw new ArithmeticException("加法溢出：a=" + a + ", b=" + b);
        }
        if (b < 0 && a < Integer.MIN_VALUE - b) {
            throw new ArithmeticException("加法溢出：a=" + a + ", b=" + b);
        }
        return a + b;
    }

    // 金额计算（使用BigDecimal）
    public static BigDecimal calculateAmount(BigDecimal price, int count) {
        // 非空校验
        Objects.requireNonNull(price, "价格不能为null");
        if (count < 0) {
            throw new IllegalArgumentException("数量不能为负数：" + count);
        }
        // 乘法：指定精度和舍入模式
        return price.multiply(BigDecimal.valueOf(count))
                    .setScale(2, RoundingMode.HALF_UP);
    }
}

---

三、各场景专项规范

1. 集合 / 容器规范

• 初始化指定容量：创建 HashMap/ArrayList 时，根据预估大小指定初始容量（减少扩容开销）；
• 并发容器使用 ：多线程场景使用ConcurrentHashMap/CopyOnWriteArrayList，避免非线程安全容器；
• 遍历修改 ：遍历集合时禁止直接修改（如list.remove()），使用迭代器remove()或stream.filter()；
• Map 取值 ：Map.get(key)后判空，或使用Map.getOrDefault(key, defaultValue)。

2. IO / 资源规范

• 路径校验 ：文件操作前校验路径合法性，避免路径遍历漏洞（如../）；
• 分批读写：大文件读写采用分批处理（如每次读取 1024 字节），避免内存溢出；
• 超时控制：网络 IO / 数据库操作必须设置超时时间（如 JDBC 连接超时、HTTP 请求超时）；
• 权限校验 ：文件操作前检查读写权限，避免AccessDeniedException。

3. 并发 / 线程规范

• 线程池使用 ：自定义线程池（避免Executors默认实现），指定核心参数 + 拒绝策略；
• 锁的使用 ：锁粒度最小化，避免死锁（按固定顺序加锁），使用tryLock()设置超时；
• 原子操作 ：多线程修改共享变量使用AtomicInteger/LongAdder，避免手动同步；
• 线程关闭 ：线程池使用shutdown()/awaitTermination()优雅关闭，避免强制中断。

4. 接口 / API 规范

• 幂等性设计：对外接口必须保证幂等（如订单创建接口使用唯一订单号）；
• 超时重试 ：远程调用接口添加超时重试（使用RetryTemplate），重试次数 / 间隔合理；
• 限流降级：高并发接口添加限流（如令牌桶），降级策略明确（返回默认值 / 提示语）；
• 参数脱敏：接口入参 / 返回值脱敏（如手机号显示为 138****8000），避免敏感信息泄露。

---

四、验证与保障（规范落地）

1. 单元测试覆盖：针对所有边界条件编写单元测试（如 null、空、越界、极值）；
2. 静态代码检查：引入 SonarQube/Alibaba Java Coding Guidelines 插件，自动检测违规代码；
3. 代码评审：重点检查输入校验、异常处理、资源释放等关键环节；
4. 日志规范：关键操作记录日志（入参、出参、异常），日志级别合理（ERROR/WARN/INFO）；
5. 监控告警：对异常场景（如接口超时、数据校验失败）添加监控，及时告警。

---

总结

1. 核心核心 ：代码健壮性的核心是 "先校验，后执行"，所有外部输入和临界操作必须做合法性判断，异常场景显式处理；
2. 关键手段：通过输入校验、异常封装、空值优雅处理、资源闭环管理四大手段，覆盖绝大多数健壮性问题；
3. 落地保障：规范不仅要 "写出来"，更要通过单元测试、静态检查、代码评审等手段确保 "落地执行"。

这套规范可根据团队业务场景（如分布式、高并发）补充专项规则，核心思路保持一致即可。

（二）怎样判断边界条件？

边界条件是指 "正常逻辑的临界点"，通常分为以下几类，结合示例说明如何识别和处理：

1. 数值类型边界

常见边界：最大值 / 最小值（如 Integer.MAX_VALUE）、0、负数、空值（null）、超出业务范围的值。

判断逻辑：先校验数值是否在合法区间，再执行计算 / 赋值。

/**
 * 计算两数之和（示例：数值边界处理）
 * @param a 整数1
 * @param b 整数2
 * @return 两数之和
 */
public static int safeAdd(Integer a, Integer b) {
    // 边界1：参数为null
    if (a == null || b == null) {
        throw new IllegalArgumentException("参数不能为null");
    }
    // 边界2：防止整数溢出（Integer最大值边界）
    if (b > 0 && a > Integer.MAX_VALUE - b) {
        throw new ArithmeticException("两数之和超出Integer最大值");
    }
    if (b < 0 && a < Integer.MIN_VALUE - b) {
        throw new ArithmeticException("两数之和超出Integer最小值");
    }
    // 边界3：业务范围限制（示例：只允许非负数相加）
    if (a < 0 || b < 0) {
        throw new IllegalArgumentException("参数必须为非负数");
    }
    return a + b;
}

2. 集合 / 数组边界

集合 / 数组是日常开发中边界问题的重灾区，核心是 "索引" 和 "空 / 长度" 相关的临界点：

常见边界：

1. 集合 / 数组为 null（未初始化）；
2. 集合 / 数组长度为 0（空集合 / 空数组）；
3. 索引越界（索引 < 0、索引 ≥ 长度、索引等于长度 - 1（最后一个元素））；
4. 集合操作的边界，遍历到最后一个元素（如 List 的subList(from, to)中from=to、from>to，Map 的get(key)返回 null）；

并发修改（遍历集合时添加 / 删除元素）。

判断逻辑 ：操作集合前先校验非空、非空集合，索引范围需在[0, size-1]内。

Java 示例2（处理 List 边界）

import java.util.List;
import java.util.Optional;

/**
 * 获取集合指定索引的元素（示例：集合边界处理）
 * @param list 目标集合
 * @param index 索引
 * @return 索引对应元素（Optional包装，避免空指针）
 */
public static <T> Optional<T> getListElement(List<T> list, int index) {
    // 边界1：集合为null
    if (list == null) {
        return Optional.empty();
    }
    // 边界2：索引越界（小于0 或 大于等于集合长度）
    if (index < 0 || index >= list.size()) {
        return Optional.empty();
    }
    // 边界3：集合为空（size=0），已被index >= list.size()覆盖
    return Optional.ofNullable(list.get(index));
}

Java 示例2（处理 List 边界）

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

public class CollectionBoundaryDemo {
    // 安全获取子列表（处理subList边界）
    public static List<String> safeSubList(List<String> list, int fromIndex, int toIndex) {
        // 边界1：集合为null → 返回空集合
        if (list == null) {
            return Collections.emptyList();
        }
        int size = list.size();
        // 边界2：fromIndex/toIndex越界 → 修正为合法范围
        fromIndex = Math.max(0, Math.min(fromIndex, size));
        toIndex = Math.max(fromIndex, Math.min(toIndex, size));
        // 边界3：fromIndex >= toIndex → 返回空集合
        if (fromIndex >= toIndex) {
            return Collections.emptyList();
        }
        // 避免subList的原始集合修改导致的异常 → 新建List
        return new ArrayList<>(list.subList(fromIndex, toIndex));
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("A");
        list.add("B");
        // 测试边界：toIndex超出长度
        System.out.println(safeSubList(list, 0, 5)); // 输出 [A, B]
        // 测试边界：fromIndex > toIndex
        System.out.println(safeSubList(list, 2, 1)); // 输出 []
        // 测试边界：集合为null
        System.out.println(safeSubList(null, 0, 2)); // 输出 []
    }
}

3. 字符串边界

字符串的边界问题常和 "空 / 空白 / 长度 / 格式" 相关，是接口参数、用户输入校验的重点：

常见边界

1. 字符串为 null；
2. 空字符串（""）；
3. 全空白字符串（" "、"\t\n"等空白字符）；
4. 字符串长度超出业务限制（如用户名最长 20 位、手机号必须 11 位）；
5. 字符串格式边界（如日期字符串"2026-02-30"（非法日期）、手机号"1380013800"（10 位））；
6. 字符串编码边界（如包含特殊字符、乱码、非 UTF-8 编码）。

/**
 * 校验用户名合法性（示例：字符串边界处理）
 * @param username 用户名
 * @return 合法返回true，否则false
 */
public static boolean isValidUsername(String username) {
    // 边界1：字符串为null
    if (username == null) {
        return false;
    }
    // 边界2：空字符串或全空格
    String trimedName = username.trim();
    if (trimedName.isEmpty()) {
        return false;
    }
    // 边界3：长度超出业务范围（示例：3-20位）
    if (trimedName.length() < 3 || trimedName.length() > 20) {
        return false;
    }
    return true;
}

import org.apache.commons.lang3.StringUtils;
import java.util.regex.Pattern;

public class StringBoundaryDemo {
    // 校验手机号合法性（处理格式/长度边界）
    private static final Pattern PHONE_PATTERN = Pattern.compile("^1[3-9]\\d{9}$");

    public static boolean isValidPhone(String phone) {
        // 边界1：null/空/全空白
        if (StringUtils.isBlank(phone)) {
            return false;
        }
        // 边界2：长度不是11位（先快速校验，减少正则匹配开销）
        if (phone.length() != 11) {
            return false;
        }
        // 边界3：格式不符合手机号规则
        return PHONE_PATTERN.matcher(phone).matches();
    }

    public static void main(String[] args) {
        System.out.println(isValidPhone(null)); // false（null边界）
        System.out.println(isValidPhone("")); // false（空字符串）
        System.out.println(isValidPhone("1380013800")); // false（长度10位）
        System.out.println(isValidPhone("13800138000")); // true（合法）
    }
}

注：示例中使用了 Apache Commons Lang3 的StringUtils，可简化空白字符串判断，Maven 依赖：

xml

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.14.0</version>
</dependency>

4. 循环边界

常见边界：循环次数为 0、循环次数为 1、循环次数超出预期（如死循环）。

判断逻辑：明确循环终止条件，避免无限循环，处理循环次数为 0 的场景。

/**
 * 累加数组元素（示例：循环边界处理）
 * @param arr 目标数组
 * @return 累加和
 */
public static int sumArray(int[] arr) {
    int sum = 0;
    // 边界1：数组为null 或 长度为0（循环次数为0）
    if (arr == null || arr.length == 0) {
        return sum;
    }
    // 循环边界：i从0到arr.length-1，避免i >= arr.length导致索引越界
    for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
    return sum;
}

5. IO / 资源边界

IO 操作涉及外部资源，边界问题多和 "资源状态" 相关，处理不当易导致内存泄漏或程序崩溃：

常见边界

1. 资源不存在（文件路径错误、数据库连接失败、网络端口未开放）；
2. 资源为空（空文件、空流、查询结果为空）；
3. 资源权限不足（文件只读、数据库无操作权限）；
4. 资源读取 / 写入边界（流读取到末尾（返回 - 1）、写入超出磁盘空间、大文件读写内存溢出）；
5. 资源释放边界（流未关闭、连接未释放、并发关闭资源）。

判断逻辑：使用 try-with-resources 自动释放资源，校验文件 / 流的合法性，处理读取末尾的场景。

Java 示例（处理文件读取边界）

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class IOBoundaryDemo {
    // 安全读取文件内容（处理IO边界）
    public static String safeReadFile(String filePath) {
        // 边界1：文件路径为null/空
        if (filePath == null || filePath.isBlank()) {
            return "";
        }
        // 使用try-with-resources自动释放流（边界5：资源释放）
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            StringBuilder sb = new StringBuilder();
            String line;
            // 边界4：流读取到末尾（line == null）
            while ((line = br.readLine()) != null) {
                sb.append(line).append(System.lineSeparator());
            }
            return sb.toString().trim();
        } catch (IOException e) {
            // 边界2/3：文件不存在、权限不足等 → 捕获异常并返回空字符串
            System.err.println("读取文件失败：" + e.getMessage());
            return "";
        }
    }

    public static void main(String[] args) {
        // 测试边界：文件不存在
        System.out.println(safeReadFile("nonexistent.txt")); // 输出空字符串，控制台打印异常
        // 测试边界：空文件
        System.out.println(safeReadFile("empty.txt")); // 输出空字符串
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * 读取文件前N个字节（示例：IO边界处理）
 * @param filePath 文件路径
 * @param n 读取字节数
 * @return 读取的字节数组
 */
public static byte[] readFileBytes(String filePath, int n) {
    // 边界1：参数合法性校验
    if (filePath == null || filePath.trim().isEmpty() || n <= 0) {
        return new byte[0];
    }
    // 边界2：文件不存在/读取失败，通过try-catch处理
    try (InputStream is = new FileInputStream(filePath)) { // try-with-resources自动关闭流
        byte[] buffer = new byte[n];
        int readLen = is.read(buffer);
        // 边界3：读取到文件末尾（readLen=-1）或读取字节数不足n
        if (readLen == -1) {
            return new byte[0];
        }
        if (readLen < n) {
            byte[] result = new byte[readLen];
            System.arraycopy(buffer, 0, result, 0, readLen);
            return result;
        }
        return buffer;
    } catch (IOException e) {
        // 异常处理：记录日志（示例仅打印），返回空数组
        System.err.println("读取文件失败：" + e.getMessage());
        return new byte[0];
    }
}

6、时间 / 日期类边界

时间日期的边界隐蔽性强，容易因 "特殊时间点" 导致逻辑错误：

常见边界

1. 日期为 null 或非法格式（如"2026-13-01"、"2026-02-30"）；
2. 时间临界点（如 23:59:59、00:00:00、月末 / 年末、闰年 2 月 29 日）；
3. 时间范围边界（如开始时间 ≥ 结束时间、时间超出业务有效期）；
4. 时区 / 夏令时边界（如跨时区时间转换、夏令时切换导致的时间跳变）；
5. 时间单位边界（如毫秒转秒时溢出、计算年龄时 "未过生日" 的边界）。

Java 示例（处理日期边界）

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;

public class DateBoundaryDemo {
    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    // 校验日期是否在有效范围内（处理日期边界）
    public static boolean isDateInRange(String dateStr, String startStr, String endStr) {
        // 边界1：任意日期字符串为null/空
        if (dateStr == null || startStr == null || endStr == null || dateStr.isBlank() || startStr.isBlank() || endStr.isBlank()) {
            return false;
        }
        LocalDate date, start, end;
        try {
            // 边界2：日期格式非法（如2026-02-30）
            date = LocalDate.parse(dateStr, DATE_FORMATTER);
            start = LocalDate.parse(startStr, DATE_FORMATTER);
            end = LocalDate.parse(endStr, DATE_FORMATTER);
        } catch (DateTimeParseException e) {
            return false;
        }
        // 边界3：开始时间 > 结束时间（范围非法）
        if (start.isAfter(end)) {
            return false;
        }
        // 边界4：日期等于开始/结束时间（包含边界）
        return !date.isBefore(start) && !date.isAfter(end);
    }

    public static void main(String[] args) {
        // 测试边界：非法日期（2026-02-30）
        System.out.println(isDateInRange("2026-02-30", "2026-01-01", "2026-12-31")); // false
        // 测试边界：开始时间 > 结束时间
        System.out.println(isDateInRange("2026-05-01", "2026-12-31", "2026-01-01")); // false
        // 测试边界：日期等于结束时间
        System.out.println(isDateInRange("2026-12-31", "2026-01-01", "2026-12-31")); // true
    }
}

7、并发 / 线程类边界

并发场景的边界问题隐蔽且难复现，核心是 "线程安全" 和 "资源竞争" 的临界点：

常见边界

1. 线程数边界（线程池核心线程数 = 0、最大线程数超出系统限制）；
2. 锁边界（死锁、锁超时、释放未持有的锁）；
3. 共享变量边界（多线程读写共享变量未同步、原子操作边界）；
4. 并发容器边界（如 ConcurrentHashMap 的putIfAbsent返回值为 null / 已有值）；
5. 任务执行边界（任务执行超时、任务数超出队列容量、空任务）。

Java 示例（处理线程池边界）

import java.util.concurrent.*;

public class ConcurrentBoundaryDemo {
    // 安全提交任务到线程池（处理并发边界）
    public static <T> Future<T> safeSubmitTask(ExecutorService executor, Callable<T> task, long timeout, TimeUnit unit) {
        // 边界1：线程池/任务为null
        if (executor == null || task == null || unit == null) {
            return null;
        }
        // 边界2：线程池已关闭
        if (executor.isShutdown()) {
            throw new IllegalStateException("线程池已关闭，无法提交任务");
        }
        try {
            // 边界3：任务执行超时（设置超时时间）
            return executor.submit(() -> {
                try {
                    return task.call();
                } catch (Exception e) {
                    // 边界4：任务执行异常
                    System.err.println("任务执行失败：" + e.getMessage());
                    return null;
                }
            });
        } catch (RejectedExecutionException e) {
            // 边界5：任务队列满，线程池拒绝接收任务
            System.err.println("任务提交失败：线程池队列已满");
            return null;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        // 测试边界：正常任务
        Future<String> future = safeSubmitTask(executor, () -> "任务完成", 1, TimeUnit.SECONDS);
        System.out.println(future.get()); // 输出 任务完成

        // 关闭线程池后测试边界：线程池已关闭
        executor.shutdown();
        try {
            safeSubmitTask(executor, () -> "任务失败", 1, TimeUnit.SECONDS);
        } catch (IllegalStateException e) {
            System.out.println(e.getMessage()); // 输出 线程池已关闭，无法提交任务
        }
    }
}

8、接口 / 方法调用边界

方法 / 接口调用的边界聚焦 "参数传递" 和 "返回值"，是模块间交互的关键：

常见边界

1. 方法参数为 null（尤其是非基本类型参数）；
2. 方法返回值为 null（调用方未处理）；
3. 接口调用超时（网络延迟、服务不可用）；
4. 接口返回值格式异常（JSON 解析失败、字段缺失）；
5. 方法递归调用边界（递归深度超出栈容量导致 StackOverflowError）。

边界条件判断的通用方法

1. 等价类划分：将输入分为 "有效等价类" 和 "无效等价类"，边界条件多在无效等价类的临界点（如数值 0、集合长度 - 1）。
2. 反向思考：假设 "参数非法"，思考哪些情况会导致逻辑出错（如 null、越界、空值），逐一校验。
3. 借助工具：使用 JUnit 等单元测试框架，针对边界条件编写测试用例（如测试 Integer.MAX_VALUE、索引 - 1、空集合）。
4. 复用工具类 ：使用 Java 自带的工具类减少重复校验，如Objects.requireNonNull()、StringUtils.isEmpty()（Apache Commons）。

总结

识别边界条件的核心思路是：反向思考 "什么情况下代码会出错"，把所有 "异常临界点" 都纳入校验范围，再通过单元测试覆盖这些边界场景，就能大幅提升代码健壮性。

1. 核心原则：代码健壮性的关键是 "先校验，后执行"，所有外部输入和临界操作必须做合法性判断。
2. 边界类型：重点关注数值（最值 / 0）、集合（空 / 越界）、字符串（null / 空）、循环（次数 0 / 越界）、IO（资源不存在 / 读取末尾）五类边界。
3. Java 实践：利用 Optional 避免空指针、try-with-resources 释放资源、异常合理捕获，结合单元测试验证边界处理逻辑。
4. 集合 / 数组 ：核心关注null、空长度、索引越界，操作前先校验合法性；
5. 字符串 / 日期 ：重点处理null、空白、格式 / 长度非法、时间临界点；
6. IO / 并发：关注资源存在性 / 权限、流释放、线程池状态、任务超时 / 拒绝；
7. 通用原则：所有外部输入（参数、文件、接口）先校验后执行，异常场景需显式处理，避免 "默认通过"。

(三) 如何在实际项目中应用代码健壮性规范？

从项目落地流程 、分层落地策略 、工具保障 、团队落地技巧四个维度，结合实际项目场景给出具体可操作的方案，你可以直接套用到自己的项目中。

---

一、项目落地核心流程（从 0 到 1 落地规范）

步骤 1：先梳理 "最小可行规范"（避免一刀切）

实际项目中不用一开始就套用所有规范，先聚焦高频问题场景，梳理出 "最小可行规范清单"，优先解决 80% 的常见问题：

优先级	规范类型	核心落地要求
高	输入校验	所有对外接口（Controller/Feign）、工具类方法必须做参数非空 / 格式 / 范围校验
高	异常处理	禁止空 catch 块，IO / 数据库异常必须封装为业务异常，关键异常记录完整日志
高	资源释放	IO 流 / 数据库连接 / 线程池必须闭环（try-with-resources / 优雅关闭）
中	空值处理	禁止返回 null 集合 / 数组，Optional 封装可能为 null 的返回值
中	数值运算	金额用 BigDecimal，整数运算校验溢出，浮点数避免直接比较
低	并发安全	多线程场景必须使用线程安全容器，自定义线程池指定拒绝策略

步骤 2：将规范转化为 "可落地的代码模板"

把抽象规范转化为项目可复用的代码模板，让团队成员 "有样可依"，避免每个人理解不一致：

示例 1：Controller 层参数校验模板（Spring Boot 项目）

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import jakarta.validation.Valid;

// 1. 入参使用@Valid + 注解校验（JSR-380）
// 2. 统一返回结果封装
// 3. 全局异常捕获处理参数校验失败
@RestController
public class UserController {

    @PostMapping("/user/create")
    public ResultVO<UserVO> createUser(@Valid @RequestBody UserCreateDTO dto) {
        // 业务逻辑（无需重复校验dto，由@Valid完成基础校验）
        UserVO userVO = userService.createUser(dto);
        return ResultVO.success(userVO);
    }

    // 统一返回结果封装
    public static class ResultVO<T> {
        private int code;
        private String msg;
        private T data;

        public static <T> ResultVO<T> success(T data) {
            ResultVO<T> vo = new ResultVO<>();
            vo.code = 200;
            vo.msg = "success";
            vo.data = data;
            return vo;
        }

        public static <T> ResultVO<T> fail(int code, String msg) {
            ResultVO<T> vo = new ResultVO<>();
            vo.code = code;
            vo.msg = msg;
            return vo;
        }
    }
}

// DTO参数校验注解（基础校验由框架完成）
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import lombok.Data;

@Data
public class UserCreateDTO {
    @NotBlank(message = "用户名不能为空") // 非空+非空白
    private String username;

    @NotNull(message = "年龄不能为空")
    @Positive(message = "年龄必须为正数")
    private Integer age;
}

// 全局异常处理器（统一处理参数校验异常）
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class GlobalExceptionHandler {

    // 处理参数校验失败异常
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResultVO<Void> handleValidException(MethodArgumentNotValidException e) {
        String msg = e.getBindingResult().getFieldError().getDefaultMessage();
        return ResultVO.fail(400, msg);
    }

    // 处理业务异常
    @ExceptionHandler(BusinessException.class)
    public ResultVO<Void> handleBusinessException(BusinessException e) {
        return ResultVO.fail(500, e.getMessage());
    }
}

示例 2：Service 层业务逻辑模板

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import java.util.Objects;
import java.util.Optional;

@Service
public class UserService {
    private static final Logger log = LoggerFactory.getLogger(UserService.class);

    public UserVO createUser(UserCreateDTO dto) {
        // 1. 补充业务规则校验（框架注解无法覆盖的场景）
        if (dto.getUsername().length() > 20) {
            throw new BusinessException("用户名长度不能超过20位");
        }
        if (userMapper.existsByUsername(dto.getUsername())) {
            throw new BusinessException("用户名已存在：" + dto.getUsername());
        }

        // 2. 业务操作（资源操作使用try-with-resources）
        UserDO userDO = new UserDO();
        userDO.setUsername(dto.getUsername());
        userDO.setAge(dto.getAge());
        try {
            userMapper.insert(userDO);
            log.info("创建用户成功，userId：{}", userDO.getId());
        } catch (Exception e) {
            log.error("创建用户失败，dto：{}", dto, e); // 记录完整日志（含入参+异常栈）
            throw new BusinessException("创建用户失败，请重试");
        }

        // 3. 返回结果（避免返回null，封装为VO）
        return convertToVO(userDO);
    }

    // 查询方法：返回Optional避免null
    public Optional<UserVO> getUserById(Long userId) {
        // 入参校验
        Objects.requireNonNull(userId, "用户ID不能为空");
        if (userId <= 0) {
            throw new BusinessException("用户ID必须为正数");
        }

        UserDO userDO = userMapper.selectById(userId);
        return Optional.ofNullable(convertToVO(userDO));
    }

    // 转换方法：私有工具方法
    private UserVO convertToVO(UserDO userDO) {
        if (userDO == null) {
            return null;
        }
        UserVO vo = new UserVO();
        vo.setId(userDO.getId());
        vo.setUsername(userDO.getUsername());
        vo.setAge(userDO.getAge());
        return vo;
    }
}

步骤 3：在项目中落地 "规范检查点"

把规范融入项目开发的全流程，每个环节设置检查点，确保规范被执行：

开发阶段	检查点	责任人	工具 / 手段
编码阶段	1. 参数校验是否完整 2. 异常是否合理处理 3. 资源是否闭环	开发人员	IDE 插件（Alibaba 编码规范）+ 代码模板
提测前	1. 单元测试覆盖边界场景 2. 静态代码扫描无高危问题	开发人员	JUnit + SonarQube
代码评审	1. 规范落地情况 2. 边界条件处理 3. 异常处理合理性	技术负责人	评审清单（逐项核对）
测试阶段	1. 边界场景测试（null / 空 / 极值） 2. 异常场景测试（接口超时 / 参数非法）	测试人员	测试用例（覆盖所有边界）

---

二、分层落地策略（按项目层级拆解规范）

实际项目中不同层级的职责不同，规范落地的重点也不同，避免 "一刀切"：

1. 接入层（Controller/API 网关）

• 核心规范：参数校验、限流降级、超时控制、幂等性、异常统一返回
• 落地手段 ：
  • 使用 Spring Validation 完成基础参数校验（@Valid + 注解）；
  • 接入网关层限流（如 Sentinel/Zuul），设置接口超时时间；
  • 全局异常处理器统一返回格式，避免暴露底层异常；
  • 对外接口添加幂等性校验（如基于 Token / 唯一 ID）。

2. 业务层（Service）

• 核心规范：业务规则校验、异常封装、日志记录、资源闭环
• 落地手段 ：
  • 框架校验之外的业务规则，手动编码校验（如用户名唯一性）；
  • 底层异常（如 SQL 异常）封装为业务异常，向上抛出；
  • 关键操作记录日志（入参 / 出参 / 异常），日志级别合理；
  • 数据库 / Redis 操作使用 try-catch，失败时记录日志并抛出业务异常。

3. 数据层（Mapper/Repository）

• 核心规范：SQL 安全、结果处理、连接管理
• 落地手段 ：
  • 使用 MyBatis 参数绑定（#{}）避免 SQL 注入；
  • 查询结果为空时，返回空集合而非 null；
  • 数据库连接使用连接池，设置最大连接数 / 超时时间；
  • 批量操作分批处理（如每次插入 1000 条），避免锁表 / 内存溢出。

4. 工具层（Util/Common）

• 核心规范：通用性、无状态、边界处理
• 落地手段 ：
  • 工具类方法必须做参数校验，避免传入 null 导致 NPE；
  • 工具类设计为无状态（静态方法），避免成员变量；
  • 工具类返回值避免 null（如返回空集合 / Optional）。

---

三、工具保障（用工具强制落地规范）

仅靠人工难以保证规范落地，需结合工具自动化校验：

1. IDE 插件（编码阶段实时提醒）

• 推荐插件：Alibaba Java Coding Guidelines（阿里巴巴编码规范插件）
• 作用：编码时实时检测违规代码（如空 catch 块、返回 null 集合），直接在 IDE 中标红提醒，强制开发人员修改。

2. 静态代码扫描（提测前校验）

• 推荐工具：SonarQube（开源）/Alibaba Cloud CodeScan
• 落地步骤 ：
  1. 搭建 SonarQube 服务，配置项目扫描规则（开启健壮性相关规则）；
  2. 集成到 CI/CD 流程（如 Jenkins），提测前必须通过扫描，高危问题阻断构建；
  3. 定期查看扫描报告，修复存量违规问题。

3. 单元测试（覆盖边界场景）

• 核心要求 ：每个工具类 / 核心方法都要编写单元测试，覆盖：
  • 正常场景（合法参数）；
  • 边界场景（null / 空 / 极值 / 越界）；
  • 异常场景（参数非法 / 资源不存在）。
• 示例：UserService 的单元测试

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
public class UserServiceTest {
    @Mock
    private UserMapper userMapper;

    @InjectMocks
    private UserService userService;

    // 测试正常场景：创建用户成功
    @Test
    public void testCreateUser_Success() {
        UserCreateDTO dto = new UserCreateDTO();
        dto.setUsername("test");
        dto.setAge(20);
        when(userMapper.existsByUsername("test")).thenReturn(false);
        
        UserVO vo = userService.createUser(dto);
        assertNotNull(vo);
        verify(userMapper).insert(any(UserDO.class));
    }

    // 测试边界场景：用户名过长
    @Test
    public void testCreateUser_UsernameTooLong() {
        UserCreateDTO dto = new UserCreateDTO();
        dto.setUsername("testtesttesttesttesttesttesttesttesttesttest"); // 21位
        dto.setAge(20);
        
        BusinessException e = assertThrows(BusinessException.class, () -> {
            userService.createUser(dto);
        });
        assertEquals("用户名长度不能超过20位", e.getMessage());
    }

    // 测试异常场景：用户名已存在
    @Test
    public void testCreateUser_UsernameExists() {
        UserCreateDTO dto = new UserCreateDTO();
        dto.setUsername("test");
        dto.setAge(20);
        when(userMapper.existsByUsername("test")).thenReturn(true);
        
        BusinessException e = assertThrows(BusinessException.class, () -> {
            userService.createUser(dto);
        });
        assertEquals("用户名已存在：test", e.getMessage());
    }
}

4. 代码评审清单（人工兜底）

制定简单的评审清单，代码评审时逐项核对，避免遗漏：

【代码健壮性评审清单】
1. 所有外部输入是否做了校验？（√/×）
2. 是否有空catch块？（√/×）
3. 资源（流/连接）是否闭环？（√/×）
4. 是否返回null集合/数组？（√/×）
5. 数值运算是否校验溢出？（√/×）
6. 异常是否封装为业务异常？（√/×）
7. 关键操作是否记录日志？（√/×）
8. 边界条件是否处理？（√/×）

---

四、团队落地技巧（避免落地阻力）

1. 先试点后推广

• 选择一个核心模块先落地规范，形成可参考的示例；
• 组织团队学习试点模块的代码，统一理解后再推广到全项目。

2. 制定 "违规处理规则"

• 明确违规代码的处理方式（如提测前必须修复、严重违规阻断上线）；
• 对存量违规代码，制定修复计划（如迭代间隙逐步修复），不强制一次性修复。

3. 定期复盘优化

• 每月复盘规范落地情况（如 SonarQube 违规数、线上 bug 数）；
• 根据项目实际情况调整规范（如去掉不适用的规则、补充新的高频问题）。

4. 知识沉淀

• 把规范落地中的常见问题、解决方案整理成团队知识库；
• 新人入职时，通过规范学习 + 代码评审快速掌握落地要求。

---

总结

1. 落地核心 ：把抽象规范转化为可执行的代码模板 + 自动化校验工具 + 人工检查点，避免仅停留在文档层面；
2. 分层策略：按 Controller/Service/Mapper 分层落地，聚焦各层核心规范，避免 "一刀切"；
3. 工具兜底：通过 IDE 插件、静态扫描、单元测试自动化校验，减少人工成本，保证规范落地效果；
4. 团队适配：先试点后推广，结合项目实际调整规范，避免落地阻力。

按照这套方案，你可以逐步把代码健壮性规范融入项目的开发全流程，从根源上减少线上 bug，提升代码质量。

(四)如何在项目迭代中持续优化和完善代码健壮性规范？

一套能直接在公司项目里落地、跟着迭代走、越做越完善 的「代码健壮性持续优化体系」。不讲虚的，全部是可执行、可量化、可复盘的做法，Java 后端项目通用。

---

一、先定一个核心目标：让规范「跟着项目一起进化」

持续优化 = 不是一次做完，而是每次迭代都做一点点：

• 从线上问题反推规范
• 从代码坏味道补充规范
• 从新人踩坑完善规范
• 从架构升级更新规范

最终形成：问题 → 规范 → 工具 → 检查 → 复盘 → 新规范这是一个闭环。

---

二、在迭代中落地的 4 个关键动作（每次迭代必做）

1）每次迭代前：更新「健壮性检查清单」

不要大而全，只要当前最痛的 8～12 条。示例（可直接复制用）：

【迭代健壮性检查清单】
1. 入参是否非空校验？
2. 是否返回 null 集合？
3. catch 是否为空？
4. 资源是否 try-with-resources？
5. 金额是否用 BigDecimal？
6. 日期是否处理边界（月末、2月29）？
7. 外部调用是否有超时/重试/降级？
8. 异常是否统一封装，不暴露堆栈？
9. 循环是否可能死循环/超长耗时？
10. 并发场景是否线程安全？

每次迭代根据上一轮线上 bug增删 1～2 条。

---

2）每次提测前：做 10 分钟「健壮性自检」

开发自己检查，成本极低、效果极强：

• 接口入参：null、空、超长、越界、非法字符
• 边界：0、空列表、最后一条、第一条
• 异常：调用失败、超时、返回 null
• 资源：流、连接、锁是否关闭
• 日志：关键入参出参是否打印

自检一次 ≈ 提前堵掉 60% 的线上 bug

---

3）每次 Code Review：只抓「健壮性问题」

CR 不要什么都看，聚焦：

• 漏校验
• 空 catch
• 资源未释放
• 边界没处理
• 异常吞掉
• 返回 null 集合

CR 发现一个问题 → 补充到检查清单 这就是持续完善规范的来源。

---

4）每次迭代后：做 5 分钟「健壮性复盘」

只问 4 个问题：

1. 本迭代有没有因为健壮性不足出 bug？
2. 哪个环节漏了（校验 / 异常 / 边界 / 资源）？
3. 能不能写成一条规范？
4. 能不能用工具自动检查？

复盘输出 → 直接更新规范文档。小步快跑，永远比一次写 100 条规范有效。

---

三、如何让规范「越来越完善」？（体系化方法）

1）从「线上故障」反推规范（最有效）

线上出问题 → 立即提炼成一条规范 + 一个示例例如：

• 空指针 → 加规范：所有外部入参必须校验
• 溢出 → 加规范：金额 / 大数必须用 BigDecimal
• 文件泄漏 → 加规范：IO 必须 try-with-resources
• 慢查询 → 加规范：分页 /limit/ 查询条件不能为空

故障是规范最好的来源。

---

2）从「通用工具类」沉淀规范

把重复校验、重复判断抽成工具：

• AssertUtil
• CheckUtil
• DateUtil
• BigDecimalUtil
• ExceptionUtil

工具越完善，规范越容易落地。规范 = 工具 + 模板 + 检查

---

3）从「新人踩坑」完善规范

新人最容易暴露：

• 规范不清晰
• 文档看不懂
• 模板没有
• 例子太少

新人每踩一个坑，就补一条更明确、带示例的规范。

---

4）随架构升级同步升级规范

例如：

• 单体 → 微服务：新增超时、重试、熔断、幂等规范
• 单线程 → 多线程：新增线程池、锁、原子类、并发安全规范
• 同步 → 异步：新增幂等、最终一致性、失败重试规范

架构变，健壮性规范必须同步变。

---

四、如何保证规范不会烂尾？（最关键）

给你 3 条最简单、最有效的规则：

1）规范永远不超过 1 页 A4

超过就没人看、没人执行。

2）每条规范必须带：

• 错误示例
• 正确示例
• 检查方式
• 工具自动检查规则

可执行、可检查、可量化才叫规范。

3）工具自动化 > 人工检查

• IDE 插件（阿里编码规范）
• SonarQube
• 单元测试（边界必测）
• CI 构建卡点

人会忘，工具不会。

---

五、你可以直接落地的「迭代健壮性进化路线」

非常简单，3 个月就能成型：

• 第 1 个月：补基础规范（空、校验、异常、资源）
• 第 2 个月：补边界与工具类
• 第 3 个月：自动化检查 + CR 卡点
• 之后：每次迭代只优化 1～2 条

你的规范会越来越贴合项目、越来越少 bug、越来越稳定。

---

如果你愿意，我可以直接帮你按你们项目（Java/SpringBoot）输出一份《可直接落地的代码健壮性规范文档（完整版）》，包括：

• 检查清单
• 每条规范 + 错误示例 + 正确示例
• CR 模板
• 单元测试模板
• 工具配置