• https://juejin.im/post/5a6460f8f265da3e4f0a446d React Native for Android 原理分析与实践：实现原理

• https://www.cnblogs.com/android-blogs/p/5623481.html 其实没那么复杂！探究react-native通信机制

• Native与JS之间调用方式，Bridge。

• 在jsi.h中Runtime抽象类，申明了JS执行已经与Native互调的接口。在iOS和Android中分别实现。iOS的JSCRuntime，直接调用iOS系统提供JavaScriptCore框架。Android则额外引入jsc.so包提供，JavaScriptCore的功能。

• Native和JS两端都保存模块、方法数据的注册表。

• 通道优化，JS调用Naitve，先push到MessageQueue，等Native有调用时，顺带批量返回（如果5毫秒内，没有Native调用事件，则主动flush queue）。

• JS代码执行，Native与JS消息通信等都是通过该Bridge进行。

• https://swift.org/source-compatibility/#current-list-of-projects

Pods

• Assets问题 https://mp.weixin.qq.com/s?__biz=MzA5NzMwODI0MA==&mid=2647759665&idx=1&sn=4b1f2fde434f1b45ff3eac627a7b7fd9

• 组件化-动态库实战 http://www.cocoachina.com/ios/20170427/19136.html

• iOS 动态库和静态库的的区别 动态库的隔离与静态库的吸附问题以及解决方法 https://blog.csdn.net/clovejq/article/details/71107796

• Thunk程序的实现原理以及在iOS中的应用 https://juejin.im/post/5c5281e0e51d45517334dd34

• Chameleon原理详解：其它跨多端统一框架都是假的？https://mp.weixin.qq.com/s/F8ernZ57jseKNJgwGopNxg

https://developer.apple.com/library/archive/navigation/

• 深入剖析iOS动态链接库 https://www.jianshu.com/p/1de663f64c05

/**
 * Created by BeeHive.
 * Copyright (c) 2016, Alibaba, Inc. All rights reserved.
 *
 * This source code is licensed under the GNU GENERAL PUBLIC LICENSE.
 * For the full copyright and license information,please view the LICENSE file in the root directory of this source tree.
 */


#import "BHAnnotation.h"
#import "BHCommon.h"
#include <mach-o/getsect.h>
#include <mach-o/loader.h>
#include <mach-o/dyld.h>
#include <dlfcn.h>
#import <objc/runtime.h>
#import <objc/message.h>
#include <mach-o/ldsyms.h>

NSArray<NSString *>* BHReadConfiguration(char *sectionName,const struct mach_header *mhp);
static void dyld_callback(const struct mach_header *mhp, intptr_t vmaddr_slide)
{
    NSArray *mods = BHReadConfiguration(BeehiveModSectName, mhp);
    for (NSString *modName in mods) {
        Class cls;
        if (modName) {
            cls = NSClassFromString(modName);
            
            if (cls) {
                [[BHModuleManager sharedManager] registerDynamicModule:cls];
            }
        }
    }
    
    //register services
    NSArray<NSString *> *services = BHReadConfiguration(BeehiveServiceSectName,mhp);
    for (NSString *map in services) {
        NSData *jsonData =  [map dataUsingEncoding:NSUTF8StringEncoding];
        NSError *error = nil;
        id json = [NSJSONSerialization JSONObjectWithData:jsonData options:0 error:&error];
        if (!error) {
            if ([json isKindOfClass:[NSDictionary class]] && [json allKeys].count) {
                
                NSString *protocol = [json allKeys][0];
                NSString *clsName  = [json allValues][0];
                
                if (protocol && clsName) {
                    [[BHServiceManager sharedManager] registerService:NSProtocolFromString(protocol) implClass:NSClassFromString(clsName)];
                }
                
            }
        }
    }
    
}
__attribute__((constructor))
void initProphet() {
    _dyld_register_func_for_add_image(dyld_callback);
}

NSArray<NSString *>* BHReadConfiguration(char *sectionName,const struct mach_header *mhp)
{
    NSMutableArray *configs = [NSMutableArray array];
    unsigned long size = 0;
#ifndef __LP64__
    uintptr_t *memory = (uintptr_t*)getsectiondata(mhp, SEG_DATA, sectionName, &size);
#else
    const struct mach_header_64 *mhp64 = (const struct mach_header_64 *)mhp;
    uintptr_t *memory = (uintptr_t*)getsectiondata(mhp64, SEG_DATA, sectionName, &size);
#endif
    
    unsigned long counter = size/sizeof(void*);
    for(int idx = 0; idx < counter; ++idx){
        char *string = (char*)memory[idx];
        NSString *str = [NSString stringWithUTF8String:string];
        if(!str)continue;
        
        BHLog(@"config = %@", str);
        if(str) [configs addObject:str];
    }
    
    return configs;

    
}

@implementation BHAnnotation

@end

__attribute__((constructor)) void before_main() {
    printf("--- %s\n", __func__);
}

__attribute__((destructor)) void after_main() {
    printf("--- %s\n", __func__);
}

HTTP,HTTP2.0,SPDY,HTTPS你应该知道的一些事 http://www.alloyteam.com/2016/07/httphttp2-0spdyhttps-reading-this-is-enough/

HTTP/2 新特性总结 https://www.jianshu.com/p/67c541a421f9

• http2能带来如下这些收益：
  1、多路复用、多个HTTP可以在同个TCP连接上同时发送。
  2、优先级
  3、header压缩
  4、Server Push

• https://www.jianshu.com/p/4d86de908721

• Mach-O文件结构 https://www.jianshu.com/p/1f22d1e667e3

• MachOView

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    //这里必须要先加载一次NSLog，如果不写NSLog，符号表里面根本就不会出现NSLog的地址
    NSLog(@"123"); 

    //定义rebinding结构体
    struct rebinding nslogBind;
    //函数的名称
    nslogBind.name = "NSLog";
    //新的函数地址
    nslogBind.replacement = myMethod;
    //保存原始函数地址变量的指针
    nslogBind.replaced = (void *)&old_nslog;
    
    //定义数组
    struct rebinding rebs[] = {nslogBind};
    
    /**
     arg1: 存放rebinding结构体的数组
     arg2: 数组的长度
     */
    rebind_symbols(rebs, 1);
}

//函数指针，用来保存原始的函数地址
static void (*old_nslog)(NSString *format, ...);

//新的NSLog
void myMethod(NSString *format, ...) {
    //再调用原来的
    old_nslog(@"勾上了！");
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    NSLog(@"点击屏幕");
}

lldb

• iOS之LLDB常用命令 https://www.jianshu.com/p/7fb43e0b956a

https://tech.meituan.com/2018/03/11/mt-mpvue-development-framework.html

• 使用vue.js开发小程序
• 原理：增加一个中间层，将小程序的生命周期、事件、数据同步等桥接到vue对象。

Flutter

https://tech.meituan.com/2018/08/09/waimai-flutter-practice.html

• 全新思路的跨平台的移动客户端UI方案。
• 不同于Weex或ReactNative将JS数据代理到Native UI库做渲染，Flutter直接使用更加底层的图形渲染接口，从更底层去接管消息事件，在此基础上，封装跨平台的UI库。
• 对于UI层来说，这样的跨平台更彻底，一致性更强。
• 核心引擎+Widget库

