Swinject 源码框架(三）：Object Scopes

Object Scopes 指定了生成的实例在系统中是如何被共享的。

如何指定 scope

container.register(Animal.self) { _ in Cat() }

    .inObjectScope(.container)

例子如上，每次 register 方法，都会返回 ServiceEntry 实例，然后调用其 inObjectScope 方法，会设置其 objectScope。

scope 的种类

Transient
每次调用resolve，都会生成新的实例。
Graph （默认值）
每次手动调用 resolve，都会生成新的实例。
但是在其 factory 方法中生成的实例，是共享的，即如果已经生成过了，就不会重新生成了。
用于解决循环依赖
Container
被这个 Container 及其子 Container 共享。可以理解为单例。
Weak
和 Container 类似，但是Container 并不持有它。如果没有其他引用，这个实例会被销毁，下次重新生成。

Scope 的实现

每一个 ServiceEntry 都有持有一个 InstanceStorage，保存着已经生成的 instance。
每一次调用 resolve，都会先从其storage中获取 instance。如果获取不到，才会去生成新的实例。

if let persistedInstance = entry.storage.instance(inGraph: currentObjectGraph), let persistedService = persistedInstance as? Service {

    return persistedService

}

let resolvedInstance = invoker(entry.factory as! Factory)

ServiceEntry 的 storage 由其objectScope 生成。

internal lazy var storage: InstanceStorage = { [unowned self] in

    self.objectScope.makeStorage()

}()

ObjectScope 的 makeStorage方法，调用了 storageFactory 这个闭包属性。

/// Will invoke and return the result of `storageFactory` closure provided during initialisation.

public func makeStorage() -> InstanceStorage {

    if let parent = parent {

        return CompositeStorage([storageFactory(), parent.makeStorage()])

    } else {

        return storageFactory()

    }

}

这就意味着每一个ServiceEntry 的 storage 由其 ObjectScope 的 storageFactory 属性决定。

Transient 的实现

transient 的 storageFactory 是 TransientStorage.init。

public static let transient = ObjectScope(storageFactory: TransientStorage.init, description: "transient")

而 TransientStorage 每次返回的 instance 都是nil，因此每次都生成一个新的实例。

/// Does not persist stored instance.

public final class TransientStorage: InstanceStorage {

    public var instance: Any? {

        get { return nil }

        set {}

    }

    public init() {}

}

Container Scope 的实现

extension InstanceStorage {

    public func graphResolutionCompleted() {}

    public func instance(inGraph _: GraphIdentifier) -> Any? { return instance }

    public func setInstance(_ instance: Any?, inGraph _: GraphIdentifier) { self.instance = instance }

}

/// Persists stored instance until it is explicitly discarded.

public final class PermanentStorage: InstanceStorage {

    public var instance: Any?

    public init() {}

}

可见，每次生成一个实例，就会设置为其 instance 属性，并且强持有。
所以只要生成过一次，就不会被释放，也不会重新生成。

Weak Scope 的实现

/// Does not persist value types.

/// Persists reference types as long as there are strong references to given instance.

public final class WeakStorage: InstanceStorage {

    private var _instance = Weak<Any>()

    public var instance: Any? {

        get { return _instance.value }

        set { _instance.value = newValue }

    }

    public init () {}

}

和 Container 类似，但是这里的instance被包了一层，即一个强对象中，有一个 weak 的属性。真正设置的是其 weak 的属性。
所以这个 storage 并不强持有 instance。因此外部的引用都消失后，instance 的 get 方法会返回 nil。

private class Weak<Wrapped> {

    private weak var object: AnyObject?

    var value: Wrapped? {

        get {

            guard let object = object else { return nil }

            return object as? Wrapped

        }

        set { object = newValue as AnyObject? }

    }

}

Graph Scope 的实现

/// Persists storage during the resolution of the object graph

public final class GraphStorage: InstanceStorage {

    private var instances = [GraphIdentifier: Weak<Any>]()

    public var instance: Any?

    public init() {}

    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<Any>() }

        instances[graph]?.value = instance

    }

}

和 Transient 类似，不过在某一次 resolve 之后，会调用 graphResolutionCompleted，把 instance 清空。

// in Container.swift

fileprivate func decrementResolutionDepth() {

    assert(resolutionDepth > 0, "The depth cannot be negative.")

    resolutionDepth -= 1

    if resolutionDepth == 0 {

        services.values.forEach { $0.storage.graphResolutionCompleted() }

        self.currentObjectGraph = nil

    }

}

巴特西