如何避免单例模式？6个类单次实例化及依赖实现方案咨询

阿华AIGC实验室

2026-5-22

嘿，这个需求其实用**依赖注入（Dependency Injection）**的思路就能完美解决，完全不用单例模式，还能清晰管控每个对象的实例化次数和依赖关系。我给你拆解下具体怎么实现：

核心思路

我们不在类内部自行创建依赖对象，而是在应用的统一入口（比如主函数）集中创建所有实例，再把每个类需要的依赖通过构造函数传递进去。这样既能严格控制每个类只实例化一次，还能解耦类之间的依赖关系，比单例模式更灵活、更易维护。

具体实现步骤

给每个类定义带依赖参数的构造函数：比如Server1的构造函数接收A对象，Server2的构造函数接收A、B、C、Server1对象；A/B/C的构造函数接收Info对象。
按照你要求的顺序在入口处创建实例：
- 第一步：创建Info实例，完成文件读取操作
- 第二步：用Info实例创建A、B、C的实例
- 第三步：用A实例创建Server1
- 第四步：用A、B、C、Server1实例创建Server2

代码示例（以Java为例，其他语言逻辑完全一致）

首先定义各个类：

// Info类：负责读取系统信息
public class Info {
    public Info() {
        // 这里写从文件读取系统信息的逻辑
        System.out.println("Info已完成系统信息读取");
    }
    // 可以添加读取到的信息字段和get方法
}

// A类：依赖Info
public class A {
    private final Info systemInfo;
    
    public A(Info systemInfo) {
        this.systemInfo = systemInfo;
        System.out.println("A实例已创建");
    }
    // A的业务方法
}

// B类：依赖Info
public class B {
    private final Info systemInfo;
    
    public B(Info systemInfo) {
        this.systemInfo = systemInfo;
        System.out.println("B实例已创建");
    }
    // B的业务方法
}

// C类：依赖Info
public class C {
    private final Info systemInfo;
    
    public C(Info systemInfo) {
        this.systemInfo = systemInfo;
        System.out.println("C实例已创建");
    }
    // C的业务方法
}

// Server1类：依赖A
public class Server1 {
    private final A aInstance;
    
    public Server1(A aInstance) {
        this.aInstance = aInstance;
        System.out.println("Server1实例已创建");
    }
    // Server1的业务方法
}

// Server2类：依赖A、B、C、Server1
public class Server2 {
    private final A aInstance;
    private final B bInstance;
    private final C cInstance;
    private final Server1 server1;
    
    public Server2(A aInstance, B bInstance, C cInstance, Server1 server1) {
        this.aInstance = aInstance;
        this.bInstance = bInstance;
        this.cInstance = cInstance;
        this.server1 = server1;
        System.out.println("Server2实例已创建");
    }
    // Server2的业务方法
}

然后在应用入口统一创建所有实例：

public class AppEntry {
    public static void main(String[] args) {
        // 1. 先创建Info对象，完成文件读取
        Info systemInfo = new Info();
        
        // 2. 基于Info创建A、B、C
        A a = new A(systemInfo);
        B b = new B(systemInfo);
        C c = new C(systemInfo);
        
        // 3. 创建Server1，传入依赖的A对象
        Server1 server1 = new Server1(a);
        
        // 4. 创建Server2，传入所有依赖的对象
        Server2 server2 = new Server2(a, b, c, server1);
        
        // 后续可以使用server1和server2处理业务逻辑
    }
}

方案优势