Picasso 大众点评自研的Native动态化方案

https://tech.meituan.com/2018/06/21/picasso-the-future.html

• 对比

Hybrid WebView
Weex、RN、Flutter

• 基本原理
  DSL（TypeScript）-》 PModel -〉 iOS、Android、H5、小程序渲染引擎 -》 UI

• DSL

• 核心SDK + 适配层 + 脚手架

• 开发流程

VSCode + 插件

• 发布流程

Picasso文件 -〉JS Bundle -》 部署服务器 -〉Picasso执行环境（iOS、Android、H5、小程序）-》渲染引擎

美团客户端响应式框架Easy React

https://tech.meituan.com/2018/07/19/react-programming-framework-easyreact-opensource.html

• 对比ReactiveCocoa、ReactiveX
• 基于Objective-C
• EasyMVVM

Logan:美团点评的开源移动端基础日志库 - 美团技术团队

https://tech.meituan.com/2018/10/11/logan-open-source.html

MCI:移动持续集成在大众点评的实践

https://tech.meituan.com/2018/07/12/mci.html

美团外卖Android Crash治理之路

https://tech.meituan.com/2018/06/14/waimai-android-crash.html

运营平台

• 运营、平台管理、前端开发
• 同一个运营位，多维度内容的展示。
• 运营效果

监控系统

HTTP服务治理框架

• https://www.jianshu.com/p/4d86de908721

微服务

单体到微服务是一个演化过程，别在一开始就过度设计

“ The Art of Scalability ”一书描述了一种 三维可伸缩性模型 （AKF Scale Cube），其中三个轴分别代表了不同类型的缩放：

X：水平复制和克隆；-> (Docker，容器)
Y：功能分解和分割（微服务）；
Z：水平数据分区（分片）。

微服务架构设计

微服务架构设计

vue

https://juejin.im/post/5c488a3cf265da615705cc2a?utm_source=tuicool&utm_medium=referral

社交

Tumblr、Pinterest……一个个想创造新模式的应用都失败了，它们改变了什么又为何没落？ | 好奇心商业史

https://www.qdaily.com/articles/60688.html?utm_source=tuicool&utm_medium=referral

三个软件可能要被整合到一起：WhatsApp、Instagram和Facebook Messenger

https://www.qdaily.com/articles/60669.html

数据垄断和信息孤岛，是如何驯化我们的？
https://www.huxiu.com/article/282751.html?utm_source=tuicool&utm_medium=referral

• 电商脑爆图

• 技术图谱

• 性能优化

• 移动客户端开发图谱

• iOS框架梳理

• 软件架构
• 架构服务于效率、质量、体验、性能等
• 架构优化的短期成本和长期收益的权衡
• 架构要与当前业务发展和团队规模相匹配
• 架构设计的方法论和实践 解耦：模块化、组件化，
复用：基础组件，
分层：视图、业务、基础服务，
协议化等
• 滴滴插件化项目VirtualAPK开源
• 微信Android模块化架构重构实践
• Atlas-手淘组件化框架的前世今生和未来的路
• 架构的保持
• 代码之外

• WebViewJavascriptBridge

方案比较通用，对UIWebView也支持。

• DSBridge-IOS

需要改用DWKWebView，对原有代码略有侵入。

目前方案

• 直接使用WKWebView原生接口

• JS调用Native

[config.userContentController addScriptMessageHandler:[WKScriptMessageHandlerWrapper wrapper:self] name:JS_HANDLER_UrlRouter];

- (void)userContentController:(WKUserContentController *)userContentController didReceiveScriptMessage:(WKScriptMessage *)message {
    NSLog(@"Recv Js call : name =  %@", message.name);
    if ([message.name isEqualToString:JS_HANDLER_UrlRouter]) {
        [self handleUrlRouterMessage:message.body];
    } else if ([message.name isEqualToString:JS_HANDLER_ShareService]) {
        [self handleShareServiceMessage:message.body];
    }
}

• Native调用JS

[self.webView evaluateJavaScript:@"window.JSHandler()" completionHandler:^(id _Nullable obj, NSError * _Nullable error) {
    if (obj) {
        NSLog(@"receive js response %@", obj);
    }
}];

• JS调用Native不支持返回值。

• 接口调用不支持回调：JS和Native侧都增加个Callback队列，根据CallbackId执行对应的回调函数。

• 阿里技术参考图册（研发类）
  https://102.alibaba.com/downloadFile.do?file=1523962960197/AliTech101_RD.pdf

• 阿里技术参考图册（算法类）
  https://102.alibaba.com/downloadFile.do?file=1523848064814/AliTech101_Algorithms.pdf

• FB大规模重构React Native，Airbnb宣布回归原生，前端巨变来临？
  https://mp.weixin.qq.com/s/xbVNGGoH6mlmx6T0YL-r1w
  React Native面临挑战，重构求变。
  RN在跨平台开发并没有做到完全抽象，不同平台仍会有些差异性存在。
  Airbnb放弃RN，回归原生。
  Flutter跨平台开发框架，媲美Native的性能，发布release版本，

• 携程RN实践
  https://static001.geekbang.org/con/31/pdf/2987539114/file/GMTC2018-%E3%80%8A%E6%90%BA%E7%A8%8B%E5%A4%A7%E8%A7%84%E6%A8%A1%E5%BA%94%E7%94%A8React+Native%E7%9A%84%E5%B7%A5%E7%A8%8B%E5%8C%96%E5%AE%9E%E8%B7%B5%E3%80%8B-%E8%B5%B5%E8%BE%9B%E8%B4%B5.pdf

• 我们可能会为同一类型的公司构建相同类型的Web应用。
  经济学规律告诉我们，在这种环境下，我们将从“探索”——
  尝试新的实践、范式、技术——转向“开发”：以更快的速度、
  更低的成本构建相似的东西。

我想说的是，在接下来的几年里，我们已经发展起来的微型库架
构将逐渐被那些单体框架所取代。它们将采用一种约定配置
（convention-over-configuration）的方式，用透明度
换取生产力的提升。

• 提现到支付宝
  绑定支付宝 https://docs.open.alipay.com/218/ 单笔转账到支付宝 https://docs.open.alipay.com/309/

RN

• 优势：跨平台、动态性、性能媲美原生、Web开发人力
• 劣势：兼容性问题（也许花在处理多端不一致、兼容性等问题上的时间比使用原生方案实现业务所花的时间更多）、包大小、与原生数据的异步交互等等

1. https://p.pinduoduo.com/xdAm1Gtf
   ->
2. https://mobile.yangkeduo.com/duo_coupon_landing.html?goods_id=4083182873&pid=1785354_23382017&cpsSign=CC1785354_23382017_25d8fe9702daa3db655031eb6d73b02f&duoduo_type=2&launch_wx=1 ->
3. weixin://dl/business/?ticket=tb762fc13a3de2a463ad84e382a05819a

• Android：最全面的 Webview 详解
• Android：你要的WebView与 JS 交互方式 都在这里了
• Android混合开发之WebView使用总结
• 还在用Android自带的WebView组件？太Out了！
• 关于Android APP集成腾讯X5 WebKit
• JsBridge
• UIWebView和WKWebView的使用及js交互
• WebViewJavascriptBridge
• 淘宝的Windvane、微信的小程序也算是Hybrid框架，在WebView基础上，提供组件定制化、规范化、性能优化、访问Native能力等

