反射 Mirror ｜ Swift 动态性

Posted 2023-02-09 博BOBO

Mirror是Swift中的反射机制，反射就是可以动态的获取类型以及成员信息，同时也可以在运行时动态的调用方法和属性等。

1. Mirror 简介

Mirror是Swift中的反射机制的实现，它的本质是一个结构体。
创建 Mirror 最简单的方式就是使用 reflecting 构造器：

public init(reflecting subject: Any)

正如你所见，对象的类型是 Any。这是 Swift 中最通用的类型。Swift 中的任何东西至少都是 Any类型的。这样一来 mirror 就可以兼容 struct, class, enum, Tuple, Array, Dictionary, set 等。

下面列举了 Mirror 可用的属性 / 方法：

• let children: Children：对象的子节点。
• displayStyle: Mirror.DisplayStyle?：对象的展示类型
• let subjectType: Any.Type：对象的类型
• func superclassMirror() -> Mirror?：对象父类的 mirror

displayStyle

public enum DisplayStyle 
    case Struct
    case Class
    case Enum
    case Tuple
    case Optional
    case Collection
    case Dictionary
    case Set

它会返回 DisplayStyle enum 的其中一种情况。如果你想要对某种不支持的类型进行反射，你会得到一个空的 Optional 值。
例如：
正如之前我们知道的，反射只要求对象是 Any 类型，而且Swift 标准库中还有很多类型为 Any 的东西没有被列举在上面的 DisplayStyle enum 中。如果试图反射它们中间的某一个又会发生什么呢？比如 closure。

let closure =  (a: Int) -> Int in return a * 2 
let aMirror = Mirror(reflecting: closure)
print("\\(aMirror)----------\\(aMirror.displayStyle)")
//Mirror for (Int) -> Int----------nil

children

这会返回一个包含了对象所有的子节点的 AnyForwardCollection<Child>。这些子节点不单单限于 Array 或者 Dictionary 中的条目。诸如 struct 或者 class 中所有的属性也是由 AnyForwardCollection<Child> 这个属性返回的子节点。AnyForwardCollection 协议意味着这是一个支持遍历的 Collection 类型。

public class Store 
    let storesToDisk: Bool = true

public class BookmarkStore: Store 
    let itemCount: Int = 10

public struct Bookmark 
     enum Group 
     case Tech
     case News
     
     private let store = 
           return BookmarkStore()
     ()
     let title: String?
     let url: NSURL
     let keywords: [String]
     let group: Group

let aBookmark = Bookmark(title: "Appventure", url: NSURL(string: "appventure.me")!, keywords: ["Swift", "ios", "OSX"], group: .Tech)
        
let aMirror = Mirror(reflecting: aBookmark)
for case let (label?, value) in aMirror.children 
    print (label, value)

//输出:
//store TestDemo3.ViewController.BookmarkStore
//title Optional("Appventure")
//url appventure.me
//keywords ["Swift", "iOS", "OSX"]
//group Tech

SubjectType

这是对象的类型：

print(aMirror.subjectType)
//输出 : Bookmark
print(Mirror(reflecting: 5).subjectType)
//输出 : Int
print(Mirror(reflecting: "test").subjectType)
//输出 : String
print(Mirror(reflecting: NSNull()).subjectType)
//输出 : NSNull

SuperclassMirror

这是我们对象父类的 mirror。如果这个对象不是一个类，它会是一个空的 Optional 值。如果对象的类型是基于类的，你会得到一个新的 Mirror：

// 试试 struct
print(Mirror(reflecting: aBookmark).superclassMirror)
// 输出: nil
// 试试 class
print(Mirror(reflecting: aBookmark.store).superclassMirror)
// 输出: Optional(Mirror for Store)

2.反射 Mirror 使用

1.Mirror 转换对象为字典

• 定义如下对象：

    struct Person 
        var name: String = "YDW"
        var isMale: Bool = true
        var birthday: Date = Date()
    
     
    class Animal: NSObject 
        private var eat: String = "吃"
        var age: Int = 0
        var optionValue: String?
    
     
    class Cat: Animal 
        var like: [String] = ["mouse", "fish"]
        var master = Person()
    

