Refactoring Data Validation with Java 8 Functional Interfaces

In Java development, repetitive validation code makes projects heavy and hard to maintain. Java 8 brings functional programming features, notably the Function interface and MyBatis‑Plus's SFunction , which act as a powerful tool to eliminate this redundancy.

The article presents a real‑world scenario where database field values need to be validated repeatedly. Traditional implementations contain duplicated query logic for each entity, such as separate methods for checking user IDs and department IDs.

// Check if user ID is valid
public void checkUserExistence(String userId) {
    User user = userDao.findById(userId);
    if (user == null) {
        throw new RuntimeException("用户ID无效");
    }
}

// Check if department ID is valid
public void checkDeptExistence(String deptId) {
    Dept dept = deptDao.findById(deptId);
    if (dept == null) {
        throw new RuntimeException("部门ID无效");
    }
}

Java 8's functional interfaces allow us to encapsulate the validation logic into a generic method. The core method ensureColumnValueValid receives the value to check, a column extractor, a query executor, and an error‑message template, performing the validation in a reusable way.

/**
 * Validate a column value (generic)
 *
 * @param
Type of the value to check
 * @param valueToCheck Value to be validated
 * @param columnExtractor Function to extract the column from the entity
 * @param queryExecutor   Function that executes a single‑row query
 * @param errorMessage    Template for the exception message
 */
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));
    }
}

Using this method, the original duplicated checks can be replaced with 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无效");
    // business logic continues...
}

The comparison shows a significant reduction in code size and clearer intent, enhancing readability and maintainability.

Beyond the basic validation, the article extends the idea with two additional generic methods:

validateColumnValueMatchesExpected – verifies that a column’s value matches an expected value, useful for role checks or state transitions.

validateColumnValueInExpectedList – ensures a column’s value belongs to a predefined list, ideal for validating order statuses, allowed roles, etc.

Both methods accept functional parameters for the target column, condition column, condition value, and a query executor, keeping the validation logic abstract and reusable.

Overall, the article illustrates the power of functional programming in Java 8 to abstract repetitive data‑validation patterns, achieve high code reuse, improve clarity, and simplify future extensions.