防御性编程:让系统坚不可摧

京东云开发者
• 阅读 249

1. 引言

面对复杂多变的运行环境、不可预测的用户输入以及潜在的编程错误,如何确保软件在遭遇异常情况时依然能够稳定运行,是每位开发者必须面对的挑战。防御性编程(Defensive Programming)正是为解决这一问题而生的一种编程范式,它强调在编程过程中预见并防范潜在的错误和异常情况,从而增强软件的健壮性和稳定性。作为一种细致、谨慎的编程方法,通过提前考虑并防范可能出现的错误,从而有效减少软件漏洞和故障。本文将详细介绍防御性编程的基本概念、关键策略,并通过实际案例展示其在实际项目中的应用。

2. 防御性编程的基本概念

防御性编程的核心思想在于承认程序总会存在问题和需要修改,因此聪明的程序员会提前考虑并防范可能的错误。它强调在编程过程中不仅要实现功能,还要确保程序在面对错误输入、异常情况和并发操作时能够稳定运行

3. 防御性编程的核心原则

3.1 风险识别

非系统性风险:只影特定场景下的响单次调用,不对系统整体稳定性产生影响。比如空指针异常、数据越界等。

系统性风险:导致整个服务不可用的风险。比如 死循环,分页查询pageSize过大等。

3.2 防御原则

1.假设输入总是错误的:不依赖外部输入的绝对正确性,对所有输入进行验证和清理。

2.最小化错误的影响范围:通过异常处理、错误隔离等措施,限制错误对系统整体的影响。

3.使用断言进行内部检查:在代码的关键位置加入断言,确保程序状态符合预期。

4.代码清晰易懂:编写易于理解和维护的代码,便于团队成员发现潜在问题。

5.持续测试:通过单元测试、集成测试等手段,不断验证软件的正确性和稳定性。

4. 防御性编程案例

4.1 输入验证与清理

场景

用户输入数据到Web表单中,系统需要处理这些数据以进行后续操作。

防御性编程实践

风险识别:系统性风险,可能导致系统整体不可用。

防御策略

验证数据类型:确保用户输入的数据类型符合预期(如数字、字符串、日期等)。如果类型不匹配,应给出错误提示并要求用户重新输入。

长度和范围检查:对于字符串、数字等类型的数据,进行长度和范围检查,确保它们不超过系统处理能力的限制。

清理输入数据:去除输入数据中的非法字符或格式,如去除字符串两端的空格、将特殊字符转换为普通字符等。

分页参数防御式编程案例

下面以分页参数防御式编程为案例进行举例说明:

场景描述: 假设开发一个Web API,该API需要根据用户请求返回特定数据的分页结果。分页请求包含以下参数:

pageSize:每页应显示的记录数。

pageNumber:用户请求的当前页码。

防御性编程措施

1.验证pageSize:确保pageSize是一个正整数,并且不超过一个合理的最大值(例如100),以防止资源过度消耗。

2.验证pageNumber:确保pageNumber是一个正整数,并且不会请求到不存在的页码(即基于总记录数和pageSize计算出的最大页码之后)。

3.处理无效参数:如果参数无效,则返回清晰的错误消息,并可能设置一个默认的页码或每页记录数。

4.计算总页数:基于总记录数和pageSize计算总页数,以便在返回分页信息时包含给用户。

示例代码(伪代码):

