Swinject源码导读

Sources/
├── Container.swift                 # 核心容器：注册、解析、对象图管理
├── Container.Arguments.swift       # 带参数的注册/解析（ERB 自动生成，支持 1~9 个参数）
├── Container.TypeForwarding.swift  # 类型转发：forward(_:to:)
├── Container.Logging.swift         # 日志功能
├── Resolver.swift                  # Resolver 协议定义（ERB 自动生成）
├── _Resolver.swift                 # 内部 _Resolver 协议，供扩展使用
├── ServiceEntry.swift              # 服务注册条目
├── ServiceEntry.TypeForwarding.swift # implements() 类型转发扩展
├── ServiceKey.swift                # 服务查找键（ServiceType + ArgumentsType + Name + Option）
├── ObjectScope.swift               # 对象作用域协议与基类
├── ObjectScope.Standard.swift      # 四种标准作用域定义
├── InstanceStorage.swift           # 实例存储协议与五种实现
├── GraphIdentifier.swift           # 对象图唯一标识
├── InstanceWrapper.swift           # Lazy / Provider / Optional 包装器
├── Assembler.swift                 # 模块化组装器
├── Assembly.swift                  # Assembly 协议
├── Behavior.swift                  # 行为扩展协议
├── RecursiveLock.swift             # 递归锁封装
├── DebugHelper.swift               # 调试辅助（解析失败日志）
├── FunctionType.swift              # 工厂闭包类型别名
└── UnavailableItems.swift          # v1 -> v2 迁移标记

// 注册：告诉容器"当需要 Animal 时，创建一个 Cat"
container.register(Animal.self) { _ in Cat() }

// 解析：从容器中获取 Animal 的实例
let animal = container.resolve(Animal.self)!

internal struct ServiceKey {
    internal let serviceType: Any.Type
    internal let argumentsType: Any.Type
    internal let name: String?
    internal let option: ServiceKeyOption?
}

extension ServiceKey: Hashable {
    public func hash(into hasher: inout Hasher) {
        ObjectIdentifier(serviceType).hash(into: &hasher)
        ObjectIdentifier(argumentsType).hash(into: &hasher)
        name?.hash(into: &hasher)
        option?.hash(into: &hasher)
    }
}

container.register(Animal.self) { _ in Cat() }                     // argumentsType = (Resolver)
container.register(Animal.self) { (_, name: String) in Cat(name) }  // argumentsType = (Resolver, String)

public final class ServiceEntry<Service>: ServiceEntryProtocol {
    internal let serviceType: Any.Type
    internal let argumentsType: Any.Type
    internal let factory: FunctionType    // 实际是 Any，存储工厂闭包
    internal weak var container: Container?

    internal var objectScope: ObjectScopeProtocol = ObjectScope.graph
    internal lazy var storage: InstanceStorage = { [unowned self] in
        self.objectScope.makeStorage()
    }()

    fileprivate var initCompletedActions: [(Resolver, Service) -> Void] = []
}

container.register(Animal.self) { _ in Cat() }
    .inObjectScope(.container)          // 设置作用域
    .initCompleted { resolver, cat in   // 初始化完成回调
        cat.friend = resolver.resolve(Animal.self)
    }
    .implements(Cat.self)               // 类型转发

internal var initCompleted: FunctionType? {
    guard !initCompletedActions.isEmpty else { return nil }

    return { [weak self] (resolver: Resolver, service: Any) -> Void in
        guard let strongSelf = self else { return }
        strongSelf.initCompletedActions.forEach { $0(resolver, service as! Service) }
    }
}

internal typealias FunctionType = Any

public final class Container {
    internal var services = [ServiceKey: ServiceEntryProtocol]()
    private let parent: Container?
    private var resolutionDepth = 0
    private let debugHelper: DebugHelper
    private let defaultObjectScope: ObjectScope
    private let synchronized: Bool
    internal var currentObjectGraph: GraphIdentifier?
    internal let lock: RecursiveLock
    internal var behaviors = [Behavior]()
}

@discardableResult
public func register<Service>(
    _ serviceType: Service.Type,
    name: String? = nil,
    factory: @escaping (Resolver) -> Service
) -> ServiceEntry<Service> {
    return _register(serviceType, factory: factory, name: name)
}

