YTKNetwork源码详解

本人已迁移博客至掘进,以后会在掘进平台更新最新的文章也会有更多的干货,欢迎大家关注!!!https://juejin.im/user/588993965333309

 

 

本篇是第三篇关于网络请求的,将讲述YTKNetwork源码,上述两篇分别讲述AFNetworking源码解析以及结合自己项目封装AFNetworking。

AFNetworking源码解析:https://www.cnblogs.com/guohai-stronger/p/9191497.html

封装AFNetworking代码:https://www.cnblogs.com/guohai-stronger/p/9193465.html  相应的github地址:https://github.com/zxy1829760/testAF

YTKNetwork不仅是对AFNetworking源码的再次封装,而且功能也增多了不少。读完本篇大约需要20-35分钟,建议先收藏一下。其实想对YTKNetwork进行讲解很久了,由于本人现在的项目基于YTKNetwork,抽时候给大家讲解对YTKNetwork的理解。

 

 一、YTKNetwork思想

YTK基本思想是把每一个网络请求封装成对象。把每一个网络请求封装成对象模式也就是设计模式-Command模式(Encapsulate a request as an object,thereby letting you parameterize clients with different requests,queue or log requests,and support undoable operations.(将一个请求封装成一个对象,从而让你使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能。))

拓展>>>>

Command模式:命令模式

命令模式的本质是命令的封装,将发出命令的责任和执行命令的责任分隔开。命令模式允许请求的一方和接受的一方独立开来,使得请求的一方不必知道接收请求的一方的接口,更不必知道请求是如何被接收,以及操作是否被执行,何时被执行,以及怎么被执行的。

举一个例子:

一个客人在点菜,把服务员喊过来,1.服务员给菜单2,你点菜,点好菜给服务员3,服务员把点菜给厨师4,厨师做好菜之后给服务员5,服务员把菜给你。

在这里,命令就好比是订单,而你是命令的发起者。你的命令通过服务员交给了执行命令的厨师,所以至于这道菜到底是谁做的,怎么做你是不需要知道的,你做的只是发出命令和接受结果。而且对于餐厅来说,厨师是可以随便换的,而你对此可以一无所知。反过来,厨师只需要好好把菜做好,至于是谁点的菜也不需要他考虑。

好处:

(1)将网络请求与具体的第三方依赖库隔离,方便以后更换底层的网络层;

(2)方便在基类中处理公共逻辑;

(3)方便在基类中处理缓存逻辑以及其他一些公共逻辑;

(4)方便做对象的持久化。

YTKNetwork对命令模式的实现是很符合其设计标准的,它将请求的发起者和接收者分离开来(中间隔着调用者),可以让我们随时更换接受者。

 

二、YTKNetwork优势(相比AFNetworking)

相比AFNetworking而言,功能增加不少:下面将一一介绍这些功能怎么实现的。

(1)支持统一配置服务器和CDN的地址;

(2)支持按时间缓存网络请求内容;

(3)支持批量的网络请求发送,并统一配置回调;

(4)支持相互依赖的网络请求的发送;

(5)支持检查JSON内容的合法性;

(6)支持按版本号缓存网络请求内容;

(7)支持文件的断点上传;

(8)支持网络请求的Url的filter,可以统一为网络请求加上一些参数或者修改一些路径。

 

三、YTKNetwork代码结构与各类功能

通过下载YTKNetwork,YTKNetwork github地址:https://github.com/yuantiku/YTKNetwork

下面是YTKNetwork代码结构如下:

上面就是YTKNetwork的代码类别,下面我们就一一说明各个类的作用。

 1.YTKBaseRequest

所有请求类的基类,持有NSURLSessionTask实例,responseData等重要数据,提供了一些需要子类实现的与网络请求相关的放阿飞,处理回调的block和代理,命令YTKNetworkAgent发起网络请求。

2.YTKRequest

YTKBaseRequest的子类。负责缓存的处理,请求前查询缓存;请求后写入缓存。

3.YTKNetworkConfig

被YTKRequest和YTKNetworkAgent访问。负责所有请求的全局配置,对于baseUrl和CDNUrl等等。

4.YTKNetworkAgent

真正发起请求的类,负责发起请求,结束请求,并持有一个字典来存储正在执行的请求。

5.YTKBatchRequest

可以发起批量请求,持有一个数组来保存所有的请求类。在请求执行后遍历这个数组发起请求,如果其中有一个请求返回失败,则认定本组请求失败。

6.YTKBatchRequestAgent

负责管理多个YTKBatchRequest实例,持有一个数组保存YTKBatchRequest。支持添加和删除YTKBatchRequest实例。

7.YTKChainRequest

可以发起链式请求,持有一个数组来保存所有的请求类。当某个请求结束后才能发起下一个请求,如果其中有一个请求返回失败,则认定本请求链失败。(链式请求:例如:发送请求 A,根据请求 A 的结果,选择性的发送请求 B 和 C,再根据 B 和 C 的结果,选择性的发送请求 D。)

8.YTKChainRequestAgent

负责管理多个YTKChainRequestAgent实例,持有一个数组来保存YTKChainRequest。支持添加和删除YTKChainRequest实例。

9.YTKNetworkPrivate

提供JSON验证,appVersion等辅助性的方法;给YTKBaseRequest增加一些分类。

 

四、代码解析

1.YTKNetwork.h

YTKNetwork通过YTKNetwork.h管理其他类别,只需要在.pch导入YTKNetwork.h即可,YTKNetwork.h代码如下:

#import <Foundation/Foundation.h>

#ifndef _YTKNETWORK_
    #define _YTKNETWORK_

#if __has_include(<YTKNetwork/YTKNetwork.h>)

    FOUNDATION_EXPORT double YTKNetworkVersionNumber;
    FOUNDATION_EXPORT const unsigned char YTKNetworkVersionString[];

    #import <YTKNetwork/YTKRequest.h>
    #import <YTKNetwork/YTKBaseRequest.h>
    #import <YTKNetwork/YTKNetworkAgent.h>
    #import <YTKNetwork/YTKBatchRequest.h>
    #import <YTKNetwork/YTKBatchRequestAgent.h>
    #import <YTKNetwork/YTKChainRequest.h>
    #import <YTKNetwork/YTKChainRequestAgent.h>
    #import <YTKNetwork/YTKNetworkConfig.h>

#else

    #import "YTKRequest.h"
    #import "YTKBaseRequest.h"
    #import "YTKNetworkAgent.h"
    #import "YTKBatchRequest.h"
    #import "YTKBatchRequestAgent.h"
    #import "YTKChainRequest.h"
    #import "YTKChainRequestAgent.h"
    #import "YTKNetworkConfig.h"

#endif /* __has_include */

#endif /* _YTKNETWORK_ */

 

2.YTKBaseRequest

所有请求类的基类,持有NSURLSessionTask实例,responseData等重要数据,提供了一些需要子类实现的与网络请求相关的放阿飞,处理回调的block和代理,命令YTKNetworkAgent发起网络请求。

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

FOUNDATION_EXPORT NSString *const YTKRequestValidationErrorDomain;

NS_ENUM(NSInteger) {
    YTKRequestValidationErrorInvalidStatusCode = -8,
    YTKRequestValidationErrorInvalidJSONFormat = -9,
};

// HTTP 请求方式
typedef NS_ENUM(NSInteger, YTKRequestMethod) {
    YTKRequestMethodGET = 0,
    YTKRequestMethodPOST,
    YTKRequestMethodHEAD,
    YTKRequestMethodPUT,
    YTKRequestMethodDELETE,
    YTKRequestMethodPATCH,
};

// 请求数据序列化的方式 HTTP还是JSON
typedef NS_ENUM(NSInteger, YTKRequestSerializerType) {
    YTKRequestSerializerTypeHTTP = 0,
    YTKRequestSerializerTypeJSON,
};

// 返回数据的序列化方式,决定了responseObject的数据类型
typedef NS_ENUM(NSInteger, YTKResponseSerializerType) {
    -- NSData
    YTKResponseSerializerTypeHTTP,
    -- JSON 对象
    YTKResponseSerializerTypeJSON,
    -- NSXMLParser
    YTKResponseSerializerTypeXMLParser,
};

