Swift进阶-Mirror使用及源码解析

我们知道Swift是一门静态语言，但让类继承NSObject，然后在属性和方法前面添加@objc，可以让它动态的处理一些事情。其实Swift本身也可以动态的获取类的成员及类型，这种方式就叫做反射(Mirror)

Mirror的Api简介

Mirror是一个结构体，它的Api如下：

struct Mirror {
    public enum DisplayStyle : Sendable {
        case `struct`
        case `class`
        case `enum`
        case tuple
        case optional
        case collection
        case dictionary
        case set
        public static func == (a: Mirror.DisplayStyle, b: Mirror.DisplayStyle) -> Bool
        public func hash(into hasher: inout Hasher)
        public var hashValue: Int { get }
    }
    // 初始化
    public init(reflecting subject: Any)
    public enum AncestorRepresentation {
        case generated
        case customized(() -> Mirror)
        case suppressed
    }
    public init<Subject, C>(_ subject: Subject, children: C, displayStyle: Mirror.DisplayStyle? = nil, ancestorRepresentation: Mirror.AncestorRepresentation = .generated) where C : Collection, C.Element == Mirror.Child
    public init<Subject, C>(_ subject: Subject, unlabeledChildren: C, displayStyle: Mirror.DisplayStyle? = nil, ancestorRepresentation: Mirror.AncestorRepresentation = .generated) where C : Collection
    public init<Subject>(_ subject: Subject, children: KeyValuePairs<String, Any>, displayStyle: Mirror.DisplayStyle? = nil, ancestorRepresentation: Mirror.AncestorRepresentation = .generated)
    public let displayStyle: Mirror.DisplayStyle?

    // 反射主体的类型
    public let subjectType: Any.Type
    public typealias Child = (label: String?, value: Any)
    public typealias Children = AnyCollection<Mirror.Child>
    public let children: Mirror.Children
  
    // 父mirror，没有则为nil
    public var superclassMirror: Mirror? { get }
    public func descendant(_ first: MirrorPath, _ rest: MirrorPath...) -> Any?
}
复制代码

Api主要分为三类：
- 1. 4个初始化方法：
  - init(reflecting subject: Any)是最简单的初始化方法，subject是实例对象
- 1. 成员变量：
  - displayStyle: 反射主题在枚举DisplayStyle中对应的类型
  - children: 是一个集合，结合的元素是元组，元祖由可选变迁label，和值value构成。
  - subjectType: 反射主体的类型
- 1. 方法：descendant

Mirror简单使用

下面来通过案例介绍mirror的一些简单用法

struct WSTeacher {
    var name: String = "wushuang"
    var age: Int = 18
}
let t = WSTeacher()
let mirror = Mirror(reflecting: t)

for obj in mirror.children {
    print("\(obj.label!) : \(obj.value)")
}
复制代码

此案例可以将struct的成员变量以及其在实例中对应的值都打印出来：

截屏2022-01-11 23.14.46.png

既然mirror可以根据实例对象，获取给对象类型中的成员变量以及对应的值，我们可以使用mirror来将对象转成JSON

对象转`JSON`

具体代码如下：

struct WSTeacher {
    var name: String = "wushuang"
    var age: Int = 18
}

let t = WSTeacher()

func test(_ obj: Any) -> Any {
    let mirror = Mirror(reflecting: obj)
    guard !mirror.children.isEmpty else { return obj }
  
    var keyValue: [String: Any] = [:]
    for child in mirror.children {
        if let key = child.label {
            keyValue[key] = test(child.value)
        } else {
            print(" key is not exist ")
        }
    }
    return keyValue
}
复制代码

代码主要是根据对象创建mirror对象，然后遍历children中的child，将child中的label为key，value为值存入Dictionary中，如果value也是一个对象，则也走一遍上述流程。最终得到JSON数据如下：

还可以将遍历的过程写成协议，具体过程如下：

protocol WSJSONMap {
    func jsonMap() -> Any
}
extension WSJSONMap {
    func jsonMap() -> Any {
        let mirror = Mirror(reflecting: self)
        guard !mirror.children.isEmpty else { return self }
      
        var keyValue: [String: Any] = [:]
        for children in mirror.children {
            if let value = children.value as? WSJSONMap {
                if let key = children.label {
                    keyValue[key] = value.jsonMap()
                } else {
                    print(" key is not exist ")
                }
            } else {
                print(" value is not obey WSJSONMap ")
            }
        }
        return keyValue
    }
}