• 架构服务于效率、质量、体验、性能等
• 架构优化的短期成本和长期收益的权衡
• 架构要与当前业务发展和团队规模相匹配
• 架构设计的方法论和实践 解耦：模块化、组件化，
复用：基础组件，
分层：视图、业务、基础服务，
协议化等
• 滴滴插件化项目VirtualAPK开源
• 微信Android模块化架构重构实践
• Atlas-手淘组件化框架的前世今生和未来的路
• 架构的保持
• 代码之外：人的因素

• Mars
• 微信终端跨平台组件 Mars 正式开源！
• 关于 iOS HTTP2.0 的一次学习实践
• AFNetworking
• Alamofire
• RestKit
• YTKNetwork
• Retrofit
• okhttp
• 蘑菇街App Chromium网络栈实践
• iOS9.0+支持HTTP2
• NSURLSession
• 蘑菇街11.11：移动流量猛增，如何设计高并发多终端的无线网关
• Linux的SOCKET编程详解

• Android 数据存储五种方式使用与总结
• AndroidDataStorage
• realm-java
• greenDAO

• AwesomeCache
• YYCache 基于Disk、Memory的缓存
• YTKKeyValueStore 基于Sqlite的健值对数据的存储
• SwiftyUserDefaults
• FMDB
• ObjectiveRecord CoreData的封装
• realm Realm is a mobile database: a replacement for Core Data & SQLite.
• Valet 基于Keychain的数据存储，接口简洁易用，支持同一开发者下应用间数据共享，支持iCloud数据同步，通过TouchID或设备密码保护数据。
• UICKeyChainStore
• KeychainAccess
• Keychain-Dumper Keychain is not safe.

参考

• keychain_services
• NSUbiquitousKeyValueStore
• iOS应用程序安全(20)-本地数据存储及其安全性（NSUserDefaults, CoreData, Sqlite, Plist 文件）
• Keychain is not safe

• iOS 10.3开始可以动态改变app图标
• 浅谈iOS视频播放的N种解决方案
• 【React Native】从源码一步一步解析它的实现原理
• 十分钟搞清字符集和字符编码
• iOS 高性能异构滚动视图构建方案 —— LazyScrollView
• 页面动态化的基础 —— Tangram

• iOS10 设备安装率超7成

看了下自己app的友盟统计，还有6%的iOS 8.x设备。等iOS 11出来后，再考虑放弃iOS 8.x用户吧。

• TIOBE 2月编程语言排行榜，Swift和Objective-C语言分别排在12和19位

OC稳住呀～

文章推荐（转）

• 移动端图片格式调研

最近看到Lottie项目，一个iOS，Android和React Native库，可以实时渲染After Effects动画，并且允许本地app像静态资源那样轻松地使用动画。回过头又把这篇图片格式调研的文章看了一遍，哈。这篇文章把移动开发常用的几种静态、动态图片做了详细的比较。

• 让 WKWebView 支持 NSURLProtocol

WKWebView不支持NSURLProtocol，导致基于UIWebView＋NSURLProtocol并做了一些深度优化的，很难一下子就迁移到WKWebView。WKWebView内部使用了NSURLProtocol，但没有对外开放，不知道出于什么考虑。这篇文章以比较hack的方式让WKWebView支持NSURLProtocol。

• DynamicCocoa：滴滴 iOS 动态化方案的诞生与起航

另一种Native动态化的方案，在OC编译器上动手脚，将OC代码自动编译成可动态下发的JS代码。

• Xcode8带来的新特性和坑

有些特性需要配合ios 10设备使用，比如内存循环引用、DYLD_PRINT_STATISTICS（打印应用预加载时间）等。

在Scheme的Environment Variables添加DYLD_PRINT_STATISTICS＝YES，可以打印应用预加载时间。从打印出来的日志看，dylib loading time占用了不少时间，应该是跟加载的系统库和三方库有关。
The loading of Apple system frameworks is highly optimized but loading your embedded frameworks can be expensive. 当三方库不采用Framework形式打包，加载时间是少了不少。

// 三方库以Frameworks形式打包
Total pre-main time: 392.25 milliseconds (100.0%)
         dylib loading time: 336.73 milliseconds (85.8%)
        rebase/binding time:  10.88 milliseconds (2.7%)
            ObjC setup time:  15.91 milliseconds (4.0%)
           initializer time:  28.65 milliseconds (7.3%)
           slowest intializers :
             libSystem.B.dylib :   4.63 milliseconds (1.1%)
                  AFNetworking :  12.03 milliseconds (3.0%)

// 三方库以.a静态链接库形式链接
Total pre-main time:  93.71 milliseconds (100.0%)
         dylib loading time:  11.46 milliseconds (12.2%)
        rebase/binding time:  27.05 milliseconds (28.8%)
            ObjC setup time:  13.16 milliseconds (14.0%)
           initializer time:  41.94 milliseconds (44.7%)
           slowest intializers :
             libSystem.B.dylib :   5.47 milliseconds (5.8%)
   libBacktraceRecording.dylib :   4.48 milliseconds (4.7%)
                        Fanmei :  54.14 milliseconds (57.7%)　

项目

• Lottie

After Effects动画的渲染引擎。

• Keyframes

A library for converting Adobe AE shape based animations to a data format and playing it back on Android and iOS devices.

跟Lottie类似，也是After Effects动画的渲染引擎。

• Instagram/IGListKit

A data-driven UICollectionView framework for building fast and flexible lists.

• Flipboard/FLEX

An in-app debugging and exploration tool for iOS

iOS设备调试工具，可以查看沙盒，抓包，查看视图信息等。

• material-components-ios

仿android的meterial design风格的控件

• 2016 移动应用质量大数据报告

主要是针对Crash和ANR的统计。

文章推荐

• 移动端监控体系之技术原理剖析

监控先于优化。没有数据支撑的优化，往往没有说服力，也很难衡量优化的效果如何。

• iOS 中数据持久化的几种方式

大部分App或多或少都会涉及到存储（持久化或缓存）。ibireme/YYCache，支持在硬盘持久化和在内存中缓存，从功能、性能和接口易用性上都不错，目前项目中也在用，推荐。

• 移动开发 OR WEB 前端？

• Flex 布局教程

老文章了，视图布局机制在iOS、Android、Html CSS是相通的，可以互相借鉴。youngsoft/MyLinearLayout实现很多布局机制。

MyLinearLayout is equivalent to: UIStackView of iOS and LinearLayout of Android.

MyRelativeLayout is equivalent to: AutoLayout of iOS and RelativeLayout of Android.

MyFrameLayout is equivalent to: FrameLayout of Android.

MyTableLayout is equivalent to: TableLayout of Android and table of HTML.

MyFlowLayout is equivalent to: flexbox of CSS3.

MyFloatLayout is equivalent to: float of CSS.

借鉴Android的LinearLayout以及Html CSS的FlexBox，自己写了FMLayouts，对iOS的布局机制做补充。

Android

• 2017年,身为Android开发的你必须要掌握的热门开源框架

• 你可能不知道 GOOGLE 最近的「小动作」

项目

• SnapKit/SnapKit

SnapKit/Masonry的Swift版本

