Swift進階教程Mirror反射示例詳解

Posted on 2022-06-17 by WalkonNet

元類型與.self

AnyObject

在Swift開發中，我們經常會使用AnyObject來代表任意類的實例、類的類型、以及僅類遵守的協議。

代表任意類的實例、類的類型

class LGTeacher {
    var age = 18
}
var t = LGTeacher()
var t1: AnyObject = t //代表LGTeacher類的實例
var t2: AnyObject = LGTeacher.self //代表LGTeacher類的類型

代表僅類遵循的協議

這裡使用瞭AnyObjcct來修飾協議，可以看到，當struct類型的structLGTeacher去遵循協議時，編譯器會報錯。隻允許class類型遵循協議。

我們在和OC交互的過程中，也經常通過AnyObject來表示某種類型的instance。

我們在代碼編寫的過程中有時候不知道具體的類型，⽤AnyObject來表示；那如果我們知道瞭確定瞭類型，該如何把AnyObject轉換成具體的類型，這⾥我們使⽤三個關鍵字as，as?，as!進行類型轉換。

AnyClass

AnyClass代表瞭任意實例的類型，我們可以從源碼裡面去查看AnyClass的定義

public typealias AnyClass = AnyObject.Type

我們可以看到，AnyClass的定義就是AnyObject.Type，也就是實例對象的類型，所以我們不能用具體的實例對象賦值給AnyClass，編譯器會報錯。

Any

Any可以代表任意類型（枚舉、結構體、類），也包括函數類型和Optional類型。

var array:[AnyObject] = [1,2]

上面這段代碼會報錯，因為AnyObject代表任意類的實例和類型，而我們傳入的是Int類型，是屬於值類型，無法用AnyObject表示。這時，我們要使用Any。

var array:[Any] = [1,2]

type(Of:)

type(Of:)⽤來獲取⼀個值的動態類型。什麼是動態類型呢？

靜態類型(static type)，這個是在編譯時期確定的類型。
動態類型(dynamic Type)，這個是在運⾏時期確定的類型。

接下來我們用代碼來描述靜態類型和動態類型。

可以看到，在編譯期間就能知道a的類型是Int，因為初始化數據的時候賦值的是Int類型數據，但是在test方法的形參定義的類型是Any，因此在編譯期間並不知道其形參類型，所以將a傳入時也被編譯器當作是Any類型，但是在運行時，可以動態得知傳入的a是Int類型，因此type(of:)就可以用來獲取當前值在運行時的實際類型。

self

在Swift中，我們可以使用類型或者實例對象來訪問self。

T.self: T 是實例對象，當前 T.self 返回的就是實例對象本身。

如果 T 是類，當前 T.self 返回的就是元類型。

我們通過代碼驗證一下。

從代碼中，我們可以看到，當我po t 和po t1時，可以看到t和t1指向同一個地址。然後當我po t2時，發現打印出來的是LGTeaher類型。接下來我用x/8g命令打印t2，打印出t2的內存地址。再打印出t的內存地址，然後打印t裡面存儲metadata的內存地址。發現和t2的內存地址一模一樣。

所以，在 T.self 中，當 T 為實例對象的時候，T.self 返回的是實例對象本身。當 T 為類的時候，T.self 返回的是一個元類型，也就是前面講的元數據（metadata）。

self在方法裡面的作用

我們可以看到，在實例方法中，self指向的就是當前調用方法的實例對象，而在類方法裡面，self指向的就是當前類型的元數據。

Self引用

Self類型不是特定類型，⽽是讓您⽅便地引⽤當前類型，⽽⽆需重復或知道該類型的名稱。

在協議聲明或協議成員聲明中，Self類型是指最終符合協議的類型。

Self作為實例方法的返回類型代表自身類型

計算屬性/實例方法中訪問自身的類型屬性，類型方法

Swift Runtime

在OC中，我們可以通過Runtime特性來獲取一個類的屬性和方法。而Swift中沒有Runtime，能使用OC的Runtime獲取一個類的屬性和方法嗎？我們通過代碼測試一下。

代碼結果沒有打印任何東西。

現在我們往LGTeacher類的屬性和方法前面加上@objc標識符，看看會有什麼結果？

這時可以通過Runtime API打印方法和屬性名，但是OC無法進行調動。

