面向对象设计中新功能放置的考量与实践-js教程-PHP中文网

面向对象设计中新功能放置的考量与实践

DDD

发布： 2025-11-06 15:22:14

原创

798人浏览过

面向对象设计中新功能放置的考量与实践

在面向对象设计中，为新功能选择合适的放置位置，即将其作为现有类的实例方法、静态方法，还是独立服务，并非技术上的优劣之分，而在于如何合理分配职责。本文将深入探讨这一核心原则，结合SOLID/GRASP等设计建议，通过具体案例分析，指导开发者根据业务语义和上下文，为功能找到最符合面向对象理念的归属。

在面向对象编程（OOP）中，当需要设计一个新功能foo，它接收类型A的实例并产生类型B的实例时，开发者常面临两种常见的设计选择：

将foo作为A的实例方法：class A { foo(): B { /* … */ } }
将foo作为B的静态方法：class B { static foo(a: A): B { /* … */ } }

从纯粹的技术实现角度来看，这两种设计方案在功能上可能没有本质区别。然而，面向对象设计的精髓在于职责的合理分配。一个优秀的设计应遵循SOLID原则（单一职责、开放封闭、里氏替换、接口隔离、依赖倒置）和GRASP模式（通用职责分配软件模式），确保每个类和方法都拥有清晰、内聚的职责。因此，选择哪种设计方案，取决于A、B以及foo在特定业务场景中的语义和它们之间的关系。

职责分配的指导原则

在决定功能foo的归属时，我们需要思考以下问题：

foo是A的固有行为吗？它是否改变A的状态或表示A的一个核心操作？
foo是B的创建过程吗？它是否负责根据输入参数构建B的实例？
foo是一个独立的服务或用例，它协调A和B以及其他对象来完成一个更高级别的业务流程吗？

下面通过几个具体的业务场景示例来阐述如何根据职责进行功能设计。

案例分析

1. 领域模型中的行为（A作为主体）

当foo代表A的一个核心业务行为或状态转换时，它自然应该作为A的实例方法。这种情况下，A是执行该行为的主体。

场景示例： 订单（Order）进行下单（Place）操作，产生处理结果（ProcessingResult）。

在这里，Place是Order对象的一个固有行为。Order是“被下单”的对象，它负责执行下单逻辑并返回相应的结果。将Place方法放在Order类中，符合单一职责原则，使得Order类内聚地管理其状态和行为。

public class Order 
{
    private String orderId;
    private double amount;
    // ... 其他订单属性

    /**
     * 执行订单的下单操作。
     * @return 订单处理结果。
     */
    public ProcessingResult Place() {
        // 执行下单逻辑，例如：
        // 1. 验证订单数据
        // 2. 扣减库存
        // 3. 生成支付请求
        // 4. 更新订单状态
        System.out.println("订单 " + orderId + " 正在处理下单请求...");
        // 假设处理成功
        return new ProcessingResult("SUCCESS", "订单 " + orderId + " 下单成功。");
    }
}

public class ProcessingResult {
    private String status;
    private String message;

    public ProcessingResult(String status, String message) {
        this.status = status;
        this.message = message;
    }

    // Getter methods
    public String getStatus() { return status; }
    public String getMessage() { return message; }
}

// 使用示例
// Order myOrder = new Order("ORD001", 100.0);
// ProcessingResult result = myOrder.Place();

登录后复制

2. 工厂方法模式（B作为被创建者）

当foo的职责是根据某些参数创建B的实例时，它通常被设计为B的静态工厂方法，或者一个独立的工厂类的方法。这种情况下，B是“被创建”的对象。

美图设计室

5分钟在线高效完成平面设计，AI帮你做设计

查看详情

场景示例： 根据一组参数（Parameters）创建一个新的B实例。

如果创建B的逻辑相对简单，并且紧密关联B的构造过程，可以将其作为B的静态方法。这使得B类自身承担了部分创建自己的职责，方便使用者通过B.Create(...)直接创建实例。

public class Parameters {
    private String configName;
    private int value;

    public Parameters(String configName, int value) {
        this.configName = configName;
        this.value = value;
    }

    // Getter methods
    public String getConfigName() { return configName; }
    public int getValue() { return value; }
}

public class B {
    private String internalState;

    private B(String state) {
        this.internalState = state;
    }

    /**
     * 根据参数创建B的实例。
     * 这是一个静态工厂方法。
     * @param parameters 用于创建B实例的参数。
     * @return B的实例。
     */
    public static B Create(Parameters parameters) {
        // 根据参数执行创建B的复杂逻辑
        String newState = "Configured with " + parameters.getConfigName() + " and value " + parameters.getValue();
        return new B(newState);
    }

    // Getter methods
    public String getInternalState() { return internalState; }
}

// 使用示例
// Parameters params = new Parameters("SystemConfig", 100);
// B instanceB = B.Create(params);

登录后复制

注意事项： 如果创建逻辑非常复杂，或者需要根据不同参数创建B的不同子类型，那么一个独立的工厂类（例如BFactory）会是更好的选择，以避免B类承担过多的创建职责，保持其单一职责。

3. 用例或服务层操作（独立服务作为协调者）

当foo代表一个更高级别的业务用例或服务操作，它可能涉及协调多个领域对象（包括A和B）来完成一项任务时，将其封装在一个独立的用例类或服务类中是最佳实践。这种模式常见于分层架构，如六边形架构中的应用层（Application Layer）。

场景示例： 执行一个名为FooUseCase的用例，它接收FooUseCaseParameters并产生FooUseCaseResult。

在这种设计中，FooUseCase类扮演了一个协调者的角色，它不直接属于A或B，而是负责驱动一个特定的业务流程。这有助于保持领域模型（A和B）的纯净性，使其专注于业务逻辑，而将业务流程的编排交给用例层。

public class FooUseCaseParameters {
    private String inputData;
    // ... 其他用例参数

    public FooUseCaseParameters(String inputData) {
        this.inputData = inputData;
    }

    public String getInputData() { return inputData; }
}

public class FooUseCaseResult {
    private String outputData;
    private boolean success;
    // ... 其他用例结果

    public FooUseCaseResult(String outputData, boolean success) {
        this.outputData = outputData;
        this.success = success;
    }

    public String getOutputData() { return outputData; }
    public boolean isSuccess() { return success; }
}

public class FooUseCase {
    // 可能需要注入依赖，例如领域服务、存储库等
    // private SomeDomainService domainService; 
    // private ARepository aRepository;
    // private BRepository bRepository;

    /**
     * 执行Foo业务用例。
     * @param useCaseParameters 用例输入参数。
     * @return 用例执行结果。
     */
    public FooUseCaseResult Execute(FooUseCaseParameters useCaseParameters) {
        System.out.println("执行 FooUseCase，输入：" + useCaseParameters.getInputData());

        // 示例：这里可能涉及从存储库获取A，对A执行操作，然后生成B，并保存B等
        // A aInstance = aRepository.getById(useCaseParameters.getAId());
        // B bInstance = aInstance.transformToB(); // 假设A有一个方法可以转换到B
        // bRepository.save(bInstance);

        // 模拟业务逻辑
        String processedData = "Processed: " + useCaseParameters.getInputData().toUpperCase();
        boolean success = true;

        return new FooUseCaseResult(processedData, success);
    }
}

// 使用示例
// FooUseCase useCase = new FooUseCase(); // 实际中可能通过DI框架创建
// FooUseCaseParameters params = new FooUseCaseParameters("sample_input");
// FooUseCaseResult result = useCase.Execute(params);

登录后复制