• 遍历出字典：

   func mapDic(mirror: Mirror) -> [String: Any] 
        var dic: [String: Any] = [:]
        for child in mirror.children 
            // 如果没有label就会被抛弃
            if let label = child.label 
                let propertyMirror = Mirror(reflecting: child.value)
                   dic[label] = child.value
            
        
        // 添加父类属性
        if let superMirror = mirror.superclassMirror 
            let superDic = mapDic(mirror: superMirror)
            for p in superDic 
                dic[p.key] = p.value
            
        
        return dic
    

• 使用 Mirror 转换对象并打印结果， 可以看到可以打印出私有属性：

// Mirror使用
    let objc  = Cat()
    let  mirror = Mirror(reflecting: objc)
    let mirrorDic = mapDic(mirror: mirror)
    print(mirrorDic)
     
// 打印结果
["master": TestDemo3.ViewController.Person(name: "YDW", isMale: true, birthday: 2022-07-15 03:51:59 +0000), "eat": "吃", "optionValue": nil, "age": 0, "like": ["mouse", "fish"]]

• 在实际运用中，可以将应用于元组参数传递（比如网络请求传参，传入元组，网络请求时转换为字典），优点：外部使用知道具体传入什么参数，参数更改不影响方法错误。

// 外部参数定义
    var params = (title: "name", comment: "Mirror")
     
    // 网络层统一转换为字典，进行网路请求
    let paramsDic = mapDic(mirror: Mirror(reflecting: params))
    print(paramsDic)
     
    // 打印结果
    ["title": "name", "comment": "Mirror"]

• 需要注意是只能传入基本类型，并且元组参数要命名，如果直接使用（“name”,“Mirror”）则会变成下面这种情况：

// 外部参数定义
    var params = ("name","Mirror")
     
    // 网络层统一转换为字典，进行网路请求
    let paramsDic = mapDic(mirror: Mirror(reflecting: params))
    print(paramsDic)
    // 打印
    [".1": "Mirror", ".0": "name"]

1. JSON 解析

• 定义一个 YDWTeacher 类：

class YDWTeacher 
    var age = 18
    var name = "YDW"

• 运用 Mirror 来解析，实现代码如下：

// JSON解析
    func test(_ obj: Any) -> Any 
        let mirror = Mirror(reflecting: obj)
        // 判断条件 - 递归终止条件
        guard !mirror.children.isEmpty else 
            return obj
        
        // 字典
        var keyValue: [String: Any] = [:]
        // 遍历
        for children in mirror.children 
            if let keyName = children.label 
                // 递归调用
                keyValue[keyName] = test(children.value)
             else 
                print("children.label 为空")
            
        
        return keyValue
    
    
    // 使用
    var t = YDWTeacher()
    print(test(t))

• 运行代码，打印结果如下：

["name": "YDW","age": 18]

• 如果想在工程中大量的使用上述的 JSON 解析，可以将 Mirror JSON 解析抽取成一个协议，然后提供一个默认实现，让类遵守协议，如下：

// 定义JSON解析协议
    protocol CustomJSONMap 
        func jsonMap() -> Any
    
    
    // 提供默认实现
    extension CustomJSONMap
        func jsonMap() -> Any
            let mirror = Mirror(reflecting: self)
            // 递归终止条件
            guard !mirror.children.isEmpty else 
                return self
            
            // 字典，用于存储json数据
            var keyValue: [String: Any] = [:]
            // 遍历
            for children in mirror.children 
                if let value = children.value as? CustomJSONMap 
                    if let keyName = children.label 
                        // 递归
                        keyValue[keyName] = value.jsonMap()
                     else 
                        print("key是nil")
                    
                 else 
                    print("当前-\\(children.value)-没有遵守协议")
                
            
            return keyValue
        
    
    
    // 让类遵守协议（注意：类中属性的类型也需要遵守协议，否则无法解析）
    class YDWTeacher: CustomJSONMap 
        var age = 18
        var name = "YDW"
    
    
    // 使用
    var t = YDWTeacher()
    print(t.jsonMap())

• 运行，可以发现并没达到我们预想的结果，这是因为 YDWTeacher 的属性的类型也需要遵守 CustomJSONMap 协议：

当前-18-没有遵守协议
当前-YDW-没有遵守协议

• 修改如下，这样就可以达到我们预想的结果：

// Int、String遵守协议
extension Int: CustomJSONMap
extension String: CustomJSONMap

// 打印结果 
["name": "YDW", "age": 18]

