问题背景：重复的参数校验逻辑
在软件开发中，我们经常会遇到需要对不同但结构相似的数据对象执行相同或类似操作的场景。一个典型的例子是api请求对象（request object）的参数校验。假设我们有两个请求对象 createobjectrequest 和 updateobjectrequest，它们共享大部分字段，并且需要执行几乎相同的校验逻辑。
例如，初始设计可能如下：
// 定义创建对象的请求记录
public record CreateObjectRequest (
CustomObjectA a,
CustomObjectB b,
CustomObjectC c
) {}
// 定义更新对象的请求记录
public record UpdateObjectRequest (
CustomObjectA a,
CustomObjectB b
) {}
// 针对不同请求类型编写独立的校验方法
public class RequestValidator {
public void validateRequest(CreateObjectRequest createObjectRequest) {
// 冗长的校验逻辑，例如检查字段a、b是否为空
if (createObjectRequest.a() == null) {
throw new IllegalArgumentException("字段 a 不能为空");
}
if (createObjectRequest.b() == null) {
throw new IllegalArgumentException("字段 b 不能为空");
}
if (createObjectRequest.c() == null) {
throw new IllegalArgumentException("字段 c 不能为空");
}
// ... 更多校验
}
public void validateRequest(UpdateObjectRequest updateObjectRequest) {
// 几乎相同的校验逻辑，例如检查字段a、b是否为空
if (updateObjectRequest.a() == null) {
throw new IllegalArgumentException("字段 a 不能为空");
}
if (updateObjectRequest.b() == null) {
throw new IllegalArgumentException("字段 b 不能为空");
}
// ... 更多校验
}
}这种方法虽然功能上可行，但导致了显著的代码冗余（validateRequest 方法体大部分内容相同），违反了“Don't Repeat Yourself (DRY)”原则，使得代码难以维护和扩展。当校验逻辑需要修改时，必须在多个地方进行同步更新。
解决方案：抽象父类与继承
为了解决上述代码冗余问题，我们可以利用Java的抽象类和继承机制。核心思想是识别出所有相关请求对象共享的公共字段和行为，并将它们抽象到一个共同的父类中。然后，让具体的请求类继承这个抽象父类，从而实现代码的重用。
1. 定义抽象父类
首先，创建一个抽象父类 ObjectRequest，它包含所有子类共享的字段。为了更好地封装和提供访问器方法，我们将 record 转换为 class 的形式。
立即学习“Java免费学习笔记（深入）”；
// 假设 CustomObjectA, CustomObjectB, CustomObjectC 是已定义的类型
class CustomObjectA {}
class CustomObjectB {}
class CustomObjectC {}
// 定义抽象父类，包含所有请求对象共有的字段
public abstract class ObjectRequest {
protected CustomObjectA a;
protected CustomObjectB b;
public ObjectRequest(CustomObjectA a, CustomObjectB b) {
this.a = a;
this.b = b;
}
// 提供公共字段的访问器方法
public CustomObjectA a() { return a; }
public CustomObjectB b() { return b; }
}2. 实现子类继承
接下来，让 CreateObjectRequest 和 UpdateObjectRequest 继承 ObjectRequest。它们只需要定义各自特有的字段和构造函数。
// CreateObjectRequest 继承 ObjectRequest，并添加特有字段
public class CreateObjectRequest extends ObjectRequest {
private CustomObjectC c;
public CreateObjectRequest(CustomObjectA a, CustomObjectB b, CustomObjectC c) {
super(a, b); // 调用父类构造函数初始化公共字段
this.c = c;
}
public CustomObjectC c() { return c; }
}
// UpdateObjectRequest 继承 ObjectRequest，只使用公共字段
public class UpdateObjectRequest extends ObjectRequest {
public UpdateObjectRequest(CustomObjectA a, CustomObjectB b) {
super(a, b); // 调用父类构造函数初始化公共字段
}
}3. 编写通用校验方法
现在，我们可以编写一个通用的 validateRequest 方法，它接受 ObjectRequest 类型的参数。由于多态性，这个方法可以接受 CreateObjectRequest 或 UpdateObjectRequest 的任何实例。
public class RequestValidator {
public void validateRequest(ObjectRequest objectRequest) {
// 校验公共字段
if (objectRequest.a() == null) {
throw new IllegalArgumentException("公共字段 a 不能为空");
}
if (objectRequest.b() == null) {
throw new IllegalArgumentException("公共字段 b 不能为空");
}
// 如果需要处理子类特有字段，可以使用 instanceof 运算符进行类型检查和向下转型
if (objectRequest instanceof CreateObjectRequest createRequest) {
if (createRequest.c() == null) {
throw new IllegalArgumentException("CreateObjectRequest 特有字段 c 不能为空");
}
}
// 可以在这里添加更多通用的校验逻辑
System.out.println("请求校验成功！");
}
public static void main(String[] args) {
RequestValidator validator = new RequestValidator();
// 测试 CreateObjectRequest
CreateObjectRequest createReq1 = new CreateObjectRequest(new CustomObjectA(), new CustomObjectB(), new CustomObjectC());
validator.validateRequest(createReq1); // 校验成功
// 测试 CreateObjectRequest 字段缺失
try {
CreateObjectRequest createReq2 = new CreateObjectRequest(null, new CustomObjectB(), new CustomObjectC());
validator.validateRequest(createReq2);
} catch (IllegalArgumentException e) {
System.out.println("校验失败: " + e.getMessage()); // 输出: 公共字段 a 不能为空
}
// 测试 UpdateObjectRequest
UpdateObjectRequest updateReq1 = new UpdateObjectRequest(new CustomObjectA(), new CustomObjectB());
validator.validateRequest(updateReq1); // 校验成功
// 测试 UpdateObjectRequest 字段缺失
try {
UpdateObjectRequest updateReq2 = new UpdateObjectRequest(new CustomObjectA(), null);
validator.validateRequest(updateReq2);
} catch (IllegalArgumentException e) {
System.out.println("校验失败: " + e.getMessage()); // 输出: 公共字段 b 不能为空
}
}
}优点与注意事项
优点：
- 减少代码冗余： 将共享的校验逻辑集中在一个方法中，避免了重复编写相同的代码。
- 提高可维护性： 当校验规则发生变化时，只需修改 validateRequest(ObjectRequest) 方法，而无需在多个地方进行改动。
- 增强可扩展性： 如果未来需要引入新的请求类型（例如 DeleteObjectRequest），只需让它继承 ObjectRequest，即可直接利用现有的通用校验方法，无需修改校验器本身。
- 遵循DRY原则： 有效地实践了“Don't Repeat Yourself”原则，提高了代码质量。
- 清晰的结构： 通过继承关系，清晰地表达了不同请求对象之间的共同性。
注意事项：
- 过度抽象： 并非所有相似的类都适合通过继承来抽象。如果类之间只有少数字段或行为相似，且它们在概念上不属于“is-a”关系（即子类“是”父类的一种），那么过度使用继承可能导致复杂的类层次结构。在这种情况下，组合（Composition）或接口（Interfaces）可能是更好的选择。
- 子类特有逻辑： 当通用方法需要处理子类特有的逻辑时，如示例中对 CreateObjectRequest 的 c 字段的校验，需要使用 instanceof 运算符进行类型检查和向下转型。这在一定程度上增加了通用方法的复杂性，但通常是可接受的。如果子类特有逻辑非常复杂且多样，可能需要考虑在子类中覆盖一个抽象方法，或者使用访问者模式。
- 字段可见性： 在抽象父类中，公共字段通常声明为 protected 或通过 public 访问器方法暴露，以便子类可以访问或通过公共接口进行操作。
总结
通过引入抽象父类和利用Java的继承与多态机制，我们可以有效地解决为结构相似但类型不同的参数编写重复方法的问题。这种设计模式不仅减少了代码冗余，提高了代码的可维护性和扩展性，也使得代码结构更加清晰和专业。在面对具有共同属性和行为的不同实体时，抽象和继承是构建健壮、可重用Java代码的强大工具。