// 请求的优先级
typedef NS_ENUM(NSInteger, YTKRequestPriority) {
    YTKRequestPriorityLow = -4L,
    YTKRequestPriorityDefault = 0,
    YTKRequestPriorityHigh = 4,
};

// 声明了3个block
@protocol AFMultipartFormData;

typedef void (^AFConstructingBlock)(id<AFMultipartFormData> formData);
typedef void (^AFURLSessionTaskProgressBlock)(NSProgress *);

@class YTKBaseRequest;

typedef void(^YTKRequestCompletionBlock)(__kindof YTKBaseRequest *request);

// 声明了YTKRequestDelegate协议,定义了一系列可以用来接受网络相关的消息的方法,所有的代理方法将在主队列中调用
@protocol YTKRequestDelegate <NSObject>

@optional
// 请求成功结束
- (void)requestFinished:(__kindof YTKBaseRequest *)request;
// 请求失败
- (void)requestFailed:(__kindof YTKBaseRequest *)request;

@end

// YTKRequestAccessory协议定义了一系列用来跟踪请求状态的方法,所有的代理方法将在主队列中调用
@protocol YTKRequestAccessory <NSObject>

@optional

// 请求即将开始
- (void)requestWillStart:(id)request;

// 请求即将结束(这个方法将在调用requestFinished和successCompletionBlock前执行)
- (void)requestWillStop:(id)request;

// 请求已经结束(这个方法将在调用requestFinished和successCompletionBlock后执行)
- (void)requestDidStop:(id)request;

@end

// YTKBaseRequest是网络请求的抽象类,它提供了许多选项用于构建请求,是YTKRequest的基类
@interface YTKBaseRequest : NSObject

#pragma mark - Request and Response Information
///=============================================================================
/// @name Request and Response Information
///=============================================================================

// NSURLSessionTask底层相关的

// 在请求开始之前这个值是空且不应该被访问
@property (nonatomic, strong, readonly) NSURLSessionTask *requestTask;

// 就是requestTask.currentRequest
@property (nonatomic, strong, readonly) NSURLRequest *currentRequest;

// 就是requestTask.originalRequest
@property (nonatomic, strong, readonly) NSURLRequest *originalRequest;

// 就是requestTask.response
@property (nonatomic, strong, readonly) NSHTTPURLResponse *response;

///  The response status code.
@property (nonatomic, readonly) NSInteger responseStatusCode;

///  The response header fields.
@property (nonatomic, strong, readonly, nullable) NSDictionary *responseHeaders;

// 响应的数据表现形式,请求失败则是nil
@property (nonatomic, strong, readonly, nullable) NSData *responseData;

// 响应的字符串表现形式,请求失败则是nil
@property (nonatomic, strong, readonly, nullable) NSString *responseString;

///  This serialized response object. The actual type of this object is determined by
///  `YTKResponseSerializerType`. Note this value can be nil if request failed.
///
///  @discussion If `resumableDownloadPath` and DownloadTask is using, this value will
///              be the path to which file is successfully saved (NSURL), or nil if request failed.
// 
@property (nonatomic, strong, readonly, nullable) id responseObject;

// 如果设置响应序列化方式是YTKResponseSerializerTypeJSON,这个就是响应结果序列化后的对象
@property (nonatomic, strong, readonly, nullable) id responseJSONObject;

// 请求序列化错误或者网络错误,默认是nil
@property (nonatomic, strong, readonly, nullable) NSError *error;

// 请求任务是否已经取消(self.requestTask.state == NSURLSessionTaskStateCanceling)
@property (nonatomic, readonly, getter=isCancelled) BOOL cancelled;

// 请求任务是否在执行(self.requestTask.state == NSURLSessionTaskStateRunning)
@property (nonatomic, readonly, getter=isExecuting) BOOL executing;


#pragma mark - Request Configuration
///=============================================================================
/// @name Request Configuration
///=============================================================================

// tag可以用来标识请求,默认是0
@property (nonatomic) NSInteger tag;

// userInfo可以用来存储请求的附加信息,默认是nil
@property (nonatomic, strong, nullable) NSDictionary *userInfo;

// 请求的代理,如果使用了block回调就可以忽略这个,默认为nil
@property (nonatomic, weak, nullable) id<YTKRequestDelegate> delegate;

// 请求成功的回调,如果block存在并且requestFinished代理方法也实现了的话,两个都会被调用,先调用代理,再在主队列中调用block
@property (nonatomic, copy, nullable) YTKRequestCompletionBlock successCompletionBlock;

// 请求失败的回调,如果block存在并且requestFailed代理方法也实现了的话,两个都会被调用,先调用代理,再在主队列中调用block
@property (nonatomic, copy, nullable) YTKRequestCompletionBlock failureCompletionBlock;

// 设置附加对象(这是什么鬼?)如果调用addAccessory来增加,这个数组会自动创建,默认是nil
@property (nonatomic, strong, nullable) NSMutableArray<id<YTKRequestAccessory>> *requestAccessories;

// 可以用于在POST请求中需要时构造HTTP body,默认是nil
@property (nonatomic, copy, nullable) AFConstructingBlock constructingBodyBlock;

// 设置断点续传下载请求的地址,默认是nil
// 在请求开始之前,路径上的文件将被删除。如果请求成功,文件将会自动保存到这个路径,否则响应将被保存到responseData和responseString中。为了实现这个工作,服务器必须支持Range并且响应需要支持`Last-Modified`和`Etag`,具体了解NSURLSessionDownloadTask
@property (nonatomic, strong, nullable) NSString *resumableDownloadPath;

// 捕获下载进度,也可以看看resumableDownloadPath
@property (nonatomic, copy, nullable) AFURLSessionTaskProgressBlock resumableDownloadProgressBlock;

// 设置请求优先级,在iOS8 + 可用,默认是YTKRequestPriorityDefault = 0
@property (nonatomic) YTKRequestPriority requestPriority;

// 设置请求完成回调block
- (void)setCompletionBlockWithSuccess:(nullable YTKRequestCompletionBlock)success
                              failure:(nullable YTKRequestCompletionBlock)failure;

// 清除请求回调block
- (void)clearCompletionBlock;

// 添加遵循YTKRequestAccessory协议的请求对象,相关的requestAccessories
- (void)addAccessory:(id<YTKRequestAccessory>)accessory;

#pragma mark - Request Action
// 将当前self网络请求加入请求队列,并且开始请求
- (void)start;

// 从请求队列中移除self网络请求,并且取消请求
- (void)stop;

// 使用带有成功失败blcok回调的方法开始请求(储存block,调用start)
- (void)startWithCompletionBlockWithSuccess:(nullable YTKRequestCompletionBlock)success
                                    failure:(nullable YTKRequestCompletionBlock)failure;

#pragma mark - Subclass Override
///=============================================================================
/// @name Subclass Override
///=============================================================================

// 请求成功后,在切换到主线程之前,在后台线程上调用。要注意,如果加载了缓存,则将在主线程上调用此方法,就像`request Complete Filter`一样。
- (void)requestCompletePreprocessor;
// 请求成功时会在主线程被调用
- (void)requestCompleteFilter;
// 请求成功后,在切换到主线程之前,在后台线程上调用。
- (void)requestFailedPreprocessor;
// 请求失败时会在主线程被调用
- (void)requestFailedFilter;

// 基础URL,应该只包含地址的主要地址部分,如http://www.example.com
- (NSString *)baseUrl;
// 请求地址的URL,应该只包含地址的路径部分,如/v1/user。baseUrl和requestUrl使用[NSURL URLWithString:relativeToURL]进行连接。所以要正确返回。
// 如果requestUrl本身就是一个有效的URL,将不再和baseUrl连接,baseUrl将被忽略
- (NSString *)requestUrl;
// 可选的CDN请求地址
- (NSString *)cdnUrl;