struct WSPerson: WSJSONMap {
    var name: String = "wushuang"
    var age: Int = 18
}
extension String : WSJSONMap { }
extension Int : WSJSONMap { }

var ws = WSPerson()
复制代码

只需要结构体继承协议，然后结构体中成员变量的类型遵守协议，就可以调用协议方法，如果成员变量的类型没有遵守协议，则不会写入最终的json中：

截屏2022-01-13 17.33.59.png

如果key不存在或者value没有遵守协议，就会打印出来错误信息，但我们理想的效果是通过结果直接返回，此时就需要用到错误处理Error

抛出错误

首先定义一个Error类型的枚举：

enum WSJSONMapError: Error {
    case emptyKey
    case nonComplianceProtocol
}
复制代码

然后将协议方法中的错误替换成对应的Error类型，如果直接return错误类型，则会混淆是Json返回还是错误返回，所以此时需要使用throw将错误抛出

throw和throws

throw：将错误抛出
throws：返回值中可能有错误抛出，则返回值需要用throws修饰
修改的具体代码如下：
- 由于协议方法返回值可能存在错误，所以调用时需要加上try，也就是错误处理

错误处理

有以下几种错误处理的方式：

try&try?&try!

try：只管调用，即使有错误会向抛给上层函数，可以理解为甩锅
try?：返回的是可选类型，调用的结果如下：
- 没有错误: 返回json
- 有错误：返回nil
try!：认为代码不会有错误

这三种方式处理错误，依然会使程序崩溃，所以需要结合do-catch使用

do-catch

do-catch结合try遇到错误类型时会在catch打印出具体的错误：
do-catch结合try?遇到错误类型时会在do打印出nil
do-catch结合try!遇到错误类型时，依然会崩溃

localizedError

如果想要打印更多的错误信息，则可以使用系统的localizedError，它的Api如下：

public protocol LocalizedError : Error {
    var errorDescription: String? { get } // 错误描述
    var failureReason: String? { get } // 失败原因
    var recoverySuggestion: String? { get } // 建议
    var helpAnchor: String? { get } // 帮助
}
复制代码

此时我们选择使用错误描述，代码如下：
- 在打印错误时输出error.localizedDescription就可以打印出定义的内容：

CustomNSError

CustomNSError相当于是NSError，它的Api如下：

public protocol CustomNSError : Error {

    static var errorDomain: String { get }

    var errorCode: Int { get }

    var errorUserInfo: [String : Any] { get }
}
复制代码

我们可以使自定义的协议继承它，然后根据枚举设置code：

截屏2022-01-13 22.44.38.png

在do-catch中的错误code打印如下：

截屏2022-01-13 22.48.19.png

通过对Mirror的案例使用，会产生以下疑问：
1. Mirror是怎么获取实例变量的名字以及它的值？
2. Swift是静态语言，系统做了什么使Swift具有反射特性？

带着疑问，我们去 Swift源码进行分析

Mirror源码解析

在源码中，有三个文件与Mirror相关的，他们的关系如下：
- 1. Mirror.swift：暴露给Swift上层使用的Api，以及一些方法的实现
- 1. ReflectionMirror.swift：Mirror.swift中的函数调用的是ReflectionMirror.swift中Mirror的拓展函数，而Mirror的拓展函数是@_silgen_name包装函数后的匿名函数
- 1. ReflectionMirror.cpp：@_silgen_name的包装函数都在ReflectionMirror.cpp中
@_silgen_name作用分析，代码如下：
```
// test.c
int addNum(int a, int b) {
    return a + b;
}

// main.swift
@_silgen_name("addNum")
func wushuangAdd(a: Int, b: Int) ->Int

let result = wushuangAdd(a: 20, b: 10)
print(result)
复制代码
```
- 在Swift工程中创建test.c的c文件，不创建桥接文件，然后在c文件中定义addNum方法，接着在main.swift文件中使用@_silgen_name把字符串addNum包装成swift方法wushuangAdd
- 运行结果如下：
- 结果成功的调用了c中定义的函数，使用桥接文件，然后c文件带.h的情况下也是可以调用的
- 根据结果可以得出以下结论
结论：Swift工程可以在没有c.h，没有桥接文件的条件下，使用@_silgen_name关键字将c中的函数暴露给swift使用
下面从最基本的Api开始分析，首先进入Mirror.swift文件，可以看到Mirror是一个结构体，与上面提到的Api基本一致，那我们直接来看初始化方法：
```
public init(reflecting subject: Any) {
    if case let customized as CustomReflectable = subject {
        self = customized.customMirror 
    } else {
        self = Mirror(internalReflecting: subject)
    }
}
复制代码
```
- 如果subject的类型属于CustomReflectable，则生成的mirror由它的customMirror属性决定；反之则由系统创建
然后进入ReflectionMirror.swift文件查看internalReflecting的函数实现：
- 函数主要有以下5个步骤：
  - 1. 获取实际的类型
  - 1. 获取成员变量的数量
  - 1. 将成员变量的name和value组装成child，并放入集合Children中
  - 1. 设置父mirror
  - 1. 获取对象的displayStyle

