如何利用Java继承和多态性优化重复的验证逻辑_技术教程

本文旨在解决Java中因处理不同但结构相似的对象类型而导致的验证逻辑重复问题。通过引入抽象父类和多态性，可以有效消除冗余代码，实现统一的验证方法，从而提高代码的可维护性、可扩展性，并遵循DRY（Don't Repeat Yourself）原则。

消除Java中相似类型验证逻辑重复的策略

在软件开发中，我们经常会遇到需要对结构相似但类型不同的数据对象执行相同或大部分相同的操作（例如验证）的场景。一个典型的例子是处理创建请求（createobjectrequest）和更新请求（updateobjectrequest），它们可能共享许多相同的字段，并且需要经过相同的验证规则。然而，如果为每种类型都编写一个独立的验证方法，会导致大量的代码重复，降低可维护性。

问题场景描述

考虑以下两个Java record 类型，它们分别用于创建和更新操作：

public record CreateObjectRequest (
    CustomObjectA a,
    CustomObjectB b,
    CustomObjectC c
) {}

public record UpdateObjectRequest (
    CustomObjectA a,
    CustomObjectB b
) {}

如果我们需要对这两种请求执行相同的验证逻辑，一个直观但效率低下的做法是为每种类型创建一个重载的验证方法：

public class RequestValidator {
    public void validateRequest(CreateObjectRequest createObjectRequest) {
        // 大量的验证逻辑，例如：
        // if (createObjectRequest.a() == null) { throw new IllegalArgumentException("A cannot be null"); }
        // if (createObjectRequest.b() == null) { throw new IllegalArgumentException("B cannot be null"); }
        // ...
    }

    public void validateRequest(UpdateObjectRequest updateObjectRequest) {
        // 与上述方法几乎相同的验证逻辑
        // if (updateObjectRequest.a() == null) { throw new IllegalArgumentException("A cannot be null"); }
        // if (updateObjectRequest.b() == null) { throw new IllegalArgumentException("B cannot be null"); }
        // ...
    }
}

这种方法导致了显著的代码重复（"long body"），使得修改验证规则时需要同时修改多个地方，增加了出错的风险和维护成本。

解决方案：利用继承和多态性

为了解决这种代码重复问题，我们可以利用Java的继承和多态性特性。核心思想是识别出不同请求对象之间的共同点，并将这些共同点抽象到一个父类中。

创建抽象父类

首先，定义一个抽象父类，例如 ObjectRequest，它包含所有子类共享的字段。请注意，Java record 类型不能直接继承其他类（除了 java.lang.Record），因此，为了实现继承，我们需要将 record 类型转换为传统的 class 类型。

public abstract class ObjectRequest {
    protected CustomObjectA a;
    protected CustomObjectB b;

    // 构造函数、getter方法等（如果需要）
    public ObjectRequest(CustomObjectA a, CustomObjectB b) {
        this.a = a;
        this.b = b;
    }

    public CustomObjectA getA() {
        return a;
    }

    public CustomObjectB getB() {
        return b;
    }
}

子类继承抽象父类

然后，让 CreateObjectRequest 和 UpdateObjectRequest 继承这个抽象父类，并添加它们各自特有的字段。

public class CreateObjectRequest extends ObjectRequest {
    private CustomObjectC c; // CreateObjectRequest 特有的字段

    public CreateObjectRequest(CustomObjectA a, CustomObjectB b, CustomObjectC c) {
        super(a, b);
        this.c = c;
    }

    public CustomObjectC getC() {
        return c;
    }
    // 其他特定于CreateObjectRequest的方法
}

public class UpdateObjectRequest extends ObjectRequest {
    // UpdateObjectRequest 可能没有特有字段，或者有其他特定字段
    public UpdateObjectRequest(CustomObjectA a, CustomObjectB b) {
        super(a, b);
    }
    // 其他特定于UpdateObjectRequest的方法
}

统一验证方法

最后，将验证方法修改为接受抽象父类 ObjectRequest 作为参数。这样，无论是 CreateObjectRequest 还是 UpdateObjectRequest 的实例，都可以作为 ObjectRequest 类型传递给同一个验证方法。

public class RequestValidator {
    public void validateRequest(ObjectRequest objectRequest) {
        // 统一的验证逻辑
        if (objectRequest.getA() == null) {
            throw new IllegalArgumentException("Field A cannot be null.");
        }
        if (objectRequest.getB() == null) {
            throw new IllegalArgumentException("Field B cannot be null.");
        }

        // 如果需要验证子类特有的字段，可以使用 instanceof 进行类型检查和向下转型
        if (objectRequest instanceof CreateObjectRequest createRequest) {
            if (createRequest.getC() == null) {
                throw new IllegalArgumentException("Field C cannot be null for Create request.");
            }
        }
        // 更多验证逻辑...
    }
}

优点与注意事项

减少代码重复（DRY原则）：核心验证逻辑只需编写一次，极大地减少了冗余代码。
提高可维护性：当验证规则发生变化时，只需修改一个地方。
增强可扩展性：如果将来引入新的请求类型（如 DeleteObjectRequest），只要它继承 ObjectRequest，就可以直接使用现有的验证方法，或者只添加少量特定验证逻辑。
清晰的类型层级：通过继承，明确了不同请求对象之间的“is-a”关系，提高了代码的可读性和结构性。

注意事项：

Record类型限制：如前所述，Java record 类型不能直接继承普通类。如果必须使用 record 类型，可以考虑使用接口（Interface）来定义共同的行为，但这通常不适用于共享字段的场景。对于共享字段和行为，将 record 转换为 class 是更直接的解决方案。
字段访问修饰符：在父类中，如果子类需要直接访问父类的字段，可以使用 protected 修饰符。否则，通过 getter 方法访问是更好的实践。
子类特定验证：如果子类有自己特有的字段或需要额外的验证规则，可以在统一验证方法内部使用 instanceof 运算符进行类型检查，并进行相应的向下转型来访问子类特有的属性和执行特定验证。