// 设置请求超时时间,默认60秒.
// 如果使用了resumableDownloadPath(NSURLSessionDownloadTask),NSURLRequest的timeoutInterval将会被完全忽略,一个有效的设置超时时间的方法就是设置NSURLSessionConfiguration的timeoutIntervalForResource属性。
- (NSTimeInterval)requestTimeoutInterval;

// 设置请求的参数
- (nullable id)requestArgument;

// 重写这个方法可以在缓存时过滤请求中的某些参数
- (id)cacheFileNameFilterForRequestArgument:(id)argument;

// 设置 HTTP 请求方式
- (YTKRequestMethod)requestMethod;

// 设置请求数据序列化的方式
- (YTKRequestSerializerType)requestSerializerType;

// 设置请求数据序列化的方式. See also `responseObject`.
- (YTKResponseSerializerType)responseSerializerType;

// 用来HTTP授权的用户名和密码,应该返回@[@"Username", @"Password"]这种格式
- (nullable NSArray<NSString *> *)requestAuthorizationHeaderFieldArray;

// 附加的HTTP 请求头
- (nullable NSDictionary<NSString *, NSString *> *)requestHeaderFieldValueDictionary;

// 用来创建完全自定义的请求,返回一个NSURLRequest,忽略`requestUrl`, `requestTimeoutInterval`,`requestArgument`, `allowsCellularAccess`, `requestMethod`,`requestSerializerType`
- (nullable NSURLRequest *)buildCustomUrlRequest;

// 发送请求时是否使用CDN
- (BOOL)useCDN;

// 是否允许请求使用蜂窝网络,默认是允许
- (BOOL)allowsCellularAccess;

// 验证 responseJSONObject 是否正确的格式化了
- (nullable id)jsonValidator;

// 验证 responseStatusCode 是否是有效的,默认是code在200-300之间是有效的
- (BOOL)statusCodeValidator;

@end

NS_ASSUME_NONNULL_END

在其实现类:YTKBaseRequest.m没有过多的知识,仅仅对各个方法的简单实现,大家看上面方法的作用就可以啦。(如果有时间看一下YTKBaseRequest.m也是可以的)。

 

3.YTKRequest

YTKBaseRequest的子类。负责缓存的处理,请求前查询缓存;请求后写入缓存。

@interface YTKRequest : YTKBaseRequest
 
//表示当前请求,是否忽略本地缓存responseData
@property (nonatomic) BOOL ignoreCache;
 
/// 返回当前缓存的对象
- (id)cacheJson;
 
/// 是否当前的数据从缓存获得
- (BOOL)isDataFromCache;
 
/// 返回是否当前缓存需要更新【缓存是否超时】
- (BOOL)isCacheVersionExpired;
 
/// 强制更新缓存【不使用缓存数据】
- (void)startWithoutCache;
 
/// 手动将其他请求的JsonResponse写入该请求的缓存
- (void)saveJsonResponseToCacheFile:(id)jsonResponse;
 
/// 子类重写方法【参数方法】
- (NSInteger)cacheTimeInSeconds;    //当前请求指定时间内,使用缓存数据
- (long long)cacheVersion;    //当前请求,指定使用版本号的缓存数据
- (id)cacheSensitiveData;   
 
@end

发现YTKRequest主要是对请求数据缓存方面的处理。再看.m实现文件:

//YTKRequest.m
- (void)start {
 
    //1. 如果忽略缓存 -> 请求
    if (self.ignoreCache) {
        [self startWithoutCache];
        return;
    }
 
    //2. 如果存在下载未完成的文件 -> 请求
    if (self.resumableDownloadPath) {
        [self startWithoutCache];
        return;
    }
 
    //3. 获取缓存失败 -> 请求
    if (![self loadCacheWithError:nil]) {
        [self startWithoutCache];
        return;
    }
 
    //4. 到这里,说明一定能拿到可用的缓存,可以直接回调了(因为一定能拿到可用的缓存,所以一定是调用成功的block和代理)
    _dataFromCache = YES;
 
    dispatch_async(dispatch_get_main_queue(), ^{
 
        //5. 回调之前的操作
        //5.1 缓存处理
        [self requestCompletePreprocessor];
 
        //5.2 用户可以在这里进行真正回调前的操作
        [self requestCompleteFilter];
 
        YTKRequest *strongSelf = self;
 
        //6. 执行回调
        //6.1 请求完成的代理
        [strongSelf.delegate requestFinished:strongSelf];
 
        //6.2 请求成功的block
        if (strongSelf.successCompletionBlock) {
            strongSelf.successCompletionBlock(strongSelf);
        }
 
        //7. 把成功和失败的block都设置为nil,避免循环引用
        [strongSelf clearCompletionBlock];
    });
}

通过start()方法可以看出,它做的是请求之前的查询和检查工作。下面是具体实现的过程:

(1).ignoreCache属性是用户手动设置的,如果用户强制忽略缓存,则无论是否缓存是否存在,直接发送请求。

(2)resumableDownloadPath是断点下载路径,如果该路径不为空,说明有未完成的下载任务,则直接发送请求继续下载。

(3)loadCacheWithError:方法验证了加载缓存是否成功的方法(方法如果返回YES,说明可以加载缓存,反正则不可以加载缓存)下面是loadCacheWithError的具体实现:

- (BOOL)loadCacheWithError:(NSError * _Nullable __autoreleasing *)error {
 
    // 缓存时间小于0,则返回(缓存时间默认为-1,需要用户手动设置,单位是秒)
    if ([self cacheTimeInSeconds] < 0) {
        if (error) {
            *error = [NSError errorWithDomain:YTKRequestCacheErrorDomain code:YTKRequestCacheErrorInvalidCacheTime userInfo:@{ NSLocalizedDescriptionKey:@"Invalid cache time"}];
        }
        return NO;
    }
 
    // 是否有缓存的元数据,如果没有,返回错误(元数据是指数据的数据,在这里描述了缓存数据本身的一些特征:包括版本号,缓存时间,敏感信息等等
    if (![self loadCacheMetadata]) {
        if (error) {
            *error = [NSError errorWithDomain:YTKRequestCacheErrorDomain code:YTKRequestCacheErrorInvalidMetadata userInfo:@{ NSLocalizedDescriptionKey:@"Invalid metadata. Cache may not exist"}];
        }
        return NO;
    }
 
    // 有缓存,再验证是否有效
    if (![self validateCacheWithError:error]) {
        return NO;
    }
 
    // 有缓存,而且有效,再验证是否能取出来
    if (![self loadCacheData]) {
        if (error) {
            *error = [NSError errorWithDomain:YTKRequestCacheErrorDomain code:YTKRequestCacheErrorInvalidCacheData userInfo:@{ NSLocalizedDescriptionKey:@"Invalid cache data"}];
        }
        return NO;
    }
    return YES;
}

上面代码标红的提到缓存的元数据的,.m也实现类元数据的获取方法:loadCacheMetadata

//YTKRequest.m
- (BOOL)loadCacheMetadata {
 
    NSString *path = [self cacheMetadataFilePath];
    NSFileManager * fileManager = [NSFileManager defaultManager];
    if ([fileManager fileExistsAtPath:path isDirectory:nil]) {
        @try {
            //将序列化之后被保存在磁盘里的文件反序列化到当前对象的属性cacheMetadata
            _cacheMetadata = [NSKeyedUnarchiver unarchiveObjectWithFile:path];
            return YES;
        } @catch (NSException *exception) {
            YTKLog(@"Load cache metadata failed, reason = %@", exception.reason);
            return NO;
        }
    }
    return NO;
}
cacheMetadata(YTKCacheMetadata) 是当前reqeust类用来保存缓存元数据的属性。
YTKCacheMetadata类被定义在YTKRequest.m文件里面:
 
//YTKRequest.m
@interface YTKCacheMetadata : NSObject@property (nonatomic, assign) long long version;
@property (nonatomic, strong) NSString *sensitiveDataString;
@property (nonatomic, assign) NSStringEncoding stringEncoding;
@property (nonatomic, strong) NSDate *creationDate;
@property (nonatomic, strong) NSString *appVersionString;
 
@end