對於繼承NSObject類的Swift類，如果我們想要動態的獲取當前的屬性和⽅法，必須在其聲明前添加@objc 關鍵字，否則也是沒有辦法通過Runtime API獲取的。

繼承NSObject類的Swift類，沒有在屬性和方法聲明前面添加@objc 關鍵字，隻能獲取到init方法。

繼承NSObject類的Swift類，在屬性和方法聲明前面添加@objc關鍵字，不僅可以使用Runtime API獲取屬性和方法名，也可以在OC中被調用。

還有一些和Swift Runtime相關的結論，我在這裡總結出來，可以自己去試驗一下。

純swift類沒有動態性，但在⽅法、屬性前添加dynamic修飾，可獲得動態性。
繼承⾃NSObject的swift類，其繼承⾃⽗類的⽅法具有動態性，其它⾃定義⽅法、屬性想要獲得動態性，需要添加dynamic修飾。
若⽅法的參數、屬性類型為swift特有、⽆法映射到objective－c的類型(如Character、Tuple)，則此⽅法、屬性⽆法添加dynamic修飾(編譯器報錯)

Mirror

Mirror的基本用法

所謂反射就是可以動態獲取類型、成員信息，在運⾏時可以調⽤⽅法、屬性等⾏為的特性。在使⽤OC開發時很少強調其反射概念，因為OC的Runtime要⽐其他語⾔中的反射強⼤的多。但是 Swift 是⼀⻔類型安全的語⾔，不⽀持我們像 OC 那樣直接操作，它的標準庫仍然提供瞭反射機制來讓我們訪問成員信息，Swift 的反射機制是基於⼀個叫 Mirror 的結構體來實現的。然後就可以通過它查詢這個實例。

Mirror的基本使用如下

class LGTeacher {
    var age:Int = 18
    func teach() {
        print("teach")
    }
}
//⾸先通過構造⽅法構建⼀個Mirror實例，這⾥傳⼊的參數是 Any，也就意味著當前可以是類，結構體，枚舉等
let mirror = Mirror(reflecting: LGTeacher())
//接下來遍歷 children 屬性，這是⼀個集合
for pro in mirror.children {
    //然後我們可以直接通過 label 輸出當前的名稱，value 輸出當前反射的值
    print("\(pro.label) : \(pro.value)")
}

Mirror的簡單應用-JSON解析

class LGTeacher {
    var age:Int = 18
    var name = "FY"
}
enum JSONMapError: Error {
    case emptyKey
    case notConformProtocol
}
protocol JSONMap {
    func jsonMap() -> Any
}
extension JSONMap {
    func jsonMap() -> Any {
        let mirror = Mirror(reflecting: self)
        guard !mirror.children.isEmpty else {
            return self
        }
     
        var result: [String: Any] = [:]
      
        for child in mirror.children {
            if let value = child.value as? JSONMap {
                if let key = child.label {
                    result[key] = try? value.jsonMap()
                }
            } else {
                return JSONMapError.notConformProtocol
            }
        }        
        return result
    }
}
extension LGTeacher: JSONMap{}
extension Int: JSONMap{}
extension String: JSONMap{}
print(LGTeacher().jsonMap())
//
["age": 18, "name": "FY"]

Mirror源碼解析

⾸先我們現在源⽂件⾥⾯搜索Mirror.Swift，在源碼中我們可以很清晰的看到Mirror是由結構體實現的，我們忽略掉⼀些細節，快速定位到初始化的⽅法

public init(reflecting subject: Any) {
    if case let customized as CustomReflectable = subject {
        self = customized.customMirror
    } else {
        self = Mirror(internalReflecting: subject)
    }
}

可以看到，這⾥接受⼀個Any類型的參數，同樣的這⾥有⼀個if case的寫法來判斷當前的subject是否遵循瞭customReflectable協議，如果是我們就直接調⽤customMirror, 否則就進⾏下級函數的調⽤。

這⾥有兩個需要註意的點if case的寫法，這⾥其實枚舉Case的模式匹配，和我們的Switch⼀樣，這⾥是隻有⼀個case的 switch 語句。

於此同時這⾥出現瞭⼀個customRefletable的協議。我們來看一下它的用法。⾸先我們遵循 customReflectable 協議，並實現其中的屬性customMirror，customMirror會返回⼀個Mirror對象。代碼如下：

這裡通過遵循customReflectable 協議並實現瞭其中的計算屬性customMirror，主要作用是當我們使用lldb debug的時候，可以提供詳細的屬性信息。