public class PaginationService {        
    private static final int MAX_PAGE_SIZE = 100;        
        /**       
         * 获取分页信息并进行参数校验       
         *        
         * @param totalRecords 总记录数       
         * @param pageSize 每页记录数       
         * @param pageNumber 当前页码       
         * @return 分页信息,包括总页数、当前页码等       
         */      
         public PaginationInfo getPaginationInfo(int totalRecords, int pageSize, int pageNumber) {          
             // 校验pageSize          
             if (pageSize <= 0 || pageSize > MAX_PAGE_SIZE) {              
                 throw new IllegalArgumentException("pageSize必须为正整数且不超过" + MAX_PAGE_SIZE);          
             }            
             // 校验pageNumber          
             if (pageNumber <= 0) {              
                 pageNumber = 1; // 默认为第一页          
             }            
             // 计算总页数          
             int totalPages = (totalRecords + pageSize - 1) / pageSize;            
             // 确保pageNumber不超过总页数          
             if (pageNumber > totalPages) {              
                 pageNumber = totalPages;          
             }            
             // 计算当前页的数据起始索引(可选,根据具体需求)          
             int startIndex = (pageNumber - 1) * pageSize;            
             // 返回分页信息          
             return new PaginationInfo(totalPages, pageNumber, startIndex);      
         }        
         // PaginationInfo 是一个简单的类,用于封装分页信息 
         ...

在这个例子中,getPaginationInfo 方法首先验证了 pageSizepageNumber 参数的有效性,确保了它们符合预期的约束条件。如果参数无效,方法会抛出一个 IllegalArgumentException 异常,这有助于调用者识别并处理错误情况。然后,方法计算了总页数,并根据需要调整了 pageNumber 以确保它不会超出范围。最后,方法返回了一个包含分页信息的 PaginationInfo 对象。

这种防御性编程策略有助于防止因无效的分页参数而导致的程序错误,提高了API的健壮性和用户体验。

4.2 预防死循环

场景

在循环或者遍历场景中,没有明确的退出机制。

防御性编程实践

风险识别:系统性风险,可能导致系统整体不可用。

防御策略

参数验证:检查涉及循环步长的入参是否有效。

循环终止条件必达性确认:在涉及条件校验的场景中,避免等值条件判断,防止跳过循环终止点。

日志记录:在关键位置添加日志记录,帮助调试和追踪问题。

示例代码(Java):

/**  
 * 生成时间段。  
 *  
 * @param startMinutes 开始时间
 * @param endMinutes 结束时间
 * @param interval 时间段间隔
 * @param duration 时间的时长
 * @return 时间段列表 
 */  
public List<String> generateList(int startMinutes, int endMinutes, int interval, int duration) {

    List<String> result = new ArrayList<>();
    int nextStartTime = startMinutes;

    while (nextStartTime == endMinutes) {
        int currentStartMinutes = nextStartTime;

        int currentEndMinutes = currentStartMinutes + duration;

        result.add(currentStartMinutes + "-" + currentEndMinutes);

        nextBatchStartTime += interval;
    }
    return result;
}

针对以上代码,我们可以添加一些防御式编程的元素来确保代码的健壮性和可靠性。防御式编程侧重于预防错误的发生,包括输入验证、错误处理和边界条件检查。以下是修改后的代码,包含了防御式编程的改进:

/** 
 * 生成时间段。 
 * 
 * @param startMinutes 开始时间
 * @param endMinutes 结束时间
 * @param interval 时间段间隔
 * @param duration 时间的时长
 * @return 时间段列表 
 */ 
public List<String> generateList(int startMinutes, int endMinutes, int interval, int duration) {
    // 改进点1:校验 interval,以保证循环中的步长能够正向增长
    // 一般情况下,还需要对步长,和 endMinutes与startMinutes的区间大小做限制,避免生成“巨大”的列表。
    if (interval <= 0) {
        throw new IllegalArgumentException("Invalid parameters: interval must be positive integers.");
    }
    List<String> result = new ArrayList<>();
    int nextStartTime = startMinutes;

    //改进点2:避免使用等号做循环终止条件,以防跳过循环终止点。
    while (nextStartTime <= endMinutes) {
        int currentStartMinutes = nextStartTime;

        int currentEndMinutes = currentStartMinutes + duration;

        result.add(currentStartMinutes + "-" + currentEndMinutes);

        nextBatchStartTime += interval;
    }
    return result;
}

4.3 异常处理

场景

程序在读取文件、进行网络请求或执行其他可能失败的操作时,需要处理潜在的异常。

防御性编程实践

风险识别:非系统性风险,影响单次请求。

防御策略

使用try-except语句: 将可能抛出异常的代码块放在try语句中,并在except语句中捕获并处理这些异常。

区分异常类型: 根据实际需要捕获特定的异常类型,或捕获所有异常(使用Exception作为异常类型)。

记录错误信息: 在捕获异常后,记录详细的错误信息(如异常类型、错误消息、堆栈跟踪等),以便后续分析和调试。

示例代码(Java):

/**  
 * 读取文件内容。  
 *  
 * @param filePath 文件路径  
 * @return 文件内容,如果文件不存在或读取失败则返回null  
 */  
public static String readFile(String filePath) {  
    try {  
        byte[] encoded = Files.readAllBytes(Paths.get(filePath));  
        return new String(encoded);  
    } catch (FileNotFoundException e) {  
        log.info("文件未找到:" + filePath);  
        return null;  
    } catch (Exception e) {  
        log.info("读取文件时发生错误:" + e.getMessage());  
        return null;  
    }  
}  

4.4 边界条件检查

场景

在循环、条件判断或数组访问等操作中,需要确保不会超出预期的范围或边界。

防御性编程实践

风险识别:非系统性风险,影响单次请求。

防御策略

检查循环条件:确保循环条件在每次迭代后都能正确更新,以避免无限循环。

数组和集合访问:在访问数组、列表、字典等集合的元素之前,检查索引或键是否有效。

边界值测试:对函数或方法的输入进行边界值测试,以确保它们在边界条件下也能正常工作。

示例代码(Java):

public class ArrayAccess {      
    public static void main(String[] args) {          
        int[] numbers = {1, 2, 3, 4, 5};          
        int index = getIndexFromUser(); // 假设这是从用户那里获取的索引                    
        if (index >= 0 && index < numbers.length) {              
            log.info(numbers[index]);          
        } else {              
            log.info("索引超出数组范围");          
        }      
    }                 