//通过归档方式进行元数据的存储
- (void)encodeWithCoder:(NSCoder *)aCoder {
    [aCoder encodeObject:@(self.version) forKey:NSStringFromSelector(@selector(version))];
    [aCoder encodeObject:self.sensitiveDataString forKey:NSStringFromSelector(@selector(sensitiveDataString))];
    [aCoder encodeObject:@(self.stringEncoding) forKey:NSStringFromSelector(@selector(stringEncoding))];
    [aCoder encodeObject:self.creationDate forKey:NSStringFromSelector(@selector(creationDate))];
    [aCoder encodeObject:self.appVersionString forKey:NSStringFromSelector(@selector(appVersionString))];
}

- (nullable instancetype)initWithCoder:(NSCoder *)aDecoder {
    self = [self init];
    if (!self) {
        return nil;
    }

    self.version = [[aDecoder decodeObjectOfClass:[NSNumber class] forKey:NSStringFromSelector(@selector(version))] integerValue];
    self.sensitiveDataString = [aDecoder decodeObjectOfClass:[NSString class] forKey:NSStringFromSelector(@selector(sensitiveDataString))];
    self.stringEncoding = [[aDecoder decodeObjectOfClass:[NSNumber class] forKey:NSStringFromSelector(@selector(stringEncoding))] integerValue];
    self.creationDate = [aDecoder decodeObjectOfClass:[NSDate class] forKey:NSStringFromSelector(@selector(creationDate))];
    self.appVersionString = [aDecoder decodeObjectOfClass:[NSString class] forKey:NSStringFromSelector(@selector(appVersionString))];

    return self;
}

loadCacheMetadata方法的目的是将之前被序列化保存的缓存元数据信息反序列化,赋给自身的cacheMetadata属性上。

现在获取了缓存的元数据并赋值给cacheMetadata属性上,接下来要元数据的各项信息是否符合要求:使用validateCacheWithError:方法进行验证。

- (BOOL)validateCacheWithError:(NSError * _Nullable __autoreleasing *)error {
 
    // 是否大于过期时间
    NSDate *creationDate = self.cacheMetadata.creationDate;
    NSTimeInterval duration = -[creationDate timeIntervalSinceNow];
    if (duration < 0 || duration > [self cacheTimeInSeconds]) {
        if (error) {
            *error = [NSError errorWithDomain:YTKRequestCacheErrorDomain code:YTKRequestCacheErrorExpired userInfo:@{ NSLocalizedDescriptionKey:@"Cache expired"}];
        }
        return NO;
    }
 
    // 缓存的版本号是否符合
    long long cacheVersionFileContent = self.cacheMetadata.version;
    if (cacheVersionFileContent != [self cacheVersion]) {
        if (error) {
            *error = [NSError errorWithDomain:YTKRequestCacheErrorDomain code:YTKRequestCacheErrorVersionMismatch userInfo:@{ NSLocalizedDescriptionKey:@"Cache version mismatch"}];
        }
        return NO;
    }
 
    // 敏感信息是否符合
    NSString *sensitiveDataString = self.cacheMetadata.sensitiveDataString;
    NSString *currentSensitiveDataString = ((NSObject *)[self cacheSensitiveData]).description;
    if (sensitiveDataString || currentSensitiveDataString) {
        // If one of the strings is nil, short-circuit evaluation will trigger
        if (sensitiveDataString.length != currentSensitiveDataString.length || ![sensitiveDataString isEqualToString:currentSensitiveDataString]) {
            if (error) {
                *error = [NSError errorWithDomain:YTKRequestCacheErrorDomain code:YTKRequestCacheErrorSensitiveDataMismatch userInfo:@{ NSLocalizedDescriptionKey:@"Cache sensitive data mismatch"}];
            }
            return NO;
        }
    }
 
    // app的版本是否符合
    NSString *appVersionString = self.cacheMetadata.appVersionString;
    NSString *currentAppVersionString = [YTKNetworkUtils appVersionString];
    if (appVersionString || currentAppVersionString) {
        if (appVersionString.length != currentAppVersionString.length || ![appVersionString isEqualToString:currentAppVersionString]) {
            if (error) {
                *error = [NSError errorWithDomain:YTKRequestCacheErrorDomain code:YTKRequestCacheErrorAppVersionMismatch userInfo:@{ NSLocalizedDescriptionKey:@"App version mismatch"}];
            }
            return NO;
        }
    }
    return YES;
}

如果每一项元数据信息都能通过,再在loadCacheData方法里面验证缓存是否能取出:

- (BOOL)loadCacheData {
 
    NSString *path = [self cacheFilePath];
    NSFileManager *fileManager = [NSFileManager defaultManager];
    NSError *error = nil;
 
    if ([fileManager fileExistsAtPath:path isDirectory:nil]) {
        NSData *data = [NSData dataWithContentsOfFile:path];
        _cacheData = data;
        _cacheString = [[NSString alloc] initWithData:_cacheData encoding:self.cacheMetadata.stringEncoding];
        switch (self.responseSerializerType) {
            case YTKResponseSerializerTypeHTTP:
                // Do nothing.
                return YES;
            case YTKResponseSerializerTypeJSON:
                _cacheJSON = [NSJSONSerialization JSONObjectWithData:_cacheData options:(NSJSONReadingOptions)0 error:&error];
                return error == nil;
            case YTKResponseSerializerTypeXMLParser:
                _cacheXML = [[NSXMLParser alloc] initWithData:_cacheData];
                return YES;
        }
    }
    return NO;
}

如果通过了最终的考验,则说明当前请求对应的缓存是符合各项要求并可以被成功取出,也就是可以直接进行回调了。当确认缓存可以成功取出后,手动设置dataFromCache属性为 YES,说明当前的请求结果是来自于缓存,而没有通过网络请求。

在这里面还有一个比较重要的方法:requestCompletePreprocessor

//YTKRequest.m:
- (void)requestCompletePreprocessor {
 
    [super requestCompletePreprocessor];
 
    //是否异步将responseData写入缓存(写入缓存的任务放在专门的队列ytkrequest_cache_writing_queue进行)
    if (self.writeCacheAsynchronously) {
 
        dispatch_async(ytkrequest_cache_writing_queue(), ^{
            //保存响应数据到缓存
            [self saveResponseDataToCacheFile:[super responseData]];
        });
 
    } else {
        //保存响应数据到缓存
        [self saveResponseDataToCacheFile:[super responseData]];
    }
}

//YTKRequest.m:
//保存响应数据到缓存
- (void)saveResponseDataToCacheFile:(NSData *)data {
 
    if ([self cacheTimeInSeconds] > 0 && ![self isDataFromCache]) {
        if (data != nil) {
            @try {
                // New data will always overwrite old data.
                [data writeToFile:[self cacheFilePath] atomically:YES];
 
                YTKCacheMetadata *metadata = [[YTKCacheMetadata alloc] init];
                metadata.version = [self cacheVersion];
                metadata.sensitiveDataString = ((NSObject *)[self cacheSensitiveData]).description;
                metadata.stringEncoding = [YTKNetworkUtils stringEncodingWithRequest:self];
                metadata.creationDate = [NSDate date];
                metadata.appVersionString = [YTKNetworkUtils appVersionString];
                [NSKeyedArchiver archiveRootObject:metadata toFile:[self cacheMetadataFilePath]];
 
            } @catch (NSException *exception) {
                YTKLog(@"Save cache failed, reason = %@", exception.reason);
            }
        }
    }
}

我们可以看到, requestCompletePreprocessor方法的任务是将响应数据保存起来,也就是做缓存。但是,缓存的保存有两个条件,一个是需要cacheTimeInSeconds方法返回正整数(缓存时间,单位是秒);另一个条件就是isDataFromCache方法返回NO。

进一下研究:startWithoutCache

这个方法做了哪些?

//YTKRequest.m
- (void)startWithoutCache {
 
    //1. 清除缓存
    [self clearCacheVariables];
 
    //2. 调用父类的发起请求
    [super start];
}




