java方法参数校验实践

     在 spring 的validation 验证框架还没有发布出来，怎么很优雅地对参数合法性做校验呢 ？

有两种时间方式：

（1）

result = method1();
if (result is error){ //根据返回结果判断是否退出
         ...//加错误码
         return result;
}
result = method2();
if (result is error){ //根据返回结果判断是否退出
         ...//加错误码
         return result;
}
do something...

（2）

        try {
            validators.checkNull(appVersionId, operator);// 如果有逻辑问题抛出ErrorCodeException
            validators.checkAppVersionExist(appVersionId);// 如果有逻辑问题抛出ErrorCodeException
        } catch (ValidationException e) {
    //将ErrorCodeException异常转换为Result  
            appResult.setFinished(true);
            appResult.addResult(new Result<String, OperationException>(e.getMessage(),
                                                                       ResultStatus.ERROR, e));
            return appResult;
        }
        return deploy(appVersionId, null, operator, true);

validator 验证器里面方法：

    public void checkNull(final Object... args) throws ValidationException {
        for (Object arg : args) {
            if (null == arg) {
                throw new ValidationException("", ErrorMessages.DEPLOY_ARGS_NULL);// 将错误码封装在 具体的验证其里面
            }
            if (arg instanceof List) {
                int count = ((List) arg).size();
                for(int i = 0;i< count ; i++){
                    ((List) arg).remove(null);
                }
            }
            if (arg instanceof Collection && ((Collection) arg).size() == 0) {
                throw new ValidationException("", ErrorMessages.DEPLOY_ARGS_NULL);
            }
            if (arg instanceof Map && ((Map) arg).size() == 0) {
                throw new ValidationException("", ErrorMessages.DEPLOY_ARGS_NULL);
            }
        }
    }

尽量将 错误码封装在具体的方法中，不要统一判断然后设置错误码。

但是我推荐采用第二种方式, 理由主要有三个方面: 

1. 从重构的角度来说, 如果一个方法中有多个return出口, 当方法膨胀之后需要将一块代码抽取出来单独形成一个方法的时候比较困难, 而采用异常的方式则可以很容易的抽取出单独方法. 
2. 从代码重用的角度来说, 第一种如果method1, method2方法有多个地方调用, 这些需要调用的地方大部分情况下都要对结果进行判断加错误码并返回结果, 这个是重复的代码, 这样重复性代码在ic中是随处可见的, 我希望通过抛错误码异常的方式来减少这种重复的东西. 
3. 从封装的角度来说, 将非正常结果的处理封装在方法的内部, 可以提高内聚性.