    // 假设这个方法从用户那里获取索引值,并进行基本的验证 
    private static int getIndexFromUser() {       
        // 为了示例,我们直接返回一个示例值          
        return 2; // 假设用户输入了有效的索引值2      
    }  
}

4.5 使用断言进行内部检查

场景

在代码的关键路径上,需要确保某些条件始终为真,否则程序将无法正确执行。

防御性编程实践

使用断言:在代码的关键位置添加断言(如Python的assert语句),以验证程序状态是否符合预期。如果断言失败,则抛出AssertionError异常。

注意断言的使用场景:断言主要用于开发和测试阶段,用于捕获那些理论上不应该发生的错误。在生产环境中,应该依赖更健壮的错误处理机制。

示例代码(Java):

/**  
 * 计算年龄。  
 *  
 * @param birthYear 出生年份  
 * @return 年龄,如果输入无效则返回-1。  
 */  
public static int calculateAge(int birthYear) {  
    // 输入验证:确保出生年份是一个合理的值  
    if (birthYear <= 0 || birthYear > java.time.Year.now().getValue()) {  
        // 抛出IllegalArgumentException来指示方法接收到了非法参数  
        throw new IllegalArgumentException("出生年份必须是一个大于0且小于当前年份的整数");  
    }  

    // 计算年龄  
    int currentYear = java.time.Year.now().getValue();  
    return currentYear - birthYear;  
}  

public static void main(String[] args) {  
    try {  
        // 假设我们从某个地方(如用户输入)获取了出生年份  
        int birthYear = 1990; // 这里直接赋值作为示例  

        int age = calculateAge(birthYear);  
            if (age != -1) { // 注意:这个例子中calculateAge实际上不会返回-1,但为了展示如何处理可能的异常情况,我们可以这样设计  
                log.info("年龄是:" + age);  
            }  

        } catch (IllegalArgumentException e) {  
            // 捕获并处理IllegalArgumentException  
            log.info("错误:" + e.getMessage());  
        }  

        // 如果需要从用户输入中获取出生年份,你可以添加相应的逻辑来处理字符串到整数的转换和验证  
    }  