//YTKBaseRequest.m:
- (void)start {
 
    //1. 告诉Accessories即将回调了(其实是即将发起请求)
    [self toggleAccessoriesWillStartCallBack];
 
    //2. 令agent添加请求并发起请求,在这里并不是组合关系,agent只是一个单例
    [[YTKNetworkAgent sharedAgent] addRequest:self];
}

 

4.YTKNetworkConfig

被YTKRequest和YTKNetworkAgent访问。负责所有请求的全局配置,对于baseUrl和CDNUrl等等。

在实际业务中,作为公司的测试需要不断的切换服务器地址,确定数据的正确性,也间接说明YTKNetworkConfig的必要性。

下面是以自己目前公司所用的YTKNetwork的YTKNetworkConfig的用处:

(1)首先在AppDelegate中:- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions方法配置服务:

紧接着:[self setupServer];

 在IOAApiManager实现类方法:

我们以后就可以通过baseUrl进行不同的地址访问啦。大部分企业可能需要一些静态资源(例如图片,js,css等)这就使用到了CDN,YTKNetworkConfig的cdnUrl参数用于统一设置这一部分网络请求的地址。

上面的代码以及项目中如何对YTKNetwork再次封装的,会在下一篇博客中给出,并会上传至github。

YTKNetworkConfig源码也提供了安全策略,url过滤,缓存路径的过滤等方法如下:

// 使用类方法创建单例对象
+ (YTKNetworkConfig *)sharedConfig;

// 请求的根URL,默认是空字符串
@property (nonatomic, strong) NSString *baseUrl;

// 请求CDN URL,默认是空字符串
@property (nonatomic, strong) NSString *cdnUrl;

// URL过滤池(YTKUrlFilterProtocol协议使用)
@property (nonatomic, strong, readonly) NSArray<id<YTKUrlFilterProtocol>> *urlFilters;

// 缓存路径的过滤池(YTKCacheDirPathFilterProtocol协议使用)
@property (nonatomic, strong, readonly) NSArray<id<YTKCacheDirPathFilterProtocol>> *cacheDirPathFilters;

// 同AFNetworking中使用的安全策略
@property (nonatomic, strong) AFSecurityPolicy *securityPolicy;

// 是否记录调试信息,默认是NO
@property (nonatomic) BOOL debugLogEnabled;

// 用来初始化AFHTTPSessionManager,默认是nil
@property (nonatomic, strong) NSURLSessionConfiguration* sessionConfiguration;

// 添加一个新的URL过滤器
- (void)addUrlFilter:(id<YTKUrlFilterProtocol>)filter;

// 删除所有的URL过滤器
- (void)clearUrlFilter;

// 添加一个新的缓存地址过滤器
- (void)addCacheDirPathFilter:(id<YTKCacheDirPathFilterProtocol>)filter;

//删除所有的缓存地址过滤器
- (void)clearCacheDirPathFilter; @end

 

5.YTKNetworkAgent

真正发起请求的类,负责发起请求,结束请求,并持有一个字典来存储正在执行的请求。

(1)首先从请求开始:YTKNetworkAgent把当前的请求对象添加到了自己身上并发送请求

//YTKNetworkAgent.m
- (void)addRequest:(YTKBaseRequest *)request {
 
    //1. 获取task
    NSParameterAssert(request != nil);
 
    NSError * __autoreleasing requestSerializationError = nil;
 
    //获取用户自定义的requestURL
    NSURLRequest *customUrlRequest= [request buildCustomUrlRequest];
 
    if (customUrlRequest) {
 
        __block NSURLSessionDataTask *dataTask = nil;
        //如果存在用户自定义request,则直接走AFNetworking的dataTaskWithRequest:方法
        dataTask = [_manager dataTaskWithRequest:customUrlRequest completionHandler:^(NSURLResponse * _Nonnull response, id  _Nullable responseObject, NSError * _Nullable error) {
            //响应的统一处理
            [self handleRequestResult:dataTask responseObject:responseObject error:error];
        }];
        request.requestTask = dataTask;
 
    } else {
 
        //如果用户没有自定义url,则直接走这里
        request.requestTask = [self sessionTaskForRequest:request error:&requestSerializationError];
 
    }
 
    //序列化失败,则认定为请求失败
    if (requestSerializationError) {
        //请求失败的处理
        [self requestDidFailWithRequest:request error:requestSerializationError];
        return;
    }
 
    NSAssert(request.requestTask != nil, @"requestTask should not be nil");
 
    // 优先级的映射
    // !!Available on iOS 8 +
    if ([request.requestTask respondsToSelector:@selector(priority)]) {
        switch (request.requestPriority) {
            case YTKRequestPriorityHigh:
                request.requestTask.priority = NSURLSessionTaskPriorityHigh;
                break;
            case YTKRequestPriorityLow:
                request.requestTask.priority = NSURLSessionTaskPriorityLow;
                break;
            case YTKRequestPriorityDefault:
                /*!!fall through*/
            default:
                request.requestTask.priority = NSURLSessionTaskPriorityDefault;
                break;
        }
    }
 
    // Retain request
    YTKLog(@"Add request: %@", NSStringFromClass([request class]));
 
    //2. 将request放入保存请求的字典中,taskIdentifier为key,request为值
    [self addRequestToRecord:request];
 
    //3. 开始task
    [request.requestTask resume];
}

这个方法可以看出调用了AFNetworking的请求方法,也验证了YTKNetwork对AFNetworking高度封装。这个方法可以分成三部分:

1>获取当前请求对应的task并赋值给request的requestTask属性

2>将request放入专门用来保存请求的字典中,key为taskIdentifier

3>启动task

下面从1>开始说起

//YTKNetworkAgent.m
- (void)addRequest:(YTKBaseRequest *)request {
 
  ...
 
  if (customUrlRequest) {
 
        __block NSURLSessionDataTask *dataTask = nil;
        //如果存在用户自定义request,则直接走AFNetworking的dataTaskWithRequest:方法
        dataTask = [_manager dataTaskWithRequest:customUrlRequest completionHandler:^(NSURLResponse * _Nonnull response, id  _Nullable responseObject, NSError * _Nullable error) {
            //统一处理请求响应
            [self handleRequestResult:dataTask responseObject:responseObject error:error];
        }];
        request.requestTask = dataTask;
 
    } else {
 
        //如果用户没有自定义url,则直接走这里
        request.requestTask = [self sessionTaskForRequest:request error:&requestSerializationError];
 
    }
 
  ...
}

这里判断了用户是否自定义了request:如果用户自定义了request,则直接调用AFNetworking的dataTaskWithRequest:方法;反之,则调用YTKRequest自己生产的task方法。AFNetworking的方法这里暫不做讲解,在这讲述YTKRequest自己生产的task方法:下面是其是实现方式:

//YTKNetworkAgent.m
//根据不同请求类型,序列化类型,和请求参数来返回NSURLSessionTask
- (NSURLSessionTask *)sessionTaskForRequest:(YTKBaseRequest *)request error:(NSError * _Nullable __autoreleasing *)error {
 
    //1. 获得请求类型(GET,POST等)
    YTKRequestMethod method = [request requestMethod];
 
    //2. 获得请求url
    NSString *url = [self buildRequestUrl:request];
 
    //3. 获得请求参数
    id param = request.requestArgument;
    AFConstructingBlock constructingBlock = [request constructingBodyBlock];
 
    //4. 获得request serializer
    AFHTTPRequestSerializer *requestSerializer = [self requestSerializerForRequest:request];
 
    //5. 根据不同的请求类型来返回对应的task
    switch (method) {
 
        case YTKRequestMethodGET:
 
            if (request.resumableDownloadPath) {
                //下载任务
                return [self downloadTaskWithDownloadPath:request.resumableDownloadPath requestSerializer:requestSerializer URLString:url parameters:param progress:request.resumableDownloadProgressBlock error:error];
 
            } else {
                //普通get请求
                return [self dataTaskWithHTTPMethod:@"GET" requestSerializer:requestSerializer URLString:url parameters:param error:error];
            }
 
        case YTKRequestMethodPOST:
            //POST请求
            return [self dataTaskWithHTTPMethod:@"POST" requestSerializer:requestSerializer URLString:url parameters:param constructingBodyWithBlock:constructingBlock error:error];
 
        case YTKRequestMethodHEAD:
            //HEAD请求
            return [self dataTaskWithHTTPMethod:@"HEAD" requestSerializer:requestSerializer URLString:url parameters:param error:error];
 
        case YTKRequestMethodPUT:
            //PUT请求
            return [self dataTaskWithHTTPMethod:@"PUT" requestSerializer:requestSerializer URLString:url parameters:param error:error];
 
        case YTKRequestMethodDELETE:
            //DELETE请求
            return [self dataTaskWithHTTPMethod:@"DELETE" requestSerializer:requestSerializer URLString:url parameters:param error:error];
 
        case YTKRequestMethodPATCH:
            //PATCH请求
            return [self dataTaskWithHTTPMethod:@"PATCH" requestSerializer:requestSerializer URLString:url parameters:param error:error];
    }
}