• XCTest已基本满足单元测试和UI测试的需求，支持对同步流程、异步流程、性能的测试，UI测试代码的自动生成，代码测试覆盖率的统计等。
• UI测试也还有不足的地方，例如录制生成的代码仍不够完善，无法直接访问目标APP的接口，无法修改边界条件，在单设备或单模拟器运行效率过低，每次重启目标App后只能运行一个Case。
• 一些三方库
• Bluepill is a tool to run iOS tests in parallel using multiple simulators.
• XCTest官方手册
• iOS单元测试和UI测试
• 单元测试之旅--预见优秀
• iOS UnitTest单元测试
• Android单元测试的整理

• 2016移动开发技术巡礼

徐川大神对2016年移动技术发展的概述，以及对2017年的展望。总结了各种技术，热补丁、组件化、动态化、跨平台、直播、AR/VR等等。自己在项目实践中，也尝试了热补丁、动态化、组件化等技术，比较有体会。推荐他的博客移动开发前线，还是相当不错的。

• 苹果核 - iOS 高性能异构滚动视图构建方案 —— LazyScrollView

对于往往存在大量异构元素的app首页或集合页，该方案的思路还是可以借鉴下的。

• WKWebView从入门到趟坑

为满足大部分动态化需求，在App中内嵌一个WebView支持H5页，这是比较常见的做法。iOS上就UIWebView和WKWebView，WKWebView相比较UIWebView，性能更优，但也多了不少限制。目前自己项目中也是直接使用WKWebView，好在H5和Native的交互比较少，对WKWebView也没有做多少优化。

• Swift 并行编程现状和展望 - async/await 和参与者模式

异步编程，特别是多层嵌套的情况，即使用了GCD&Block回调方式去写，代码仍会过于凌乱，可读性也大打折扣。我会通过以下两种方法去处理，将每个异步回调的处理逻辑封装在一个函数内，或将每个异步过程封装起来（即Future／Promise的做法）。无论哪种，也都会额外增加些成本，结合自己项目内的代码风格和使用成本再选择一个合适的。

• 2017，我的iOS进阶规划

知识点比较基础，罗列得比较多，可以结合项目多看看。

代码推荐

• vsouza/awesome-ios

收集了大量的iOS开源项目、网页等等

• 33 个 2017 年必须了解的 iOS 开源库

• Alamofire跟AFNetworking的功能差不多，都是对URLSession的封装，对上层提供易用的网络请求接口。

• Alamofire和AFNetworking分别是Swift和OC的实现版本。

• 目前，这两个网络封装库的关注度和使用率非常高，代码质量也相当不错。本文想通过对Alamofire源码的简单分析，了解其基本框架和设计思路。

• 源码链接：Alamofire

一个GET请求的源码分析

• 从最简单的Get请求入手，分析Alamofire的代码。一个请求流程，可以分为请求发送流程和请求响应流程，下文将从这两个流程展开分析。

// Get请求的调用方式
Alamofire.request("https://httpbin.org/get").responseJSON { response in
    print(response.request)  // original URL request
    print(response.response) // HTTP URL response
    print(response.data)     // server data
    print(response.result)   // result of response serialization

    if let JSON = response.result.value {
        print("JSON: \(JSON)")
    }
}

请求发送流程

• Alamofire.Swift可以认为Alamofire一些对外接口的包装（Facade API）。 Alamofire.request实际上是调用了SessionManager.request。

// 调用request方法
/// Creates a `DataRequest` using the default `SessionManager` to retrieve the contents of a URL based on the specified `urlRequest`.
@discardableResult
public func request(_ urlRequest: URLRequestConvertible) -> DataRequest {
    return SessionManager.default.request(urlRequest)
}

• 在SessionManager.request，Request被组装创建，并加到发送队列中，然后等待一系列的响应事件。而SessionManager主要职责是管理发送队列，组装请求消息，设置Session相关的配置，设置工作线程等。

// 创建request对象，并开始发送
/// Creates a `DataRequest` to retrieve the contents of a URL based on the specified `urlRequest`.
    open func request(_ urlRequest: URLRequestConvertible) -> DataRequest {
        var originalRequest: URLRequest?

        do {
            originalRequest = try urlRequest.asURLRequest()
            let originalTask = DataRequest.Requestable(urlRequest: originalRequest!)

            let task = try originalTask.task(session: session, adapter: adapter, queue: queue)
            let request = DataRequest(session: session, requestTask: .data(originalTask, task))

            delegate[task] = request

            if startRequestsImmediately { request.resume() }

            return request
        } catch {
            return request(originalRequest, failedWith: error)
        }
    }

• 接着，通过Request.responseJSON设置JSON响应回调的处理方法。

// 设置回调
/// Adds a handler to be called once the request has finished.
    @discardableResult
    public func responseJSON(
        queue: DispatchQueue? = nil,
        options: JSONSerialization.ReadingOptions = .allowFragments,
        completionHandler: @escaping (DataResponse<Any>) -> Void)
        -> Self
    {
        return response(
            queue: queue,
            responseSerializer: DataRequest.jsonResponseSerializer(options: options),
            completionHandler: completionHandler
        )
    }

• Request.responseJSON实际上是调用Request.response，将回调添加到Request.delegate.queue，然后等待响应事件。

    /// Adds a handler to be called once the request has finished.
    @discardableResult
    public func response<T: DataResponseSerializerProtocol>(
        queue: DispatchQueue? = nil,
        responseSerializer: T,
        completionHandler: @escaping (DataResponse<T.SerializedObject>) -> Void)
        -> Self
    {
        delegate.queue.addOperation {
            let result = responseSerializer.serializeResponse(
                self.request,
                self.response,
                self.delegate.data,
                self.delegate.error
            )

            var dataResponse = DataResponse<T.SerializedObject>(
                request: self.request,
                response: self.response,
                data: self.delegate.data,
                result: result,
                timeline: self.timeline
            )

            dataResponse.add(self.delegate.metrics)

            (queue ?? DispatchQueue.main).async { completionHandler(dataResponse) }
        }

        return self
    }

• 至此，发送流程完成，接着就等待响应事件。

请求响应流程

• 一个请求的响应事件会有多个，并按循序上报，例如以下几个主要事件，

• HTTPS鉴权事件 func urlSession(_ session: URLSession,task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void)

• 收到Response响应头事件 func urlSession(_ session: URLSession,dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void)

• 收到Response Body数据事件 func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data)

• 响应流程完成事件 func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?)

• 本文以最后一个响应流程完成事件为例，梳理下整个响应流程。