我們接下來看如果不遵循customRefletable協議的類，那麼就會走Mirror(internalReflecting: subject)代碼。

全局搜索internalReflecting，在ReflectionMirror.swift文件裡面找到瞭這個方法的具體實現。

從代碼裡面我們可以看到，首先需要獲取subject的真實類型信息。然後再獲取subject的屬性信息。而獲取subject的真實類型信息則是通過_getNormalizedType這個方法來獲取的。搜索這個方法，然後我們就可以找到它的代碼。

這裡使用瞭一個編譯器字段 @ silgen_name 其實是 Swift 的一個隱藏符號，作用是將某個 C/C++語言函數直接映射為 Swift 函數。也可以理解為為 C++ 代碼的 swift_reflectionMirror_normalizedType 函數定義一個在 swift 中使用的別名 _getNormalizedType。

所以調用瞭_getNormalizedType方法實際上是調用瞭swift_reflectionMirror_normalizedType方法，我在ReflectionMirror.cpp文件中找到瞭具體實現。

從代碼裡面可以知道，通過call函數調用瞭ReflectionMirrorImpl類，然後返回這個類的類型。

我們先看一下ReflectionMirrorImpl類的具體內容。

從註釋中，我們可以知道，這是一個抽象基類，也就是說不同的類型反射需要不同的類實現。

我們接下來看一下call函數的具體實現

在call函數中有一個Switch方法。根據不同的類型，調用不同的ReflectionMirrorImpl類。我們就取EnumIpml類去探個究竟。

上面代碼就是EnumIpml類的具體實現。首先是isReflectable()這個方法。這個方法返回這個類型是否可以被反射，也就是找到metadata，再找到metadata中存儲的Description，通過它裡面存儲的 isReflectable來確定。

接下來我們看一下getInfo方法。在代碼裡面我們可以看到，獲取name、info屬性信息主要是通過getFieldAt來獲取。我們現在就去查看getFieldAt方法。具體代碼如下：