下面我们主要去分析前面三个步骤:

一、 获取type

获取type的核心方法是调用_getNormalizedType，而它是swift_reflectionMirror_normalizedType函数的包装函数：

@_silgen_name("swift_reflectionMirror_normalizedType")
internal func _getNormalizedType<T>(_: T, type: Any.Type) -> Any.Type
复制代码

所以核心方法实际是ReflectionMirror.cpp中的swift_reflectionMirror_normalizedType函数：

SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_API
const Metadata *swift_reflectionMirror_normalizedType(OpaqueValue *value,
                                                      const Metadata *type,
                                                      const Metadata *T) {
  return call(value, T, type, [](ReflectionMirrorImpl *impl) { return impl->type; });
}
复制代码

该方法返回的是call函数，参数value是mirror实例，type是对象的类型，T是传入的对象，而类型最终的返回值是impl->type

二、获取count

获取count的方法_getChildCount，实际是调用ReflectionMirror.cpp中的swift_reflectionMirror_count方法：

@_silgen_name("swift_reflectionMirror_count")
internal func _getChildCount<T>(_: T, type: Any.Type) -> Int
复制代码

在swift_reflectionMirror_count的方法中，它调用的也是call方法，然后通过impl->count获得count：

intptr_t swift_reflectionMirror_count(OpaqueValue *value,
                                      const Metadata *type,
                                      const Metadata *T) {
  return call(value, T, type, [](ReflectionMirrorImpl *impl) {
    return impl->count();
  });
}
复制代码

三、获取成员变量

获得成员变量和上面一样，最终也是调用包装方法：

@_silgen_name("swift_reflectionMirror_subscript")
internal func _getChild<T>(
  of: T,
  type: Any.Type,
  index: Int,
  outName: UnsafeMutablePointer<UnsafePointer<CChar>?>,
  outFreeFunc: UnsafeMutablePointer<NameFreeFunc?>
) -> Any
复制代码

swift_reflectionMirror_subscript方法最终调用的也是call：

AnyReturn swift_reflectionMirror_subscript(OpaqueValue *value, const Metadata *type,
                                           intptr_t index,
                                           const char **outName,
                                           void (**outFreeFunc)(const char *),
                                           const Metadata *T) {
  return call(value, T, type, [&](ReflectionMirrorImpl *impl) {
    return impl->subscript(index, outName, outFreeFunc);
  });
}
复制代码

最后通过impl调用subscript方法来获取成员变量

通过上面的简单分析，我们得到他们的获取都与ReflectionMirrorImpl有关，下面我们去看看它到底是个什么

`ReflectionMirrorImpl(反射基类)`

ReflectionMirrorImpl是反射基类，它是一个结构体：
- 结构体里有type，count和subscript等属性和方法

反射的种类

在文件中可以看到ReflectionMirrorImpl有几下几个子类：
- 1. TupleImpl：元祖类型的反射
- 1. StructImpl：结构体类型的反射
- 1. EnumImpl：枚举的反射
- 1. ClassImpl：类的反射
- 1. ObjCClassImpl：OCClass的反射
- 1. MetatypeImpl：元数据
- 1. OpaqueImpl：不透明类型

了解了ReflectionMirrorImpl后，我再去分析上面三个步骤的详细过程

获取type

