Refactoring Data Validation with Java 8 Functional Interfaces and Lambda Expressions

In Java backend development, repetitive validation code makes projects bulky and hard to maintain. Java 8 introduces functional interfaces such as Function and the MyBatis‑Plus specific SFunction , which can be leveraged to eliminate this duplication.

The article first presents a typical scenario where separate methods check the existence of a user ID and a department ID, each containing similar query and exception logic.

// 判断用户 ID 是否有效
public void checkUserExistence(String userId) {
    User user = userDao.findById(userId);
    if (user == null) {
        throw new RuntimeException('用户ID无效');
    }
}

// 判断部门 ID 是否有效
public void checkDeptExistence(String deptId) {
    Dept dept = deptDao.findById(deptId);
    if (dept == null) {
        throw new RuntimeException('部门ID无效');
    }
}

Using a generic method ensureColumnValueValid that accepts a value to check, a column extractor, a query executor, and an error‑message template, the same validation can be performed for any entity with a single call.

/**
 * 确认数据库字段值有效（通用）
 *
 * @param
待验证值的类型
 * @param valueToCheck 待验证的值
 * @param columnExtractor 实体类属性提取函数
 * @param queryExecutor 单条数据查询执行器
 * @param errorMessage 异常提示信息模板
 */
public static
void ensureColumnValueValid(
        V valueToCheck,
        SFunction
columnExtractor,
        SFunction
, T> queryExecutor,
        String errorMessage) {
    if (valueToCheck == null) return;
    LambdaQueryWrapper
wrapper = new LambdaQueryWrapper<>();
    wrapper.select(columnExtractor);
    wrapper.eq(columnExtractor, valueToCheck);
    wrapper.last('LIMIT 1');
    T entity = queryExecutor.apply(wrapper);
    R columnValue = columnExtractor.apply(entity);
    if (entity == null || columnValue == null) {
        throw new DataValidationException(String.format(errorMessage, valueToCheck));
    }
}

Applying this method in a service reduces the original two validation methods to a few concise calls:

public void assignTaskToUser(AddOrderDTO dto) {
    ensureColumnValueValid(dto.getUserId(), User::getId, userDao::getOne, '用户ID无效');
    ensureColumnValueValid(dto.getDeptId(), Dept::getId, deptDao::getOne, '部门ID无效');
    ensureColumnValueValid(dto.getCustomerId(), Customer::getId, customerDao::getOne, '客户ID无效');
    // ... further business logic
}

The comparison shows a substantial reduction in code volume and clearer intent, improving readability and maintainability.

Additional generic validation utilities are introduced:

validateColumnValueMatchesExpected verifies that a column’s value equals an expected value, throwing a formatted exception on mismatch.

validateColumnValueInExpectedList checks whether a column’s value belongs to a predefined list, useful for scenarios like order‑cancellation status validation.

public static
void validateColumnValueMatchesExpected(
        SFunction
targetColumn, R expectedValue,
        SFunction
conditionColumn, C conditionValue,
        SFunction
, T> queryMethod,
        String errorMessage) {
    LambdaQueryWrapper
wrapper = new LambdaQueryWrapper<>();
    wrapper.select(targetColumn);
    wrapper.eq(conditionColumn, conditionValue);
    T one = queryMethod.apply(wrapper);
    if (one == null) return;
    R actualValue = targetColumn.apply(one);
    if (!Objects.equals(actualValue, expectedValue)) {
        throw new RuntimeException(String.format(errorMessage, expectedValue, actualValue));
    }
}

These methods demonstrate how functional programming, generics, and lambda expressions can create reusable, flexible validation logic that adapts to any entity type.

Core advantages highlighted include:

Code reuse through generic functional interfaces.

Clear intent expressed by method signatures.

Flexibility to handle new validation scenarios by simply passing different lambdas.

Centralized exception handling, reducing error‑prone duplication.

In conclusion, embracing Java 8 functional programming simplifies backend code, enhances abstraction, and promotes maintainable, testable solutions for data validation and beyond.