Sonic是腾讯团队研发的一个轻量级的高性能的Hybrid框架，专注于提升页面首屏加载速度。
这些概念性的东西可以在这里查看，这篇文章我们主要来分析iOS端的表象然后再分析源码。
咋们还是放一张使用Sonic前后效果图，效果还是很明显的
Soinc效果展示.gif
先来从表象过一下Sonic对请求和响应做了哪些变化
Sonic对请求和响应做了规范约定
规范约定.png
cache-offline字段说明.png
所以我们可以看看下面四种场景请求和响应对于没使用sonic都有啥不一样
首次加载
首次加载，因为客户端本地没有数据，所以请求头部会有这样的一些数据
{
"If-None-Match" = "";
"accept-Language" = "zh-CN,zh;";
"accept-diff" = true;
"template-tag" = "";
...
}
从上面的表中可以看到If-None-Match为""表示本地没有缓存的该url的html文件；accept-diff为true表示客户端支持Sonicn规范；template-tag为""表示本地没有缓存该url的template文件。
首次加载服务器返回的响应头部为
{
"Cache-Offline" = true;
Etag = 8f53de5336b29c851d3befe20d6f74c8405faa47;
"template-change" = true;
"template-tag" = ecad7ac4506804fd64f1fdd6d30d6079d730b50e;
...
}
内容为一个完整的html文件
<html lang="en">
...
<span id="data1Content">
<!-- 模拟数据更新 -->
<!--sonicdiff-data1-->
<h2>当前时间：1503389501</h2>
<!--sonicdiff-data1-end-->
</span>
...
</html>
Cache-Offline我看了一下服务器的源码，只会返回true和http（后面sonic可能会添加），一般是返回true表示缓存到磁盘并展示返回内容；Etag有值表示本次html内容的唯一标识；template-change为true表示本次请求返回的模版文件和客户端本地缓存的模版文件不一样，首次加载本地就没有模版文件当然不一样咯；template-tag有值模版文件的唯一标识。
这时候你可以看看客户端本地对于该url缓存了4个文件，名字用url通过md5加密
客户端本地缓存文件.png
cfg文件内容为
<plist version="1.0">
<dict>
<key>Etag</key>
<string>486fde9e2343fcf44563fea7d30570e695aa31ad</string>
<key>template-tag</key>
<string>ecad7ac4506804fd64f1fdd6d30d6079d730b50e</string>
...
</dict>
</plist>
很熟悉吧，就是把服务器头部返回的保存起来了;data文件内容为
<plist version="1.0">
<dict>
<key>{data1}</key>
<string><!--sonicdiff-data1-->
<h2>当前时间：1503389501</h2>
<!--sonicdiff-data1-end--></string>
</dict>
</plist>
这个就是本次请求服务器返回的动态变化的值，也就是你前端标记了sonicdiff的标签在本次响应中的值；html就不需要说了，就是一个完整的html文件
<html lang="en">
...
<span id="data1Content">
<!-- 模拟数据更新 -->
<!--sonicdiff-data1-->
<h2>当前时间：1503389501</h2>
<!--sonicdiff-data1-end-->
</span>
...
</html>
temp是sonic根据前端html文件抽离出来的模版
<html lang="en">
...
<span id="data1Content">
<!-- 模拟数据更新 -->
{data1}
</span>
...
</html>
这样我们的首次加载就完成了，服务器返回完整的html文件、客户端本地缓存本次请求相关的文件
数据变化
第二次打开网页的时候你能马上看到页面内容，是因为Sonic加载了本地对该url缓存的html文件；请求头部变成了
{
"If-None-Match" = bbf85d933f2d42554af04b618f0875d958fa39fb;
"accept-diff" = true;
"template-tag" = ecad7ac4506804fd64f1fdd6d30d6079d730b50e;
...
}
相对于首次加载，为""的key都有了值，是因为在本地读取了sonic对于该url缓存的cfg文件；服务器响应头部变成了
{
"Cache-Offline" = true;
Etag = c70b4b4aa53295c1c6320ec1ec1dee809332669f;
"template-change" = false;
"template-tag" = ecad7ac4506804fd64f1fdd6d30d6079d730b50e;
...
}
你可以看到template-tag和请求时一样，说明模版没有变化，template-change为false是个意思；Etag和请求时If-None-Match不同说明页面内容有变化；这时候服务器返回了如下内容
{
"data": {
"{title}": "<title>Sonic Demo<\/title>",
"{data1}": "<!--sonicdiff-data1-->\n <h2>\u5f53\u524d\u65f6\u95f4\uff1a1503390256<\/h2>\n <!--sonicdiff-data1-end-->"
},
"template-tag": "ecad7ac4506804fd64f1fdd6d30d6079d730b50e",
"html-sha1": "af3f21e49dcf76ae538095a18d82bf10692db06e",
"diff": ""
}
是不是很惊讶，sonic做了处理，对于模版没有变化的页面只返回了动态数据变化的部分；没错，这大大的降低了流量，也加快了请求；这时候你再看看本地的缓存文件，temp文件内容不变，其他三个文件内容更新了（自己理解一下）
数据更新请求完了，客户端先加载本地缓存的html文件、服务器返回变化的部分、客户端本地更新必要的文件
模版变化
模版变化其实和首次加载只有一点点区别，就是客户端会先加载本地缓存的html文件；服务器响应依然会返回整个html文件（其实我觉得这个sonic可以再优化优化，估计是遇到了什么困难），客户端本地会更新所有四个文件
完全缓存
这个很好理解了，客户端会先加载本地缓存的html文件，服务器返回状态码304表示内容和客户端一摸一样，客户端只需要更新cfg文件
再来从源码发现Sonic对请求和响应做了哪些变化
依然老规矩，我们会按照官方说的首次加载、数据更新和完全缓存三种情况（官方说四种但是首次加载和模版更新客户端逻辑一样）来看一下客户端会经过哪些源码。
注：阅读此部分请你先下载我写的超简单支持Sonic的PHP服务器和iOS客户端，然后仔细阅读NSURLProtocol简单实用、Mac搭建PHP本地环境在本地部署好环境，最后结合Sonic之iOS端实现原理一起看本文章；理所当然的本文我会按照这两份源码来讲解；iOS和Web交互中间件使用WebViewJavascriptBridge。
下载服务器代码后在index.php中注释掉这一行关闭模版更新（首次加载和模版更新客户端逻辑一样）
...
//每次重新打开此界面都改变此值，模拟模版变化
$templateFlag = $_COOKIE['templateFlag'];
//模拟模版更新
// setcookie('templateFlag',!$templateFlag);
...
如果你本地php服务器环境搭建完成了，你浏览器中输入类似http://localhost/sonic-php/sample/index.php地址就会看到下面的页面，记得把客户端中的地址也改改
前端界面.png
首次加载
初始化
我们看看WebViewController.m的init方法：
...
[[SonicClient sharedClient] createSessionWithUrl:@"http://localhost/sonic-php/sample/index.php" withWebDelegate:self];
还记得这里说的客户端并行请求数据吗？说的就是在ViewController初始化的时候Sonic就开始向服务器请求数据而不用等到webView调用loadRequest；我们进入SonicClient，sharedClient就是获取SonicClient的单例对象，init时调了[self setupClient]
- (void)setupClient {
self.lock = [NSRecursiveLock new];
self.tasks = [NSMutableDictionary dictionary];
self.ipDomains = [NSMutableDictionary dictionary];
}
其中lock采用NSRecursiveLock防止死锁；tasks用于存放当前url和session对应关系，因为你可以同时存在几个带webView的vc；ipDomains存放域名和地址的对应关系，举个例子，我们的演示demo地址是http://localhost/sonic-php/sample/index.php，如果你做了下面的操作
[[SonicClient sharedClient] addDomain:@"localhost" withIpAddress:@"127.0.0.1"];
那么发起该url请求时SonicSession的serverIP值就会被设置为127.0.0.1并且请求头部也会加上一些参数（其实我提了一个issues并给腾讯团队提了pull request），最后发起请求的地址也就成了http://127.0.0.1/sonic-php/sample/index.php
现在来看看
if ([[SonicCache shareCache] isServerDisableSonic:sonicSessionID(url)])
return;
[SonicCache shareCache]同样的是获取SonicCache的单例对象，在init的时[self setupInit]
- (void)setupInit
{
self.maxCacheCount = 3;
self.lock = [NSRecursiveLock new];
self.memoryCache = [NSMutableDictionary dictionaryWithCapacity:self.maxCacheCount];
self.recentlyUsedKey = [NSMutableArray arrayWithCapacity:self.maxCacheCount];
[self setupCacheDirectory];
[self setupCacheOfflineTimeCfgDict];
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(memoryWarningClearCache) name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
}
maxCacheCount表示内存缓存中保留的SonicCacheItem个数；memoryCache表示内存缓存的SonicCacheItem；recentlyUsedKey相当于做了一个先进先出的操作，如果当前内存缓存数量超过了maxCacheCount那么就删除最先加入的；setupCacheDirectory是创建缓存目录；setupCacheOfflineTimeCfgDict是服务器容灾措施，如果服务器访问量太大，会给一部分客户响应头cache-offline值设置为http让这部分客户端暂时不能对于特定url访问服务器（offlineCacheTimeCfg会对单个url配置限制时间），本地如果有缓存的该配置文件就填充offlineCacheTimeCfg属性；最后一句话是如果应用内存紧张了就删除内存缓存的数据。
sonicSessionID(url)是Sonic用md5加密并标示标示每个url的
if ([[SonicClient sharedClient].currentUserUniq length] > 0)
return stringFromMD5([NSString stringWithFormat:@"%@_%@",[SonicClient sharedClient].currentUserUniq,sonicUrl(url)]);
else
return stringFromMD5([NSString stringWithFormat:@"%@",sonicUrl(url)]);
Sonic给我们设一个属性currentUserUniq，让我们可以设置每次进入网页的身份（你的app当然可以退出再登陆其他账号），Sonic好分用户对应文件夹村存放缓存文件。
所以我们首次加载的时候[[SonicCache shareCache] isServerDisableSonic:sonicSessionID(url)肯定是返回NO的，因为我们没有发起过请求，本地自然没有服务器对于容灾的配置文件，SonicCache的offlineCacheTimeCfg自然也是空的。然后我们走下面的代码
[self.lock lock];
SonicSession *existSession = self.tasks[sonicSessionID(url)];
//这里都会为nil，因为我们在控制器返回时从self.tasks中remove了该会话
if (existSession && existSession.delegate != nil) {
//session can only owned by one delegate
[self.lock unlock];
return;
}
加锁进行后面的操作，找到tasks中该url是否已经有一个对应的回话了，这里我们要看看WebViewController.m的dealloc
[[SonicClient sharedClient] removeSessionWithWebDelegate:self];
也就是说如果你的控制器能正常释放且你应用不会打开两个相同url界面的话， 这里的existSession肯定是nil的，我们不分析两个界面同时打开相同url
NSURL *cUrl = [NSURL URLWithString:url];
NSString *serverIP = [self.ipDomains objectForKey:cUrl.host]?:@"";
existSession = [[SonicSession alloc] initWithUrl:url withServerIP:serverIP withWebDelegate:aWebDelegate];
这里就是创建会话了，serverIP就是该url在self.ipDomains中对应的值，这个前面已经提过了;我们看看SonicSession初始化都做了什么
...
_sessionID = [sonicSessionID(aUrl) copy];
[self setupData];
- (void)setupData {
SonicCacheItem *cacheItem = [[SonicCache shareCache] cacheForSession:_sessionID];
...
}
[[SonicCache shareCache] cacheForSession:_sessionID]是获取该会话id在本地对应的缓存文件，我们看看cacheForSession
SonicCacheItem *cacheItem = nil;
cacheItem = self.memoryCache[sessionID];
if (!cacheItem) {
cacheItem = [[SonicCacheItem alloc] initWithSessionID:sessionID];
[self memoryCacheItem:cacheItem];
[self setupCacheItemFromFile:cacheItem];
[cacheItem release];
}
...
self.memoryCache[sessionID]表示先从内存缓存中找到该会话是否有保存的cacheItem，如果没有就用sessionID初始化一个，memoryCacheItem表示记录到内存缓存中
- (void)memoryCacheItem:(SonicCacheItem *)cacheItem {
//保存到内存缓存中
[self.memoryCache setObject:cacheItem forKey:cacheItem.sessionID];
//找到该cache对应的下标
NSUInteger index = [self.recentlyUsedKey indexOfObject:cacheItem.sessionID];
if (index != NSNotFound) {
[self.recentlyUsedKey removeObjectAtIndex:index];
}
//并把该cache放到第一个，用来记录最近使用的cache
[self.recentlyUsedKey insertObject:cacheItem.sessionID atIndex:0];
//如果需要缓存的cache个数大于限制
if (self.recentlyUsedKey.count > self.maxCacheCount) {
//我们就去掉最后一个，也就是最先加入的
NSString *lastUsedKey = [self.recentlyUsedKey lastObject];
[self.memoryCache removeObjectForKey:lastUsedKey];
[self.recentlyUsedKey removeObject:lastUsedKey];
}
}
再来看看[self setupCacheItemFromFile:cacheItem]
- (void)setupCacheItemFromFile:(SonicCacheItem *)item {
//检查该item是否有html data config template四个文件
//如果有任何一个文件不存在，就删除所有文件
if (![self isAllCacheExist:item.sessionID]) {
[self removeFileCacheOnly:item.sessionID];
return;
}
//如果四个文件都存在，就取出里面的数据
NSData *htmlData = [NSData dataWithContentsOfFile:[self filePathWithType:SonicCacheTypeHtml sessionID:item.sessionID]];
NSDictionary *config = [NSDictionary dictionaryWithContentsOfFile:[self filePathWithType:SonicCacheTypeConfig sessionID:item.sessionID]];
NSString *sha1 = config[kSonicSha1];
NSString *htmlSha1 = getDataSha1(htmlData);
//如果检测出来内容的sha值不是cfg中保存的值，说明数据发生了错误，需要删除文件
if (![sha1 isEqualToString:htmlSha1]) {
[self removeFileCacheOnly:item.sessionID];
}else{
//如果所有数据正常，就赋值给item
item.htmlData = htmlData;
item.config = config;
}
}
这里的意思很明确了，如果本地有该url的缓存文件就读取放到cacheItem中，如果没有那么本地啥文件都没有；接下来我们接着看SonicSession的setupData剩下的部分：
//是不是第一次加载，通过item的htmlData数据来判断
self.isFirstLoad = cacheItem.hasLocalCache;
//如果本地有该会话缓存的数据就给本session赋值
if (!cacheItem.hasLocalCache) {
self.cacheFileData = cacheItem.htmlData;
self.cacheConfigHeaders = cacheItem.config;
self.cacheResponseHeaders = cacheItem.cacheResponseHeaders;
self.localRefreshTime = cacheItem.lastRefreshTime;
}
[self setupConfigRequestHeaders];
setupConfigRequestHeaders里面的内容就不说了，就是设置请求的头部，里面有很多Sonic扩展的key可以在这里看到。
接下来继续看SonicClient中createSessionWithUrl::剩下的部分
[existSession setCompletionCallback:^(NSString *sessionID){
[existSession cancel];
[self.tasks removeObjectForKey:sessionID];
}];
[self.tasks setObject:existSession forKey:existSession.sessionID];
[existSession start];
设置会话完成时从tasks中删除该会话，把当前会话加到tasks中，然后开始start
dispatchToMain(^{
//通知控制器（因为self.delegate已经指向了打开webView的控制器），我要对该url进行请求了
if (self.delegate && [self.delegate respondsToSelector:@selector(sessionWillRequest:)]) {
[self.delegate sessionWillRequest:self];
}
//如果控制器有设置cookies，在这里同步添加到请求
[self syncCookies];
});
//异步执行请求
[self requestStartInOperation];
requestStartInOperation就是异步请求数据（按照程序执行的先后顺序，后面讲这个），看到这里我们要回过头来看WebViewController.m的viewDidLoad了
webView发起请求
...
if ([[SonicClient sharedClient] sessionWithWebDelegate:self])
[self.webView loadRequest:sonicWebRequest(request)];
...
- (SonicSession *)sessionWithWebDelegate:(id<SonicSessionDelegate>)aWebDelegate {
//检测aWebDelegate是否实现了SonicSessionDelegate协议
if (!ValidateSessionDelegate(aWebDelegate))
return nil;
SonicSession *findSession = nil;
[self.lock lock];
//从tasks中找到代理是aWebDelegate的会话
for (SonicSession *session in self.tasks.allValues) {
if (session.delegate == aWebDelegate) {
findSession = session;
break;
}
}
[self.lock unlock];
return findSession;
}
如果findSession为nil有下面两种情况
1: aWebDelegate没有实现SonicSessionDelegate协议
2：tasks中没有delegate为aWebDelegate的会话
第二种情况往往是控制器没有delloc导致的，如果你也遇到了就需要好好的检查一下了。代码走到这里后我们就要好好看一下sonicWebRequest(request)了
#define SonicHeaderValueWebviewLoad @"__SONIC_HEADER_VALUE_WEBVIEW_LOAD__"
NSMutableURLRequest *request = [[originRequest mutableCopy]autorelease];
[request setValue:SonicHeaderValueWebviewLoad forHTTPHeaderField:SonicHeaderKeyLoadType];
[request setValue:sonicSessionID(request.URL.absoluteString) forHTTPHeaderField:SonicHeaderKeySessionID];
######拦截webView请求
这里我们要注意SonicHeaderValueWebviewLoad宏，只有请求头部设置了此值webView的loadRequest才会被SonicURLProtocol所拦截（前面我让你看过NSURLProtocol文章）。所以接下来我们当然是看SonicURLProtocol.m的startLoading方法咯
NSThread *currentThread = [NSThread currentThread];
//得到当前会话的id
NSString *sessionID = [self.request valueForHTTPHeaderField:SonicHeaderKeySessionID];
//让SonicClient接管此请求
[[SonicClient sharedClient] registerURLProtocolCallBackWithSessionID:sessionID completion:^(NSDictionary *param) {
//SonicClient请求返回的数据通过callClientActionWithParams处理
[self performSelector:@selector(callClientActionWithParams:) onThread:currentThread withObject:param waitUntilDone:NO];
}];
callClientActionWithParams写法基本是固定的，就是在各个请求阶段取出SonicClient回调的数据传输给self.client去继续渲染界面。
看到这里我们大概明白了，webView的loadRequest被SonicClient接管了，我们现在来看看SonicClient的registerURLProtocolCallBackWithSessionID，这个是重点
...
[session preloadRequestActionsWithProtocolCallBack:protocolCallBack];
- (void)preloadRequestActionsWithProtocolCallBack:(SonicURLProtocolCallBack)protocolCallBack {
dispatch_block_t opBlock = ^{
self.protocolCallBack = protocolCallBack;
//如果不是第一次请求该url，是不是第一次是根据本地是否有该url缓存文件判断的
//或者模版更新sonic让webView重新loadRequest或者如果当前数据请求Sonic已经完成了（因为self.isDataUpdated只会在请求完成且没有错误才被设置），意思就是说我在webView在调用loadRequest前Sonic就已经获取完了整个请求数据
if (self.isDataUpdated || !self.isFirstLoad) {
//如果protocolCallBack不为空
if (protocolCallBack)
//直接就可以告诉SonicURLProtocol请求完成并返回数据，展示界面
[self dispatchProtocolActions:[self cacheFileActions]];
//如果模版更新sonic让webView重新loadRequest或者请求已经完成了，设置sonicStatus的状态为完全缓存;如果Sonic请求完数据会直接存到本地的，状态说是完全缓存也是理所当然的
if (self.isDataUpdated)
self.sonicStatusFinalCode = SonicStatusCodeAllCached;
} else {
//如果是第一次加载数据且Sonic请求还没有完成或者请求出错了，就把Sonic已经完成的阶段回调给SonicURLProtocol，self.isCompletion只会在请求发生错误或者请求完成时设置
//还没有完成的阶段，后面会陆续回调给SonicURLProtocol
if (self.isFirstLoad)
[self dispatchProtocolActions:[self preloadRequestActions]];
}
};
//把block丢给SonicSessionQueue，先后顺序执行
dispatchToSonicSessionQueue(opBlock);
}
上面的代码就是Sonic的核心了，为什么第二次访问url会那么快，是因为第二次是直接取对应的cacheItem让webView展示。在这里我们是首次加载，所以会走else代码块，为了方便讲解，我们假设现在Sonic一个请求阶段都没有完成，那么这时候我们就要回到刚才SonicSession的requestStartInOperation了
Class customRequest = [self canCustomRequest];
if (!customRequest) {
//If there no custom request ,then use the default
customRequest = [SonicConnection class];
}
...
//用户如果有自定义的请求连接方式（比如：用户继承SonicConnection，用AFNetWorking发起请求等）
- (Class)canCustomRequest {
Class findDestClass = nil;
for (NSInteger index = sonicRequestClassArray.count - 1; index >= 0; index--) {
Class itemClass = sonicRequestClassArray[index];
//构造一个此类的canInitWithRequest方法，调用
NSMethodSignature *sign = [itemClass methodSignatureForSelector:@selector(canInitWithRequest:)];
NSInvocation *invoke = [NSInvocation invocationWithMethodSignature:sign];
invoke.target = itemClass;
NSURLRequest *argRequest = self.request;
[invoke setArgument:&argRequest atIndex:2];
invoke.selector = @selector(canInitWithRequest:);
[invoke invoke];
BOOL canCustomRequest;
//如果有能处理该requeset的（用户继承SonicConnection，canInitWithRequest返回YES）
[invoke getReturnValue:&canCustomRequest];
if (canCustomRequest) {
findDestClass = itemClass;
break;
}
}
return findDestClass;
}
这里就比较有意思了，SonicSDK默认使用的SonicConnection类作为连接，你可以看到SonicConnection内部是用NSURLSessionDataTask发起的请求，用户可以自己继承SonicConnection用比如AFNetWorking等发起请求；所以[self canCustomRequest]方法就是获取用户自定义的请求方式是否有能响应该request的，也就是canInitWithRequest:返回YES的，如果没有就用初始化SonicConnection。接下来当然是初始化请求，然后建立请求咯
...
//初始化请求类
SonicConnection *cRequest = [[customRequest alloc]initWithRequest:self.request];
//把请求类保存到自己mCustomConnection属性中
self.mCustomConnection = cRequest;
[cRequest release];
//设置请求类发起请求的各个阶段需要通知到自己处理
//然后处理结果会通过self.protocolCallBack给到SonicURLProtocol
self.mCustomConnection.session = self;
//开始加载请求
[self.mCustomConnection startLoading];
因为我们是源码讲解，所以我们假设发起请求的类是SonicConnection；其实SonicConnection代码没啥看不懂的，就是数据请求哈，我们只讲重要的请求阶段完成后发生了啥（特别需要SonicSession的一些属性设置）
收到服务器响应
首先当然是收到服务器响应阶段了
[self.session session:self.session didRecieveResponse:(NSHTTPURLResponse *)response];
刚才说了SonicConnection的session就是SonicSession，我们会到SonicSession中
- (void)session:(SonicSession *)session didRecieveResponse:(NSHTTPURLResponse *)response {
...
self.response = response;
self.cacheResponseHeaders = response.allHeaderFields;
if (self.isFirstLoad)
[self firstLoadRecieveResponse:response];
...
}
- (void)firstLoadRecieveResponse:(NSHTTPURLResponse *)response {
[self dispatchProtocolAction:SonicURLProtocolActionRecvResponse param:response];
}
//回传给SonicURLProtocol
- (void)dispatchProtocolAction:(SonicURLProtocolAction)action param:(NSObject *)param {
NSDictionary *actionParam = [self protocolActionItem:action param:param];
if (self.protocolCallBack) {
self.protocolCallBack(actionParam);
}
}
把响应和头部存在SonicSession属性中，如果是第一次加载，回传给SonicURLProtocol。前面说了SonicURLProtocol中
- (void)callClientActionWithParams:(NSDictionary *)params {
...
}
方法是固定的，没啥特别的；服务器返回的code有以下几种情况
1000:第一次请求，及本地没有缓存文件，此时服务器会返回整个前端内容
2000:非第一次请求，本地和服务器内容模版有变化，此时服务器会返回整个前端内容
304:非第一次请求，本地可服务器内容完全一样，此时服务器不返回前端任何内容
503:服务器要求客户端不用Sonic重新加载请求
200:非第一次请求，本地和服务器内容模版无变化，但动态数据有变化，此时服务器会返回前端变化的数据
注：至于服务器是怎么判断返回什么的，你就去看看源码咯
所以我们继续走SonicConnection中请求下一个阶段
收到服务器数据
[self.session session:self.session didLoadData:data]
//收到请求返回的数据
- (void)session:(SonicSession *)session didLoadData:(NSData *)data {
dispatch_block_t opBlock = ^{
if (!self.responseData)
self.responseData = [NSMutableData data];
//如果有数据，就不断的添加到self.responseData中
if (data) {
NSData *copyData = [data copy];
[self.responseData appendData:data];
[copyData release];
//如果是第一次加载，执行firstLoadDidLoadData
if (self.isFirstLoad)
[self firstLoadDidLoadData:data];
}
};
dispatchToSonicSessionQueue(opBlock);
}
- (void)firstLoadDidLoadData:(NSData *)data
{
//回传给SonicURLProtocol
[self dispatchProtocolAction:SonicURLProtocolActionLoadData param:data];
}
收到服务器响应阶段也是如此简单，就是把返回的数据存在SonicSession的responseData中；接下来在SonicConnection中可能会走下面两个方法
//请求完成
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
...
}
//请求变无效
- (void)URLSession:(NSURLSession *)session didBecomeInvalidWithError:(nullable NSError *)error {
...
}
请求完成
//如果发生错误，执行此
if (error)
[self.session session:self.session didFaild:error];
else//如果未发生错误，执行此
[self.session sessionDidFinish:self.session];
如果发生错误，走SonicSession的下面代码
//请求完成，且发生错误
- (void)session:(SonicSession *)session didFaild:(NSError *)error {
dispatch_block_t opBlock = ^{
//把错误信息记录到SonicSession的error中
self.error = error;
//标记请求已经完成
self.isCompletion = YES;
//请求错误但是服务器返回304表示完全缓存，也就是说服务器本次请求的数据和客户端保存的数据完全一样
if (self.response.statusCode == 304) {
//是不是第一次加载
if (self.isFirstLoad)
[self firstLoadDidFinish];
else
[self updateDidSuccess];
}else{//请求错误且服务器没返回304，说明真的出错了
if (self.isFirstLoad)
[self firstLoadDidFaild:error];
else
[self updateDidFaild];
}
};
dispatchToSonicSessionQueue(opBlock);
}
...
正常的逻辑我们会走到[self firstLoadDidFaild:error]，因为本地没有缓存自然不会返回304
//第一次加载请求，并且失败了
- (void)firstLoadDidFaild:(NSError *)error {
//传给SonicURLProtocol
[self dispatchProtocolAction:SonicURLProtocolActionDidFaild param:error];
//如果self.completionCallback有值，就执行
[self checkAutoCompletionAction];
}
- (void)checkAutoCompletionAction {
//主线程依次执行回调
dispatchToMain(^{
if (!self.delegate)
if (self.completionCallback)
self.completionCallback(self.sessionID);
});
}
这里的completionCallback还记得SonicClient的createSessionWithUrl::里面吗
[existSession setCompletionCallback:^(NSString *sessionID){
[existSession cancel];
[self.tasks removeObjectForKey:sessionID];
}];
其实就是如果第一次请求发生错误，就取消该url的会话并从tasks中删除，如果第一次请求真的失败了，那么整个代码流程也就走完了。接下来我们来分析请求完成，并且没有失败的情况，会走SonicSession的sessionDidFinish:
self.isCompletion = YES;
if (self.isFirstLoad)
[self firstLoadDidFinish];
else
[self updateDidSuccess];
//第一次加载请求完成，且没有错误
- (void)firstLoadDidFinish {
//通知SonicURLProtocol请求完成
[self dispatchProtocolAction:SonicURLProtocolActionDidFinish param:nil];
if (![self isCompletionWithOutError]) {
return;
}
//服务器返回状态
switch (self.response.statusCode) {
//如果本地缓存内容和服务器内容模版无变化，但是动态数据有变化
case 200: {
//如果服务器设置了客户端的行为，也就是有cache-offline字段，这个
//服务器一般都有设置，并且值为true
if ([self isSonicResponse]) {
//获取服务器对于该客户端指派的行为
//true:缓存到磁盘并展示返回内容
//false:展示返回内容，无需缓存到磁盘
//store:缓存到磁盘，如果已经加载缓存，则下次加载，否则展示返回内容
//http:容灾字段，如果http表示终端六个小时之内不会采用sonic请求该URL
NSString *policy = [self responseHeaderValueByIgnoreCaseKey:SonicHeaderKeyCacheOffline];
//把服务器返回的数据存在cacheFileData中，后面会进行操作
self.cacheFileData = self.responseData;
//如果值为http，表示终端六个小时之内不会采用sonic请求该URL
if ([policy isEqualToString:SonicHeaderValueCacheOfflineDisable]) {
//这时候就需要把这些配置写入文件了
[[SonicCache shareCache] saveServerDisabeSonicTimeNow:self.sessionID];
self.isDataUpdated = YES;
break;
}
//如果值为true、false、store，表示需要缓存到磁盘
if ([policy isEqualToString:SonicHeaderValueCacheOfflineStoreRefresh] || [policy isEqualToString:SonicHeaderValueCacheOfflineStore] || [policy isEqualToString:SonicHeaderValueCacheOfflineRefresh]) {
//把本次请求的内容分html、data、cfg、template存放到本地缓存目录
SonicCacheItem *cacheItem = [[SonicCache shareCache] saveFirstWithHtmlData:self.responseData withResponseHeaders:self.response.allHeaderFields withUrl:self.url];
if (cacheItem) {
self.localRefreshTime = cacheItem.lastRefreshTime;
self.sonicStatusCode = SonicStatusCodeFirstLoad;
self.sonicStatusFinalCode = SonicStatusCodeFirstLoad;
}
//如果值为false，需要删除本地缓存
if ([policy isEqualToString:SonicHeaderValueCacheOfflineRefresh])
[[SonicCache shareCache] removeCacheBySessionID:self.sessionID];
//去掉服务器对客户端的访问限制，万一之前设置了，现在没设置，就可以在这里删除
[[SonicCache shareCache] removeServerDisableSonic:self.sessionID];
}
}else{
self.cacheFileData = self.responseData;
}
//设置数据已经更新到本地标志
self.isDataUpdated = YES;
}
break;
case 503://要求客户端
[self webViewRequireloadNormalRequest];
break;
default:
break;
}
//如果设置有completionCallback，挨个回调
[self checkAutoCompletionAction];
}
第一次成功请求会走200代码块，其实demo中注释我已经写的很多了，相信你也能看懂；那么如果第一次请求完成且没有错误，该走的代码也就走完了，这时候你去缓存目录看看就会多出那四个对应的文件
请求变无效
其实和请求完成发生错误走的是同一个方法，就是通知SonicURLProtocol发生错误了，如果self.completionCallback有值，就挨个回调
文章写到这里，其实大部分的代码我们都已经讲过了，我们注意到请求完成且没有错误响应数据才会写入文件，我们假设我们请求完成且没有错误且本地所有文件正常创建，接下来分析第二次请求模版不变数据更新的情况
数据更新
其实前面的步骤都是差不多的，从SonicClient的createSessionWithUrl开始有点不一样
...
existSession = [[SonicSession alloc] initWithUrl:url withServerIP:serverIP withWebDelegate:aWebDelegate];
...
[self setupData]；
- (void)setupData
{
//得到该会话的缓存数据 html template data cconfig
SonicCacheItem *cacheItem = [[SonicCache shareCache] cacheForSession:_sessionID];
//是不是第一次加载
self.isFirstLoad = cacheItem.hasLocalCache;
//如果本地有该会话缓存的数据 如果有缓存的数据，就给self赋值，添加请求头部时有用
if (!cacheItem.hasLocalCache) {
self.cacheFileData = cacheItem.htmlData;
self.cacheConfigHeaders = cacheItem.config;
self.cacheResponseHeaders = cacheItem.cacheResponseHeaders;
self.localRefreshTime = cacheItem.lastRefreshTime;
}
}
因为本地有缓存文件，所以这时候的cacheItem各项其实是有值的，self.isFirstLoad自然也是NO；
同样在SonicURLProtocol中startLoading中
[[SonicClient sharedClient] registerURLProtocolCallBackWithSessionID:sessionID completion:^(NSDictionary *param) {
...
}];
- (void)preloadRequestActionsWithProtocolCallBack:(SonicURLProtocolCallBack)protocolCallBack {
...
if (self.isDataUpdated || !self.isFirstLoad) {
//直接就可以告诉SonicURLProtocol请求完成并返回数据，展示界面
[self dispatchProtocolActions:[self cacheFileActions]];
...
}
}
这时候if是为真的，Sonic直接就把缓存的数据丢给SonicURLProtocol了，webView自然就直接显示缓存文件了，这当然是秒开咯！然后SonicConnection还是会继续发起请求的，我们直接看请求完成且没有错误时应该执行什么吧
if (error)
[self.session session:self.session didFaild:error];
else
[self.session sessionDidFinish:self.session];
- (void)sessionDidFinish:(SonicSession *)session {
dispatch_block_t opBlock = ^{
//标记请求完成
self.isCompletion = YES;
if (self.isFirstLoad)
[self firstLoadDidFinish];
else
[self updateDidSuccess];
};
dispatchToSonicSessionQueue(opBlock);
}
这时候会走 [self updateDidSuccess]方法，这个方法我们要好好的分析一下了
- (void)updateDidSuccess {
if (![self isCompletionWithOutError])
return;
switch (self.response.statusCode) {
//服务器返回304表示完全缓存
case 304: {
//记录下来 就可以直接返回了，因为完全缓存客户端并不需要做什么
self.sonicStatusCode = SonicStatusCodeAllCached;
self.sonicStatusFinalCode = SonicStatusCodeAllCached;
}
break;
//200表示模版有更新、或者模版未更新但动态数据有更新
case 200: {
//如果服务器响应中没有设置cache-offline，直接返回；说明此请求不满足Sonic规范
if (![self isSonicResponse])
break;
//如果是模版更新
if ([self isTemplateChange]) {
self.cacheFileData = self.responseData;
[self dealWithTemplateChange];
}else{//如果是模版未变化但动态数据更新
[self dealWithDataUpdate];
}
//获取服务器对于该客户端指派的行为
//true:缓存到磁盘并展示返回内容
//false:展示返回内容，无需缓存到磁盘
//store:缓存到磁盘，如果已经加载缓存，则下次加载，否则展示返回内容
//http:容灾字段，如果http表示终端六个小时之内不会采用sonic请求该URL
NSString *policy = [self responseHeaderValueByIgnoreCaseKey:SonicHeaderKeyCacheOffline];
//store true false需要删除限制
if ([policy isEqualToString:SonicHeaderValueCacheOfflineStore] || [policy isEqualToString:SonicHeaderValueCacheOfflineStoreRefresh] || [policy isEqualToString:SonicHeaderValueCacheOfflineRefresh]) {
//去掉服务器对客户端的访问限制，万一之前设置了，现在没设置，就可以在这里删除
[[SonicCache shareCache] removeServerDisableSonic:self.sessionID];
}
//false 删除该sessionID的内存缓存以及本地缓存
if ([policy isEqualToString:SonicHeaderValueCacheOfflineRefresh])
[[SonicCache shareCache] removeCacheBySessionID:self.sessionID];
//http 需要保存限制
if ([policy isEqualToString:SonicHeaderValueCacheOfflineDisable])
[[SonicCache shareCache] saveServerDisabeSonicTimeNow:self.sessionID];
}
break;
default:
break;
}
//用callBack告诉网页数据变化了
//如果有设置[[SonicClient sharedClient] sonicUpdateDiffDataByWebDelegate:self completion:^(NSDictionary *result) {...}会自动触发
if (self.webviewCallBack) {
NSDictionary *resultDict = [self sonicDiffResult];
if (resultDict)
self.webviewCallBack(resultDict);
}
[self checkAutoCompletionAction];
}
//如果是模版更新
- (void)dealWithTemplateChange{
//重新把响应写入到本地缓存文件
SonicCacheItem *cacheItem = [[SonicCache shareCache] saveFirstWithHtmlData:self.responseData withResponseHeaders:self.response.allHeaderFields withUrl:self.url];
//如果写入成功，给当前会话设置一些值
if (cacheItem) {
self.sonicStatusCode = SonicStatusCodeTemplateUpdate;
self.sonicStatusFinalCode = SonicStatusCodeTemplateUpdate;
self.localRefreshTime = cacheItem.lastRefreshTime;
self.cacheFileData = self.responseData;
self.cacheResponseHeaders = cacheItem.cacheResponseHeaders;
//标记数据已经更新到本地
self.isDataUpdated = YES;
//因为不是第一次加载数据，SonicClient会直接把缓存内容丢给SonicURLProtocol，didFinishCacheRead就是用来标记是否已经丢给了SonicURLProtocol
//这个if一般都是不执行的
if (!self.didFinishCacheRead) {
return;
}
dispatchToMain(^{
//获取服务器对于该客户端指派的行为
//true:缓存到磁盘并展示返回内容
//false:展示返回内容，无需缓存到磁盘
//store:缓存到磁盘，如果已经加载缓存，则下次加载，否则展示返回内容
//http:容灾字段，如果http表示终端六个小时之内不会采用sonic请求该URL
NSString *policy = [self responseHeaderValueByIgnoreCaseKey:SonicHeaderKeyCacheOffline];
//true false需要重新更新一下界面
//因为模版有更新，当前webView显示的内容是本地缓存的
if ([policy isEqualToString:SonicHeaderValueCacheOfflineStoreRefresh] || [policy isEqualToString:SonicHeaderValueCacheOfflineRefresh]) {
if (self.delegate && [self.delegate respondsToSelector:@selector(session:requireWebViewReload:)]) {
NSURLRequest *sonicRequest = [NSURLRequest requestWithURL:[NSURL URLWithString:self.url]];
[self.delegate session:self requireWebViewReload:sonicWebRequest(sonicRequest)];
}
}
});
}
}
//如果是动态数据变化
- (void)dealWithDataUpdate {
//只需要把变化的部分写入
SonicCacheItem *cacheItem = [[SonicCache shareCache] updateWithJsonData:self.responseData withResponseHeaders:self.response.allHeaderFields withUrl:self.url];
if (cacheItem) {
self.sonicStatusCode = SonicStatusCodeDataUpdate;
self.sonicStatusFinalCode = SonicStatusCodeDataUpdate;
self.localRefreshTime = cacheItem.lastRefreshTime;
self.cacheFileData = cacheItem.htmlData;
self.cacheResponseHeaders = cacheItem.cacheResponseHeaders;
if (_diffData) {
[_diffData release];
_diffData = nil;
}
//把这次请求和之前本地保存的数据不同的部分保存起来
_diffData = [cacheItem.diffData copy];
//标志数据更新到本地完成
self.isDataUpdated = YES;
}
}
其中要注意的是模版更新需要让webView重新loadRequest，也就是WebViewController.m下面的代码会执行并且SonicURLProtocol会重新拦截一次
- (void)session:(SonicSession *)session requireWebViewReload:(NSURLRequest *)request{
[self.webView loadRequest:request];
}
数据更新需要把diffData通知给前端，也就是WebViewController.m下面的方法会被调用
__weak typeof(webViewJavascriptBridge) weakWebViewJavascriptBridge = webViewJavascriptBridge;
//简单动态数据变化，传给前端
[[SonicClient sharedClient] sonicUpdateDiffDataByWebDelegate:self completion:^(NSDictionary *result) {
__strong typeof(webViewJavascriptBridge) strongWebViewJavascriptBridge = weakWebViewJavascriptBridge;
if (result) {
NSData *json = [NSJSONSerialization dataWithJSONObject:result options:NSJSONWritingPrettyPrinted error:nil];
NSString *jsonStr = [[NSString alloc]initWithData:json encoding:NSUTF8StringEncoding];
[strongWebViewJavascriptBridge callHandler:@"getDiffDataCallback" data:jsonStr];
}
}];
那么数据变化的请求代码也走完了，是不是觉得还是很简单呢
完全缓存
完全缓存比起数据更新情况前面都是一样的只是在SonicSession的updateDidSuccess有不同
- (void)updateDidSuccess {
if (![self isCompletionWithOutError])
return;
switch (self.response.statusCode) {
//服务器返回304表示完全缓存
case 304: {
//记录下来 就可以直接返回了，因为完全缓存客户端并不需要做什么
self.sonicStatusCode = SonicStatusCodeAllCached;
self.sonicStatusFinalCode = SonicStatusCodeAllCached;
}
...
}
这里会走304代码块，只是记录一下状态，然后就没有其他的操作了
后记
写这篇文章前我和我公司服务器相关人员一起研究了3.5天弄懂了Sonic工作原理，然后花了2天看iOS端的SonicSDK的源码，最后写这篇文章用了2天；前前后后收获很多，最开始自己不知道文章从何写起，到现在我已经能按照自己思想重新组装SonicSDK了；文章我自认为你们看了还是有很多不懂的地方，虽然我已经自己阅读了两遍；这个技术非常有意思，对于应用内部打开网页很慢的问题这就是一个良药；最后感谢自己的群小伙伴们每天自认为忙的要死，作为群主的我自然想让他们多学一点知识，就有了写这篇文章的动力；最后希望你们多多在文章下提出不懂的地方我好随时修改，让大家都受益。
网友评论