首先进入call函数：
- 在call中，先创建type和value，然后通过unwrapExistential对他们进行赋值，再赋值给impl的type
- 在unwrapExistential函数中，又调用了getDynamicType来动态获取type：
- 实际上获取type的核心步骤都在元数据中进行的，下面我们以结构体为例子去分析
先去看看StructImpl：
- StructImpl是一个结构体，在里面可以看到获取count，和获取成员变量的方法，但并没有看到type的获取，而获取count和isReflectable，是通过getDescription来得到，也许type的获取和getDescription有关。getDescription是StructMetadata的实例调用的，StructMetadata是TargetStructMetadata的别名
- TargetStructMetadata里getDescription最终调用的是this->Description，而它本身没有这个成员，说明它可能在父类TargetValueMetadata中，
进入TargetValueMetadata中，我们发现了Description：
- Description是对元数据的描述，起决定作用的是传入的TargetValueTypeDescriptor，
在进入TargetValueTypeDescriptor -> TargetTypeContextDescriptor，发现里面有个name，根据注释得知它就是type的名字：
- name是TargetRelativeDirectPointer指针，是传入的const char类型
通过进入TargetRelativeDirectPointer -> RelativeDirectPointer：
- RelativeDirectPointer里提供了父类的指针和值的获取方法，他们都是调用的是父类的get方法得到的
再进入父类RelativeDirectPointerImpl，它有一个成员变量RelativeOffset，ValueTy是传入的值，PointerTy是指针：
- get方法核心是调用applyRelativeOffset：
- applyRelativeOffset的核心代码如下：
- applyRelativeOffset主要是获取该内存的base地址，然后offset是结构体相对于base的偏移量，二者相加就得到了它的内存地址
通过分析，我们知道可以得到name，再调用get方法来获取type。但提前要搞清楚内存的结构
- TargetTypeContextDescriptor继承自TargetContextDescriptor，TargetContextDescriptor，有两个成员Flags和Parent，都是Int32类型
下面我们用伪代码来验证name是不是我们要的type

代码验证

通过上面分析，可以写出相应的数据类型：

struct WSMetadata {
    var kind: Int
    var desc: UnsafeMutablePointer<WSMetadataDesc>
}

struct WSMetadataDesc {
    var flags: Int32
    var parent: Int32
    var name: WSRelativeDirectPointer<CChar>
}

struct WSRelativeDirectPointer<T> {
    var offSet: Int32
    mutating func get() -> UnsafeMutablePointer<T> {
        let offset = self.offSet
        return withUnsafePointer(to: &self) { ptr in
            return UnsafeMutablePointer(mutating: UnsafeRawPointer(ptr).advanced(by: numericCast(offset)).assumingMemoryBound(to: T.self))
        }
    }
}
复制代码

然后通过unsafeBitCast函数进行按位强转，将WSPerson结构体的内存强转到WSMetadata上

struct WSPerson {
    var age: Int = 18
    var name: String = "wushuang"
}

let ptr = unsafeBitCast(WSPerson.self as Any.Type, to: UnsafeMutablePointer<WSMetadata>.self)
let namePtr = ptr.pointee.desc.pointee.name.get()

print(String(cString: namePtr))
复制代码

打印结果如下：

截屏2022-01-17 18.53.04.png

count

在上面的StructImpl结构中，我们知道count是通过Description中的NumFields来获取的，而getDescription返回的是TargetStructDescriptor类型，进入类中，于是发现成员NumFields和FieldOffsetVectorOffset
然后再找到TargetTypeContextDescriptor，发现name还有两个成员变量AccessFunctionPtr和Fields：
- 这两个成员变量和name的模版函数是一样的，只是传入的类型不一样

代码验证

搞清楚结构后，再来补充WSMetadataDesc的成员变量，由于AccessFunctionPtr和Fields传入的类型不确定，可以写成原生指针，具体代码如下：

struct WSMetadataDesc {
    var flags: Int32
    var parent: Int32
    var name: WSRelativeDirectPointer<CChar>
    var AccessFunctionPtr: WSRelativeDirectPointer<UnsafeRawPointer>
    var Fields: WSRelativeDirectPointer<UnsafeRawPointer>
    var NumFields: Int32
    var FieldOffsetVectorOffset: Int32
}
复制代码

然后打印NumFields：

截屏2022-01-17 19.46.50.png

改变WSPerson成员数量再打印：

截屏2022-01-17 19.48.39.png

结果与WSPerson的成员数量完全一致

获取实例变量的名字和值

获取实例变量主要跟StructImpl中的subscript方法有关

截屏2022-01-17 20.22.02.png

