反射 Mirror ｜ Swift 动态性

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。这些子节点不单单限于 Array 或者 Dictionary 中的条目。诸如 struct 或者 class 中所有的属性也是由 AnyForwardCollection 这个属性返回的子节点。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 = ["12345@qq.com", "56789@qq.com"]
                 
    // 将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(["12345@qq.com", "56789@qq.com"])

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 = ["12345@qq.com", "56789@qq.com"]
     
    // 通过属性名字符串获取对应的值
    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 ["12345@qq.com", "56789@qq.com"] <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()
    }
}