DependencyInjector+ObjectMapper

与 ObjectMapper 兼容的 Swift 依赖注入器

安装

CocoaPods

要使用 CocoaPods 安装 DependencyInjector+ObjectMapper，请将以下行添加到您的 Podfile 中。

source 'https://github.com/CocoaPods/Specs.git'
platform :ios, '9.0'
use_frameworks!

pod 'DependencyInjectorObjectMapper'

Carthage

Carthage 是一个去中心化的依赖管理器，它可以构建您的依赖项并为您提供二进制框架。

您可以使用 Homebrew，通过以下命令安装 Carthage

$ brew update
$ brew install carthage

要使用 Carthage 将 DependencyInjector+ObjectMapper 集成到您的 Xcode 项目中，请在您的 Cartfile 中指定它

github 'Digipolitan/dependency-injector-object-mapper' ~> 1.0

运行 carthage update 来构建框架，并将构建好的 DependencyInjectorObjectMapper.framework 拖到您的 Xcode 项目中。

Swift Package Manager

Swift Package Manager 是一个用于自动化 Swift 代码分发的工具，并已集成到 swift 编译器中。

设置好 Swift 包之后，只需将其添加到 Package.swift 的 dependencies 值中，即可轻松地将 DependencyInjector+ObjectMapper 添加为依赖项。

dependencies: [
    .package(url: "https://github.com/Digipolitan/dependency-injector-object-mapper.git", from: "1.0.0")
]

如何使用？

首先，您必须创建符合 BaseMappable 协议的模型

public protocol User: BaseMappable {
    var id: String { get set }
    var created: Date? { get set }
    var address: Address { get set }
}

public protocol Address: BaseMappable {
    var street: String { get set }
    var zipCode: String { get set }
    var country: String { get set }
}

之后，为每个模型创建符合 Mappable 协议的实际实现

class UserModel: User, Mappable {
    public var id: String
    public var created: Date?
    public var address: Address

    public init(id: String, address: Address) {
        self.id = id
        self.address = address
    }

    public convenience required init?(map: Map) {
        guard
            let id: String = try? map.value("id"),
            let address: Address = try? map.injectedValue("address", type: Address.self) else {
                return nil
        }
        self.init(id: id, address: address)
    }

    public func mapping(map: Map) {
        self.id >>> map["id"]
        self.created <- (map["createdAt"], DateTransform())
        self.address >>> map.inject("address", type: Address.self)
    }
}

class AddressModel: Address, Mappable {
    public var street: String
    public var zipCode: String
    public var country: String

    public init(street: String, zipCode: String, country: String) {
        self.street = street
        self.zipCode = zipCode
        self.country = country
    }

    public convenience required init?(map: Map) {
        guard let street: String = try? map.value("street"), let zipCode: String = try? map.value("zipCode"), let country: String = try? map.value("country") else {
            return nil
        }
        self.init(street: street, zipCode: zipCode, country: country)
    }

    public func mapping(map: Map) {
        self.street >>> map["street"]
        self.zipCode >>> map["zipCode"]
        self.country >>> map["country"]
    }
}

对于非空属性，请在初始化器中设置值
要注入自定义实现，请在初始化过程中使用 map.injectedValue，或在 mapping 函数中使用 map.inject

之后，您必须在一个模块中注册实现，并将该模块推入注入器中

class DefaultModule: Module {

    override init() {
        super.init()
        self.bind(User.self).to(UserModel.self)
        self.bind(Address.self).to(AddressModel.self)
    }
}
Injector.default.register(module: DefaultModule(), with: "default")

最后，按如下方式注入 User 模型

let user = try? Injector.default.inject(User.self, arguments: [
    "id": "1",
    "address": [
        "street": "abc",
        "zipCode": "75116",
        "country": "France"
    ]
])

贡献

有关更多详细信息，请参阅 CONTRIBUTING.md！

本项目遵守贡献者盟约行为准则。通过参与，您需要遵守此代码。如果您发现不可接受的行为，请报告给 contact@digipolitan.com。

许可

DependencyInjector+ObjectMapper 采用 BSD 3-Clause 许可。