static std::pair&lt;StringRef /*name*/, FieldType /*fieldInfo*/&gt;
getFieldAt(const Metadata *base, unsigned index) {
    using namespace reflection;
    auto failedToFindMetadata = [&amp;]() -&gt; std::pair&lt;StringRef, FieldType&gt; {
        auto typeName = swift_getTypeName(base, /*qualified*/ true);
        missing_reflection_metadata_warning(
            "warning: the Swift runtime found no field metadata for "
            "type '%*s' that claims to be reflectable. Its fields will show up as "
            "'unknown' in Mirrors\n",
            (int)typeName.length, typeName.data);
        return {"unknown", FieldType(&amp;METADATA_SYM(EMPTY_TUPLE_MANGLING))};
    };
    auto *baseDesc = base-&gt;getTypeContextDescriptor();
    if (!baseDesc) return failedToFindMetadata();
    auto *fields = baseDesc-&gt;Fields.get();
    if (!fields) return failedToFindMetadata();
    auto &amp;field = fields-&gt;getFields()[index];
// Bounds are always valid as the offset is constant.
    auto name = field.getFieldName();
// Enum cases don't always have types.
    if (!field.hasMangledTypeName())
        return {name, FieldType::untypedEnumCase(field.isIndirectCase())};
    auto typeName = field.getMangledTypeName();
    SubstGenericParametersFromMetadata substitutions(base);
    auto result = swift_getTypeByMangledName(
        MetadataState::Complete, typeName, substitutions.getGenericArgs(),
        [&amp;substitutions](unsigned depth, unsigned index) {
            return substitutions.getMetadata(depth, index);
        },
        [&amp;substitutions](const Metadata *type, unsigned index) {
        return substitutions.getWitnessTable(type, index);
    });
// If demangling the type failed, pretend it's an empty type instead with
// a log message.
    TypeInfo typeInfo;
    if (result.isError()) {
        typeInfo = TypeInfo({&amp;METADATA_SYM(EMPTY_TUPLE_MANGLING),
        MetadataState::Complete}, {});
        auto *error = result.getError();
        char *str = error-&gt;copyErrorString();
        missing_reflection_metadata_warning(
            "warning: the Swift runtime was unable to demangle the type "
            "of field '%*s'. the mangled type name is '%*s': %s. this field will "
            "show up as an empty tuple in Mirrors\n",
            (int)name.size(), name.data(), (int)typeName.size(), typeName.data(),
            str);
        error-&gt;freeErrorString(str);
    } else {
        typeInfo = result.getType();
    }
    auto fieldType = FieldType(typeInfo.getMetadata());
    fieldType.setIndirect(field.isIndirectCase());
    fieldType.setReferenceOwnership(typeInfo.getReferenceOwnership());
    fieldType.setIsVar(field.isVar());
    return {name, fieldType};

這裡可以看到可以看到所有的信息都是通過Metadata、getDescription()、FieldDescrition 這幾個東西來去實現的，⼀個是當前類型的元數據，⼀個是當前類型的描述，⼀個是對當前類型屬性的描述。

Enum Metadata探索

我們在類和結構體這篇文章裡面，描述瞭類的Metadata結構，並把它的C++代碼轉換成瞭Swift代碼。我們這次來嘗試轉換Enum和struct的MetaData結構。首先來探索Enum的Metadata結構。

還原TargetEnumMetadata

通過源碼全局搜索EnumMetadata，我們找到瞭TargetEnumMetadata。沿著TargetEnumMetadata的繼承鏈往上查找，TargetEnumMetadata-> TargetValueMetadata -> TargetMetadata

struct TargetEnumMetadata : public TargetValueMetadata<Runtime> {
}
struct TargetValueMetadata : public TargetMetadata<Runtime> {
    TargetSignedPointer<Runtime, const TargetValueTypeDescriptor<Runtime> *Description;
}
struct TargetMetadata {
    StoredPointer Kind;
}

從上面的源碼中我們可以知道，TargetMetadata有一個屬性Kind，這個Kind主要是存儲MetadataKind類，是個int_32類型。TargetValueMetadata裡面有Description屬性，因此我們可以把TargetEnumMetadata轉成這樣的結構體

struct TargetEnumMetadata {
    var kind: Int
    var typeDescriptor: UnsafeRawPointer
}

還原TargetEnumDescriptor

接下來，我們要還原typeDescriptor的結構，雖然在TargetValueMetadata類中是TargetValueTypeDescriptor類，而我們在TargetMetadata發現Description屬性是TargetEnumDescriptor類，所以，Description屬性和TargetMetadata一樣，應該也是有繼承鏈的。

在TargetMetadata源碼中，獲取Description屬性的方法是這樣的：

const TargetEnumDescriptor<Runtime> *getDescription() const {
    return llvm::cast<TargetEnumDescriptor<Runtime>>(this->Description);
}

然後我們去源碼裡面查看TargetEnumDescriptor類，得到它的繼承鏈TargetEnumDescriptor-> TargetValueTypeDescriptor -> TargetTypeContextDescriptor-> TargetContextDescriptor 它們包含的屬性的代碼如下：

class TargetEnumDescriptor final : public TargetValueTypeDescriptor<Runtime>,
        public TrailingGenericContextObjects<TargetEnumDescriptor<Runtime>,
        TargetTypeGenericContextDescriptorHeader,
/*additional trailing objects*/
        TargetForeignMetadataInitialization<Runtime>,
        TargetSingletonMetadataInitialization<Runtime>,
        TargetCanonicalSpecializedMetadatasListCount<Runtime>,
        TargetCanonicalSpecializedMetadatasListEntry<Runtime>,
        TargetCanonicalSpecializedMetadatasCachingOnceToken<Runtime>> {
    uint32_t NumPayloadCasesAndPayloadSizeOffset;
    uint32_t NumEmptyCases;
}
class TargetValueTypeDescriptor: public TargetTypeContextDescriptor<Runtime> {
}
class TargetTypeContextDescriptor: public TargetContextDescriptor<Runtime> {
    TargetRelativeDirectPointer<Runtime, const char, /*nullable*/ false> Name;
    TargetRelativeDirectPointer<Runtime, MetadataResponse(...), /*Nullable*/ true> AccessFunctionPtr;
    TargetRelativeDirectPointer<Runtime, const reflection::FieldDescriptor,/*nullable*/ true> Fields;
}
struct TargetContextDescriptor {
    ContextDescriptorFlags Flags;
    TargetRelativeContextPointer<Runtime> Parent;
}

從上面的代碼我們可以把TargetEnumDescriptor使用Swift把它還原出來，還原的代碼如下：

struct TargetEnumDescriptor{
    var flags: Int32
    var parent: TargetRelativeDirectPointer<UnsafeRawPointer>
    var name: TargetRelativeDirectPointer<CChar>
    var accessFunctionPointer: TargetRelativeDirectPointer<UnsafeRawPointer>
    var fieldDescriptor: TargetRelativeDirectPointer<UnsafeRawPointer>
    var NumPayloadCasesAndPayloadSizeOffset: UInt32
    var NumEmptyCases: UInt32
}

此時TargetMetadata中的數據結構也可以修改一下

struct TargetEnumMetadata{
    var kind: Int
    var typeDescriptor: UnsafeMutablePointer<TargetEnumDescriptor>
}

相對偏移指針

在上面的源碼中，我們可以發現，TargetValueTypeDescriptor中的屬性、比如name、Fields等，他們的類型都是用TargetRelativeDirectPointer來定義。我們現在來看一下TargetRelativeDirectPointer是什麼？

從上面的源碼定義可以知道，它是一個模板類，（接收三個參數，⼀個是Runtime, ⼀個是Pointee , Bool類型默認為True）。接下來我們看一下RelativeDirectPointer。

這個指針類代碼比較簡單，其中 T 就是我們進來的類型，Offset就是int32_t 的類型，從字面意思上看應該是偏移量之類的。我們再看下它的get()方法。

從以上代碼，我們可以看出TargetRelativeDirectPointer應該是一個用來相對尋址的指針類。在 Swift中引⽤⼀個實例對象有兩種情況：一種是直接尋址，另外一種是相對尋址。比如 TargetEnumDescriptor 中的 Name，這個 Name 存儲的值並不是 Name 表意上的值，Name存儲的是一個叫做相對偏移量或者叫偏移信息。此時，我們拿到 Name 的值的內存地址做法是：Name 的內存地址 + 相對偏移量。在 Swift 裡面有很多這樣的偏移信息，這樣做可以節省內存空間，避免存儲大量的內存地址。

對此，我們把TargetRelativeDirectPointer給還原出來。還原代碼如下：

struct TargetRelativeDirectPointer<Pointee>{
    var offset: Int32
    
    mutating func getmeasureRelativeOffset() -> UnsafeMutablePointer<Pointee>{
        let offset = **self**.offset   
        return withUnsafePointer(to: &self) { p in
           return UnsafeMutablePointer(mutating: UnsafeRawPointer(p).advanced(by: numericCast(offset)).assumingMemoryBound(to: Pointee.self))
        }
    }
}

打印枚舉中的屬性

最後，我們來打印一下枚舉中的屬性。代碼如下：

enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}
let ptr = unsafeBitCast(Planet.self as Any.Type to:UnsafeMutablePointer<TargetEnumMetadata>.self)
let namePtr = ptr.pointee.typeDescriptor.pointee.name.getmeasureRelativeOffset()
print("name: ",String(cString: namePtr))
print("NumPayloadCasesAndPayloadSizeOffset ",ptr.pointee.typeDescriptor.pointee.NumPayloadCasesAndPayloadSizeOffset)
print("NumEmptyCases ",ptr.pointee.typeDescriptor.pointee.NumEmptyCases)

