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
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"]
- 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 = ["[email protected]", "[email protected]"]
// 将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(["[email protected]", "[email protected]"])
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 = ["[email protected]", "[email protected]"]
// 通过属性名字符串获取对应的值
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 ["[email protected]", "[email protected]"]
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()
}
}