swift 私有库之间相互依赖的解决方案

注：本章cocoapods创建私有库的方式不做阐述，主要解决私有库之间的相互依赖以及相互调用的场景。

在iOS中，如果你有两个私有库A和B相互依赖，并且你想要定义一个接口层来隔离它们之间的方法，你可以采用以下步骤：

1、创建接口库C：

创建一个新的私有库C，作为A和B的接口库。在这个库中，你需要包含A和B之间需要相互调用的方法的协议声明

// ModuleC.swift

import Foundation

public protocol ModuleAProtocol: AnyObject {
    func methodInModuleA()
}

public protocol ModuleBProtocol: AnyObject {
    func methodInModuleB()
}

2、A 模块依赖 C 并实现协议：

// ModuleA.swift

import Foundation
import ModuleC

public class ModuleA: ModuleAProtocol {
    public init() {}

    public func methodInModuleA() {
        print("ModuleA: Method in Module A")
    }

    public func callModuleB() {
        // 获取 ModuleB 实例并调用其方法（协议管理器注册相应模块就可以使用啦！）
        if let moduleB = ProtocolManager.serviceProvideInstanceMethod(forProtocolName: "ModuleBProtocol") as? ModuleBProtocol {
            moduleB.methodInModuleB()
        }
    }
}

3、B 模块依赖 C 并实现协议：

// ModuleB.swift

import Foundation
import ModuleC

public class ModuleB: ModuleBProtocol {
    public init() {}

    public func methodInModuleB() {
        print("ModuleB: Method in Module B")
    }

    public func callModuleA() {
        // 获取 ModuleA 实例并调用其方法
        if let moduleA = ProtocolManager.serviceProvideInstanceMethod(forProtocolName: "ModuleAProtocol") as? ModuleAProtocol {
            moduleA.methodInModuleA()
        }
    }
}

4、定义协议管理器（此部分针对项目结构，可以放在公共的依赖base或common里面）

// ProtocolManager.swift

import Foundation

class ProtocolManager {
    private static var implementations: [String: Any] = [:]

    static func registerImplementation<T>(_ implementation: T, forProtocolName protocolName: String) {
        implementations[protocolName] = implementation
    }

    static func serviceProvideInstanceMethod<T>(forProtocolName protocolName: String) -> T? {
        return implementations[protocolName] as? T
    }
}

5、组装模块并注册到协议管理器（默认已经在主工程依赖A和B模块）：
在应用程序的入口处，创建模块的实例并注册到协议管理器：

let userModule = UserModule()
let orderModule = OrderModule()

ProtocolManager.registerImplementation(userModule, forProtocolName: "UserModuleProtocol")
ProtocolManager.registerImplementation(orderModule, forProtocolName: "OrderModuleProtocol")

通过这种方式，A 和 B 模块通过中间的私有库 C 进行了解耦。模块 A 通过协议管理器调用模块 B 中的方法，而两者之间没有直接的依赖关系。这种模块化的设计可以使得模块 A 和 B 在私有库 C 的桥梁下相互通信。