    // 注意:在这个例子中,我们没有直接使用assert,因为Java的assert主要用于调试,且默认是禁用的。  
    // 而是通过显式的条件检查和异常抛出来实现防御性编程。  

5. 防御式编程的挑战

5.1 是不是防御式代码越多越好呢?

No,过度的防御式编程会使程序会变得臃肿而缓慢,增加软件的复杂度。

要考虑好什么地方需要进行防御,然后因地制宜地调整进行防御式编程的优先级。

一般在入口处或者接入层做通用性防御性编程,比如数据准入校验;但对于循环类逻辑,应始终在使用处做细节性防御

5.2 通用性防御措施 优于 细节性的防御

例如对于网络请求,一般是统一处理超时、鉴权、各种错误code,而不是在业务层个别处理

5.3 根据使用场景,调整防御力度

如项目内部使用的utils函数和公开发布的package,后者防御要求更高

6. 结论

防御性编程是一种积极主动的编程策略,它要求开发者在编写代码时,不仅要关注功能的实现,更要关注代码的健壮性和稳定性。通过预见并防范潜在的错误和异常情况,防御性编程能够显著提升软件的质量,减少因外部因素导致的程序崩溃,提升系统稳定性。

文章中难免会有不足之处,希望读者能给予宝贵的意见和建议。谢谢!

点赞
收藏
评论区
推荐文章
Wesley13 Wesley13
3年前
AOP相关概念
1.AOP(面向切面编程)在软件业,AOP为AspectOrientedProgramming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术.AOP是OOP的延续,在软件开发中的一个热点,也是Spring框架中的一个重要内容,是函数式编程的一种衍生泛型.利用AOP
Wesley13 Wesley13
3年前
Java代码编写规范(转)
编码规范1前言为确保系统源程序可读性,从而增强系统可维护性,java编程人员应具有基本类似的编程风格,兹制定下述Java编程规范,以规范系统Java部分编程。系统继承的其它资源中的源程序也应按此规范作相应修改。2适用范围本文档将作为java编程人员软件开发的编程格式规范。在项目Java部分的编码、测试及维护过程中,要求严格遵守
Stella981 Stella981
3年前
Guava库学习:学习Guava EventBus(一)EventBus
  在软件开发过程中,对象信息的分享以及相互直接的协作是必须的,困难在于确保对象之间的沟通是有效完成的,而不是拥有成本高度耦合的组件。当对象对其他组件的责任有太多的细节时,它被认为是高度耦合的。当一个应用程序有高度的耦合,维护将变得非常具有挑战,任何变化都将带来涟漪效应。为了解决这一类的软件设计问题,我们就需要基于事件的编程。本篇,我们就来学习Guava
Stella981 Stella981
3年前
GitHub上的今年第一本《Java异步编程实战》美团T9亲荐,太赞了
异步编程是可以让程序并行运行的一种手段,可以让程序中的一个工作单元与主应用程序线程分开独立运行,进而提高应用程序的性能和响应能力等。虽然Java为不同技术域提供了相应的异步编程技术,但是这些异步编程技术被散落到不同技术域的
Wesley13 Wesley13
3年前
NEO从源码分析看网络通信
_0x00前言_NEO被称为中国版的Ethereum,支持C和java开发,并且在社区的努力下已经把SDK拓展到了js,python等编程环境,所以进行NEO开发的话是没有太大语言障碍的。比特币在解决拜占庭错误这个问题时除了引入了区块链这个重要的概念之外,还引入了工作量证明(PoW)这个机智的解决方案,通过数学意义上的难题来保证每个
小万哥 小万哥
1年前
C++异常和错误处理机制:如何使您的程序更加稳定和可靠
在C编程中,异常处理和错误处理机制是非常重要的。它们可以帮助程序员有效地处理运行时错误和异常情况。本文将介绍C中的异常处理和错误处理机制。什么是异常处理?异常处理是指在程序执行过程中发生异常或错误时,程序能够捕获并处理这些异常或错误的机制。例如,当
京东云开发者 京东云开发者
4个月前
pfinder实现原理揭秘
1.引言在现代软件开发过程中,性能优化和故障排查是保证应用稳定运行的关键任务之一。Java作为一种广泛使用的编程语言,其生态中涌现出了许多优秀的监控和诊断工具,诸如:SkyWalking、Zipkin等,它们帮助开发者和运维人员深入了解应用的运行状态,快速
京东云开发者 京东云开发者
2个月前
防御性编程:让系统坚不可摧
1.引言面对复杂多变的运行环境、不可预测的用户输入以及潜在的编程错误,如何确保软件在遭遇异常情况时依然能够稳定运行,是每位开发者必须面对的挑战。防御性编程(DefensiveProgramming)正是为解决这一问题而生的一种编程范式,它强调在编程过程中预