下面再逐渐讲解这个私有方法需要的每个参数的获取方法:

1>.1.获得请求类型(GET,POST等):

//YTKNetworkAgent.m,requestMethod方法最初在YTKBaseRequest里面已经实现了,默认返回了YTKRequestMethodGET。
- (NSURLSessionTask *)sessionTaskForRequest:(YTKBaseRequest *)request error:(NSError * _Nullable __autoreleasing *)error {
 
  ...
  YTKRequestMethod method = [request requestMethod];
  ...
 
}

用户可以根据实际的需求在自定义request类里面重写这个方法:

- (YTKRequestMethod)requestMethod {
    return YTKRequestMethodPOST;
}

1>.2获取请求参数

//YTKNetworkAgent.m
- (NSURLSessionTask *)sessionTaskForRequest:(YTKBaseRequest *)request error:(NSError * _Nullable __autoreleasing *)error {
 
   ...
      //获取用户提供的请求参数
    id param = request.requestArgument;
 
    //获取用户提供的构造请求体的block(默认是没有的)
    AFConstructingBlock constructingBlock = [request constructingBodyBlock];
 
   ...
 
}

requestArgument是一个get方法,用户也可以根据自己定义的请求体定义参数。

如下是自己项目中重写的

我们拿到参数之后,然后看一下dataTaskWithHTTPMethod:requestSerializer:URLString:parameters:error:方法来获取NSURLSessionTask实例这个方法。

//YTKNetworkAgent.m
- (NSURLSessionDataTask *)dataTaskWithHTTPMethod:(NSString *)method
                               requestSerializer:(AFHTTPRequestSerializer *)requestSerializer
                                       URLString:(NSString *)URLString
                                      parameters:(id)parameters
                                           error:(NSError * _Nullable __autoreleasing *)error {
    return [self dataTaskWithHTTPMethod:method requestSerializer:requestSerializer URLString:URLString parameters:parameters constructingBodyWithBlock:nil error:error];
}
 
//最终返回NSURLSessionDataTask实例
- (NSURLSessionDataTask *)dataTaskWithHTTPMethod:(NSString *)method
                               requestSerializer:(AFHTTPRequestSerializer *)requestSerializer
                                       URLString:(NSString *)URLString
                                      parameters:(id)parameters
                       constructingBodyWithBlock:(nullable void (^)(idformData))block
                                           error:(NSError * _Nullable __autoreleasing *)error {
    NSMutableURLRequest *request = nil;
 
    //根据有无构造请求体的block的情况来获取request
    if (block) {
        request = [requestSerializer multipartFormRequestWithMethod:method URLString:URLString parameters:parameters constructingBodyWithBlock:block error:error];
    } else {
        request = [requestSerializer requestWithMethod:method URLString:URLString parameters:parameters error:error];
    }
 
    //获得request以后来获取dataTask
    __block NSURLSessionDataTask *dataTask = nil;
    dataTask = [_manager dataTaskWithRequest:request
                           completionHandler:^(NSURLResponse * __unused response, id responseObject, NSError *_error) {
                               //响应的统一处理
                               [self handleRequestResult:dataTask responseObject:responseObject error:_error];
                           }];
 
    return dataTask;
}

上面的两个方法就是获取NSURLSessionDataTask实例方法。继续往下走,到了优先级的映射部分

// 优先级的映射
    // !!Available on iOS 8 +
    if ([request.requestTask respondsToSelector:@selector(priority)]) {
        switch (request.requestPriority) {
            case YTKRequestPriorityHigh:
                request.requestTask.priority = NSURLSessionTaskPriorityHigh;
                break;
            case YTKRequestPriorityLow:
                request.requestTask.priority = NSURLSessionTaskPriorityLow;
                break;
            case YTKRequestPriorityDefault:
                /*!!fall through*/
            default:
                request.requestTask.priority = NSURLSessionTaskPriorityDefault;
                break;
        }
    }

到现在我们拿到了task的实例并设置好了优先级,下面是addRequest方法的第二个部分啦!

2>YTKNetworkAgent将request实例放在了一个字典中,保存起来。

将request放入专门用来保存请求的字典中,key为taskIdentifier。

//YTKNetworkAgent.m
- (void)addRequest:(YTKBaseRequest *)request {
 
  //将request实例放入保存请求的字典中,taskIdentifier为key,request为值
  [self addRequestToRecord:request];
 
   ...
 
}

- (void)addRequestToRecord:(YTKBaseRequest *)request {
 
    //加锁
    Lock();
    _requestsRecord[@(request.requestTask.taskIdentifier)] = request;
    Unlock();
}

添加前和添加后是进行了加锁和解锁的处理的。而且request实例被保存的时候,将其task的identifier作为key来保存。

3>启动task

- (NSURLSessionTask *)sessionTaskForRequest:(YTKBaseRequest *)request error:(NSError * _Nullable __autoreleasing *)error {
 
   ...
 
   [request.requestTask resume];
 
   ...
 
}

(2)对回调的处理

//YTKNetworkAgent.m
//统一处理请求结果,包括成功和失败的情况
- (void)handleRequestResult:(NSURLSessionTask *)task responseObject:(id)responseObject error:(NSError *)error {
 
    //1. 获取task对应的request
    Lock();
    YTKBaseRequest *request = _requestsRecord[@(task.taskIdentifier)];
    Unlock();
 
    //如果不存在对应的request,则立即返回
    if (!request) {
        return;
    }
 
    。。。
 
    //2. 获取request对应的response
    request.responseObject = responseObject;
 
    //3. 获取responseObject,responseData和responseString
    if ([request.responseObject isKindOfClass:[NSData class]]) {
 
       //3.1 获取 responseData
        request.responseData = responseObject;
 
        //3.2 获取responseString
        request.responseString = [[NSString alloc] initWithData:responseObject encoding:[YTKNetworkUtils stringEncodingWithRequest:request]];
 
         //3.3 获取responseObject(或responseJSONObject)
        //根据返回的响应的序列化的类型来得到对应类型的响应
        switch (request.responseSerializerType)
        {
            case YTKResponseSerializerTypeHTTP:
                // Default serializer. Do nothing.
                break;
 
            case YTKResponseSerializerTypeJSON:
                request.responseObject = [self.jsonResponseSerializer responseObjectForResponse:task.response data:request.responseData error:&serializationError];
                request.responseJSONObject = request.responseObject;
                break;
 
            case YTKResponseSerializerTypeXMLParser:
                request.responseObject = [self.xmlParserResponseSerialzier responseObjectForResponse:task.response data:request.responseData error:&serializationError];
                break;
        }
    }
 
    //4. 判断是否有错误,将错误对象赋值给requestError,改变succeed的布尔值。目的是根据succeed的值来判断到底是进行成功的回调还是失败的回调
    if (error) {
        //如果该方法传入的error不为nil
        succeed = NO;
        requestError = error;
 
    } else if (serializationError) {
        //如果序列化失败了
        succeed = NO;
        requestError = serializationError;
 
    } else {
 
        //即使没有error而且序列化通过,也要验证request是否有效
        succeed = [self validateResult:request error:&validationError];
        requestError = validationError;
    }
 
    //5. 根据succeed的布尔值来调用相应的处理
    if (succeed) {
        //请求成功的处理
        [self requestDidSucceedWithRequest:request];
    } else {
 
        //请求失败的处理
        [self requestDidFailWithRequest:request error:requestError];
    }
 
     //6. 回调完成的处理
    dispatch_async(dispatch_get_main_queue(), ^{
        //6.1 在字典里移除当前request
        [self removeRequestFromRecord:request];
         //6.2 清除所有block
        [request clearCompletionBlock];
    });
}