• 首先，SessionDelegate会收到由URLSession.delegate上报的urlSession:task:didCompleteWithError，根据task找到URLSessionTask并通过其delegate上报事件给TaskDelegate。

    /// Tells the delegate that the task finished transferring data.
    open func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        /// Executed after it is determined that the request is not going to be retried
        let completeTask: (URLSession, URLSessionTask, Error?) -> Void = { [weak self] session, task, error in
            guard let strongSelf = self else { return }

            if let taskDidComplete = strongSelf.taskDidComplete {
                taskDidComplete(session, task, error)
            } else if let delegate = strongSelf[task]?.delegate {
                delegate.urlSession(session, task: task, didCompleteWithError: error)
            }

            NotificationCenter.default.post(
                name: Notification.Name.Task.DidComplete,
                object: strongSelf,
                userInfo: [Notification.Key.Task: task]
            )

            strongSelf[task] = nil
        }

        guard let request = self[task], let sessionManager = sessionManager else {
            completeTask(session, task, error)
            return
        }

        // Run all validations on the request before checking if an error occurred
        request.validations.forEach { $0() }

        // Determine whether an error has occurred
        var error: Error? = error

        if let taskDelegate = self[task]?.delegate, taskDelegate.error != nil {
            error = taskDelegate.error
        }

        /// If an error occurred and the retrier is set, asynchronously ask the retrier if the request
        /// should be retried. Otherwise, complete the task by notifying the task delegate.
        if let retrier = retrier, let error = error {
            retrier.should(sessionManager, retry: request, with: error) { [weak self] shouldRetry, timeDelay in
                guard shouldRetry else { completeTask(session, task, error) ; return }

                DispatchQueue.utility.after(timeDelay) { [weak self] in
                    guard let strongSelf = self else { return }

                    let retrySucceeded = strongSelf.sessionManager?.retry(request) ?? false

                    if retrySucceeded, let task = request.task {
                        strongSelf[task] = request
                        return
                    } else {
                        completeTask(session, task, error)
                    }
                }
            }
        } else {
            completeTask(session, task, error)
        }
    }

• 接着，TaskDelegate收到该事件后，恢复queue队列，按循序执行其中的回调，如ResponseJSON。

    @objc(URLSession:task:didCompleteWithError:)
    func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        if let taskDidCompleteWithError = taskDidCompleteWithError {
            taskDidCompleteWithError(session, task, error)
        } else {
            if let error = error {
                if self.error == nil { self.error = error }

                if
                    let downloadDelegate = self as? DownloadTaskDelegate,
                    let resumeData = (error as NSError).userInfo[NSURLSessionDownloadTaskResumeData] as? Data
                {
                    downloadDelegate.resumeData = resumeData
                }
            }

            // queue队列中的operaion开始按循序执行，回调到上层。
            queue.isSuspended = false
        }
    }

其他模块

• 除了发送，响应相关的代码，Alamofire还有许多其他模块。例如，

• NetworkReachabilityManager管理网络状态。

• ParameterEncoding 入参编解码方式。

• ResponseSerialization 响应的反序列化方式。

• ServerTrustPolicy HTTPS的鉴权

• 等等。

总结

• 分析得比较简单，抱砖引玉。

深入理解RunLoop

• 多线程&同步

iOS多线程编程指南

• Core Animation

CoreAnimation编程指南

Core Animation编程指南
iOS-Core-Animation-Advanced-Techniques

• Block

Block介绍

• GCD

GCD入门

• Core Foundation

Core Foundation源码

应用优化

• iOS 保持界面流畅的技巧

• WWDC心得与延伸:iOS图形性能

• iOS 事件处理机制与图像渲染过程

• 微信iOS卡顿监控系统

- (void)application:(UIApplication *)application didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)deviceToken {
    NSLog(@"didRegisterForRemoteNotificationsWithDeviceToken");
    
    // 注册用户登录登出监听
    [self handleRemoteNotificationDidRegistered];
}

- (void)application:(UIApplication *)application didFailToRegisterForRemoteNotificationsWithError:(NSError *)error {
    NSLog(@"didFailToRegisterForRemoteNotificationsWithError");
}

- (void)application:(UIApplication *)application didReceiveRemoteNotification:(NSDictionary *)userInfo {
    NSLog(@"didReceiveRemoteNotification");
    
    [UMessage didReceiveRemoteNotification:userInfo];
    
    NSString *jsonString = [userInfo objectForKey:@"custom"];
    NSData *jsonData = [jsonString dataUsingEncoding:NSUTF8StringEncoding];
    NSDictionary *dic = [NSJSONSerialization JSONObjectWithData:jsonData
                                                        options:NSJSONReadingMutableContainers
                                                          error:nil];
    if (dic==nil || [dic isEqual:[NSNull null]]) {
        return;
    }

    [self handleRemoteNotification:dic];
}

• 一步一步实现iOS应用PUSH功能 - 咪咕咪咕
• iOS上简单推送通知（Push Notification）的实现
• 十大豪门推送sdk，哪个更适合你
• 个推
• 腾讯信鸽
• 友盟U-Push

• ios-security
• 在线支付逻辑漏洞总结
• 扫盲文件完整性校验——关于散列值和数字签名
• 数字证书及 CA 的扫盲介绍
• https-ssl-tls

    NSString *textToShare = @"要分享的文本内容";
    UIImage *imageToShare = [UIImage imageNamed:@"shop"];
    NSURL *urlToShare = [NSURL URLWithString:@"http://blog.csdn.net/hitwhylz"];
    NSArray *activityItems = @[textToShare, imageToShare, urlToShare];
    
    UIActivityViewController *vc = [[UIActivityViewController alloc]initWithActivityItems:activityItems applicationActivities:nil];
    [self presentViewController:vc animated:YES completion:nil];

• 新浪微博 http://open.weibo.com
• 腾讯微博 http://dev.t.qq.com
• QQ空间，朋友网 http://connect.qq.com/intro/login/
• QQ分享（QQ好友，QQ群等）http://mobile.qq.com/api/
• 豆瓣社区 http://developers.douban.com
• 人人网 http://dev.renren.com
• 微信好友 微信朋友圈 http://open.weixin.qq.com
• 友盟U-Share
• 用过友盟Share，但是遇到友盟ShareSDK中使用的微信SDK版本与官方不同步的问题，后来放弃了友盟ShareSDK，全部采用原生官方SDK，如微信（好友、朋友圈）、QQ、微博，在国内，这三个分享渠道已经能覆盖80%了。

URL Schemes

• iOS应用间可以通过URL Schemes解决相互通信的问题。
• DemoA通过openURL唤起DemoB，并带上参数。

DemoA

[[UIApplication sharedApplication] openURL:[NSURL URLWithString:@"demob://page?sourcescheme=demoa"]];

• DemoB收到并解析参数并作逻辑处理，然后同样通过openURL返回到DemoA，并带上参数。

DemoB

- (BOOL)handleUrl:(NSURL *)url {
    NSArray *querys = [url.query componentsSeparatedByString:@"&"];
    
    NSMutableDictionary *queryDict = [[NSMutableDictionary alloc] init];
    for (NSString *q in querys) {
        NSArray *kv = [q componentsSeparatedByString:@"="];
        if (kv.count == 2) {
            queryDict[kv[0]] = kv[1];
        }
    }
    
    NSString *returnScheme = queryDict[@"sourcescheme"];
    
    UIAlertController *vc = [UIAlertController alertControllerWithTitle:@"url"
                                                                message:url.absoluteString
                                                         preferredStyle:UIAlertControllerStyleAlert];
    [vc addAction:[UIAlertAction actionWithTitle:@"返回原应用"
                                           style:UIAlertActionStyleDefault
                                         handler:^(UIAlertAction * _Nonnull action) {
                                             [[UIApplication sharedApplication] openURL:[NSURL URLWithString:[NSString stringWithFormat:@"%@://", returnScheme]]];
                                         }]];
    
    [vc addAction:[UIAlertAction actionWithTitle:@"留在当前应用"
                                           style:UIAlertActionStyleCancel
                                         handler:^(UIAlertAction * _Nonnull action) {
                                         }]];
    
    [self.window.rootViewController presentViewController:vc animated:YES completion:nil];
    
    return YES;
}