public func _register<Service, Arguments>(
    _ serviceType: Service.Type,
    factory: @escaping (Arguments) -> Any,
    name: String? = nil,
    option: ServiceKeyOption? = nil
) -> ServiceEntry<Service> {
    let key = ServiceKey(serviceType: Service.self, argumentsType: Arguments.self, name: name, option: option)
    let entry = ServiceEntry(
        serviceType: serviceType,
        argumentsType: Arguments.self,
        factory: factory,
        objectScope: defaultObjectScope
    )
    entry.container = self
    services[key] = entry

    behaviors.forEach { $0.container(self, didRegisterType: serviceType, toService: entry, withName: name) }

    return entry
}

fileprivate func resolve<Service, Factory>(
    entry: ServiceEntryProtocol,
    invoker: @escaping (Factory) -> Any
) -> Service? {
    let resolution: () -> Service? = { [self] in
        self.incrementResolutionDepth()
        defer { self.decrementResolutionDepth() }

        guard let currentObjectGraph = self.currentObjectGraph else {
            fatalError("If accessing container from multiple threads, make sure to use a synchronized resolver.")
        }

        // 1. 先检查是否已有持久化实例（处理循环依赖和 container scope）
        if let persistedInstance = self.persistedInstance(Service.self, from: entry, in: currentObjectGraph) {
            return persistedInstance
        }

        // 2. 调用工厂闭包创建新实例
        let resolvedInstance = invoker(entry.factory as! Factory)

        // 3. 再次检查（factory 内部可能触发了同一 entry 的解析）
        if let persistedInstance = self.persistedInstance(Service.self, from: entry, in: currentObjectGraph) {
            return persistedInstance
        }

        // 4. 存入 storage
        entry.storage.setInstance(resolvedInstance as Any, inGraph: currentObjectGraph)

        // 5. 执行 initCompleted 回调
        if let completed = entry.initCompleted as? (Resolver, Any) -> Void,
            let resolvedInstance = resolvedInstance as? Service {
            completed(self, resolvedInstance)
        }

        return resolvedInstance as? Service
    }

    if synchronized {
        return lock.sync { return resolution() }
    } else {
        return resolution()
    }
}

public struct GraphIdentifier: Identifiable {
    public let id = UUID()
}

let parent = Container()
parent.register(Animal.self) { _ in Cat() }

let child = Container(parent: parent)
child.resolve(Animal.self) // 在子容器中找不到，会向上查找父容器

fileprivate func getEntry(for key: ServiceKey) -> ServiceEntryProtocol? {
    if let entry = services[key] {
        return entry
    } else {
        return parent?.getEntry(for: key)
    }
}

internal init(parent: Container? = nil, ...) {
    lock = parent.map { $0.lock } ?? RecursiveLock()
}

public func synchronize() -> Resolver {
    return Container(parent: self,
                     debugHelper: debugHelper,
                     defaultObjectScope: defaultObjectScope,
                     synchronized: true)
}

if synchronized {
    return lock.sync { return resolution() }
} else {
    return resolution()
}

public protocol ObjectScopeProtocol: AnyObject {
    func makeStorage() -> InstanceStorage
}

public class ObjectScope: ObjectScopeProtocol, CustomStringConvertible {
    private var storageFactory: () -> InstanceStorage
    private let parent: ObjectScopeProtocol?

    public func makeStorage() -> InstanceStorage {
        if let parent = parent {
            return CompositeStorage([storageFactory(), parent.makeStorage()])
        } else {
            return storageFactory()
        }
    }
}

extension ObjectScope {
    public static let transient  = ObjectScope(storageFactory: TransientStorage.init, description: "transient")
    public static let graph      = ObjectScope(storageFactory: GraphStorage.init, description: "graph")
    public static let container  = ObjectScope(storageFactory: PermanentStorage.init, description: "container")
    public static let weak       = ObjectScope(storageFactory: WeakStorage.init, description: "weak",
                                               parent: ObjectScope.graph)
}

public final class TransientStorage: InstanceStorage {
    public var instance: Any? {
        get { return nil }
        set {}
    }
}

