Refactoring Data Validation with Java 8 Functional Interfaces and SFunction

Introduction

In Java development we often encounter repetitive validation code that makes projects bulky and hard to maintain. Java 8 introduces functional programming features, such as the Function interface, which provide a powerful way to eliminate this duplication.

Background: Data‑validation Pain Points

Typical business systems need to verify whether a field value exists and meets expectations. Traditional implementations repeat similar query logic for each entity, leading to verbose and hard‑to‑maintain code. The article shows two simple methods that check user‑ID and department‑ID validity, each containing duplicated DAO calls and null checks.

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

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

Java 8 Magic: Functional Interfaces

Java 8 defines functional interfaces; the most basic is Function<T,R> . In MyBatis‑Plus, SFunction is a further wrapper around lambda expressions that allows flexible manipulation of entity attributes.

Practical Refactor: Generic Assertion Method

The following generic method ensureColumnValueValid uses functional interfaces to validate any column value of any entity, reducing duplication:

/**
 * Confirm database field value is valid (generic)
 * @param
Type of the value to check
 * @param valueToCheck   The value to validate
 * @param columnExtractor   Entity attribute extractor
 * @param queryExecutor   Single‑row query executor
 * @param errorMessage   Exception message template
 */
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 previous validation logic becomes concise:

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 …
}

Comparison

Before refactor each validation required its own method with duplicated DAO calls. After refactor the code size shrinks dramatically and the intent becomes clearer, improving readability and maintainability.

Advantages

Reduced duplicate code: All column‑value checks share a single reusable method.

Enhanced reusability: The generic method works for any entity and any attribute.

Improved readability: Lambda expressions express the validation intent directly.

Flexibility and extensibility: Changing validation rules only requires updating the single utility method.

Extending Validation Logic

Assert column value equals expected value

The method validateColumnValueMatchesExpected adds a condition column and compares the actual value with an expected one:

/**
 * Verify that a column value matches the expected value.
 */
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));
    }
}

Example usage in a permission‑management scenario:

validateColumnValueMatchesExpected(User::getRoleType, "普通用户", User::getId, userId, userMapper::getOne, "用户角色不是普通用户，无法升级为管理员！");

Assert column value is within an expected list

The method validateColumnValueInExpectedList checks whether the retrieved column value belongs to a predefined list:

/**
 * Verify that a column value is in the expected list.
 */
public static
void validateColumnValueInExpectedList(
        SFunction
targetColumn, List
expectedValueList,
        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 (actualValue == null) throw new RuntimeException("列查询结果为空");
    if (!expectedValueList.contains(actualValue)) {
        throw new RuntimeException(errorMessage);
    }
}

Example in an e‑commerce order‑cancellation flow:

List
cancelableStatuses = Arrays.asList(OrderStatusEnum.WAITING_PAYMENT.getValue(), OrderStatusEnum.WAITING_DELIVERY.getValue());
validateColumnValueInExpectedList(Order::getStatus, cancelableStatuses, Order::getOrderId, orderId, orderMapper::selectOne, "订单当前状态不允许取消！");

Core Benefits

Code reuse: Generic, lambda‑driven validation works for any entity.

Clear intent: Method signatures convey purpose directly.

Flexibility: Callers only need to supply a few lambdas; underlying query details stay hidden.

Maintainability: Updating validation logic in one place instantly propagates to all callers.

Power of Functional Programming

By embracing Java 8 functional programming, developers can write more concise, flexible, and testable code. The patterns shown here are applicable to everyday backend development and system design, encouraging a shift toward cleaner, more maintainable Java codebases.