- (BOOL)application:(UIApplication *)application handleOpenURL:(NSURL *)url NS_DEPRECATED_IOS(2_0, 9_0, "Please use application:openURL:options:") __TVOS_PROHIBITED {
    return [self handleUrl:url];
}

- (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(nullable NSString *)sourceApplication annotation:(id)annotation NS_DEPRECATED_IOS(4_2, 9_0, "Please use application:openURL:options:") __TVOS_PROHIBITED {
    return [self handleUrl:url];
}

- (BOOL)application:(UIApplication *)app openURL:(NSURL *)url options:(NSDictionary<NSString*, id> *)options NS_AVAILABLE_IOS(9_0) {
    return [self handleUrl:url];

}

三方分享或认证

• 三方应用分享或认证都会用到URL Schemes流程，实际过程和参数会更复杂点，还需要考虑安全性。

• 如微信三方登录认证，除了三方应用通过URL Scheme跳转微信拿到code，再通过https请求微信后台拿到access_token，后续用https带上access_token可以请求各种资源。
  

• 三方分享则是通过URL Schemes带上不同格式的数据（文本、图片、链接等）。

23种设计模式

系统架构师

前篇

  1、系统架构师-基础到企业应用架构系列之--开卷有益
  2、系统架构师-基础到企业应用架构-系统建模[上篇]
  3、系统架构师-基础到企业应用架构-系统建模[中篇](上)
  4、系统架构师-基础到企业应用架构-系统建模[中篇](下)
  5、系统架构师-基础到企业应用架构-系统建模[下篇]
  6、系统架构师-基础到企业应用架构-系统设计规范与原则[上篇]
  7、系统架构师-基础到企业应用架构-系统设计规范与原则[下篇]
  8、系统架构师-基础到企业应用架构-设计模式[上篇]
  9、系统架构师-基础到企业应用架构-设计模式[中篇]
  10、系统架构师-基础到企业应用架构-设计模式[下篇]

中篇

  11、系统架构师-基础到企业应用架构-企业应用架构
  12、系统架构师-基础到企业应用架构-分层[上篇]
  13、系统架构师-基础到企业应用架构-分层[中篇]
  14、系统架构师-基础到企业应用架构-分层[下篇]
  15、系统架构师-基础到企业应用架构-表现层
  16、系统架构师-基础到企业应用架构-服务层
  17、系统架构师-基础到企业应用架构-业务逻辑层
  18、系统架构师-基础到企业应用架构-数据访问层
  19、系统架构师-基础到企业应用架构-组件服务
  20、系统架构师-基础到企业应用架构-安全机制

后篇

  21、单机应用、客户端/服务器、多服务、企业数据总线全解析
  22、系统架构师-基础到企业应用架构-单机应用(实例及demo)
  23、系统架构师-基础到企业应用架构-客户端/服务器(实例及demo)
  24、系统架构师-基础到企业应用架构-多服务(实例及demo)
  25、系统架构师-基础到企业应用架构-企业数据总线(实例及demo)
  26、系统架构师-基础到企业应用架构-性能优化(架构瓶颈)
  27、系统架构师-基础到企业应用架构-完整的架构方案实例[上篇]
  28、系统架构师-基础到企业应用架构-完整的架构方案实例[中篇]
  29、系统架构师-基础到企业应用架构-完整的架构方案实例[下篇]
  30、系统架构师-基础到企业应用架构-总结及后续

• On-Demand Resources

• App Thinning

• iOS微信安装包瘦身

• iOS可执行文件瘦身方法

• Deep Link深度链接，打破APP沙盒壁垒，链接到App内具体的内容。另外，iOS9 CoreSpotlight.framework提供了些APP内容搜索的API，也可以认为是深度链接。
• Defferred Deep Link延迟深度链接，在深度链接基础上改进，如果链接的App未安装，则先跳转到应用中心或AppStore提示安装App。
• Universal Link，iOS9上提供了Associated－Domain关联域名，用于在网页或App内唤起其他App。Universal Links通用链接应用跳转总结以及坑
• Custom URL Scheme，iOS提供的App间跳转的协议。

产品

• DeepShare

参考

• iOS 中的 Deferred Deep Linking
• 实战iOS 9：开发者必须掌握的三种搜索API

• 本文简单地梳理下Touch事件的处理流程。

• 参考文档：Event Handling Guide for iOS

• Touch事件流程可以分成，找第一响应和事件传递处理。

Hit-Test找第一响应视图

1. 用户在屏幕上的点击、滑动等都会转换成Touch事件，并加到待处理队列。
2. 接着，RunLoop设置的回调__CFRUNLOOP_IS_CALLING_OUT_TO_A_SOURCE0_PERFORM_FUNCTION__被触发，然后由_UIApplicationHandleEventQueue从待处理队列取出事件并分发给UIApplication。
3. -[UIApplication sendEvent:]分发事件到UIWindow。
4. UIWindow先通过hit-test递归找出第一响应的视图，然后再从第一响应视图开始处理该事件。这里可以重载这两个函数改变第一响应视图的查找，- [pointInside:withEvent:]，-[hitTest:withEvent:]。

基于响应链的事件传递

1. 第一响应视图通过重载以下几个方法-[touchesBegan:withEvent:]，-[touchesMoved:withEvent:]，-[touchesEnded:withEvent:]开始处理touch事件。
2. 如果第一响应视图上存在Gesture，则Gesture也会收到touch事件并将自己置为UIGestureRecognizerStatePossible状态。
3. Gesture识别到对应手势后，则切换到UIGestureRecognizerStateBegan状态，并cancel掉第一响应视图的事件处理-[touchesCancelled:withEvent:]。
4. 如果存在多个Gesture都在识别手势，则可以通过Gesture的属性和委托处理多个Gesture的协同问题。
5. 如果第一响应视图没有处理，则事件沿着响应链继续传递。（默认的响应链是当前视图->父视图->当前视图控制器->UIWindow->UIApplication）

1、依赖库的`+load`。
2、当前库`+load`，`class`的`+load`优先于`category`，父`class`优先于子`class`。
3、当前库的`All C++ static initializers and C/C++ __attribute__(constructor) functions`。
4、被依赖库的`+load`。

void prepare_load_methods(const headerType *mhdr)
{
    size_t count, i;

    runtimeLock.assertWriting();

    classref_t *classlist = 
        _getObjc2NonlazyClassList(mhdr, &count);
    for (i = 0; i < count; i++) {
        schedule_class_load(remapClass(classlist[i]));
    }

    category_t **categorylist = _getObjc2NonlazyCategoryList(mhdr, &count);
    for (i = 0; i < count; i++) {
        category_t *cat = categorylist[i];
        Class cls = remapClass(cat->cls);
        if (!cls) continue;  // category for ignored weak-linked class
        realizeClass(cls);
        assert(cls->ISA()->isRealized());
        add_category_to_loadable_list(cat);
    }
}

static void schedule_class_load(Class cls)
{
    if (!cls) return;
    assert(cls->isRealized());  // _read_images should realize

    if (cls->data()->flags & RW_LOADED) return;

    // Ensure superclass-first ordering
    schedule_class_load(cls->superclass);

    add_class_to_loadable_list(cls);
    cls->setInfo(RW_LOADED); 
}

IMP lookUpImpOrForward(Class cls, SEL sel, id inst, 
                       bool initialize, bool cache, bool resolver)
{
    // ...

    if (initialize  &&  !cls->isInitialized()) {
        _class_initialize (_class_getNonMetaClass(cls, inst));
        // If sel == initialize, _class_initialize will send +initialize and 
        // then the messenger will send +initialize again after this 
        // procedure finishes. Of course, if this is not being called 
        // from the messenger then it won't happen. 2778172
    }

    // ...

    return imp;
}

• understanding-objective-c-runtime
• ObjCRuntimeGuide
• runtime源码
• Objective-C 的动态提示和技巧
• NSObject的load和initialize方法
• associated-objects
• method-swizzling

NSLog(@"    method name = %s", sel_getName(method_getName(method)));
NSLog(@"    method type encode = %s", method_getTypeEncoding(method));
NSLog(@"    NumberOfArguments = %d", method_getNumberOfArguments(method));
NSLog(@"    ReturnType = %s", method_copyReturnType(method));

2016-04-08 20:54:59.351 OCRuntime[54195:953880]     method name = setNumberProperty:
2016-04-08 20:54:59.352 OCRuntime[54195:953880]     method type encode = v24@0:8@16
2016-04-08 20:54:59.352 OCRuntime[54195:953880]     NumberOfArguments = 3
2016-04-08 20:54:59.352 OCRuntime[54195:953880]     ReturnType = v

// 设置或交换IMP
IMP method_setImplementation(Method m, IMP imp);
void method_exchangeImplementations(Method m1, Method m2);

BOOL class_addMethod(Class cls, SEL name, IMP imp, const char *types);
                                 
// 如果原来没有这个方法，则直接添加Method，效果同class_addMethod
// 如果原来有，则替换掉原来的IMP，忽略参数类型
IMP class_replaceMethod(Class cls, SEL name, IMP imp, const char *types);

+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class class = [self class];

        // When swizzling a class method, use the following:
        // Class class = object_getClass((id)self);

        SEL originalSelector = @selector(viewWillAppear:);
        SEL swizzledSelector = @selector(xxx_viewWillAppear:);

        Method originalMethod = class_getInstanceMethod(class, originalSelector);
        Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);

        BOOL didAddMethod =
            class_addMethod(class,
                originalSelector,
                method_getImplementation(swizzledMethod),
                method_getTypeEncoding(swizzledMethod));

        if (didAddMethod) {
            class_replaceMethod(class,
                swizzledSelector,
                method_getImplementation(originalMethod),
                method_getTypeEncoding(originalMethod));
        } else {
            method_exchangeImplementations(originalMethod, swizzledMethod);
        }
    });
}

