Java中利用抽象父类和多态优化多类型参数的通用方法验证-java教程-PHP中文网

Java中利用抽象父类和多态优化多类型参数的通用方法验证

本文探讨了在Java中处理具有相似结构但类型不同的对象时，如何避免重复的验证逻辑。通过引入抽象父类和多态性，可以将多个重载方法合并为一个，从而大幅减少代码冗余，提高可维护性和扩展性。这种方法尤其适用于共享大量公共字段和验证规则的请求或数据模型。

在软件开发中，我们经常会遇到需要对结构相似但类型不同的对象执行相同操作的场景。例如，一个api可能定义了用于创建资源和更新资源的请求对象，它们通常共享大部分字段和验证规则。如果为每种请求类型都编写一个独立的、内容几乎完全相同的处理方法，会导致大量的代码重复和维护负担。

问题描述：重复的验证逻辑

考虑以下Java记录类型，它们分别代表创建对象和更新对象的请求：

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

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

登录后复制

假设这两个请求对象都需要通过一个工具方法进行验证，并且验证逻辑对字段 a 和 b 是完全相同的。如果采用方法重载的方式，代码可能会变得冗长：

public class RequestValidator {
    public void validateRequest(CreateObjectRequest createObjectRequest) {
        // 对字段 a 和 b 进行验证的冗长逻辑
        // ...
        // 可能还有对字段 c 的特定验证
    }

    public void validateRequest(UpdateObjectRequest updateObjectRequest) {
        // 对字段 a 和 b 进行验证的相同冗长逻辑
        // ...
    }
}

登录后复制

这种模式的缺点在于，一旦字段 a 或 b 的验证规则发生变化，开发者需要修改所有重载的方法，容易出错且效率低下。

解决方案：引入抽象父类与多态

为了解决上述问题，我们可以利用Java的继承和多态特性。核心思想是识别这些请求对象之间的共同点，并将这些共同点抽象到一个父类中。然后，让具体的请求类型继承这个父类，从而实现对共享逻辑的统一处理。

立即学习“Java免费学习笔记（深入）”；

1. 定义抽象父类

首先，创建一个抽象父类 ObjectRequest，它包含所有子类共享的字段（例如 CustomObjectA a 和 CustomObjectB b）。

YOYA优雅

多模态AI内容创作平台

106

查看详情

// 辅助类定义，简化示例
public record CustomObjectA(String valueA) {}
public record CustomObjectB(int valueB) {}
public record CustomObjectC(boolean valueC) {}

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

    public ObjectRequest(CustomObjectA a, CustomObjectB b) {
        this.a = a;
        this.b = b;
    }

    public CustomObjectA getA() { return a; }
    public CustomObjectB getB() { return b; }
}

登录后复制

2. 子类继承抽象父类

接下来，让 CreateObjectRequest 和 UpdateObjectRequest 记录类型继承 ObjectRequest。需要注意的是，当记录类型继承一个类时，其主构造函数需要调用父类的构造函数来初始化继承的字段。

public record CreateObjectRequest(CustomObjectA a, CustomObjectB b, CustomObjectC c) extends ObjectRequest {
    public CreateObjectRequest { // 紧凑构造函数
        super(a, b); // 调用父类构造函数初始化 a 和 b
    }
    // 字段 a, b, c 的访问器由记录类型自动生成
}

public record UpdateObjectRequest(CustomObjectA a, CustomObjectB b) extends ObjectRequest {
    public UpdateObjectRequest { // 紧凑构造函数
        super(a, b); // 调用父类构造函数初始化 a 和 b
    }
    // 字段 a, b 的访问器由记录类型自动生成
}

登录后复制

3. 重构通用验证方法

有了共同的父类 ObjectRequest，现在可以将验证方法重构为只接受 ObjectRequest 类型参数的单个方法。通过多态性，这个方法将能够处理 CreateObjectRequest 和 UpdateObjectRequest 的实例。

public class RequestValidator {
    public void validateRequest(ObjectRequest objectRequest) {
        // 对字段 a 和 b 进行的通用验证逻辑
        System.out.println("Executing common validation for fields 'a' and 'b'...");
        if (objectRequest.getA() == null || objectRequest.getA().valueA().isEmpty()) {
            throw new IllegalArgumentException("CustomObjectA cannot be null or empty.");
        }
        if (objectRequest.getB() == null || objectRequest.getB().valueB() < 0) {
            throw new IllegalArgumentException("CustomObjectB cannot be null or negative.");
        }
        System.out.println("Common validation passed for fields 'a' and 'b'.");

        // 如果存在特定于子类的验证，可以在这里使用 instanceof 进行判断和向下转型
        if (objectRequest instanceof CreateObjectRequest createRequest) {
            System.out.println("Executing specific validation for CreateObjectRequest...");
            if (createRequest.c() == null) {
                throw new IllegalArgumentException("CustomObjectC cannot be null for CreateObjectRequest.");
            }
            System.out.println("Specific validation for CustomObjectC passed.");
        }
        // 如果 UpdateObjectRequest 有特有字段，也类似处理
    }
}

登录后复制

示例代码

以下是一个完整的示例，展示了如何使用这种模式：

// 辅助类定义
public record CustomObjectA(String valueA) {}
public record CustomObjectB(int valueB) {}
public record CustomObjectC(boolean valueC) {}