从代码中可知，获取实例变量名字调用getFieldAt方法：
- 这里主要是先从desc->Fields中获取fields数组，然后根据下标获取其中一个field，最后再从field中获取name
在上面分析中我们知道Field是模版函数TargetRelativeDirectPointer传入类型FieldDescriptor构造来的，下面来看看FieldDescriptor：
- FieldDescriptor是一个类，有5个成员变量：
  - MangledTypeName和Superclass是RelativeDirectPointer模版函数构造，且传入的都是const char类型
  - Kind和FieldRecordSize是uint16_t类型
  - NumFields是uint32_t类型
- 在getFields方法中，可以看出它是一片连续的内存，存储FieldRecord类型的数据
- 再查看FieldRecord的数据类型:
- 它有三个成员，而FieldName就是我们要找的成员变量的名字

下面将WSMetadataDesc的结构体继续改写：

struct WSMetadata {
    var kind: Int
    var desc: UnsafeMutablePointer<WSMetadataDesc>
}

struct WSMetadataDesc {
    var flags: Int32
    var parent: Int32
    var name: WSRelativeDirectPointer<CChar>
    var AccessFunctionPtr: WSRelativeDirectPointer<UnsafeRawPointer>
    var Fields: WSRelativeDirectPointer<WSFieldDescriptor>
    var NumFields: Int32
    var FieldOffsetVectorOffset: Int32
}

struct WSFieldDescriptor {
    var MangledTypeName: WSRelativeDirectPointer<CChar>
    var Superclass: WSRelativeDirectPointer<CChar>
    var Kind: Int16
    var FieldRecordSize: Int16
    var NumFields: Int32
    var fields: WSFieldRecord // 一块连续的内存，存储的都是 WSFieldRecord 类型数据
}

struct WSFieldRecord {
    var Flags: Int32
    var MangledTypeName: WSRelativeDirectPointer<CChar>
    var FieldName: WSRelativeDirectPointer<CChar>
}

struct WSRelativeDirectPointer<T> {
    var offSet: Int32
    mutating func get() -> UnsafeMutablePointer<T> {
        let offset = self.offSet
        return withUnsafePointer(to: &self) { ptr in
            return UnsafeMutablePointer(mutating: UnsafeRawPointer(ptr).advanced(by: numericCast(offset)).assumingMemoryBound(to: T.self))
        }
    }
}
复制代码

调用方法如下：

struct WSPerson {
  var age: Int = 18
  var name: String = "wushuang"
  var height: CGFloat = 185.0
  var hobby: String = "basketball"
  var nickName: String = "ws"
}
// 指向 WSMetadata的指针
let ptr = unsafeBitCast(WSPerson.self as Any.Type, to: UnsafeMutablePointer<WSMetadata>.self) 

// 获取指向 fields 的首地址
var fieldsDesPtr = ptr.pointee.desc.pointee.Fields.get()
let recordPtr = withUnsafePointer(to: &fieldsDesPtr.pointee.fields) { ptr in
    return UnsafeMutablePointer(mutating: UnsafeRawPointer(ptr).assumingMemoryBound(to: WSFieldRecord.self))
}

// 获取成员变量的名字的方式
let age = recordPtr.pointee.FieldName.get()
print(String(cString: age))

 let name = (recordPtr + 1).pointee.FieldName.get()
print(String(cString: name))

let height = recordPtr[2].FieldName.get()
print(String(cString: height))

let hobby = recordPtr.advanced(by: 3).pointee.FieldName.get()
print(String(cString: hobby))
复制代码

打印成员变量主要有三个步骤：
- 1. 获取指向WSMetadata的指针
- 1. 获取指向连续内存fields的首地址
- 1. 根据内存平移获取每个成员变量的field，再获取对应的FieldName

总结

mirror在反射时，通过反射对象的实例来初始化一个struct类型数据，这个数据的内存结构与反射对象对应的类是一致的，然后通过访问对应内存的位置来读取相应的type，count，以及成员变量信息。

Swift进阶-Mirror使用及源码解析

Mirror的Api简介

Mirror简单使用

对象转JSON

抛出错误

throw和throws

错误处理

try&try?&try!

do-catch

localizedError

CustomNSError

Mirror源码解析

ReflectionMirrorImpl(反射基类)

反射的种类

获取type

代码验证

count

代码验证

获取实例变量的名字和值

总结

对象转`JSON`

`ReflectionMirrorImpl(反射基类)`