利用Java Composition设计可扩展的系统架构。

Java Composition是一种设计原则，它强调通过组合和聚合来构建复杂的系统，而不是通过继承。这种设计方法有助于提高系统的可扩展性和灵活性。以下是一个利用Java Composition设计可扩展系统架构的示例：

1. 定义接口和组件

首先，定义一些接口和组件，这些组件将作为系统的构建块。

// 定义一个服务接口
public interface Service {
    void execute();
}

// 实现服务接口的具体组件
public class ServiceA implements Service {
    @Override
    public void execute() {
        System.out.println("ServiceA is executing.");
    }
}

public class ServiceB implements Service {
    @Override
    public void execute() {
        System.out.println("ServiceB is executing.");
    }
}

2. 使用组合来构建复杂系统

接下来，使用组合来构建复杂的系统。可以创建一个容器类，该类包含多个服务，并提供一个方法来执行这些服务。

import java.util.List;

// 定义一个容器类，用于组合多个服务
public class ServiceContainer {
    private List<Service> services;

    public ServiceContainer(List<Service> services) {
        this.services = services;
    }

    public void executeAll() {
        for (Service service : services) {
            service.execute();
        }
    }
}

3. 创建服务组合

现在，可以创建不同的服务组合，以满足不同的业务需求。

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 创建服务实例
        Service serviceA = new ServiceA();
        Service serviceB = new ServiceB();

        // 创建服务组合
        ServiceContainer container1 = new ServiceContainer(Arrays.asList(serviceA));
        ServiceContainer container2 = new ServiceContainer(Arrays.asList(serviceB));
        ServiceContainer container3 = new ServiceContainer(Arrays.asList(serviceA, serviceB));

        // 执行服务组合
        container1.executeAll(); // 输出: ServiceA is executing.
        container2.executeAll(); // 输出: ServiceB is executing.
        container3.executeAll(); // 输出: ServiceA is executing. ServiceB is executing.
    }
}

4. 添加新服务

如果需要添加新的服务，只需实现Service接口并将其添加到服务容器中，而无需修改现有的代码结构。

public class ServiceC implements Service {
    @Override
    public void execute() {
        System.out.println("ServiceC is executing.");
    }
}

// 在主方法中使用新的服务
public class Main {
    public static void main(String[] args) {
        // 创建服务实例
        Service serviceA = new ServiceA();
        Service serviceB = new ServiceB();
        Service serviceC = new ServiceC();

        // 创建服务组合
        ServiceContainer container1 = new ServiceContainer(Arrays.asList(serviceA));
        ServiceContainer container2 = new ServiceContainer(Arrays.asList(serviceB));
        ServiceContainer container3 = new ServiceContainer(Arrays.asList(serviceA, serviceB));
        ServiceContainer container4 = new ServiceContainer(Arrays.asList(serviceA, serviceB, serviceC));

        // 执行服务组合
        container1.executeAll(); // 输出: ServiceA is executing.
        container2.executeAll(); // 输出: ServiceB is executing.
        container3.executeAll(); // 输出: ServiceA is executing. ServiceB is executing.
        container4.executeAll(); // 输出: ServiceA is executing. ServiceB is executing. ServiceC is executing.
    }
}

通过这种方式，系统架构变得灵活且可扩展。添加新服务时，只需实现Service接口并将其添加到服务容器中，而无需修改现有的代码结构。这有助于保持系统的整洁和可维护性。