// 抽象父类
public abstract class ObjectRequest {
    protected CustomObjectA a;
    protected CustomObjectB b;

    public ObjectRequest(CustomObjectA a, CustomObjectB b) {
        this.a = a;
        this.b = b;
    }

    public CustomObjectA getA() { return a; }
    public CustomObjectB getB() { return b; }
}

// 子类：CreateObjectRequest
public record CreateObjectRequest(CustomObjectA a, CustomObjectB b, CustomObjectC c) extends ObjectRequest {
    public CreateObjectRequest {
        super(a, b);
    }
}

// 子类：UpdateObjectRequest
public record UpdateObjectRequest(CustomObjectA a, CustomObjectB b) extends ObjectRequest {
    public UpdateObjectRequest {
        super(a, b);
    }
}

// 统一验证器
public class RequestValidator {
    public void validateRequest(ObjectRequest objectRequest) {
        System.out.println("--- Starting validation for: " + objectRequest.getClass().getSimpleName() + " ---");

        // 通用验证逻辑 (适用于所有 ObjectRequest 的子类)
        if (objectRequest.getA() == null || objectRequest.getA().valueA() == null || objectRequest.getA().valueA().isEmpty()) {
            throw new IllegalArgumentException("Error: CustomObjectA value cannot be null or empty.");
        }
        if (objectRequest.getB() == null || objectRequest.getB().valueB() < 0) {
            throw new IllegalArgumentException("Error: CustomObjectB value cannot be null or negative.");
        }
        System.out.println("Common validation for A and B passed.");

        // 特定于子类的验证逻辑
        if (objectRequest instanceof CreateObjectRequest createRequest) {
            System.out.println("Performing specific validation for CreateObjectRequest...");
            if (createRequest.c() == null) {
                throw new IllegalArgumentException("Error: CustomObjectC cannot be null for CreateObjectRequest.");
            }
            System.out.println("Specific validation for C passed.");
        }
        // 如果 UpdateObjectRequest 有特有字段，也类似处理

        System.out.println("Validation successful for " + objectRequest.getClass().getSimpleName() + ".\n");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        RequestValidator validator = new RequestValidator();

        // 示例 1: 有效的 CreateObjectRequest
        CreateObjectRequest validCreateReq = new CreateObjectRequest(
            new CustomObjectA("valueA1"),
            new CustomObjectB(10),
            new CustomObjectC(true)
        );
        try {
            validator.validateRequest(validCreateReq);
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage());
        }

        // 示例 2: 有效的 UpdateObjectRequest
        UpdateObjectRequest validUpdateReq = new UpdateObjectRequest(
            new CustomObjectA("valueA2"),
            new CustomObjectB(20)
        );
        try {
            validator.validateRequest(validUpdateReq);
        } catch (IllegalArgumentException e) {
            System.err.println(e.getMessage());
        }

        // 示例 3: 无效的 CreateObjectRequest (CustomObjectA 为空)
        CreateObjectRequest invalidCreateReqA = new CreateObjectRequest(
            new CustomObjectA(""), // Invalid
            new CustomObjectB(10),
            new CustomObjectC(true)
        );
        try {
            validator.validateRequest(invalidCreateReqA);
        } catch (IllegalArgumentException e) {
            System.err.println("Caught error for invalidCreateReqA: " + e.getMessage() + "\n");
        }

        // 示例 4: 无效的 CreateObjectRequest (CustomObjectC 为空)
        CreateObjectRequest invalidCreateReqC = new CreateObjectRequest(
            new CustomObjectA("valueA3"),
            new CustomObjectB(10),
            null // Invalid
        );
        try {
            validator.validateRequest(invalidCreateReqC);
        } catch (IllegalArgumentException e) {
            System.err.println("Caught error for invalidCreateReqC: " + e.getMessage() + "\n");
        }

        // 示例 5: 无效的 UpdateObjectRequest (CustomObjectB 为负数)
        UpdateObjectRequest invalidUpdateReqB = new UpdateObjectRequest(
            new CustomObjectA("valueA4"),
            new CustomObjectB(-5) // Invalid
        );
        try {
            validator.validateRequest(invalidUpdateReqB);
        } catch (IllegalArgumentException e) {
            System.err.println("Caught error for invalidUpdateReqB: " + e.getMessage() + "\n");
        }
    }
}

登录后复制

注意事项

适用场景： 这种模式最适用于当多个类型共享大量字段和处理逻辑时。如果类型之间的共同点很少，或者它们的处理逻辑差异很大，那么强行引入继承可能导致类层次结构复杂化，反而降低可读性。
Liskov替换原则： 确保子类可以在任何需要父类的地方被替换，而不会破坏程序的正确性。这意味着父类中定义的行为和属性必须对所有子类都适用。
特定字段的验证： 在 validateRequest(ObjectRequest objectRequest) 方法中，只能直接访问 ObjectRequest 中定义的字段 (a 和 b)。如果子类有其特有的字段（如 CreateObjectRequest 中的 c），并且这些字段也需要验证，则需要在通用方法内部使用 instanceof 运算符进行类型检查和向下转型，然后执行特定验证。虽然这引入了一点类型耦合，但它将所有验证逻辑集中在一个地方，通常比完全独立的重载方法更易于管理。
接口替代方案： 如果共享的不是数据结构而是行为（即没有共同的字段，只有共同的方法），那么使用接口会是更合适的选择。