• understanding-objective-c-runtime
• ObjCRuntimeGuide
• runtime源码
• Objective-C 的动态提示和技巧
• NSObject的load和initialize方法
• associated-objects
• method-swizzling

    OCHelper *object = [[OCHelper alloc] init];
    
    // 以下两句代码效果是相同的。
    [object onHandler];
    objc_msgSend(object, @selector(onHandler));

IMP lookUpImpOrForward(Class cls, SEL sel, id inst, 
                       bool initialize, bool cache, bool resolver)
{
    Class curClass;
    IMP methodPC = nil;
    Method meth;
    bool triedResolver = NO;

    methodListLock.assertUnlocked();

    // Optimistic cache lookup
    if (cache) {
        methodPC = _cache_getImp(cls, sel);
        if (methodPC) return methodPC;    
    }

    // Check for freed class
    if (cls == _class_getFreedObjectClass())
        return (IMP) _freedHandler;

    // Check for +initialize
    if (initialize  &&  !cls->isInitialized()) {
        _class_initialize (_class_getNonMetaClass(cls, inst));
        // If sel == initialize, _class_initialize will send +initialize and 
        // then the messenger will send +initialize again after this 
        // procedure finishes. Of course, if this is not being called 
        // from the messenger then it won't happen. 2778172
    }

    // The lock is held to make method-lookup + cache-fill atomic 
    // with respect to method addition. Otherwise, a category could 
    // be added but ignored indefinitely because the cache was re-filled 
    // with the old value after the cache flush on behalf of the category.
 retry:
    methodListLock.lock();

    // Ignore GC selectors
    if (ignoreSelector(sel)) {
        methodPC = _cache_addIgnoredEntry(cls, sel);
        goto done;
    }

    // Try this class's cache.

    methodPC = _cache_getImp(cls, sel);
    if (methodPC) goto done;

    // Try this class's method lists.

    meth = _class_getMethodNoSuper_nolock(cls, sel);
    if (meth) {
        log_and_fill_cache(cls, cls, meth, sel);
        methodPC = method_getImplementation(meth);
        goto done;
    }

    // Try superclass caches and method lists.

    curClass = cls;
    while ((curClass = curClass->superclass)) {
        // Superclass cache.
        meth = _cache_getMethod(curClass, sel, _objc_msgForward_impcache);
        if (meth) {
            if (meth != (Method)1) {
                // Found the method in a superclass. Cache it in this class.
                log_and_fill_cache(cls, curClass, meth, sel);
                methodPC = method_getImplementation(meth);
                goto done;
            }
            else {
                // Found a forward:: entry in a superclass.
                // Stop searching, but don't cache yet; call method 
                // resolver for this class first.
                break;
            }
        }

        // Superclass method list.
        meth = _class_getMethodNoSuper_nolock(curClass, sel);
        if (meth) {
            log_and_fill_cache(cls, curClass, meth, sel);
            methodPC = method_getImplementation(meth);
            goto done;
        }
    }

    // No implementation found. Try method resolver once.

    if (resolver  &&  !triedResolver) {
        methodListLock.unlock();
        _class_resolveMethod(cls, sel, inst);
        triedResolver = YES;
        goto retry;
    }

    // No implementation found, and method resolver didn't help. 
    // Use forwarding.

    _cache_addForwardEntry(cls, sel);
    methodPC = _objc_msgForward_impcache;

 done:
    methodListLock.unlock();

    // paranoia: look for ignored selectors with non-ignored implementations
    assert(!(ignoreSelector(sel)  &&  methodPC != (IMP)&_objc_ignored_method));

    return methodPC;
}

@interface NSObject
- (id)forwardingTargetForSelector:(SEL)aSelector;
- (void)forwardInvocation:(NSInvocation *)anInvocation;
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector;
+ (BOOL)resolveClassMethod:(SEL)sel;
+ (BOOL)resolveInstanceMethod:(SEL)sel;
@end

• understanding-objective-c-runtime
• ObjCRuntimeGuide
• runtime源码
• Objective-C 的动态提示和技巧
• NSObject的load和initialize方法
• associated-objects
• method-swizzling

void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy);
id objc_getAssociatedObject(id object, const void *key);
void objc_removeAssociatedObjects(id object);