3.错误处理

• 为了让封装的JSON 解析更加完善，除了对正常返回的处理，还需要对其中的错误进行处理，在上面的封装中，采用的是 print 打印的，这样并不规范，也不好维护及管理。那么如何在 swift 中正确的表达错误呢？
• Swift 中，提供了 Error 协议来标识当前应用程序发生错误的情况，其中 Error 的定义如下：

public protocol Error  

• 可以看到：Error 是一个空协议，其中没有任何实现，这也就意味着可以遵守该协议，然后自定义错误类型，因此不管是 struct、Class、enum，都可以遵循这个 Error 来表示一个错误。
• 那么上面封装的 JSON 解析修改错误处理，首先定义一个 JSONMapError 错误枚举，将默认实现的 print 替换成枚举类型：

// 定义错误类型
enum JSONMapError: Error
    case emptyKey
    case notConformProtocol

extension CustomJSONMap 
        func jsonMap() throws -> Any 
            let mirror = Mirror(reflecting: self)
            // 递归终止条件
            guard !mirror.children.isEmpty else 
                return self
            
            // 字典，用于存储json数据
            var keyValue: [String: Any] = [:]
            // 遍历
            for children in mirror.children 
                if let value = children.value as? CustomJSONMap 
                    if let keyName = children.label 
                        // 递归
                        keyValue[keyName] = try value.jsonMap()
                     else 
                        throw JSONMapError.emptyKey
                    
                 else 
                    throw JSONMapError.notConformProtocol
                
            
            return keyValue
        
    

• 封装完成，使用如下：

// 使用时需要加上try
var t = YDWTeacher()
do
     _ = try t.jsonMap()
catch JSONMapError.emptyKey
     print("???emptyKey????")
catch JSONMapError.notConformProtocol
     print("???notConformProtocol?????")
catch

4.获取类型，属性个数及其值

• 定义一个用户类：

class YDWUser 
     var name: String = ""
     var nickName: String?
     var age: Int?
     var emails: [String]?

• 然后创建一个用户对象，并通过反射获取这个对象的信息：

// 创建一个User实例对象
    let user = YDWUser()
    user.name = "DW"
    user.age = 18
    user.emails = ["[e-mail]", "[e-mail]"]
                 
    // 将user对象进行反射
    let hMirror = Mirror(reflecting: user)
                 
    print("对象类型：\\(hMirror.subjectType)")
    print("对象子元素个数：\\(hMirror.children.count)")
                 
    print("--- 对象子元素的属性名和属性值分别如下 ---")
    for case let  (label?, value)  in  hMirror.children 
        print("属性：\\(label)     值：\\(value)")
    

• 打印如下：

对象类型：YDWUser
对象子元素个数：4
--- 对象子元素的属性名和属性值分别如下 ---
属性：name     值：DW
属性：nickName     值：nil
属性：age     值：Optional(18)
属性：emails     值：Optional(["[e-mail]", "[e-mail]"])

5.通过属性名（字符串）获取对应的属性值，并对值做类型判断（包括是否为空）

• 定义两个方法：getValueByKey() 是用来根据传入的属性名字符串来获取对象中对应的属性值，unwrap() 是用来给可选类型拆包的（对于非可选类型则返回原值）：

// 根据属性名字符串获取属性值
    func getValueByKey(obj: AnyObject, key: String) -> Any 
         let hMirror = Mirror (reflecting: obj)
         for case let (label?, value) in hMirror.children 
             if label == key 
                return unwrap(any: value)
             
         
         return  NSNull ()
    
     
    // 将可选类型（Optional）拆包
    func unwrap(any: Any ) ->  Any  
         let mi =  Mirror (reflecting: any)
        if mi.displayStyle! != .optional 
             return any
         
         
         if mi.children.count == 0 
            return any
         
         let  (_, some) = mi.children.first!
         return  some
    

• 用上例的 YDWUser 对象做测试：