打印結果如下

name:  Planet
NumPayloadCasesAndPayloadSizeOffset  0
NumEmptyCases  8

Struct Metadata探索

現在我們來解析一下struct類型的Metadata。

首先，和上面的Enum一樣，通過全局搜索，找到struct的MetaData是TargetStructMetadata類。通過它的繼承鏈TargetStructMetadata-> TargetValueMetadata -> TargetMetadata可以知道，TargetStructMetadata的數據結構和TargetEnumMetadata一樣，因此，我們可以還原一下 TargetStructMetadata的數據結構如下：

struct TargetStructMetadata {
    var kind: Int
    var typeDescriptor: UnsafeRawPointer
}

然後，我們去尋找typeDescriptor的類型，從TargetStructMetadata的源碼中，我們找到typeDescriptor的類型是TargetStructDescriptor。我們去搜索TargetStructDescriptor的源碼，得到瞭TargetStructDescriptor類的定義以及屬性如下：

class TargetStructDescriptor final: public TargetValueTypeDescriptor<Runtime>,
        public TrailingGenericContextObjects<TargetStructDescriptor<Runtime>,
                TargetTypeGenericContextDescriptorHeader,
/*additional trailing objects*/
                TargetForeignMetadataInitialization<Runtime>,
                TargetSingletonMetadataInitialization<Runtime>,
                TargetCanonicalSpecializedMetadatasListCount<Runtime>,
                TargetCanonicalSpecializedMetadatasListEntry<Runtime>,
                TargetCanonicalSpecializedMetadatasCachingOnceToken<Runtime>> {
    uint32_t NumFields;
    uint32_t FieldOffsetVectorOffset;
}