我们可以和上面一样,对于上面代码做剖析处理

1>首先是通过task的identifier值从YTKNetworkAgent保存的字典里获取对应的请求;

2>然后将获得的responseObject进行处理,将处理后获得的responseObject,responseData和  responseString赋值给当前的请求实例request;

3>根据获取情况判断succes值,然后根据success值进行成功和失败的回调。

(1.1)验证完返回的JSON数据是否有效以后,就可以进行回调啦!成功的回调如下:

//YTKNetworkAgent.m
//请求成功:主要负责将结果写入缓存&回调成功的代理和block
- (void)requestDidSucceedWithRequest:(YTKBaseRequest *)request {
 
    @autoreleasepool {
        //写入缓存 
        [request requestCompletePreprocessor];
    }
 
    dispatch_async(dispatch_get_main_queue(), ^{
 
        //告诉Accessories请求就要停止了
        [request toggleAccessoriesWillStopCallBack];
 
        //在真正的回调之前做的处理,用户自定义
        [request requestCompleteFilter];
 
        //如果有代理,则调用成功的代理
        if (request.delegate != nil) {
            [request.delegate requestFinished:request];
        }
 
        //如果传入了成功回调的代码,则调用
        if (request.successCompletionBlock) {
            request.successCompletionBlock(request);
        }
 
        //告诉Accessories请求已经结束了
        [request toggleAccessoriesDidStopCallBack];
    });
}

我们可以看到请求成功之后,第一件事是写入缓存。requestCompletePreprocessor该方法在YTKRequest.m里有实现。

//YTKRequest.m
- (void)requestCompletePreprocessor {
 
    [super requestCompletePreprocessor];
 
    //是否异步将responseData写入缓存(写入缓存的任务放在专门的队列进行)
    if (self.writeCacheAsynchronously) {
 
        dispatch_async(ytkrequest_cache_writing_queue(), ^{
            //写入缓存文件
            [self saveResponseDataToCacheFile:[super responseData]];
        });
 
    } else {
         //写入缓存文件
        [self saveResponseDataToCacheFile:[super responseData]];
    }
}
 
//写入缓存文件
- (void)saveResponseDataToCacheFile:(NSData *)data {

 //写入缓存操作的执行条件:当cacheTimeInSeconds方法返回大于0并且isDataFromCache为NO的时候会进行写入缓存。
//cacheTimeInSeconds方法返回的是缓存保存的时间,它最初定义在YTKBaseRquest里面,默认返回是-1,YTKNetwork默认是不进行缓存的,如果用户需要做缓存,则需要在自定义的request类里面返回一个大于0的整数,这个整数的单位是秒
    if ([self cacheTimeInSeconds] > 0 && ![self isDataFromCache]) {
        if (data != nil) {
            @try {
                // 1. 保存request的responseData到cacheFilePath
                [data writeToFile:[self cacheFilePath] atomically:YES];
 
                // 2. 保存request的metadata到cacheMetadataFilePath
                YTKCacheMetadata *metadata = [[YTKCacheMetadata alloc] init];
                metadata.version = [self cacheVersion];
                metadata.sensitiveDataString = ((NSObject *)[self cacheSensitiveData]).description;
                metadata.stringEncoding = [YTKNetworkUtils stringEncodingWithRequest:self];
                metadata.creationDate = [NSDate date];
                metadata.appVersionString = [YTKNetworkUtils appVersionString];
                [NSKeyedArchiver archiveRootObject:metadata toFile:[self cacheMetadataFilePath]];
            } @catch (NSException *exception) {
                YTKLog(@"Save cache failed, reason = %@", exception.reason);
            }
        }
    }
}

对于缓存,YTKNetwork保存的有两种形式:第一种是纯粹的NSData类型的实例。第二种是描述当前NSData实例的元数据YTKCacheMetadata的实例。

(1.2)上面是成功的回调,看一下失败的回调:

//YTKNetworkAgent.m
//请求失败
- (void)requestDidFailWithRequest:(YTKBaseRequest *)request error:(NSError *)error {
 
    request.error = error;
    YTKLog(@"Request %@ failed, status code = %ld, error = %@",
           NSStringFromClass([request class]), (long)request.responseStatusCode, error.localizedDescription);
 
    // 储存未完成的下载数据
    NSData *incompleteDownloadData = error.userInfo[NSURLSessionDownloadTaskResumeData];
    if (incompleteDownloadData) {
        [incompleteDownloadData writeToURL:[self incompleteDownloadTempPathForDownloadPath:request.resumableDownloadPath] atomically:YES];
    }
 
    // Load response from file and clean up if download task failed.
    //如果下载任务失败,则取出对应的响应文件并清空
    if ([request.responseObject isKindOfClass:[NSURL class]]) {
        NSURL *url = request.responseObject;
 
        //isFileURL:是否是文件,如果是,则可以再isFileURL获取;&&后面是再次确认是否存在改url对应的文件
        if (url.isFileURL && [[NSFileManager defaultManager] fileExistsAtPath:url.path]) {
 
            //将url的data和string赋给request
            request.responseData = [NSData dataWithContentsOfURL:url];
            request.responseString = [[NSString alloc] initWithData:request.responseData encoding:[YTKNetworkUtils stringEncodingWithRequest:request]];
 
            [[NSFileManager defaultManager] removeItemAtURL:url error:nil];
        }
 
        //清空request
        request.responseObject = nil;
    }
 
 
    @autoreleasepool {
        //请求失败的预处理,YTK没有定义,需要用户定义
        [request requestFailedPreprocessor];
    }
 
    dispatch_async(dispatch_get_main_queue(), ^{
 
        //告诉Accessories请求就要停止了
        [request toggleAccessoriesWillStopCallBack];
 
        //在真正的回调之前做的处理
        [request requestFailedFilter];
 
        //如果有代理,就调用代理
        if (request.delegate != nil) {
            [request.delegate requestFailed:request];
        }
 
        //如果传入了失败回调的block代码,就调用block
        if (request.failureCompletionBlock) {
            request.failureCompletionBlock(request);
        }
 
        //告诉Accessories请求已经停止了
        [request toggleAccessoriesDidStopCallBack];
    });
}

通过上面方法可看出:首先判断了当前任务是不是下载任务,如果是,储存当前已经下载好的data到resumableDownloadPath里面。而如果下载任务失败,则将其对应的在本地保存的路径上的文件清空。

以上就是YTKNetworkAgent类的大概内容,也是YTKNetwork单个请求的流程。

 

6.YTKBatchRequest

可以发起批量请求,持有一个数组来保存所有的请求类。在请求执行后遍历这个数组发起请求,如果其中有一个请求返回失败,则认定本组请求失败。

下面看一个初始化方法

//YTKBatchRequest.m
- (instancetype)initWithRequestArray:(NSArray*)requestArray {
    self = [super init];
    if (self) {
 
        //保存为属性
        _requestArray = [requestArray copy];
 
        //批量请求完成的数量初始化为0
        _finishedCount = 0;
 
        //类型检查,所有元素都必须为YTKRequest或的它的子类,否则强制初始化失败
        for (YTKRequest * req in _requestArray) {
            if (![req isKindOfClass:[YTKRequest class]]) {
                YTKLog(@"Error, request item must be YTKRequest instance.");
                return nil;
            }
        }
    }
    return self;
}

初始化以后,我们就可以调用start方法来发起当前YTKBatchRequest实例所管理的所有请求了。

