# 03 知识点梳理：iOS底层 ## 1 KVC原理 `KVC`可以通过`Key`直接访问对象的属性，可以方便的在运行时对对象的属性进行访问和修改。 > **需要注意的是:** 有时我们通过`KVC`去修改系统控件未暴露出的属性的时候，会出现部分内部API进行了调整导致崩溃。 **1.1 API** ```Swift - (void)setValue:(id)value forKeyPath:(NSString *)keyPath; - (void)setValue:(id)value forKey:(NSString *)key; - (id)valueForKeyPath:(NSString *)keyPath; - (id)valueForKey:(NSString *)key; ``` `forKeyPath` 用于访问对象内对象属性的属性，如：`user.name` **1.2 写过程** * 查看`setKey:`方法是否存在, 如果存在直接调用, 如果不存在进入下一步 * 查看`_setKey:`方法是否存在, 如果存在直接调用, 如果不存在进入下一步 * 查看`+ (BOOL)accessInstanceVariablesDirectly`方法的返回值, 默认返回`YES` * `YES`: 可以访问成员变量, 进入下一步 * `NO`: 不可以访问成员变量, 同时调用`- (void)setValue:(id)value forUndefinedKey:(NSString *)key`方法, 如果方法不存在会抛出异常 * 调用成员变量:`_key`, `_isKey`, `key`, `isKey` * 调用顺序, 从左到右, 只有发现存在成员变量, 就不会在调用后续变量 * 如果没有成员变量, 会调用`- (void)setValue:(id)value forUndefinedKey:(NSString *)key`方法, 如果方法不存在会抛出异常 **1.3 读过程** * 判断是否有这几个方法: `getKey`, `key`, `isKey`, `_key` * 从左到右, 如果有方法, 直接调用, 取值结束 * 如果没有进入下一步 * 调用+ (BOOL)accessInstanceVariablesDirectly查看是否可以访问成员变量. 默认`YES` * `YES`: 可以访问成员变量, 进入下一步 * `NO`: 不可以访问成员变量, 判断是否实现`- (id)valueForUndefinedKey:(NSString *)key`方法, 实现时调用, 未实现报错 * 判断是否有这几个成员变量: `_key`, `_isKey`, `key`, `isKey` * 从左到右, 如果有成员变量, 直接访问, 取值结束 * 如果没有这几个成员变量, 直接进入下一步 * 判断是否实现`- (id)valueForUndefinedKey:(NSString *)key`方法, 实现时调用, 未实现报错 **1.4 如何禁用KVC** 如果重写了类方法 `+ (BOOL)accessInstanceVariablesDirectly` 返回 `NO` 的话，那么会直接调用 `valueForUndefinedKey:` 方法，默认是抛出异常 ## 2 讲一下atomic的实现机制；为什么不能保证绝对的线程安全（最好可以结合场景来说）？ **A: atomic的实现机制** * `atomic`是`property`的修饰词之一，表示是原子性的，使用方式为`@property(atomic)int age`;此时编译器会自动生成 `getter/setter` 方法，最终会调用`objc_getProperty`和`objc_setProperty`方法来进行存取属性。 * 若此时属性用`atomic`修饰的话，在这两个方法内部使用`os_unfair_lock` 来进行加锁，来保证读写的原子性。锁都在`PropertyLocks` 中保存着（在iOS平台会初始化8个，mac平台64个），在用之前，会把锁都初始化好，在需要用到时，用对象的地址加上成员变量的偏移量为`key`，去`PropertyLocks`中去取。因此存取时用的是同一个锁，所以atomic能保证属性的存取时是线程安全的。 * 注：由于锁是有限的，不用对象，不同属性的读取用的也可能是同一个锁 **B: atomic为什么不能保证绝对的线程安全？** * `atomic`在`getter/setter`方法中加锁，仅保证了存取时的线程安全，假设我们的属性是`@property(atomic)NSMutableArray *array`;可变的容器时,无法保证对容器的修改是线程安全的. * 在编译器自动生产的`getter/setter`方法，最终会调用`objc_getProperty`和`objc_setProperty`方法存取属性，在此方法内部保证了读写时的线程安全的，当我们重写`getter/setter`方法时，就只能依靠自己在`getter/setter`中保证线程安全 ## 3 Autoreleasepool所使用的数据结构是什么？AutoreleasePoolPage结构体了解么？ * `Autoreleasepool`是由多个`AutoreleasePoolPage`以双向链表的形式连接起来的. * `Autoreleasepool`的基本原理：在每个自动释放池创建的时候，会在当前的`AutoreleasePoolPage`中设置一个标记位，在此期间，当有对象调用`autorelsease`时，会把对象添加 `AutoreleasePoolPage`中 * 若当前页添加满了，会初始化一个新页，然后用双向量表链接起来，并把新初始化的这一页设置为`hotPage`,当自动释放池pop时，从最下面依次往上pop，调用每个对象的`release`方法，直到遇到标志位。 **`AutoreleasePoolPage`结构如下** ```C++ class AutoreleasePoolPage { magic_t const magic; id *next;//下一个存放autorelease对象的地址 pthread_t const thread; //AutoreleasePoolPage 所在的线程 AutoreleasePoolPage * const parent;//父节点 AutoreleasePoolPage *child;//子节点 uint32_t const depth;//深度,也可以理解为当前page在链表中的位置 uint32_t hiwat; } ``` ## 4 iOS中内省的几个方法？class方法和objc\_getClass方法有什么区别? **4.1 什么是内省？** > 在计算机科学中，内省是指计算机程序在运行时（Run time）检查对象（Object）类型的一种能力，通常也可以称作运行时类型检查。 不应该将内省和反射混淆。相对于内省，反射更进一步，是指计算机程序在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力。 **4.2 iOS中内省的几个方法？** * `isMemberOfClass` //对象是否是某个类型的对象 * `isKindOfClass` //对象是否是某个类型或某个类型子类的对象 * `isSubclassOfClass` //某个类对象是否是另一个类型的子类 * `isAncestorOfObject` //某个类对象是否是另一个类型的父类 * `respondsToSelector` //是否能响应某个方法 * `conformsToProtocol` //是否遵循某个协议\* **4.3 `class`方法和`object_getClass`方法有什么区别?** * 实例`class`方法就直接返回`object_getClass(self)` * 类`class`方法直接返回`self`，而`object_getClass`(类对象)，则返回的是元类 ## 5 分类和扩展有什么区别？可以分别用来做什么？分类有哪些局限性？分类的结构体里面有哪些成员？ * 分类 * 主要用来为某个类添加方法，属性，协议（我一般用来为系统的类扩展方法或者把某个复杂的类的按照功能拆到不同的文件里） * 扩展 * 主要用来为某个类原来没有的成员变量、属性、方法。注：方法只是声明（我一般用扩展来声明私有属性，或者把.h的只读属性重写成可读写的） **分类和扩展的区别：** * 分类是在运行时把分类信息合并到类信息中，而扩展是在编译时，就把信息合并到类中的 * 分类声明的属性，只会生成`getter/setter`方法的声明，不会自动生成成员变量和`getter/setter`方法的实现，而扩展会 * 分类不可用为类添加实例变量，而扩展可以 * 分类可以为类添加方法的实现，而扩展只能声明方法，而不能实现 **分类的局限性：** * 无法为类添加实例变量，但可通过关联对象进行实现，注：关联对象中内存管理没有weak，用时需要注意野指针的问题，可通过其他办法来实现，具体可参考[iOS weak 关键字漫谈](http://mrpeak.cn/blog/ios-weak/) * 分类的方法若和类中原本的实现重名，会覆盖原本方法的实现，注：并不是真正的覆盖 * 多个分类的方法重名，会调用最后编译的那个分类的实现 **分类的结构体里有哪些成员** ```C++ struct category_t { const char *name; //名字 classref_t cls; //类的引用 struct method_list_t *instanceMethods;//实例方法列表 struct method_list_t *classMethods;//类方法列表 struct protocol_list_t *protocols;//协议列表 struct property_list_t *instanceProperties;//实例属性列表 // 此属性不一定真正的存在 struct property_list_t *_classProperties;//类属性列表 }; ``` ## 6 能不能简述一下 Dealloc 的实现机制 Dealloc 的实现机制是内容管理部分的重点，把这个知识点弄明白，对于全方位的理解内存管理的只是很有 必要。 **1.Dealloc 调用流程** * 1.首先调用 `_objc_rootDealloc()` * 2.接下来调用 `rootDealloc()` * 3.这时候会判断是否可以被释放，判断的依据主要有 5 个，判断是否有以上五种情况 * `NONPointer_ISA` * `weakly_reference` * `has_assoc` * `has_cxx_dtor` * `has_sidetable_rc` * 4-1.如果有以上五中任意一种，将会调用 `object_dispose()`方法，做下一步的处理。 * 4-2.如果没有之前五种情况的任意一种，则可以执行释放操作，`C 函数的 free()`。 * 5.执行完毕。 **2.object\_dispose() 调用流程**。 * 1.直接调用 `objc_destructInstance()`。 * 2.之后调用 C 函数的 free()。 **3.`objc_destructInstance()` 调用流程** * 1.先判断 `hasCxxDtor`，如果有 C++ 的相关内容，要调用 `object_cxxDestruct()` ，销毁 C++ 相关的内容。 * 2.再判断 `hasAssocitatedObjects`，如果有的话，要调用 `object_remove_associations()`， 销毁关联对象的一系列操作。 * 3.然后调用 `clearDeallocating()`。 * 4.执行完毕。 **4.`clearDeallocating()` 调用流程**。 * 1.先执行 `sideTable_clearDellocating()`。 * 2.再执行 `weak_clear_no_lock`，在这一步骤中，会将指向该对象的弱引用指针置为 `nil`。 * 3.接下来执行 `table.refcnts.eraser()`，从引用计数表中擦除该对象的引用计数。 * 4.至此为止，`Dealloc` 的执行流程结束。 ## 7 静态链接了解么？静态库和动态库的区别？ * 静态链接是指将多个目标文件合并为一个可执行文件，直观感觉就是将所有目标文件的段合并。需要注意的是可执行文件与目标文件的结构基本一致，不同的是是否“可执行”。 * 静态库：链接时完整地拷贝至可执行文件中，被多次使用就有多份冗余拷贝。 * 动态库：链接时不复制，程序运行时由系统动态加载到内存，供程序调用，系统只加载一次，多个程序共用，节省内存。 ## 8 App网络层有哪些优化策略？ * 优化DNS解析和缓存 * 对传输的数据进行压缩，减少传输的数据 * 使用缓存手段减少请求的发起次数 * 使用策略来减少请求的发起次数，比如在上一个请求未着地之前，不进行新的请求 * 避免网络抖动，提供重发机制 ## 9 \[self class] 与 \[super class] ```Swift @implementation Son : Father - (id)init { self = [super init]; if (self) { NSLog(@"%@", NSStringFromClass([self class])); NSLog(@"%@", NSStringFromClass([super class])); } return self; } @end ``` **self和super的区别：** * `self` 是类的一个隐藏参数，每个方法的实现的第一个参数即为`self`。 * super并不是隐藏参数，它实际上只是一个\*\*”编译器标示符”\*\*，它负责告诉编译器，当调用方法时，去调用父类的方法，而不是本类中的方法。 在调用`[super class]`的时候，`runtime`会去调用`objc_msgSendSuper`方法，而不是`objc_msgSend` ```Swift OBJC_EXPORT void objc_msgSendSuper(void /* struct objc_super *super, SEL op, ... */ ) /// Specifies the superclass of an instance. struct objc_super { /// Specifies an instance of a class. __unsafe_unretained id receiver; /// Specifies the particular superclass of the instance to message. #if !defined(__cplusplus) && !__OBJC2__ /* For compatibility with old objc-runtime.h header */ __unsafe_unretained Class class; #else __unsafe_unretained Class super_class; #endif /* super_class is the first class to search */ } ``` 在`objc_msgSendSuper`方法中，第一个参数是一个`objc_super`的结构体，这个结构体里面有两个变量，一个是接收消息的`receiver`，一个是当前类的父类`super_class`。 **入院考试第一题错误的原因就在这里，误认为`[super class]`是调用的`[super_class class]`。** **`objc_msgSendSuper`的工作原理应该是这样的:** * 从`objc_super`结构体指向的`superClass`父类的方法列表开始查找selector， * 找到后以`objc->receiver`去调用父类的这个`selector`。注意，最后的调用者是`objc->receiver`，而不是`super_class`！ **那么`objc_msgSendSuper`最后就转变成** ```Swift objc_msgSend(objc_super->receiver, @selector(class)) + (Class)class { return self; } ``` ## 10 isKindOfClass 与 isMemberOfClass 下面代码输出什么？ ```Swift @interface Sark : NSObject @end @implementation Sark @end int main(int argc, const char * argv[]) { @autoreleasepool { BOOL res1 = [(id)[NSObject class] isKindOfClass:[NSObject class]]; BOOL res2 = [(id)[NSObject class] isMemberOfClass:[NSObject class]]; BOOL res3 = [(id)[Sark class] isKindOfClass:[Sark class]]; BOOL res4 = [(id)[Sark class] isMemberOfClass:[Sark class]]; NSLog(@"%d %d %d %d", res1, res2, res3, res4); } return 0; } ``` 先来分析一下源码这两个函数的对象实现 ```Swift + (Class)class { return self; } - (Class)class { return object_getClass(self); } Class object_getClass(id obj) { if (obj) return obj->getIsa(); else return Nil; } inline Class objc_object::getIsa() { if (isTaggedPointer()) { uintptr_t slot = ((uintptr_t)this >> TAG_SLOT_SHIFT) & TAG_SLOT_MASK; return objc_tag_classes[slot]; } return ISA(); } inline Class objc_object::ISA() { assert(!isTaggedPointer()); return (Class)(isa.bits & ISA_MASK); } + (BOOL)isKindOfClass:(Class)cls { for (Class tcls = object_getClass((id)self); tcls; tcls = tcls->superclass) { if (tcls == cls) return YES; } return NO; } - (BOOL)isKindOfClass:(Class)cls { for (Class tcls = [self class]; tcls; tcls = tcls->superclass) { if (tcls == cls) return YES; } return NO; } + (BOOL)isMemberOfClass:(Class)cls { return object_getClass((id)self) == cls; } - (BOOL)isMemberOfClass:(Class)cls { return [self class] == cls; } ``` 首先题目中NSObject 和 Sark分别调用了class方法。 * `+ (BOOL)isKindOfClass:(Class)cls`方法内部，会先去获得`object_getClass`的类，而`object_getClass`的源码实现是去调用当前类的`obj->getIsa()`，最后在`ISA()`方法中获得`meta class`的指针。 * 接着在`isKindOfClass`中有一个循环，先判断`class`是否等于`meta class`，不等就继续循环判断是否等于`super class`，不等再继续取`super class`，如此循环下去。 ![](https://github.com/LGCooci/LGiOSQuestions/blob/master/%E8%B5%84%E6%BA%90%E6%96%87%E4%BB%B6/isa%E6%B5%81%E7%A8%8B%E5%9B%BE.png) * `[NSObject class]`执行完之后调用`isKindOfClass`，第一次判断先判断`NSObject` 和 `NSObject`的`meta class`是否相等，之前讲到`meta class`的时候放了一张很详细的图，从图上我们也可以看出，`NSObject`的`meta class`与本身不等。 * 接着第二次循环判断`NSObject`与`meta class`的`superclass`是否相等。还是从那张图上面我们可以看到：`Root class(meta)` 的`superclass` 就是 `Root class(class)`，也就是`NSObject`本身。所以第二次循环相等，于是第一行`res1`输出应该为`YES`。 * 同理，`[Sark class]`执行完之后调用`isKindOfClass`，第一次`for`循环，`Sark`的`Meta Class`与`[Sark class]`不等，第二次`for循环`，`Sark` `Meta Class的super class` 指向的是 `NSObject Meta Class`， 和 `Sark Class`不相等。 * 第三次for循环，`NSObject Meta Class`的`super class`指向的是`NSObject Class`，和 `Sark Class` 不相等。第四次循环，`NSObject Class`的 `super class` 指向 `nil`， 和 `Sark Class`不相等。第四次循环之后，退出循环，所以第三行的`res3输出为NO`。 * 如果把这里的Sark改成它的实例对象，`[sark isKindOfClass:[Sark class]`，那么此时就应该输出`YES`了。因为在`isKindOfClass`函数中，判断sark的`meta class`是自己的元类`Sark`，第一次for循环就能输出`YES`了。 * `isMemberOfClass`的源码实现是拿到自己的`isa指针`和自己比较，是否相等。 * 第二行`isa` 指向 `NSObject` 的 `Meta Class`，所以和 `NSObject Class`不相等。第四行，`isa`指向`Sark`的`Meta Class`，和`Sark Class`也不等，所以第二行`res2`和第四行`res4`都输出NO。 ## 11 Class与内存地址 **下面的代码会？`Compile Error / Runtime Crash / NSLog…?`** ```Swift @interface Sark : NSObject @property (nonatomic, copy) NSString *name; - (void)speak; @end @implementation Sark - (void)speak { NSLog(@"my name's %@", self.name); } @end @implementation ViewController - (void)viewDidLoad { [super viewDidLoad]; id cls = [Sark class]; void *obj = &cls; [(__bridge id)obj speak]; } @end ``` 这道题有两个难点。 * 难点一:`obj`调用`speak`方法，到底会不会崩溃。 * 难点二:如果`speak`方法不崩溃，应该输出什么？ **首先需要谈谈隐藏参数self和\_cmd的问题。** 当`[receiver message]`调用方法时，系统会在运行时偷偷地动态传入两个隐藏参数`self`和`_cmd`，之所以称它们为隐藏参数，是因为在源代码中没有声明和定义这两个参数。`self`在已经明白了，接下来就来说说`_cmd`。`_cmd`表示当前调用方法，其实它就是一个方法选择器`SEL`。 * 难点一，能不能调用`speak`方法？ ```Swift id cls = [Sark class]; void *obj = &cls; ``` 答案是可以的。`obj`被转换成了一个指向`Sark Class`的指针，然后使用`id`转换成了`objc_object`类型。`obj`现在已经是一个`Sark`类型的实例对象了。当然接下来可以调用speak的方法。 * 难点二，如果能调用`speak`，会输出什么呢？ **很多人可能会认为会输出sark相关的信息。这样答案就错误了。** 正确的答案会输出 `my name is ` > 内存地址每次运行都不同，但是前面一定是`ViewController。why？` 我们把代码改变一下，打印更多的信息出来。 ```Swift - (void)viewDidLoad { [super viewDidLoad]; NSLog(@"ViewController = %@ , 地址 = %p", self, &self); id cls = [Sark class]; NSLog(@"Sark class = %@ 地址 = %p", cls, &cls); void *obj = &cls; NSLog(@"Void *obj = %@ 地址 = %p", obj,&obj); [(__bridge id)obj speak]; Sark *sark = [[Sark alloc]init]; NSLog(@"Sark instance = %@ 地址 = %p",sark,&sark); [sark speak]; } ``` 我们把对象的指针地址都打印出来。输出结果： ```Swift ViewController = , 地址 = 0x7fff543f5aa8 Sark class = Sark 地址 = 0x7fff543f5a88 Void *obj = 地址 = 0x7fff543f5a80 my name is Sark instance = 地址 = 0x7fff543f5a78 my name is (null) ``` **objc\_msgSendSuper2 解读** ```Swift // objc_msgSendSuper2() takes the current search class, not its superclass. OBJC_EXPORT id objc_msgSendSuper2(struct objc_super *super, SEL op, ...) __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_2_0); ``` objc\_msgSendSuper2方法入参是一个objc\_super \*super。 ```Swift /// Specifies the superclass of an instance. struct objc_super { /// Specifies an instance of a class. __unsafe_unretained id receiver; /// Specifies the particular superclass of the instance to message. #if !defined(__cplusplus) && !__OBJC2__ /* For compatibility with old objc-runtime.h header */ __unsafe_unretained Class class; #else __unsafe_unretained Class super_class; #endif /* super_class is the first class to search */ }; #endif ``` 所以按viewDidLoad执行时各个变量入栈顺序从高到底为`self`, `_cmd`, `self.class`, `self`, `obj`。 * 第一个`self`和第二个`_cmd`是隐藏参数。 * 第三个`self.class`和第四个`self`是`[super viewDidLoad]`方法执行时候的参数。 * 在调用`self.name`的时候，本质上是`self`指针在内存向高位地址偏移一个指针。在32位下面，一`个指针是4字节=4*8bit=32bit`。**（64位不一样但是思路是一样的）** * 从打印结果我们可以看到，`obj`就是`cls`的地址。在`obj`向上偏移`32bit`就到了`0x7fff543f5aa8`，这正好是`ViewController`的地址。 **所以输出为my name is ``。** 至此，`Objc`中的对象到底是什么呢？ > 实质：`Objc`中的对象是一个指向`ClassObject`地址的变量，即 `id obj = &ClassObject` ， 而对象的实例变量 `void *ivar = &obj + offset(N)` 加深一下对上面这句话的理解，下面这段代码会输出什么？ ```Swift - (void)viewDidLoad { [super viewDidLoad]; NSLog(@"ViewController = %@ , 地址 = %p", self, &self); NSString *myName = @"halfrost"; id cls = [Sark class]; NSLog(@"Sark class = %@ 地址 = %p", cls, &cls); void *obj = &cls; NSLog(@"Void *obj = %@ 地址 = %p", obj,&obj); [(__bridge id)obj speak]; Sark *sark = [[Sark alloc]init]; NSLog(@"Sark instance = %@ 地址 = %p",sark,&sark); [sark speak]; } ViewController = , 地址 = 0x7fff56a48a78 Sark class = Sark 地址 = 0x7fff56a48a50 Void *obj = 地址 = 0x7fff56a48a48 my name is halfrost Sark instance = 地址 = 0x7fff56a48a40 my name is (null) ``` 由于加了一个字符串，结果输出就完全变了，`[(__bridge id)obj speak]`;这句话会输出`“my name is halfrost”` > 原因还是和上面的类似。按`viewDidLoad`执行时各个变量入栈顺序从高到底为`self`，`_cmd`，`self.class`，`self`，`myName`，`obj`。`obj`往上偏移32位，就是`myName`字符串，所以输出变成了输出`myName`了。 ## 12 iOS开发中的加密方式 iOS加密相关算法框架：`CommonCrypto`。 **1:对称加密： `DES、3DES、AES`** * 加密和解密使用同一个密钥。 * 加密解密过程： * `明文->密钥加密->密文`， * `密文->密钥解密->明文`。 * 优点：算法公开、计算量少、加密速度快、加密效率高、适合大批量数据加密； * 缺点：双方使用相同的密钥，密钥传输的过程不安全，易被破解，因此为了保密其密钥需要经常更换。 > AES：AES又称高级加密标准，是下一代的加密算法标准，支持128、192、256位密钥的加密，加密和解密的密钥都是同一个。iOS一般使用ECB模式，16字节128位密钥。 AES算法主要包括三个方面：**轮变化**、**圈数**和**密钥扩展**。 * 优点：高性能、高效率、灵活易用、安全级别高。 * 缺点：加密与解密的密钥相同，所以前后端利用AES进行加密的话，如何安全保存密钥就成了一个问题。 > DES：数据加密标准，DES算法的入口参数有三个：`Key`、`Data`、`Mode`。 * 其中Key为7个字节共56位，是DES算法的工作密钥；Data为8个字节64位，是要被加密或被解密的数据；Mode为DES的工作方式，有两种：**加密、解密**。 * 缺点：与AES相比，安全性较低。 > 3DES：3DES是DES加密算法的一种模式，它使用3条64位的密钥对数据进行三次加密。是DES向AES过渡的加密算法，是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。 **2.非对称加密:RSA加密** * 非对称加密算法需要成对出现的两个密钥，公开密钥(`publickey`) 和私有密钥(`privatekey`) 。 * \*\*加密解密过程：\*\*对于一个私钥，有且只有一个与之对应的公钥。生成者负责生成私钥和公钥，并保存私钥，公开公钥。 > 公钥加密，私钥解密；或者私钥数字签名，公钥验证。公钥和私钥是成对的，它们互相解密。 * **特点：** * 1\). \*\*对信息保密，防止中间人攻击：\*\*将明文通过接收人的公钥加密，传输给接收人，因为只有接收人拥有对应的私钥，别人不可能拥有或者不可能通过公钥推算出私钥，所以传输过程中无法被中间人截获。只有拥有私钥的接收人才能阅读。**此方法通常用于交换对称密钥**。 * 2\). \*\*身份验证和防止篡改：\*\*权限狗用自己的私钥加密一段授权明文，并将授权明文和加密后的密文，以及公钥一并发送出来，接收方只需要通过公钥将密文解密后与授权明文对比是否一致，就可以判断明文在中途是否被篡改过。**此方法用于数字签名。** * \*\*优点：\*\*加密强度小，加密时间长，常用于数字签名和加密密钥、安全性非常高、解决了对称加密保存密钥的安全问题。 * \*\*缺点：\*\*加密解密速度远慢于对称加密，不适合大批量数据加密。 **3. 哈希算法加密：`MD5加密`、`.SHA加密`、`HMAC加密`** * 哈希算法加密是通过哈希算法对数据加密，加密后的结果不可逆，即加密后不能再解密。 * \*\*特点：\*\*不可逆、算法公开、相同数据加密结果一致。 * \*\*作用：\*\*信息摘要，信息“指纹”，用来做数据识别的。如：用户密码加密、文件校验、数字签名、鉴权协议。 > MD5加密：\*\*对不同的数据加密的结果都是定长的32位字符。 > \*\*.SHA加密：\*\*安全哈希算法，主要适用于数字签名标准(`DSS`)里面定义的数字签名算法(DSA)。对于长度小于`2^64`位的消息，`SHA1`会产生一个160位的消息摘要。当接收到消息的时候，这个消息摘要可以用来验证数据的完整性。在传输的过程中，数据很可能会发生变化，那么这时候就会产生不同的消息摘要。当然除了`SHA1`还有`SHA256`以及`SHA512`等。 > \*\*HMAC加密：\*\*给定一个密钥，对明文加密，做两次“散列”，得到的结果还是32位字符串。 **4. Base64加密** * 一种编码方式，严格意义上来说不算加密算法。其作用就是将二进制数据编码成文本，方便网络传输。 * 用 `base64` 编码之后，数据长度会变大，增加了大约 1/3，但是好处是编码后的数据可以直接在邮件和网页中显示； * 虽然 `base64` 可以作为加密，但是 `base64` 能够逆运算，非常不安全！ * base64 编码有个非常显著的特点，末尾有个 ‘=’ 号。 * **原理：** * 1\). 将所有字符转化为ASCII码； * 2\). 将ASCII码转化为8位二进制； * 3\). 将二进制三位一组不足补0，共24位，再拆分成6位一组共四组； * 4\). 统一在6位二进制前补两个0到八位； * 5\). 将补0后的二进制转为十进制； * 6\). 最后从Base64编码表获取十进制对应的Base64编码。 ## 13 App安全，数字签名，App签名，重签名 因为应用实际上是一个加壳的ipa文件，但是有可能被砸壳甚至越狱手机下载的ipa包直接就是脱壳的，可以直接反编译，所以不要在`plist文件`、项目中的`静态文件`中存储关键的信息。所以敏感信息对称加密存储或者就存储到`keychain`里。而且加密密钥也要定期更换。 **数字签名是通过`HASH算法`和`RSA加密`来实现的。** 我们将明文数据加上\*\*通过`RSA加密`的数据`HASH值`\*\*一起传输给对方，对方可以解密拿出`HASH值`来进行验证。这个通过RSA加密`HASH值`数据，我们称之为数字签名。 **App签名** * 1.在Mac开发机器上生成一对公钥和私钥，这里称为公钥L，私钥L(L：Local)。 * 2.苹果自己有固定的一对公钥和私钥，**私钥**在苹果后台，**公钥**在每个iOS设备上。这里称为公钥A，私钥A(A：Apple)。 * 3.把**开发机器上的公钥L**传到苹果后台，用**苹果后台的私钥A**去签名**公钥L**。得到一个包含**公钥L**以及其**签名**数据证书。 * 4.在苹果后台申请AppID，配置好**设备ID列表**和**APP可使用的权限**，再加上第③步的**证书**，组成的数据用**私钥A**签名，把数据和签名一起组成一个`Provisioning Profile`描述文件，下载到**本地Mac开发机器**。 * 5.在开发时，编译完一个APP后，用**本地的私钥L**对这个APP进行签名，同时把第④步得到的`Provisioning Profile`描述文件打包进APP里，文件名为`embedded.mobileprovision`，把 APP安装到手机上。 * 6.在安装时，iOS系统取得证书，通过**系统内置的公钥A**，去验证`embedded.mobileprovision`的**数字签名**是否正确，里面的证书签名也会再验一遍。 * 7.确保了`embedded.mobileprovision`里的数据都是苹果授权的以后，就可以取出里面的数据，做各种验证，包括用公钥 L 验证APP签名，验证设备 ID 是否在 ID 列表上，AppID 是否对应得上，权限开关是否跟 APP 里的 Entitlements 对应等。 ## 14 OC数据类型 ![](https://upload-images.jianshu.io/upload_images/869753-5c06e93492e0f8bb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240) **① 基本数据类型** * C语言基本数据类型（如`short、int、float`等）在OC中都不是对象，只是一定字节的内存空间用于存储数值，他们都不具备对象的特性，没有属性方法可以被调用。 * **OC中的基本数据类型：** * `NSInteger`(相当于long型整数)、 * `NSUInteger`(相当于unsigned long型整数)、 * `CGFloat`(在64位系统相当于double，32位系统相当于float)等。 * 他们并不是类，只是用`typedef`对基本数据类型进行了重定义，**`他们依然只是基本数据类型`**。 * \*\*枚举类型：\*\*其本质是无符号整数。 * \*\*BOOL类型：\*\*是宏定义，OC底层是使用signed char来代表BOOL。 **② 指针数据类型** **指针数据类型包括：** `类class`、`id`。 * **类class：**`NSString`、`NSSet`、`NSArray`、`NSMutableArray`、`NSDictionary`、`NSMutableDictionary`、`NSValue`、`NSNumber(继承NSValue)`等，都是class，创建后便是对象，继承**NSObject**。 OC中提供了`NSValue`、`NSNumber`来封装C语言的基本类型，这样我们就可以让他们具有面向对象的特征了。 * **id：**`id`是指向Objective-C对象的指针，等价于C语言中的`void*`，可以映射任何对象指针指向他，或者映射它指向其他的对象。常见的id类型就是类的delegate属性。 **集合NSSet和数组NSArray区别：** * 都是存储不同的对象的地址； * 但是NSArray是有序的集合，NSSet是无序的集合，它们俩可以互相转换。 * NSSet会自动删除重复元素。 * 集合是一种哈希表，运用散列算法，查找集合中的元素比数组速度更快，但是它没有顺序。 **③ 构造类型** \*\*构造类型包括：\*\*结构体、联合体 * **结构体：**`struct`，将多个基本数据类型的变量组合成一个整体。结构体中访问内部成员用点运算符访问。 * **联合体(共用体)：**`union`，有些类似结构体`struct`的一种数据结构，联合体(`union`)和结构体(`struct`)同样可以包含很多种数据类型和变量。 **结构体和联合体的区别：** * 结构体(`struct`)中所有变量是“共存”的，同一时刻每个成员都有值，其`sizeof`为所以成员的和。 \*\*优点：\*\*是“有容乃大”，全面； \*\*缺点：\*\*是struct内存空间的分配是粗放的，不管用不用，**全分配，会造成内存浪费。** * 联合体(`union`)中各变量是“互斥”的，同一时刻只有一个成员有值，其`sizeof`为最长成员的`sizeof`。 \*\*优点：\*\*是内存使用更为精细灵活，也节省了内存空间。 \*\*缺点：\*\*就是不够“包容”，修改其中一个成员时会覆盖原来的成员值； ## 15 property和属性修饰符 **@property的本质**是 `ivar(实例变量)` + `setter` + `getter`. **我们每次增加一个属性时内部都做了什么：** * 1.系统都会在 `ivar_list` 中添加一个成员变量的描述； * 2.在 `method_list` 中增加 `setter` 与 `getter` 方法的描述； * 3.在属性列表中增加一个属性的描述； * 4.然后计算该属性在对象中的偏移量； * 5.给出 `setter` 与 `getter` 方法对应的实现，在 `setter` 方法中从偏移量的位置开始赋值，在 `getter` 方法中从偏移量开始取值，为了能够读取正确字节数，系统对象偏移量的指针类型进行了类型强转。 **修饰符：** * **MRC下：** `assign、retain、copy、readwrite、readonly、nonatomic、atomic`等。 * **ARC下：**`assign、strong、weak、copy、readwrite、readonly、nonatomic、atomic、nonnull、nullable、null_resettable、_Null_unspecified`等。 下面分别解释 * `assign`：用于基本数据类型，不更改引用计数。如果修饰对象(对象在堆需手动释放内存，基本数据类型在栈系统自动释放内存)，会导致对象释放后指针不置为nil 出现野指针。 * `retain`：和strong一样，释放旧对象，传入的新对象引用计数+1；在MRC中和release成对出现。 * `strong`：在ARC中使用，告诉系统把这个对象保留在堆上，直到没有指针指向，并且ARC下不需要担心引用计数问题，系统会自动释放。 * `weak`：在被强引用之前，尽可能的保留，不改变引用计数；weak引用是弱引用，你并没有持有它；它本质上是分配一个不被持有的属性，当引用者被销毁(dealloc)时，weak引用的指针会自动被置为nil。**可以避免循环引用。** * `copy`：一般用来修饰不可变类型属性字段，如：`NSString`、`NSArray`、`NSDictionary`等。用copy修饰可以防止本对象属性受外界影响，在`NSMutableString`赋值给`NSString`时，修改前者 会导致 后者的值跟着变化。还有`block`也经常使用 copy 修饰符，但是其实在ARC中编译器会自动对block进行copy操作，和strong的效果是一样的。但是在MRC中方法内部的block是在栈区，使用copy可以把它放到堆区。 * `readwrite`：可以读、写；编译器会自动生成setter/getter方法。 * `readonly`：只读；会告诉编译器不用自动生成setter方法。属性不能被赋值。 * `nonatomic`：非原子性访问。用nonatomic意味着可以多线程访问变量，会导致读写线程不安全。但是会提高执行性能。 * `atomic`：原子性访问。编译器会自动生成互斥锁，对 setter 和 getter 方法进行加锁来保证属性的 赋值和取值 原子性操作是线程安全的，但不包括可变属性的操作和访问。比如我们对数组进行操作，给数组添加对象或者移除对象，是不在atomic的负责范围之内的，所以给被atomic修饰的数组添加对象或者移除对象是没办法保证线程安全的。**原子性访问的缺点是会消耗性能导致执行效率慢。** * `nonnull`：设置属性或方法参数不能为空，专门用来修饰指针的，不能用于基本数据类型。 * `nullable`：设置属性或方法参数可以为空。 * `null_resettable`：设置属性，get方法不能返回为空，set方法可以赋值为空。 * `_Null_unspecified`：设置属性或方法参数不确定是否为空。 > 后四个属性应该主要就是为了提高开发规范，提示使用的人应该传什么样的值，如果违反了对规范值的要求，就会有警告。 **weak修饰的对象释放则自动被置为nil的实现原理：** `Runtime`维护了一个`weak表`，存储指向某个对象的所有`weak指针`。`weak表`其实是一个`hash（哈希）表`，`Key`是所指对象的地址，`Value`是`weak`指针的地址数组（这个地址的值是所指对象的地址）。 **weak 的实现原理可以概括一下三步：** * 1、初始化时：`runtime`会调用`objc_initWeak`函数，初始化一个新的weak指针指向对象的地址。 * 2、添加引用时：`objc_initWeak`函数会调用 `objc_storeWeak()`函数， `objc_storeWeak()` 的作用是更新指针指向，创建对应的弱引用表。 * 3、释放时，调用`clearDeallocating`函数。`clearDeallocating`函数首先根据对象地址获取所有`weak`指针地址的数组，然后遍历这个数组把其中的数据设为`nil`，最后把这个entry从weak表中删除，最后清理对象的记录。 ## 16 成员变量`ivar`和属性`property`的区别，以及不同关键字的作用 \*\*成员变量：\*\*成员变量的默认修饰符是`@protected`、不会自动生成set和get方法，需要手动实现、不能使用点语法调用，因为没有set和get方法，只能使用`->`。 \*\*属性：\*\*属性会默认生成带下划线的成员变量和`setter/getter`方法、可以用点语法调用，实际调用的是set和get方法。 **注意：分类中添加的属性是不会自动生成 `setter/getter`方法的，必须要手动添加。** \*\*实例变量：\*\*class类进行实例化出来的对象为实例对象 **关键字作用：** * **访问范围关键字** * `@public`：声明公共实例变量，在任何地方都能直接访问对象的成员变量。 * `@private`：声明私有实例变量，只能在当前类的对象方法中直接访问，子类要访问需要调用父类的get/set方法。 * `@protected`：可以在当前类及其子类对象方法中直接访问(系统默认)。 * `@package`：在同一个包下就可以直接访问，比如说在同一个框架。 * **关键字** * `@property`：声明属性，自动生成一个以下划线开头的成员变量\_propertyName(默认用@private修饰)、属性setter、getter方法的声明、属性setter、getter方法的实现。\*\*注意：\*\*在`协议@protocol`中只会生成getter和setter方法的声明，所以不仅需要手动实现getter和setter方法还需要手动定义变量。 * `@sythesize`：修改@property自动生成的\_propertyName成员变量名，`@synthesize propertyName = newName；`。 * `@dynamic`：告诉编译器：属性的 setter 与 getter 方法由用户自己实现，不自动生成。\*\*谨慎使用：\*\*如果对属性赋值取值可以编译成功，但运行会造成程序崩溃，这就是常说的动态绑定。 * `@interface`：声明类 * `@implementation`：类的实现 * `@selecter`：创建一个SEL，类成员指针 * `@protocol`：声明协议 * `@autoreleasepool`：ARC中的自动释放池 * `@end`：类结束 ## 17 类簇 > **类簇**是Foundation框架中广泛使用的设计模式。**类簇在公共抽象超类下对多个私有的具体子类进行分组**。以这种方式对类进行分组简化了面向对象框架的公共可见体系结构，而不会降低其功能丰富度。**类簇是基于抽象工厂设计模式的**。 常见的类簇有 `NSString`、`NSArray`、`NSDictionary`等。\*\*以数组为例：\*\*不管创建的是可变还是不可变的数组，在`alloc`之后得到的类都是 `__NSPlaceholderArray`。而当我们 `init` 一个不可变的空数组之后，得到的是 `__NSArray0`；如果有且只有一个元素，那就是 `__NSSingleObjectArrayI`；有多个元素的，叫做 `__NSArrayI`；`init` 出来一个可变数组的话，都是 `__NSArrayM`。 **优点：** * 可以将抽象基类背后的复杂细节隐藏起来。 * 程序员不会需要记住各种创建对象的具体类实现，简化了开发成本，提高了开发效率。 * 便于进行封装和组件化。 * 减少了 if-else 这样缺乏扩展性的代码。 * 增加新功能支持不影响其他代码。 **缺点：** * 已有的类簇非常不好扩展。 **我们运用类簇的场景：** * 出现 bug 时，可以通过崩溃报告中的类簇关键字，快速定位 bug 位置。 * 在实现一些固定且并不需要经常修改的事物时，可以高效的选择类簇去实现。例： * 针对不同版本，不同机型往往需要不同的设置，这时可以选择使用类簇。 * app 的设置页面这种并不需要经常修改的页面，可以使用类簇去创建大量重复的布局代码。 ## 18 设计模式 **创建型模式：** * 单例模式： * 在整个应用程序中，共享一份资源。保证在程序运行过程中，一个类只有一个实例，而且该实例只提供一个全局访问点供外界访问，从而方便控制实例个数，节约系统资源。 * 优点是：提供了对唯一实例的受控访问、可扩展、避免频繁创建销毁对象影响性能。 * 缺点是：延长了声明周期，一直存在占用内存。如果两个单例循环依赖会造成死锁，所以尽量不去产生单例间的依赖关系。 * 工厂方法模式： * 通过类继承创建抽象产品，创建一种产品，子类化创建者并重载工厂方法以创建新产品。 * 抽象工厂模式： * 通过对象组合创建抽象产品，可以创建多系列产品，必须修改父类的接口才能支持新的产品。 **结构型模式：** * 代理模式 * 代理用来处理事件的监听和参数传递。`@required`修饰必须实现这个协议方法方法，`@optional`修饰是可选实现。使用方法时最好先判断方法是否实现`respondsToSelector:` ，避免找不到方法而崩溃。 > delegate和block、Notification对比优缺点：delegate和block是一对一通信、block比delegate更加简洁清晰，但是如果通信事件较多时delegate运行成本较低且不易造成循环引用；通知适合一对多通信，代码清晰简单，但问题查找溯源会比较困难，并且注册通知要注意在合适的时间移除，避免对野指针发送消息引起崩溃（\*\*注意：\*\*iOS9之后已经做了弱引用处理不需要移除了，之前版本使用不安全引用\_\_unsafe\_unretained是为了兼容旧版本）。 * 类簇： * 见上边 5. 类簇 * 装饰模式 * 在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。如：**分类**。 * 享元模式： * 使用共享物件，减少同一类对象的大量创建。如：`UITableviewCell`复用。 **行为型模式：** * 观察者模式： * 其本质上是一种`发布-订阅`模型，用来消除具有不同行为的对象之间的耦合，通过这一模式，不同对象可以协同工作。如：**KVO**。 * 命令模式： * 是一种将方法调用封装为对象的设计模式，在iOS中具体实现为**NSInvocation**。下边为`NSInvocation`的实现代码。 ```Swift - (void)viewDidLoad { NSMethodSignature *signature = [ViewController instanceMethodSignatureForSelector:@selector(sendMessageWithPhone:WithName:)]; // 方法签名：用来获得方法的返回类型和参数类型 NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature]; invocation.target = self; // 目标：接收消息的对象 invocation.selector = @selector(sendMessageWithPhone:WithName:); // 选择器：被发送的消息, 方法必须和签名中的方法一致。 NSString *phone = @"13512345678"; // 注意：设置参数的索引时不能从0开始，因为0已经被self占用，1已经被_cmd占用 [invocation setArgument:&phone atIndex:2]; // 参数：可以添加任意数量的参数。 NSString *name = @"Dezi"; [invocation setArgument:&name atIndex:3]; /* 注：调用invocation的invoke方法，就代表需要执行NSInvocation对象中指定对象的指定方法，并且传递指定的参数 */ [invocation invoke]; } - (void)sendMessageWithPhone:(NSString*)phone WithName:(NSString*)name { NSLog(@"电话号=%@, 姓名=%@",phone, name); } // 电话号=13512345678, 姓名Dezi ``` * MVC和MVVM算是架构。 ## 19 架构设计 **MVC：** * **M** 是数据模型`Model`，负责处理数据，以及数据改变时发出通知(`Notification、KVO`)，`Model`和`View`不能直接进行通信，这样会违背MVC设计模式； * **V** 是视图`View`，用来展示界面，和用户进行交互，为了解耦合一般不会直接持有 或者 操作数据层中的数据模型(可以通过`action-target`、`delegate`、`block`等方式解耦)； * **C** 是控制器`Controller`用来调节`Model`和`View`之间的交互，可以直接与Model还有View进行通信，操作Model进行数据更新，刷新View。 **优点：**`View`、`Model`低耦合、高复用、容易维护。 **缺点：**`Controller`的代码过于臃肿，如果`View`与`Model`直接交互会导致`View`和`Model`之间的耦合性比较大、网络逻辑会加重`Controller`的臃肿。 **MVVM：**`Model - View - ViewModel` * **MVVM**衍生于**MVC**，是MVC的一种演进，促进了UI代码和业务逻辑的分离，抽取`Controller`中的展示逻辑放到`ViewModel`里边。 * **M：** 数据模型`Model`。 * **V：** 就是`View`和`Controller`联系到一起，视为是一个组件`View`。View和Controller都不能直接引用模型Model，可以引用视图模型ViewModel。ViewController 尽量不涉及业务逻辑，让 ViewModel 去做这些事情。ViewController 只是一个中间人，负责接收 View 的事件、调用 ViewModel 的方法、响应 ViewModel 的变化。 * **VM：**`ViewModel`负责封装业务逻辑、网络处理和数据缓存。使用ViewModel会轻微的增加代码量，但是总体上减少了代码的复杂性。`ViewModel`之间可以有依赖。 **注意事项：** * `View`引用`ViewModel`，但反过来不行，因为如果VM跟V产生了耦合，不方便复用。即不要在`viewModel`中引入`#import UIKit.h`，任何视图本身的引用都不应该放在`viewModel`中 (**注意：基本要求，必须满足**)。 * `ViewModel`可以引用`Model`，但反过来不行。 **优点：** 低耦合、可复用、数据流向清晰、而且兼容MVC，便于代码的移植、并且ViewModel可以拆出来独立开发、方便测试。 **缺点：** 类会增多、`ViewModel`会越来越庞大、调用复杂度增加、双向绑定数据会导致问题调试变得困难。 **总结：** * **MVVM**其实是MVC的变种。`MVVM`只是帮`MVC`中的`Controller`瘦身，把一些逻辑代码和网络请求分离出去。不让Controller处理更多的东西，不会变得臃肿，`MVVM`和`MVC`可以根据实际需求进行灵活选择。 * **MVVM** 在使用当中，通常还会利用双向绑定技术，使得`Model` 变化时，`ViewModel`会自动更新，而`ViewModel`变化时，`View` 也会自动变化。OC中可以用\*\*RAC(ReactiveCocoa)\*\*函数响应式框架来实现响应式编程。 ## 20 ReactiveCocoa的使用及优缺点 > **ReactiveCocoa**简称RAC，是函数响应式编程框架，因为它具有函数式编程和响应式编程的特性。 * 由于该框架的编程思想，使得它具有相当魅惑人心的功能，它能实现传统设计模式和事件监听所能实现的功能，比如**KVO、通知、block回调、action、协议**等等，它的全面性并不是它最为优越的特色，RAC最值得炫耀的是它提供了统一的消息传递机制，这种机制使得它的代码更加的简洁，同一功能代码块更少，这正是符合了我们编程的思想：高聚合、低耦合，它非常适合MVVM设计模式的开发。 * 不过它也并不能完全取代传统的编码方式，在多人开发和代码维护方面，RAC还是有着一些让人头痛的问题。 * 优点： * 使用灵活方便、代码简洁、逻辑清晰 * 缺点： * 维护成本较高、问题溯源困难 **使用：** RAC的统一消息传递机制，其所以动作都离不开`信号(sigal)`。 * 1\). **信号的创建、发送、接收** ``` // 创建 此时为冷信号，并不会被触发 RACSignal *signal = [RACSignal createSignal:^RACDisposable *(id `runloop`：通过系统内部维护的循环进行事件/消息管理的一个对象。runloop实际上就是一个`do...while`循环，有任务时开始，无任务时休眠。 **其本质是通过`mach_msg()`函数接收、发送消息。** **RunLoop 与线程的关系：** * `RunLoop`的作用就是来管理线程的，当线程的`RunLoop`开启后，线程就会在执行完任务后，处于休眠状态，随时等待接受新的任务，不会退出。 * 只有主线程的`RunLoop`是默认开启的，其他线程的`RunLoop`需要手动开启。所以当程序开启后，主线程会一直运行，不会退出。 **runloop 事件循环机制内部流程** ![](https://img-blog.csdnimg.cn/20191011113020740.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM0ODAwNzA=,size_16,color_FFFFFF,t_70) **RunLoop主要涉及五个类：** `CFRunLoop`：RunLoop对象、 `CFRunLoopMode`：五种RunLoop运行模式、 `CFRunLoopSource`：输入源/事件源，包括`Source0` 和 `Source1` `CFRunLoopTimer`：定时源，就是NSTimer、 `CFRunLoopObserver`：观察者，用来监听RunLoop。 * `CFRunLoop`：**RunLoop对象** * `CFRunLoopMode`：**RunLoop运行模式，有五种：** * `kCFRunLoopDefaultMode`：默认的运行模式，通常主线程是在这个 Mode 下运行的。 * `UITrackingRunLoopMode`：界面跟踪 Mode，用于 ScrollView 追踪触摸滑动，保证界面滑动时不受其他 Mode 影响。 * `UIInitializationRunLoopMode`：在刚启动 App 时第进入的第一个 Mode，启动完成后就不再使用。 * `GSEventReceiveRunLoopMode`：接受系统事件的内部 Mode，通常用不到。 * `kCFRunLoopCommonModes`：是一个伪模式，可以在标记为CommonModes的模式下运行，RunLoop会自动将`_commonModeItems`里的 `Source`、`Observer`、`Timer` 同步到具有此标记的Mode里。 * `CFRunLoopSource`：**输入源/事件源，包括Source0 和 Source1两种：** * `Source1`：基于mach\_Port，处理来自系统内核或其它进程的事件，比如点击手机屏幕。 * `Source0` ：非基于Port的处理事件，也就是应用层事件，需要手动标记为待处理和手动唤醒RunLoop。 * 简单举例：一个APP在前台静止，用户点击APP界面，屏幕表面的事件会先包装成`Event`告诉`source1(mach_port)`，`source1`唤醒`RunLoop`将事件`Event`分发给`source0`，由`source0`来处理。 * `CFRunLoopTimer`：**定时源**，就是NSTimer。在预设的时间点唤醒RunLoop执行回调。因为它是基于RunLoop的，因此它不是实时的（就是NSTimer 是不准确的。 因为RunLoop只负责分发源的消息。如果线程当前正在处理繁重的任务，就有可能导致Timer本次延时，或者少执行一次）。 * `CFRunLoopObserver`：**观察者，用来监听以下时间点：CFRunLoopActivity** * `kCFRunLoopEntry`：RunLoop准备启动 * `kCFRunLoopBeforeTimers`：RunLoop将要处理一些Timer相关事件 * `kCFRunLoopBeforeSources`：RunLoop将要处理一些Source事件 * `kCFRunLoopBeforeWaiting`：RunLoop将要进行休眠状态,即将由用户态切换到内核态 * `kCFRunLoopAfterWaiting`：RunLoop被唤醒，即从内核态切换到用户态后 * `kCFRunLoopExit`：RunLoop退出 * `kCFRunLoopAllActivities`：监听所有状态 **各数据结构之间的联系：** * 1：`Runloop`和`线程`是**一对一**的关系 * 2：`Runloop`和`RunloopMode`是**一对多**的关系 * 3：`RunloopMode`和`RunloopSource`是**一对多**的关系 * 4：`RunloopMode`和`RunloopTimer`是**一对多**的关系 * 5：`RunloopMode`和`RunloopObserver`是**一对多**的关系 **为什么 main 函数能够保持一直存在且不退出？** > 在 main 函数内部会调用 `UIApplicationMain` 这样一个函数，而在`UIApplicationMain`内部会启动主线程的 `runloop`，可以做到有消息处理时，能够迅速从**内核态到用户态**的切换，立刻唤醒处理，而没有消息处理时通过**用户态到内核态**的切换进入等待状态，**避免资源占用**。**因此 main 函数能够一直存在且不退出**。 ## 27 runtime **什么是runtime？** runtime 一套c、c++、汇编编写的API，为OC提供运行时功能。能够将数据类型的确定由编译期推迟到运行时。 **问1：方法的本质，问2：runtime的消息机制** **方法的本质其实就是发送消息**。 发送消息主要流程： * 快速查找：`objc_msgSend`查找`cache_t`缓存消息 * 慢速查找：递归自己和父类查找方法`lookUpImpOrForward` * 查找不到消息，进行动态方法解析：`resolveInstanceMethod` * 消息快速转发：`forwardingTargetForSelector` * 消息慢速转发：消息签名`methodSignatureForSelector`和分发`forwardInvocation` * 最终仍未找到消息：程序crash，报经典错误信息`unrecognized selector sent to instance xxx` **SEL是什么？IMP是什么？两者有什么联系？** * `SEL`是方法编号，即方法名称，在dyld加载镜像时，通过read\_image方法加载到内存的表中了。 * `IMP`是函数实现指针，找IMP就是找函数的过程 * **两者的关系：**`sel`相当于书本的目录标题，`imp`就是书本的页码。查找具体的函数就是想看这本书里面具体篇章的内容： * 1\). 我们首先知道想看什么，也就是title -sel * 2\). 然后根据目录对应的页码 -imp * 3\). 打开具体的内容 -方法的具体实现 **runtime应用：** * 1.方法的交换：具体应用拦截系统自带的方法调用（Method Swizzling黑魔法） * 2.实现给分类增加属性 * 3.实现字典的模型和自动转换 * 4.JSPatch替换已有的OC方法实行等 * 5.aspect 切面编程 **能否向编译后得到的类中增加实例变量？能否向运行时创建的类中添加实例变量？为什么？** * 1.不能向编译后得到的类中增加实例变量。 * 2.可以向运行时创建的类中添加实例变量。 * 3.因为编译后的类已经注册在 runtime 中，类结构体中的 `objc_ivar_list`**实例变量的链表**和 `instance_size` **实例变量的内存大小**已经确定，同时`runtime`会调用 `class_setIvarLayout`或`class_setWeakIvarLayout`来处理 `strong`、`weak`引用，所以不能向存在的类中添加实例变量。 运行时创建的类是**可以添加实例变量**，调用`class_addIvar`函数。但是得在调用`objc_allocateClassPair`之后，`objc_registerClassPair`之前，原因同上。 **Category中添加属性和成员变量的区别** * `Category`它的主要作用是在不改变原有类的前提下，动态地给这个类添加一些方法。 * 分类的结构体指针中，没有属性列表，只有方法列表。原则上它只能添加方法，不能添加属性(成员变量)，但是可以借助运行时关联对象`objc_setAssociatedObject(self, @selector(name), name, OBJC_ASSOCIATION_COPY_NONATOMIC);`、`objc_getAssociatedObject(self,@selector(name));`。 * 分类中的可以写`@property`，但不会生成setter/getter方法声明和实现，也不会生成私有的成员变量，会编译通过，但是引用变量会报错。 * 如果分类中有和原有类同名的方法，会优先调用分类中的方法，就是说会忽略原有类的方法，同名方法调用的优先级为 分类 本类 父类，因为方法是放在方法栈中，遵循先进后出原则； ## 28 isa指针 * `isa`是一个`Class类型`的指针，其源码结构为`isa_t`联合体，在类中以Class对象存在，指向类的地址，大小为8字节(64位)。 * 每个实例对象都有`isa`的指针指向对象的类。`Class`里也有个`isa`的指针指向`meteClass`(元类)。元类保存了类方法的列表。当类方法被调用时，先会从本身查找类方法的实现，如果没有，元类会向他父类查找该方法。元类（meteClass）也是类，它也是对象，也有isa指针。 **isa的指向**：对象的`isa`指向类，类的`isa`指向元类(meta class)，元类`isa`指向根元类，根元类的`isa`指向本身，形成了一个封闭的内循环。isa可以帮助一个对象找到它的方法。 **isa指向图中类的继承关系**：`Teacher -> Person -> NSObject -> nil`。这里需要注意的是根元类的父类是 `NSObject`，`NSObject`的父类是`nil`。 ## 29 block **什么是Block** Block是将函数及其执行上下文封装起来的对象。 **什么是Block调用** Block调用即是函数的调用。 **Block的几种形式(类型)** Block有三种形式，包括： * **全局Block**(`_NSConcreteGlobalBlock`)：当我们声明一个block时，如果这个block没有捕获外部的变量，那么这个block就位于全局区(已初始化数据(.data)区)。 * **栈Block**(`_NSConcreteStackBlock`)： * 1\). ARC环境下，当我们声明并且定义了一个block，系统默认使用`__strong修饰符`，如果该`Block`捕获了外部变量，实质上是从`__NSStackBlock__`转变到`__NSMallocBlock__`的过程，只不过是系统帮我们完成了copy操作，将栈区的block迁移到堆区，延长了Block的生命周期。对于`栈block`而言，变量作用域结束，空间被回收。 * 2\). ARC的环境下，如果我们在声明一个block的时候，使用了`__weak`或者`__unsafe__unretained`的修饰符，那么系统就**不会做copy的操作**，也就**不会将其迁移到堆区**。 * **堆Block**(`_NSConcreteMallocBlock`)： * 1\). 在MRC环境下，我们需要手动调用copy方法才可以将block迁移到堆区 * 2\). 而在ARC环境下，`__strong`修饰的（默认）block捕获了外部变量就会位于堆区，`NSMallocBlock`支持`retain`、`release`，会对其引用计数＋1或 -1。 * **只有局部变量 - 和定义的属性 才会拷贝到堆区** 1\). 存储在程序的数据区域，在 block 内部没有引用任何外部变量。 2\). 使用外部变量并且未进行copy操作的block是栈block。 3\). 对`栈block`进行copy操作，就是`堆block`。对`堆Block`进行copy，将会`增加引用计数`。对`全局block`进行copy，仍是`全局block`。 **在什么场景下使用\_\_block修饰符呢？** * 1\). 对截获变量进行赋值操作需要添加`__block修饰符`（赋值 != 使用）。 * 2\). 对局部变量（基本数据类型和对象类型）进行赋值需要`__block修饰符`。 其内部其实是对该`__block对象`进行拷贝，所以通过`__block`可以修改被截获变量的值且不会和外部变量互相影响。 * 3\). 对静态局部变量、全局变量、静态全局变量不需要`__block修饰符`。 **block 的截获变量特性？** 基本数据类型的局部变量 Block 可以截获其值。 对于对象类型的局部变量连同所有权修饰符一起截获。 局部静态变量以指针的形式进行截获。 全局变量和静态全局变量，block 是不截获的。 **weak打破Block循环引用原理** > `block`内部操作的是`weakSelf`的指针地址，它和`self`是两个不同的指针地址，即 没有直接持有`self`，所以可以`weakSelf`可以打破`self`的循环引用关系 `self -block - weakSelf`。