// 创建一个User实例对象
    let user = YDWUser()
    user.name = "DW"
    user.age = 18
    user.emails = ["[e-mail]", "[e-mail]"]
     
    // 通过属性名字符串获取对应的值
    let name = getValueByKey(obj: user, key:  "name")
    let nickName = getValueByKey(obj: user, key:  "nickName")
    let age = getValueByKey(obj: user, key:  "age")
    let emails = getValueByKey(obj: user, key:  "emails")
    let tel = getValueByKey(obj: user, key:  "tel")
    print(name, nickName, age, emails, tel)
     
    // 对于获取到的值进行类型判断
    if name is NSNull 
        print("name这个属性不存在")
     else if (name as? AnyObject) == nil 
        print("name这个属性是个可选类型，且为nil")
     else if name is String 
        print("name这个属性String类型，其值为：\\(name)")
    
    if tel is NSNull 
        print("tel这个属性不存在")
     else if (tel as? AnyObject) == nil 
        print("tel这个属性是个可选类型，且为nil")
     else if tel is String 
        print("tel这个属性String类型，其值为：\\(tel)")
    

• 运行程序，打印如下：

DW nil 18 ["[e-mail]", "[e-mail]"] <null>
name这个属性String类型，其值为：DW
tel这个属性不存在

3.Swift动态性

• 所谓动态：就是在运行阶段才知道自己的类是什么
• 父类对象指向子类对象，是动态特性，因为在运行的时候，才知道这个变量真正的类型是子类
• 具有方法动态派发（函数表派发，消息派发）
• 继承自OC的类Swift类，具有动态特性
• dynamic修饰的方法和属性，具有动态特性
• Swift中的反射机制，是动态特性

静态派发
在编译期的时候，编译器就知道要为某个方法调用某种实现

动态派发
对于每个方法的调用，编译器必须在方法列表中查找执行方法的实现，比如在运行时判断是选择父类的实现，还是子类的实现。对于对象的内存都是在运行时分配的，因此只能在运行时执行检查

编译型语言的函数派发方式

• 直接派发（Direct Dispatch）
  编译后确定了方法的调用地址（静态派发），汇编代码中，直接跳到了方法的地址执行，生成的汇编指令最少，速度最快
  例如C语言，C++默认也是直接派发
  由于缺乏动态性，无法实现多态
• 函数表派发(Table Dispatch)
  在运行时通过函数查找需要执行的方法，多一次查表的过程，速度比直接派发慢
  C++的虚函数(Virtual Table)，维护一个虚函数表，对象创建的时候会保存虚表的指针，调用方之前，会从对象中取出虚表地址，根据编译时的方法偏移量从虚表取出方法的地址，跳到方法的地址执行
• 消息派发（Message Dispatch）
  objc消息发送机制
• 性能：直接派发 > 函数表派发 > 消息机制派发

直接派发

• 全局函数
• 使用static声明的方法
• 使用final声明的所有方法，使用final声明的类里面的所有方法
• 使用private声明的方法和属性，会隐式final声明
• 值类型的方法，比如struct和enum中的方法
• 在extension中没有使用@objc修饰的实例方法

函数表派发

• 只有引用类型才是函数表派发
• 在Swift中，类的方法默认使用函数表派发的方式
• Swift对于协议Protocol默认使用的是函数表派发，协议可以为struct提供多态的支持
• Swift的函数表叫做 witness table(C++叫做virtual table)
  1.每个子类都有自己的表结构
  2.对于类中每个重写的方法，都有不同的函数指针
  3.当子类添加新方法时，这些方法指针会添加到函数表的末尾
  4.在运行时使用此表来调用函数的实现 (函数表指针 + 函数偏移 就能找到对应的方法)

消息派发

• 用dynamic修饰的方法是消息派发
• 对于继承自NSObject的Swift类，消息派发方式
  注意： @objc修饰方法，只是把方法暴露给objc,是函数表派发

例子

• 普通的实例方法，使用函数表派发
• @objc声明的方法，使用函数表派发
• 对于重写了OC的方法。使用消息派发
• extension中的方法，直接派发
• dynamic修饰的方法，使用消息派发

//举例说明：
class CustomView: UIView 
    /// static修饰：直接派发
    static func staticMehod() 
    /// private: 直接派发
    private func privateMethod() 
    /// final修饰：直接派发
    final func finalMethod() 
    /// 直接派发
    static func staticMethod() 
    /// 普通的实例方法 函数表派发
    func commonMethod() 
    /// @objc修饰 函数表派发
    @objc func method1() 
    /// dynamic修饰： 消息派发
    @objc dynamic
    func method2() 
    /// 重写了OC的方法： 消息派发
    override func layoutSubviews() 
        super.layoutSubviews()