public final class GraphStorage: InstanceStorage {
    private var instances = [GraphIdentifier: Weak<Any>]()
    public var instance: Any?

    public func graphResolutionCompleted() {
        instance = nil
    }

    public func instance(inGraph graph: GraphIdentifier) -> Any? {
        return instances[graph]?.value
    }

    public func setInstance(_ instance: Any?, inGraph graph: GraphIdentifier) {
        self.instance = instance
        if instances[graph] == nil { instances[graph] = Weak() }
        instances[graph]?.value = instance
    }
}

public final class WeakStorage: InstanceStorage {
    private var _instance = Weak<Any>()

    public var instance: Any? {
        get { return _instance.value }
        set { _instance.value = newValue }
    }
}

public final class CompositeStorage: InstanceStorage {
    private let components: [InstanceStorage]

    public var instance: Any? {
        get { return components.compactMap { $0.instance }.first }
        set { components.forEach { $0.instance = newValue } }
    }
}

container.register(Dog.self) { _ in Dog() }
    .implements(Animal.self)
    .implements(Pet.self)

let dog = container.resolve(Dog.self)!
let animal = container.resolve(Animal.self)!
let pet = container.resolve(Pet.self)!

public func forward<T, S>(_ type: T.Type, name: String? = nil, to service: ServiceEntry<S>) {
    let key = ServiceKey(
        serviceType: T.self,
        argumentsType: service.argumentsType,
        name: name,
        option: nil
    )
    services[key] = service
    behaviors.forEach { $0.container(self, didRegisterType: type, toService: service, withName: name) }
}

public func implements<T>(_ type: T.Type, name: String? = nil) -> ServiceEntry<Service> {
    container?.forward(type, name: name, to: self)
    return self
}

public final class Lazy<Service>: InstanceWrapper {
    private let factory: (GraphIdentifier?) -> Any?
    private let graphIdentifier: GraphIdentifier?
    private var _instance: Service?

    public var instance: Service {
        if let instance = _instance {
            return instance
        } else {
            _instance = makeInstance()
            return _instance!
        }
    }
}

public final class Provider<Service>: InstanceWrapper {
    private let factory: (GraphIdentifier?) -> Any?

    public var instance: Service {
        return factory(.none) as! Service
    }
}

extension Optional: InstanceWrapper {
    static var wrappedType: Any.Type { return Wrapped.self }

    init?(inContainer _: Container, withInstanceFactory factory: ((GraphIdentifier?) -> Any?)?) {
        self = factory?(.none) as? Wrapped
    }
}

public func _resolve<Service, Arguments>(...) -> Service? {
    var resolvedInstance: Service?
    let key = ServiceKey(serviceType: Service.self, ...)

    if let entry = getEntry(for: key) {
        resolvedInstance = resolve(entry: entry, invoker: invoker)
    }

    // 普通解析失败，尝试作为包装器解析
    if resolvedInstance == nil {
        resolvedInstance = resolveAsWrapper(name: name, option: option, invoker: invoker)
    }

    return resolvedInstance
}

public protocol Assembly {
    func assemble(container: Container)
    func loaded(resolver: Resolver)
}

public final class Assembler {
    private let container: Container

    public var resolver: Resolver {
        return container
    }

    private func run(assemblies: [Assembly]) {
        // 第一遍：所有 Assembly 注册服务
        for assembly in assemblies {
            assembly.assemble(container: container)
        }
        // 第二遍：通知所有 Assembly 加载完成
        for assembly in assemblies {
            assembly.loaded(resolver: resolver)
        }
    }
}

class NetworkAssembly: Assembly {
    func assemble(container: Container) {
        container.register(HTTPClient.self) { _ in URLSessionClient() }
            .inObjectScope(.container)
        container.register(APIService.self) { r in
            APIServiceImpl(client: r.resolve(HTTPClient.self)!)
        }
    }
}

class DatabaseAssembly: Assembly {
    func assemble(container: Container) {
        container.register(Database.self) { _ in SQLiteDatabase() }
            .inObjectScope(.container)
    }
}

let assembler = Assembler([NetworkAssembly(), DatabaseAssembly()])
let apiService = assembler.resolver.resolve(APIService.self)!