- (void)start {
 
    //如果batch里第一个请求已经成功结束,则不能再start
    if (_finishedCount > 0) {
        YTKLog(@"Error! Batch request has already started.");
        return;
    }
 
    //最开始设定失败的request为nil
    _failedRequest = nil;
 
    //使用YTKBatchRequestAgent来管理当前的批量请求
    [[YTKBatchRequestAgent sharedAgent] addBatchRequest:self];
    [self toggleAccessoriesWillStartCallBack];
 
    //遍历所有request,并开始请求
    for (YTKRequest * req in _requestArray) {
        req.delegate = self;
        [req clearCompletionBlock];
        [req start];
    }
}

所以在这里是遍历YTKBatchRequest实例的_requestArray并逐一发送请求。因为已经封装好了单个的请求,所以在这里直接start就好了。

(1)在请求之后,在每一个请求的回调的代理方法里面,来判断这次请求是否是成功的,也是在YTKRequest子类YTKBatchRequest.m判断。

//YTKBatchRequest.m
#pragma mark - Network Request Delegate
- (void)requestFinished:(YTKRequest *)request {
 
    //某个request成功后,首先让_finishedCount + 1
    _finishedCount++;
 
    //如果_finishedCount等于_requestArray的个数,则判定当前batch请求成功
    if (_finishedCount == _requestArray.count) {
 
        //调用即将结束的代理
        [self toggleAccessoriesWillStopCallBack];
 
        //调用请求成功的代理
        if ([_delegate respondsToSelector:@selector(batchRequestFinished:)]) {
            [_delegate batchRequestFinished:self];
        }
 
        //调用批量请求成功的block
        if (_successCompletionBlock) {
            _successCompletionBlock(self);
        }
 
        //清空成功和失败的block
        [self clearCompletionBlock];
 
        //调用请求结束的代理
        [self toggleAccessoriesDidStopCallBack];
 
        //从YTKBatchRequestAgent里移除当前的batch
        [[YTKBatchRequestAgent sharedAgent] removeBatchRequest:self];
    }
}

在某个请求的回调成功以后,会让成功计数+1。在+1以后,如果成功计数和当前批量请求数组里元素的个数相等,则判定当前批量请求成功,并进行当前批量请求的成功回调。

(2)失败回调

//YTKBatchRequest.m
- (void)requestFailed:(YTKRequest *)request {
 
    _failedRequest = request;
 
    //调用即将结束的代理
    [self toggleAccessoriesWillStopCallBack];
 
    //停止batch里所有的请求
    for (YTKRequest *req in _requestArray) {
        [req stop];
    }
 
    //调用请求失败的代理
    if ([_delegate respondsToSelector:@selector(batchRequestFailed:)]) {
        [_delegate batchRequestFailed:self];
    }
 
    //调用请求失败的block
    if (_failureCompletionBlock) {
        _failureCompletionBlock(self);
    }
 
    //清空成功和失败的block
    [self clearCompletionBlock];
 
    //调用请求结束的代理
    [self toggleAccessoriesDidStopCallBack];
 
    //从YTKBatchRequestAgent里移除当前的batch
    [[YTKBatchRequestAgent sharedAgent] removeBatchRequest:self];
}

从上面代码可以看出,如果批量请求里面有一个request失败了,则判定当前批量请求失败。

 

7.YTKBatchRequestAgent

负责管理多个YTKBatchRequest实例,持有一个数组保存YTKBatchRequest。支持添加和删除YTKBatchRequest实例。

 YTKBatchRequestAgent和YTKRequestAgent差不多,只不过是一个和多个区别,没有多少要核心讲的,可以自己看一下YTKBatchRequestAgent的源码,相信都能看懂。

 

8.YTKChainRequest

可以发起链式请求,持有一个数组来保存所有的请求类。当某个请求结束后才能发起下一个请求,如果其中有一个请求返回失败,则认定本请求链失败。(链式请求:例如:发送请求 A,根据请求 A 的结果,选择性的发送请求 B 和 C,再根据 B 和 C 的结果,选择性的发送请求 D。)

 处理链式请求的类是YTKChainRequest,利用YTKChainRequestAgent单例来管理YTKChainRequest实例。

初始化方法

//YTKChainRequest.m
- (instancetype)init {
 
    self = [super init];
    if (self) {
 
        //下一个请求的index
        _nextRequestIndex = 0;
 
        //保存链式请求的数组
        _requestArray = [NSMutableArray array];
 
        //保存回调的数组
        _requestCallbackArray = [NSMutableArray array];
 
        //空回调,用来填充用户没有定义的回调block
        _emptyCallback = ^(YTKChainRequest *chainRequest, YTKBaseRequest *baseRequest) {
            // do nothing
        };
    }
    return self;
}

YTKChainRequest提供了添加和删除request的接口。

//在当前chain添加request和callback
- (void)addRequest:(YTKBaseRequest *)request callback:(YTKChainCallback)callback {
 
    //保存当前请求
    [_requestArray addObject:request];
 
    if (callback != nil) {
        [_requestCallbackArray addObject:callback];
    } else {
        //之所以特意弄一个空的callback,是为了避免在用户没有给当前request的callback传值的情况下,造成request数组和callback数组的不对称
        [_requestCallbackArray addObject:_emptyCallback];
    }
}

(1)链式请求发起

//YTKChainRequest.m
- (void)start {
    //如果第1个请求已经结束,就不再重复start了
    if (_nextRequestIndex > 0) {
        YTKLog(@"Error! Chain request has already started.");
        return;
    }
    //如果请求队列数组里面还有request,则取出并start
    if ([_requestArray count] > 0) {
        [self toggleAccessoriesWillStartCallBack];
        //取出当前request并start
        [self startNextRequest];
        //在当前的_requestArray添加当前的chain(YTKChainRequestAgent允许有多个chain)
        [[YTKChainRequestAgent sharedAgent] addChainRequest:self];
    } else {
        YTKLog(@"Error! Chain request array is empty.");
    }
}

通过查看链式请求的实现,发现链式请求的请求队列是可以变动的,用户可以无限制地添加请求。只要请求队列里面有请求存在,则YTKChainRequest就会继续发送它们。

(2)链式请求的请求和回调

下面是终止方法stop()

//YTKChainRequest.m
//终止当前的chain
- (void)stop {
 
    //首先调用即将停止的callback
    [self toggleAccessoriesWillStopCallBack];
 
    //然后stop当前的请求,再清空chain里所有的请求和回掉block
    [self clearRequest];
 
    //在YTKChainRequestAgent里移除当前的chain
    [[YTKChainRequestAgent sharedAgent] removeChainRequest:self];
 
    //最后调用已经结束的callback
    [self toggleAccessoriesDidStopCallBack];
}

stop方法是可以在外部调用的,所以用户可以随时终止当前链式请求的进行。它首先调用clearReuqest方法,将当前request停止,再将请求队列数组和callback数组清空。

//YTKChainRequest.m
- (void)clearRequest {
    //获取当前请求的index
    NSUInteger currentRequestIndex = _nextRequestIndex - 1;
    if (currentRequestIndex < [_requestArray count]) {
        YTKBaseRequest *request = _requestArray[currentRequestIndex];
        [request stop];
    }
    [_requestArray removeAllObjects];
    [_requestCallbackArray removeAllObjects];
}

然后在YTKChainRequestAgent单例里面,将自己移除掉。

 

9.YTKNetworkPrivate

提供JSON验证,appVersion等辅助性的方法;给YTKBaseRequest增加一些分类。

如果你通读了上述文章,你会发现在各个类里面可能会用到的一些工具类方法,在YTKNetworkPrivate都会给出,进一步提高了封装性和代码的可移植性。

 

上述就是YTKNetwork源码的全部内容,希望对想要了解YTKNetwork内容的工程师有所帮助。今天又是端午的最后一天,自己花了11个小时写了这篇文章,也是答应说在端午前后对于网络请求的第三次讲解。

明天就上班啦,自己也会抽出时间写对YTKNetwork再次针对实际过的项目进行封装,也会及时上传到github上。好饿了,还没有吃晚餐,回去吃晚餐啦。

今天是端午,祝大家端午安康!!!

 

posted @ 2018-06-18 21:35  国孩  阅读(4394)  评论(0编辑  收藏  举报