id _object_get_associative_reference(id object, void *key) {
    id value = nil;
    uintptr_t policy = OBJC_ASSOCIATION_ASSIGN;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        disguised_ptr_t disguised_object = DISGUISE(object);
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            ObjectAssociationMap *refs = i->second;
            ObjectAssociationMap::iterator j = refs->find(key);
            if (j != refs->end()) {
                ObjcAssociation &entry = j->second;
                value = entry.value();
                policy = entry.policy();
                if (policy & OBJC_ASSOCIATION_GETTER_RETAIN) ((id(*)(id, SEL))objc_msgSend)(value, SEL_retain);
            }
        }
    }
    if (value && (policy & OBJC_ASSOCIATION_GETTER_AUTORELEASE)) {
        ((id(*)(id, SEL))objc_msgSend)(value, SEL_autorelease);
    }
    return value;
}

void _object_set_associative_reference(id object, void *key, id value, uintptr_t policy) {
    // retain the new value (if any) outside the lock.
    ObjcAssociation old_association(0, nil);
    id new_value = value ? acquireValue(value, policy) : nil;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        disguised_ptr_t disguised_object = DISGUISE(object);
        if (new_value) {
            // break any existing association.
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i != associations.end()) {
                // secondary table exists
                ObjectAssociationMap *refs = i->second;
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    j->second = ObjcAssociation(policy, new_value);
                } else {
                    (*refs)[key] = ObjcAssociation(policy, new_value);
                }
            } else {
                // create the new association (first time).
                ObjectAssociationMap *refs = new ObjectAssociationMap;
                associations[disguised_object] = refs;
                (*refs)[key] = ObjcAssociation(policy, new_value);
                object->setHasAssociatedObjects();
            }
        } else {
            // setting the association to nil breaks the association.
            AssociationsHashMap::iterator i = associations.find(disguised_object);
            if (i !=  associations.end()) {
                ObjectAssociationMap *refs = i->second;
                ObjectAssociationMap::iterator j = refs->find(key);
                if (j != refs->end()) {
                    old_association = j->second;
                    refs->erase(j);
                }
            }
        }
    }
    // release the old value (outside of the lock).
    if (old_association.hasValue()) ReleaseValue()(old_association);
}

id 
object_dispose(id obj)
{
    if (!obj) return nil;

    objc_destructInstance(obj);

    free(obj);

    return nil;
}

void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = !UseGC && obj->hasAssociatedObjects();
        bool dealloc = !UseGC;

        // This order is important.
        if (cxx) object_cxxDestruct(obj);
        if (assoc) _object_remove_assocations(obj);
        if (dealloc) obj->clearDeallocating();
    }

    return obj;
}

void _object_remove_assocations(id object) {
    vector< ObjcAssociation,ObjcAllocator<ObjcAssociation> > elements;
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.associations());
        if (associations.size() == 0) return;
        disguised_ptr_t disguised_object = DISGUISE(object);
        AssociationsHashMap::iterator i = associations.find(disguised_object);
        if (i != associations.end()) {
            // copy all of the associations that need to be removed.
            ObjectAssociationMap *refs = i->second;
            for (ObjectAssociationMap::iterator j = refs->begin(), end = refs->end(); j != end; ++j) {
                elements.push_back(j->second);
            }
            // remove the secondary table.
            delete refs;
            associations.erase(i);
        }
    }
    // the calls to releaseValue() happen outside of the lock.
    for_each(elements.begin(), elements.end(), ReleaseValue());
}

• ObjCRuntimeGuide
• runtime源码
• Objective-C 的动态提示和技巧
• NSObject的load和initialize方法
• associated-objects

struct old_ivar {
    char *ivar_name;
    char *ivar_type;
    int ivar_offset;
#ifdef __LP64__
    int space;
#endif
};

struct old_property {
    const char *name;
    const char *attributes;
};

struct old_method {
    SEL method_name;
    char *method_types;
    IMP method_imp;
};

struct old_protocol {
    Class isa;
    const char *protocol_name;
    struct old_protocol_list *protocol_list;
    struct objc_method_description_list *instance_methods;
    struct objc_method_description_list *class_methods;
};

struct objc_method_description *
lookup_protocol_method(old_protocol *proto, SEL aSel, 
                       bool isRequiredMethod, bool isInstanceMethod, 
                       bool recursive)
{
    struct objc_method_description *m = nil;
    old_protocol_ext *ext;

    if (isRequiredMethod) {
        if (isInstanceMethod) {
            m = lookup_method(proto->instance_methods, aSel);
        } else {
            m = lookup_method(proto->class_methods, aSel);
        }
    } else if ((ext = ext_for_protocol(proto))) {
        if (isInstanceMethod) {
            m = lookup_method(ext->optional_instance_methods, aSel);
        } else {
            m = lookup_method(ext->optional_class_methods, aSel);
        }
    }

    if (!m  &&  recursive  &&  proto->protocol_list) {
        int i;
        for (i = 0; !m  &&  i < proto->protocol_list->count; i++) {
            m = lookup_protocol_method(proto->protocol_list->list[i], aSel, 
                                       isRequiredMethod,isInstanceMethod,true);
        }
    }

    return m;
}

struct old_category {
    char *category_name;
    char *class_name;
    struct old_method_list *instance_methods;
    struct old_method_list *class_methods;
    struct old_protocol_list *protocols;
    uint32_t size;
    struct old_property_list *instance_properties;
};

• ObjCRuntimeGuide
• runtime源码
• Objective-C 的动态提示和技巧
• NSObject的load和initialize方法
• associated-objects

The Objective-C Runtime is a Runtime Library, it's a library written 
mainly in C & Assembler that adds the Object Oriented capabilities 
to C to create Objective-C. This means it loads in Class information, 
does all method dispatching, method forwarding, etc. The Objective-C 
runtime essentially creates all the support structures that make 
Object Oriented Programming with Objective-C Possible.

// 伪代码，对源码稍做修改。

static Class *g_classList;

struct objc_class {
    Class isa;          // 指向元类
    Class super_class;  // 指向父类
    
    // 类基本信息
    const char *name;
    long version;
    long info;
    long instance_size;
    
    // 类的变量、方法、协议的元信息
    struct objc_ivar_list *ivars;
    struct objc_method_list **methodLists;
    struct objc_protocol_list *protocols;
    
    // 方法缓存
    struct objc_cache *cache;
};
typedef struct objc_class *Class;

bool isMetaClass() {
        return info & CLS_META;
    }

// 伪代码，对源码稍做修改。

struct objc_object {
    Class isa;
    
    // 变量的数据
    void *varsLayout;
}

typedef struct objc_object *id

// 伪代码

{
    // 找到类
    Class cls = findClass("NSObject");
    
    // 找到alloc方法，执行生成对象
    IMP imp = findImp(cls, "alloc");
    id obj = imp(cls);
    
    // 找到init方法，执行初始化对象
    IMP imp = findImp(cls, "init");
    imp(obj);
    
    // 返回对象
    return obj;
}   
    
id alloc(Class cls) {
    id obj = malloc(sizeof(struct objc_object));
    obj->isa = cls;
    return obj;
}

id init(id obj) {
    obj->varsLayout = xxx;
}   

• 总的来说，全局维护一张类表，存放类方法、实例方法、实例变量的元信息等。程序加载阶段会初始化这张表。运行阶段，也可以通过addMethod、class_replaceMethod、class_addIvar、class_addProtocol、class_addProperty等接口动态修改这张表。
  ### 参考
• ObjCRuntimeGuide
• runtime源码
• Objective-C 的动态提示和技巧
• NSObject的load和initialize方法
• associated-objects