public init(
    _ assemblies: [Assembly],
    parent: Assembler?,
    defaultObjectScope: ObjectScope = .graph,
    behaviors: [Behavior] = []
) {
    container = Container(parent: parent?.container, defaultObjectScope: defaultObjectScope, behaviors: behaviors)
    run(assemblies: assemblies)
}

public protocol Behavior {
    func container<Type, Service>(
        _ container: Container,
        didRegisterType type: Type.Type,
        toService entry: ServiceEntry<Service>,
        withName name: String?
    )
}

class LoggingBehavior: Behavior {
    func container<Type, Service>(
        _ container: Container,
        didRegisterType type: Type.Type,
        toService entry: ServiceEntry<Service>,
        withName name: String?
    ) {
        print("Registered: \(type) -> \(Service.self), name: \(name ?? "nil")")
    }
}

let container = Container(behaviors: [LoggingBehavior()])

// 1 参数
public func register<Service, Arg1>(
    _ serviceType: Service.Type,
    name: String? = nil,
    factory: @escaping (Resolver, Arg1) -> Service
) -> ServiceEntry<Service> {
    return _register(serviceType, factory: factory, name: name)
}

// 2 参数
public func register<Service, Arg1, Arg2>(
    _ serviceType: Service.Type,
    name: String? = nil,
    factory: @escaping (Resolver, Arg1, Arg2) -> Service
) -> ServiceEntry<Service> {
    return _register(serviceType, factory: factory, name: name)
}

public func resolve<Service, Arg1>(
    _: Service.Type,
    name: String?,
    argument: Arg1
) -> Service? {
    typealias FactoryType = ((Resolver, Arg1)) -> Any
    return _resolve(name: name) { (factory: FactoryType) in factory((self, argument)) }
}

// NOTICE:
// Container.Arguments.swift is generated from Container.Arguments.erb by ERB.
// Do NOT modify Container.Arguments.swift directly.

internal final class LoggingDebugHelper: DebugHelper {
    func resolutionFailed<Service>(
        serviceType: Service.Type,
        key: ServiceKey,
        availableRegistrations: [ServiceKey: ServiceEntryProtocol]
    ) {
        var output = [
            "Swinject: Resolution failed. Expected registration:",
            "\t{ \(description(serviceType: serviceType, serviceKey: key)) }",
            "Available registrations:",
        ]
        output += availableRegistrations
            .filter { $0.1 is ServiceEntry<Service> }
            .map { "\t{ " + $0.1.describeWithKey($0.0) + " }" }

        Container.log(output.joined(separator: "\n"))
    }
}

Swinject: Resolution failed. Expected registration:
    { Service: Animal, Factory: (Resolver) -> Animal }
Available registrations:
    { Service: Animal, Factory: (Resolver, String) -> Animal, ObjectScope: graph }

Container.loggingFunction = nil           // 关闭日志
Container.loggingFunction = { os_log($0) } // 自定义输出

class Parent {
    var child: Child?
}

class Child {
    var parent: Parent?
}

container.register(Parent.self) { r in
    let parent = Parent()
    parent.child = r.resolve(Child.self) // 这会再次 resolve Parent → 无限循环
    return parent
}

container.register(ParentProtocol.self) { r in
    Parent(child: r.resolve(ChildProtocol.self)!)  // 构造器注入
}
container.register(ChildProtocol.self) { _ in Child() }
    .initCompleted { r, c in
        let child = c as! Child
        child.parent = r.resolve(ParentProtocol.self)  // 属性注入（延迟到 initCompleted）
    }

container.register(ParentProtocol.self) { _ in Parent() }
    .initCompleted { r, p in
        let parent = p as! Parent
        parent.child = r.resolve(ChildProtocol.self)
    }
container.register(ChildProtocol.self) { _ in Child() }
    .initCompleted { r, c in
        let child = c as! Child
        child.parent = r.resolve(ParentProtocol.self)
    }

guard resolutionDepth < maxResolutionDepth else {
    fatalError("Infinite recursive call for circular dependency has been detected. " +
        "To avoid the infinite call, 'initCompleted' handler should be used to inject circular dependency.")
}