從源碼中我們可以看到，TargetStructDescriptor繼承自TargetValueTypeDescriptor，因此繼承鏈和TargetEnumDescriptor一樣，我們還原出來的TargetStructDescriptor的數據結構如下：

struct TargetStructDescriptor{
    var flags: Int32
    var parent: TargetRelativeDirectPointer<UnsafeRawPointer>
    var name: TargetRelativeDirectPointer<CChar>
    var accessFunctionPointer: TargetRelativeDirectPointer<UnsafeRawPointer>
    var fieldDescriptor: TargetRelativeDirectPointer<FieldDescriptor>
    var NumFields: UInt32
    var FieldOffsetVectorOffset: UInt32
    ```
    func getFieldOffsets(_ metadata: UnsafeRawPointer) -> UnsafePointer<Int32> {
            return UnsafeRawPointer(metadata.assumingMemoryBound(to: Int.self).advanced(by: numericCast(self.FieldOffsetVectorOffset))).assumingMemoryBound(to: Int32.self)
    }
    //參考handyjson 中
    var genericArgumentOffset: Int {
        return 2
    }

}

此時`TargetStructMetadata`中的數據結構也可以修改一下
```swift
struct TargetStructMetadata{
    var kind: Int
    var typeDescriptor: UnsafeMutablePointer<TargetStructDescriptor>
}

接著我們還原FieldDescriptor的數據結構。我們先找到FieldDescriptor類的源碼，找出它的屬性，和方法，代碼如下：

class FieldDescriptor {
    const FieldRecord *getFieldRecordBuffer() const {
        return reinterpret_cast<const FieldRecord *>(this + 1);
    }
public:
    const RelativeDirectPointer<const char> MangledTypeName;
    const RelativeDirectPointer<const char> Superclass;
    FieldDescriptor() = delete;
    const FieldDescriptorKind Kind;
    const uint16_t FieldRecordSize;
    const uint32_t NumFields;
    llvm::ArrayRef<FieldRecord> getFields() const {
        return {getFieldRecordBuffer(), NumFields};
    }
}

我們來看一下getFields()方法，這個方法就是獲取 fields 的方法，fields 存的是 FieldRecords，通過getFieldRecordBuffer()來讀取FieldRecords。

在getFieldRecordBuffer()方法中，通過 reinterpret_cast 將 (this + 1) 強制轉換成 FieldRecord * 類型。所以我們可以推測這個 fields 是一塊連續的內存空間，這一塊連續的內存空間存儲的是 FieldRecord 類型，並且 NumFields 是它的容量大小。

在 C++ 中， this 是一個指向該對象的指針，由於它是一個指針，因此它可以應用指針算術甚至數組索引。如果這個 this 是數組中的一個元素，(this + 1) 則將指向數組中的下一個對象。

所以我們可以把FieldDescriptor的數據結構還原成下面結構。

struct FieldDescriptor {
    var MangledTypeName: TargetRelativeDirectPointer<CChar>
    var Superclass: TargetRelativeDirectPointer<CChar>
    var Kind: UInt16
    var FieldRecordSize:UInt16
    var NumFields: UInt32
    var fields: FieldRecordBuffer<FieldRecord>
}

其中FieldRecordBuffer我們可以把它還原成一個有連續空間的數組，容量為NumFields，存儲的是FieldRecord。還原結構如下：

struct FiledRecordBuffer<Element>{
    var element: Element    
    mutating func buffer(n: Int) -> UnsafeBufferPointer<Element> {
        return withUnsafePointer(to: &self) {
            let ptr = $0.withMemoryRebound(to: Element.self, capacity: 1) { start in
                return start
            }
            return UnsafeBufferPointer(start: ptr, count: n)
        }
    }
    
    mutating func index(of i: Int) -> UnsafeMutablePointer<Element> {
        return withUnsafePointer(to: &self) {
            return UnsafeMutablePointer(mutating: UnsafeRawPointer($0).assumingMemoryBound(to: Element.self).advanced(by: i))
        }
    }
}

最後我們看一下FieldRecord的源碼，得到的源碼屬性如下：

class FieldRecord {
    const FieldRecordFlags Flags;
public:
    const RelativeDirectPointer<const char> MangledTypeName;
    const RelativeDirectPointer<const char> FieldName;
}

還原FieldRecord得到的數據結構如下：

struct FieldRecord {
    var Flags: UInt32
    var MangledTypeName: TargetRelativeDirectPointer<CChar>
    var FieldName: TargetRelativeDirectPointer<CChar>
}

至此，我們把結構體的MetaData結構都還原出來。

獲取結構體的屬性

現在我們來驗證一下結構體，獲取結構體的屬性。代碼如下：

@_silgen_name("swift_getTypeByMangledNameInContext")
func swift_H_getTypeByMangledNameInContext(typeName: UnsafeRawPointer, len: Int, context: UnsafeRawPointer, generic: UnsafeRawPointer) -> UnsafeRawPointer
protocol BridgeProtocol {
}
extension BridgeProtocol {
    static func get(from pointer: UnsafeRawPointer) -> Any {
        pointer.assumingMemoryBound(to: Self.self).pointee
    }
}
struct BridgeProtocolMetadata {
    let type: Any.Type
    let witness: Int
}
func customCast(type: Any.Type) -> BridgeProtocol.Type {
    let container = BridgeProtocolMetadata(type: type, witness: 0)
    let cast = unsafeBitCast(container, to: BridgeProtocol.Type.self)
    return cast
}
struct LGStudent {
    var age = 18
    var name = "FWJ"
    let money = 2000
}
var t = LGStudent()
let ptr = unsafeBitCast(LGStudent.self as Any.Type, to: UnsafeMutablePointer<TargetStructMetadata>.self)
print("----------開始解析---------------")
let namePtr = ptr.pointee.typeDescriptor.pointee.name.getmeasureRelativeOffset()
let filedNum = ptr.pointee.typeDescriptor.pointee.NumFields
print("當前結構體的名稱: \(String(cString: namePtr))")
print("當前結構體的屬性數量 \(filedNum)")
print("============開始解析屬性============")
let offsets = ptr.pointee.typeDescriptor.pointee.getFieldOffsets(UnsafeRawPointer(ptr).assumingMemoryBound(to: Int.self))
for i in 0..<filedNum {
    let fieldRecord = ptr.pointee.typeDescriptor.pointee.fieldDescriptor.getmeasureRelativeOffset().pointee.fields.index(of: Int(i))
   
    let fieldOffset = offsets[Int(i)]
    let fieldName = fieldRecord.pointee.FieldName.getmeasureRelativeOffset()
    print("--- \(String(cString: fieldName)) 屬性信息 ---")    
    let mangledTypeName = fieldRecord.pointee.MangledTypeName.getmeasureRelativeOffset()
    print("mangledTypeName: \(String(cString: mangledTypeName))")
    
    let typeNameLength = Int(256)    
    let genericVector = UnsafeRawPointer(ptr).advanced(by: ptr.pointee.typeDescriptor.pointee.genericArgumentOffset * MemoryLayout<UnsafeRawPointer>.size).assumingMemoryBound(to: Any.Type.self)
    
    **let** fieldType = swift_H_getTypeByMangledNameInContext(typeName: mangledTypeName, len: typeNameLength, context: UnsafeRawPointer(ptr.pointee.typeDescriptor), generic: genericVector)
    let type = unsafeBitCast(fieldType, to: Any.Type.self)
    print("fieldType: \(type)")    
    let brigeProtocolType = customCast(type: type)
    
    let instanceAddress = withUnsafePointer(to: &t) {
        return UnsafeRawPointer($0)
    }
       
    let fieldValue = brigeProtocolType.get(from: instanceAddress.advanced(by: Int(fieldOffset)))
    print("fieldValue: \(fieldValue)")
    print("--- \(String(cString: fieldName)) 屬性信息 ---")
}
//打印結果
----------開始解析---------------
當前結構體的名稱: LGStudent**
當前結構體的屬性數量 3
============開始解析屬性============
--- age 屬性信息 ---
mangledTypeName: Si
fieldType: Int
fieldValue: 18
--- age 屬性信息 ---
--- name 屬性信息 ---
mangledTypeName: SS
fieldType: String
fieldValue: FWJ
--- name 屬性信息 ---
--- money 屬性信息 ---
mangledTypeName: Si
fieldType: Int
fieldValue: 2000
--- money 屬性信息 ---

swift_getTypeByMangledNameInContext 函數

這個函數的源碼在MetadataLookup.cpp文件中，我們來看一下它的具體實現

SWIFT_CC(swift) SWIFT_RUNTIME_EXPORT
const Metadata * _Nullable
swift_getTypeByMangledNameInContext(
                             const char *typeNameStart,
                             size_t typeNameLength,
                             const TargetContextDescriptor<InProcess> *context,
                             const void * const *genericArgs) {
    llvm::StringRef typeName(typeNameStart, typeNameLength);
    SubstGenericParametersFromMetadata substitutions(context, genericArgs);
    return swift_getTypeByMangledName(MetadataState::Complete, typeName,
                                genericArgs,
                                [&substitutions](unsigned depth, unsigned index) {
                                    return substitutions.getMetadata(depth, index);
                                },
                                [&substitutions](const Metadata *type, unsigned index) {
                                    return substitutions.getWitnessTable(type, index);
                                }).getType().getMetadata();
}

這個函數返回的是Metadata類型的指針，也就是Swift函數中的Type類型。可以通過這個函數獲取到每個函數的類型。但是這個函數是C++函數，需要把它轉換成Swift函數。這裡參考瞭HandyJSON這個第三方庫，使用@_silgen_name映射成swift函數。具體代碼如下：

@_silgen_name("swift_getTypeByMangledNameInContext")
func swift_H_getTypeByMangledNameInContext(typeName: UnsafeRawPointer, len: Int, context: UnsafeRawPointer, generic: UnsafeRawPointer) -> UnsafeRawPointer

獲取屬性的值

我們可以根據類型和 FieldOffsetVectorOffset屬性值存儲相對於實例的偏移量獲取屬性值，獲取屬性值存儲的指針。參考 HandyJSON 通過協議中Self 代表真實的類型去讀取指針的值。代碼如下：

protocol BridgeProtocol {
}
extension BridgeProtocol {
    static func get(from pointer: UnsafeRawPointer) -> Any {
        pointer.assumingMemoryBound(to: Self.self).pointee
    }
}
struct BridgeProtocolMetadata {
    let type: Any.Type
    let witness: Int
}
func customCast(type: Any.Type) -> BridgeProtocol.Type {
    let container = BridgeProtocolMetadata(type: type, witness: 0)
    let cast = unsafeBitCast(container, to: BridgeProtocol.Type.self)
    return cast
}

這個函數傳入一個Any.Type的類型，通過它來創建一個協議的 Metadata結構相同的BrigeProtocolMetadata實例
通過 BrigeProtocolMetadata轉換成協議的 BrigeProtocol.Type.self，也就是協議的 Metadata，那麼此時這個協議類型可以獲取到屬性的真實類型
將屬性值指針轉換為 Self類型的類型指針，通過pointee就可以獲取真實的值

以上就是Swift進階教程Mirror反射示例詳解的詳細內容，更多關於Swift進階Mirror反射的資料請關註WalkonNet其它相關文章！

Swift進階教程Mirror反射示例詳解

目錄

元類型與.self

AnyObject

AnyClass

Any

type(Of:)

self

self在方法裡面的作用

Self引用

Swift Runtime

Mirror

Mirror的基本用法

Mirror的簡單應用-JSON解析

Mirror源碼解析

Enum Metadata探索

還原TargetEnumMetadata

還原TargetEnumDescriptor

相對偏移指針

打印枚舉中的屬性

Struct Metadata探索

獲取結構體的屬性

swift_getTypeByMangledNameInContext 函數

獲取屬性的值

推薦閱讀：

發佈留言取消回覆

近期文章

目錄

元類型與.self

AnyObject

AnyClass

Any

type(Of:)

self

self在方法裡面的作用

Self引用

Swift Runtime

Mirror

Mirror的基本用法

Mirror的簡單應用-JSON解析

Mirror源碼解析

Enum Metadata探索

還原TargetEnumMetadata

還原TargetEnumDescriptor

相對偏移指針

打印枚舉中的屬性

Struct Metadata探索

獲取結構體的屬性

swift_getTypeByMangledNameInContext 函數

獲取屬性的值

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