YTKNetwork是猿題庫 iOS 研發團隊基于 AFNetworking 封裝的 iOS 網絡庫，提供了更高層次的網絡訪問抽象。
相比于AFNetworking,YTKNetwork提供了更高級的功能
·支持按時間緩存網絡請求內容
·支持按版本號緩存網絡請求內容
·支持統一設置服務器和 CDN 的地址
·支持檢查返回 JSON 內容的合法性
·支持文件的斷點續傳
·支持 block 和 delegate 兩種模式的回調方式
·支持批量的網絡請求發送，并統一設置它們的回調（實現在 YTKBatchRequest 類中）
·支持方便地設置有相互依賴的網絡請求的發送，例如：發送請求 A，根據請求 A 的結果，選擇性·的發送請求 B 和 C，再根據 B 和 C 的結果，選擇性的發送請求 D。（實現在 YTKChainRequest 類中）
·支持網絡請求 URL 的 filter，可以統一為網絡請求加上一些參數，或者修改一些路徑。
定義了一套插件機制，可以很方便地為 YTKNetwork 增加功能。猿題庫官方現在提供了一個插件，可以在某些網絡請求發起時，在界面上顯示“正在加載”的 HUD。
YTKNetwork使用了設計模式里面的command模式，簡單來說，就是把請求封裝成一個對象，使需要請求的類與第三方底層網絡分開，降低耦合性，也方便了我們更換網絡庫。同時也方便處理一些處理公共邏輯和對象的持久化。
接下來我們來看看YTK是怎么工作的。
在github的基礎教程里面我們可以看到YTK是把每個網絡請求都封裝成對象，所以我們每個請求都需要繼承YTKRequest,通過重寫父類的方法來構造我們想要的網絡請求，所以我們來重寫一下YTKRequest從而進行一個網絡請求
#import <YTKNetwork/YTKNetwork.h>
@interface ZJRequest : YTKRequest
@end
#import "ZJRequest.h"
@implementation ZJRequest
- (NSString *)requestUrl
{
return @"/api/4/news/latest";
}
- (YTKRequestMethod)requestMethod
{
return YTKRequestMethodGET;
}
- (id)requestArgument
{
return @{};
}
@end
這里我們requestUrl去掉了域名信息，因為域名信息我們已經在AppDelegate利用YTKNetworkConfig設置過域名。
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
YTKNetworkConfig *config = [YTKNetworkConfig sharedConfig];
config.baseUrl = @"https://news-at.zhihu.com";
return YES;
}
上述代碼我們重寫了參數和請求方式方法，使用GET方法來請求。
我們構造完成ZJRequest之后，來我們需要網絡請求的ViewController，調用我們的ZJRequest，并使用block來取得網絡請求結果
ZJRequest *request = [[ZJRequest alloc]init];
[request startWithCompletionBlockWithSuccess:^(__kindof YTKBaseRequest * _Nonnull request) {
NSLog(@"succeed");
} failure:^(__kindof YTKBaseRequest * _Nonnull request) {
NSLog(@"failure");
}];
除此之外，YTKNetwork還支持delegate回調
- (void)viewDidLoad {
[super viewDidLoad];
ZJRequest *request = [[ZJRequest alloc]init];
// [request startWithCompletionBlockWithSuccess:^(__kindof YTKBaseRequest * _Nonnull request) {
// NSLog(@"succeed");
// } failure:^(__kindof YTKBaseRequest * _Nonnull request) {
// NSLog(@"failure");
// }];
request.delegate = self;
[request start];
}
- (void)requestFinished:(YTKBaseRequest *)request {
NSLog(@"succeed");
}
- (void)requestFailed:(YTKBaseRequest *)request {
NSLog(@"failed");
}
我們先從startWithCompletionBlockWithSuccess:failure點進去看看里面的實現
- (void)startWithCompletionBlockWithSuccess:(YTKRequestCompletionBlock)success
failure:(YTKRequestCompletionBlock)failure {
[self setCompletionBlockWithSuccess:success failure:failure];
[self start];
}
YTK先設置了成功的block和失敗的回調，具體是用setter方法把YTKBaseRequest里面的successCompletionBlock和failureCompletionBlock賦值進去
- (void)setCompletionBlockWithSuccess:(YTKRequestCompletionBlock)success
failure:(YTKRequestCompletionBlock)failure {
self.successCompletionBlock = success;
self.failureCompletionBlock = failure;
}
接下來調用start方法，此處先調用YTKRequest的start方法
- (void)start {
//是否忽略響應緩存
if (self.ignoreCache) {
[self startWithoutCache];
return;
}
//是否有待恢復的下載請求
if (self.resumableDownloadPath) {
[self startWithoutCache];
return;
}
//是否有錯誤的緩存
if (![self loadCacheWithError:nil]) {
[self startWithoutCache];
return;
}
_dataFromCache = YES;
dispatch_async(dispatch_get_main_queue(), ^{
[self requestCompletePreprocessor];
[self requestCompleteFilter];
YTKRequest *strongSelf = self;
[strongSelf.delegate requestFinished:strongSelf];
if (strongSelf.successCompletionBlock) {
strongSelf.successCompletionBlock(strongSelf);
}
[strongSelf clearCompletionBlock];
});
}
YTK使用了三個判斷，都是是否需要進行無緩存的請求
如果我們的緩存里面已經有響應了，YTK就會調用requestCompletePreprocessor和requestCompleteFilter兩個方法，但這兩個方法都是留給我們去實現，YTK并沒有實現，然后并調用了自身的完成回調并傳遞為成功回調
我們先假設緩存為nil，進入startWithoutCache看看
- (void)startWithoutCache {
//先清除所有緩存的變量
[self clearCacheVariables];
[super start];
}
- (void)clearCacheVariables {
_cacheData = nil;//
_cacheXML = nil;
_cacheJSON = nil;
_cacheString = nil;
_cacheMetadata = nil;
_dataFromCache = NO;
}
YTK先清除緩存的所有變量，包括響應的Data數據，XML,JSON,String,元Data，還有一個布爾值，方便我們做響應的存儲，分別對應各種數據格式
接下來調用父類YTKBaseRequest的重點方法start
- (void)start {
[self toggleAccessoriesWillStartCallBack];
[[YTKNetworkAgent sharedAgent] addRequest:self];
}
- (void)toggleAccessoriesWillStartCallBack {
for (id<YTKRequestAccessory> accessory in self.requestAccessories) {
if ([accessory respondsToSelector:@selector(requestWillStart:)]) {
[accessory requestWillStart:self];
}
}
}
第一個方法就是調用協議里面的requestWillStart:來通知請求即將開始。其中self.requestAccessories是YTKBaseRequest定義的一個可變數組，用來儲存協議YTKRequestAccessory，第二個方法即是通過YTKNetworkAgent的單例調用addRequest方法
我們來看這個單例是什么
+ (YTKNetworkAgent *)sharedAgent {
static id sharedInstance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedInstance = [[self alloc] init];
});
return sharedInstance;
}
- (instancetype)init {
self = [super init];
if (self) {
_config = [YTKNetworkConfig sharedConfig];
_manager = [[AFHTTPSessionManager alloc] initWithSessionConfiguration:_config.sessionConfiguration];
_requestsRecord = [NSMutableDictionary dictionary];
_processingQueue = dispatch_queue_create("com.yuantiku.networkagent.processing", DISPATCH_QUEUE_CONCURRENT);
_allStatusCodes = [NSIndexSet indexSetWithIndexesInRange:NSMakeRange(100, 500)];
pthread_mutex_init(&_lock, NULL);
_manager.securityPolicy = _config.securityPolicy;
_manager.responseSerializer = [AFHTTPResponseSerializer serializer];
// Take over the status code validation
_manager.responseSerializer.acceptableStatusCodes = _allStatusCodes;
_manager.completionQueue = _processingQueue;
}
return self;
}
這個類包括創建了YTKNetworkConfig的單例，還有AFHTTPSessionManager的實例并把單例內的sessionConfig傳進AFHTTPSessionManager，還有相應的安全政策，設定可接受響應碼，并創建了一個并行隊列設置為AF的完成隊列和互斥鎖lock
然后我們進入addRequest:這個方法
- (void)addRequest:(YTKBaseRequest *)request {
//參數判斷request不能為空
NSParameterAssert(request != nil);
NSError * __autoreleasing requestSerializationError = nil;
//這里如果我們設置了url就直接用url請求
NSURLRequest *customUrlRequest= [request buildCustomUrlRequest];
if (customUrlRequest) {
__block NSURLSessionDataTask *dataTask = nil;
//調用AF請求
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 {
//如果沒有，則創建
request.requestTask = [self sessionTaskForRequest:request error:&requestSerializationError];
}
if (requestSerializationError) {
[self requestDidFailWithRequest:request error:requestSerializationError];
return;
}
NSAssert(request.requestTask != nil, @"requestTask should not be nil");
// Set request task priority
// !!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]));
//綁定request的id，這里跟AF的思想是一樣的，用一個字典存儲請求，并設置一個id為key
[self addRequestToRecord:request];
[request.requestTask resume];
}
這里面涉及的方法很多，我們來一個一個看
首先YTK先獲取CustomRequest，如果我們重寫了一個request則直接調用AF請求，并設置響應內容調用了handleRequestResult:responseObject:error，記錄了dataTask。反之，則用request的參數通過sessionTaskRequest:error自己生成了一個requestTask，再用requestRecord記錄了這個request，最后resume這個task。
AF的方法在這就暫不描述，感興趣可以看這篇AFNetworking解析，它做了什么
我們來看回調里面YTK調用的方法
- (void)handleRequestResult:(NSURLSessionTask *)task responseObject:(id)responseObject error:(NSError *)error {
//避免多線程下取到的request不一致，這里用了線程鎖
Lock();
YTKBaseRequest *request = _requestsRecord[@(task.taskIdentifier)];
Unlock();
//在AF中，request如果被取消或者在record里被刪除，將會調用失敗回調，在YTK則直接返回，
不做回調
if (!request) {
return;
}
YTKLog(@"Finished Request: %@", NSStringFromClass([request class]));
NSError * __autoreleasing serializationError = nil;
NSError * __autoreleasing validationError = nil;
NSError *requestError = nil;
BOOL succeed = NO;
//獲取響應內容，序列化內容
request.responseObject = responseObject;
if ([request.responseObject isKindOfClass:[NSData class]]) {
request.responseData = responseObject;
//根據響應內容的編碼做轉換，其中調用了AF2.6.3中方法
request.responseString = [[NSString alloc] initWithData:responseObject encoding:[YTKNetworkUtils stringEncodingWithRequest:request]];
//判斷序列化方式
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;
}
}
if (error) {
succeed = NO;
requestError = error;
} else if (serializationError) {
succeed = NO;
requestError = serializationError;
} else {
succeed = [self validateResult:request error:&validationError];
requestError = validationError;
}
if (succeed) {
[self requestDidSucceedWithRequest:request];
} else {
[self requestDidFailWithRequest:request error:requestError];
}
dispatch_async(dispatch_get_main_queue(), ^{
[self removeRequestFromRecord:request];
//YTK在這里把回調都置為nil，從而打破循環引用，所以我們可以直接在最開始的startWithCompletionBlockWithSuccess:failure:里面的block直接使用self
[request clearCompletionBlock];
});
}
這段代碼很容易看懂，就是獲取到響應內容，并做序列化，最后再返回序列化后的內容
其中我們可以通過重寫YTK的responseSerializerType分別對數據進行解析，分為HTTP（不做處理），JSON，XML，使用的都是AF里面的方法。YTK最后還對響應的內容做了合法化判斷（如果你重寫了jsonValidator），我們可以看看這個方法做了什么
- (BOOL)validateResult:(YTKBaseRequest *)request error:(NSError * _Nullable __autoreleasing *)error {
//判斷響應碼是否在200~299
BOOL result = [request statusCodeValidator];
if (!result) {
if (error) {
*error = [NSError errorWithDomain:YTKRequestValidationErrorDomain code:YTKRequestValidationErrorInvalidStatusCode userInfo:@{NSLocalizedDescriptionKey:@"Invalid status code"}];
}
return result;
}
id json = [request responseJSONObject];
id validator = [request jsonValidator];
//獲取響應的json和需要驗證的字段
if (json && validator) {
result = [YTKNetworkUtils validateJSON:json withValidator:validator];
if (!result) {
if (error) {
*error = [NSError errorWithDomain:YTKRequestValidationErrorDomain code:YTKRequestValidationErrorInvalidJSONFormat userInfo:@{NSLocalizedDescriptionKey:@"Invalid JSON format"}];
}
return result;
}
}
return YES;
}
我們接著看validateJSON:withValidator:
+ (BOOL)validateJSON:(id)json withValidator:(id)jsonValidator {
if ([json isKindOfClass:[NSDictionary class]] &&
[jsonValidator isKindOfClass:[NSDictionary class]]) {
NSDictionary * dict = json;
NSDictionary * validator = jsonValidator;
BOOL result = YES;
NSEnumerator * enumerator = [validator keyEnumerator];
NSString * key;
while ((key = [enumerator nextObject]) != nil) {
id value = dict[key];
id format = validator[key];
if ([value isKindOfClass:[NSDictionary class]]
|| [value isKindOfClass:[NSArray class]]) {
result = [self validateJSON:value withValidator:format];
if (!result) {
break;
}
} else {
if ([value isKindOfClass:format] == NO &&
[value isKindOfClass:[NSNull class]] == NO) {
result = NO;
break;
}
}
}
return result;
} else if ([json isKindOfClass:[NSArray class]] &&
[jsonValidator isKindOfClass:[NSArray class]]) {
NSArray * validatorArray = (NSArray *)jsonValidator;
if (validatorArray.count > 0) {
NSArray * array = json;
NSDictionary * validator = jsonValidator[0];
for (id item in array) {
BOOL result = [self validateJSON:item withValidator:validator];
if (!result) {
return NO;
}
}
}
return YES;
} else if ([json isKindOfClass:jsonValidator]) {
return YES;
} else {
return NO;
}
這個方法就是遞歸調用遍歷jsonValidator和json看數據類型是否跟我們要求的一樣，方法很簡單清晰
我們再回到handleRequestResult:responseObject:error:這個方法里面
if (succeed) {
[self requestDidSucceedWithRequest:request];
} else {
[self requestDidFailWithRequest:request error:requestError];
}
我們來看succeed為YES的時候YTK做了什么
- (void)requestDidSucceedWithRequest:(YTKBaseRequest *)request {
@autoreleasepool {
[request requestCompletePreprocessor];
}
dispatch_async(dispatch_get_main_queue(), ^{
[request toggleAccessoriesWillStopCallBack];
[request requestCompleteFilter];
if (request.delegate != nil) {
[request.delegate requestFinished:request];
}
if (request.successCompletionBlock) {
request.successCompletionBlock(request);
}
[request toggleAccessoriesDidStopCallBack];
});
}
- (void)requestCompletePreprocessor {
[super requestCompletePreprocessor];
//是否要異步寫入緩存
if (self.writeCacheAsynchronously) {
//創建了一個異步隊列單例
dispatch_async(ytkrequest_cache_writing_queue(), ^{
[self saveResponseDataToCacheFile:[super responseData]];
});
} else {
[self saveResponseDataToCacheFile:[super responseData]];
}
}
當succeed為YES的時候YTK首先調用了requestCompletePreprocessor把請求回來的數據做了一個緩存，然后調用requestWillStop:和requestCompleteFilter，這兩個方法都沒有具體的實現，是想我們自己實現吧，接下來分別調用requestFinished和成功完成的回調和協議。
我們來看YTK是如何做緩存的，緩存策略是什么
- (void)saveResponseDataToCacheFile:(NSData *)data {
//緩存時間存在和要緩存的數據不是來自緩存
if ([self cacheTimeInSeconds] > 0 && ![self isDataFromCache]) {
if (data != nil) {
@try {
這里開始寫入數據
[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);
}
}
}
}
- (NSString *)cacheBasePath {
NSString *pathOfLibrary = [NSSearchPathForDirectoriesInDomains(NSLibraryDirectory, NSUserDomainMask, YES) objectAtIndex:0];
NSString *path = [pathOfLibrary stringByAppendingPathComponent:@"LazyRequestCache"];
//如果自定義了緩存地址，則使用自定義地址緩存
NSArray<id<YTKCacheDirPathFilterProtocol>> *filters = [[YTKNetworkConfig sharedConfig] cacheDirPathFilters];
if (filters.count > 0) {
for (id<YTKCacheDirPathFilterProtocol> f in filters) {
path = [f filterCacheDirPath:path withRequest:self];
}
}
[self createDirectoryIfNeeded:path];
return path;
}
- (void)createDirectoryIfNeeded:(NSString *)path {
NSFileManager *fileManager = [NSFileManager defaultManager];
BOOL isDir;
//如果沒有這個文件就直接創建，有的話就先移除再創建
if (![fileManager fileExistsAtPath:path isDirectory:&isDir]) {
[self createBaseDirectoryAtPath:path];
} else {
if (!isDir) {
NSError *error = nil;
[fileManager removeItemAtPath:path error:&error];
[self createBaseDirectoryAtPath:path];
}
}
}
- (void)createBaseDirectoryAtPath:(NSString *)path {
NSError *error = nil;
[[NSFileManager defaultManager] createDirectoryAtPath:path withIntermediateDirectories:YES
attributes:nil error:&error];
if (error) {
YTKLog(@"create cache directory failed, error = %@", error);
} else {
//禁止icloud備份
[YTKNetworkUtils addDoNotBackupAttribute:path];
}
}
- (NSString *)cacheFileName {
NSString *requestUrl = [self requestUrl];
NSString *baseUrl = [YTKNetworkConfig sharedConfig].baseUrl;
id argument = [self cacheFileNameFilterForRequestArgument:[self requestArgument]];
NSString *requestInfo = [NSString stringWithFormat:@"Method:%ld Host:%@ Url:%@ Argument:%@",
(long)[self requestMethod], baseUrl, requestUrl, argument];
NSString *cacheFileName = [YTKNetworkUtils md5StringFromString:requestInfo];
return cacheFileName;
}
- (NSString *)cacheFilePath {
NSString *cacheFileName = [self cacheFileName];
NSString *path = [self cacheBasePath];
path = [path stringByAppendingPathComponent:cacheFileName];
return path;
}
- (NSString *)cacheMetadataFilePath {
NSString *cacheMetadataFileName = [NSString stringWithFormat:@"%@.metadata", [self cacheFileName]];
NSString *path = [self cacheBasePath];
path = [path stringByAppendingPathComponent:cacheMetadataFileName];
return path;
}
YTK緩存文件名由請求方法，完整的url地址和參數，并做md5變換。先創建地址名為“LazyRequestCache”緩存的文件夾，最后再把數據寫進文件。然后把創建了一個YTKCacheMetadata的實例，專門用來儲存當前這個緩存的附加信息，也存在了跟data相同的文件夾里面
接下來來看Succeed為NO的時候
- (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);
//如果是下載的數據，則先對下載的數據做緩存。因為可能是序列化數據的時候出現了問題，所以先對下載的數據做緩存，其中resumeableDownloadPath的為自定義路徑，提供恢復下載的地址
NSData *incompleteDownloadData = error.userInfo[NSURLSessionDownloadTaskResumeData];
if (incompleteDownloadData) {
[incompleteDownloadData writeToURL:[self incompleteDownloadTempPathForDownloadPath:request.resumableDownloadPath] atomically:YES];
}
//如果下載中斷，則對url進行緩存
if ([request.responseObject isKindOfClass:[NSURL class]]) {
NSURL *url = request.responseObject;
if (url.isFileURL && [[NSFileManager defaultManager] fileExistsAtPath:url.path]) {
request.responseData = [NSData dataWithContentsOfURL:url];
request.responseString = [[NSString alloc] initWithData:request.responseData encoding:[YTKNetworkUtils stringEncodingWithRequest:request]];
[[NSFileManager defaultManager] removeItemAtURL:url error:nil];
}
request.responseObject = nil;
}
@autoreleasepool {
[request requestFailedPreprocessor];
}
dispatch_async(dispatch_get_main_queue(), ^{
[request toggleAccessoriesWillStopCallBack];
[request requestFailedFilter];
if (request.delegate != nil) {
[request.delegate requestFailed:request];
}
if (request.failureCompletionBlock) {
request.failureCompletionBlock(request);
}
[request toggleAccessoriesDidStopCallBack];
});
}
總的來說，如果有下載的數據，就先做緩存，下載失敗，則緩存url。最后在分別調用requestFailedPreprocessor和requestFailedFilter，具體實現YTK留給用戶實現，然后調用失敗回調。
回到我們的addRequest:方法里面
if (customUrlRequest) {
__block NSURLSessionDataTask *dataTask = nil;
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 {
request.requestTask = [self sessionTaskForRequest:request error:&requestSerializationError];
}
我們來看YTK創建requestTask的方法
- (NSURLSessionTask *)sessionTaskForRequest:(YTKBaseRequest *)request error:(NSError * _Nullable __autoreleasing *)error {
//獲取request必要的參數
YTKRequestMethod method = [request requestMethod];
NSString *url = [self buildRequestUrl:request];
id param = request.requestArgument;
//此處block是為了上傳圖片等附件形式
AFConstructingBlock constructingBlock = [request constructingBodyBlock];
AFHTTPRequestSerializer *requestSerializer = [self requestSerializerForRequest:request];
switch (method) {
case YTKRequestMethodGET:
if (request.resumableDownloadPath) {
return [self downloadTaskWithDownloadPath:request.resumableDownloadPath requestSerializer:requestSerializer URLString:url parameters:param progress:request.resumableDownloadProgressBlock error:error];
} else {
return [self dataTaskWithHTTPMethod:@"GET" requestSerializer:requestSerializer URLString:url parameters:param error:error];
}
case YTKRequestMethodPOST:
return [self dataTaskWithHTTPMethod:@"POST" requestSerializer:requestSerializer URLString:url parameters:param constructingBodyWithBlock:constructingBlock error:error];
case YTKRequestMethodHEAD:
return [self dataTaskWithHTTPMethod:@"HEAD" requestSerializer:requestSerializer URLString:url parameters:param error:error];
case YTKRequestMethodPUT:
return [self dataTaskWithHTTPMethod:@"PUT" requestSerializer:requestSerializer URLString:url parameters:param error:error];
case YTKRequestMethodDELETE:
return [self dataTaskWithHTTPMethod:@"DELETE" requestSerializer:requestSerializer URLString:url parameters:param error:error];
case YTKRequestMethodPATCH:
return [self dataTaskWithHTTPMethod:@"PATCH" requestSerializer:requestSerializer URLString:url parameters:param error:error];
}
}
前面是獲取request的一些必要參數，在獲取url的獲取，YTK用了一個方法buildRequestUrl:，里面做了對Url的合法性判斷，還有是否需要cdn加速。接下來獲取了request的序列化類的實例，并準備開始請求。我們先來看dataTaskWithHTTPMethod:requestSerializer:URLString:parameters:error:這個通用方法,YTK傳入了請求方法、序列化方式、參數和url，如果為post方法還加入了constructingBlock。
- (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 *)dataTaskWithHTTPMethod:(NSString *)method
requestSerializer:(AFHTTPRequestSerializer *)requestSerializer
URLString:(NSString *)URLString
parameters:(id)parameters
constructingBodyWithBlock:(nullable void (^)(id <AFMultipartFormData> formData))block
error:(NSError * _Nullable __autoreleasing *)error {
NSMutableURLRequest *request = nil;
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];
}
__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;
}
如果是文件上傳的方式，則調用AF的文件上傳方法，反之，則使用普通的請求方式。
總結，YTKbaseRequest就是把我們每個請求都封裝成一個對象，具體的實現請求都交給了AFNetworking。代碼還是結構還是很清晰的，閱讀難度也不大
接下我們來看YTK的YTKBatchRequest類
YTKBatchRequest可以統一處理多個請求
用法如下
- (void)sendBatchRequest {
GetImageApi *a = [[GetImageApi alloc] initWithImageId:@"1.jpg"];
GetImageApi *b = [[GetImageApi alloc] initWithImageId:@"2.jpg"];
GetImageApi *c = [[GetImageApi alloc] initWithImageId:@"3.jpg"];
GetUserInfoApi *d = [[GetUserInfoApi alloc] initWithUserId:@"123"];
YTKBatchRequest *batchRequest = [[YTKBatchRequest alloc] initWithRequestArray:@[a, b, c, d]];
[batchRequest startWithCompletionBlockWithSuccess:^(YTKBatchRequest *batchRequest) {
NSLog(@"succeed");
NSArray *requests = batchRequest.requestArray;
GetImageApi *a = (GetImageApi *)requests[0];
GetImageApi *b = (GetImageApi *)requests[1];
GetImageApi *c = (GetImageApi *)requests[2];
GetUserInfoApi *user = (GetUserInfoApi *)requests[3];
// deal with requests result ...
} failure:^(YTKBatchRequest *batchRequest) {
NSLog(@"failed");
}];
}
我們來看下init方法
- (instancetype)initWithRequestArray:(NSArray<YTKRequest *> *)requestArray {
self = [super init];
if (self) {
_requestArray = [requestArray copy];
_finishedCount = 0;
for (YTKRequest * req in _requestArray) {
if (![req isKindOfClass:[YTKRequest class]]) {
YTKLog(@"Error, request item must be YTKRequest instance.");
return nil;
}
}
}
return self;
}
初始化方法中，先取得request的數組requestArray,并且設置完成請求數量finishCount為0。
接下來來看
- (void)startWithCompletionBlockWithSuccess:(void (^)(YTKBatchRequest *batchRequest))success
failure:(void (^)(YTKBatchRequest *batchRequest))failure {
[self setCompletionBlockWithSuccess:success failure:failure];
[self start];
}
- (void)setCompletionBlockWithSuccess:(void (^)(YTKBatchRequest *batchRequest))success
failure:(void (^)(YTKBatchRequest *batchRequest))failure {
self.successCompletionBlock = success;
self.failureCompletionBlock = failure;
}
跟YTKBaseRequest一樣，都是先設置好回調的Block，再調用start方法
- (void)start
if (_finishedCount > 0) {
YTKLog(@"Error! Batch request has already started.");
return;
}
_failedRequest = nil;
[[YTKBatchRequestAgent sharedAgent] addBatchRequest:self];
[self toggleAccessoriesWillStartCallBack];
for (YTKRequest * req in _requestArray) {
req.delegate = self;
[req clearCompletionBlock];
[req start];
}
先判斷時候有正在進行的request，如果有就返回，沒有的話，遍歷requestArray里面的內容，并開始請求，并設置了delegate
我們來看回調
- (void)requestFinished:(YTKRequest *)request {
_finishedCount++;
if (_finishedCount == _requestArray.count) {
[self toggleAccessoriesWillStopCallBack];
if ([_delegate respondsToSelector:@selector(batchRequestFinished:)]) {
[_delegate batchRequestFinished:self];
}
if (_successCompletionBlock) {
_successCompletionBlock(self);
}
[self clearCompletionBlock];
[self toggleAccessoriesDidStopCallBack];
[[YTKBatchRequestAgent sharedAgent] removeBatchRequest:self];
}
}
- (void)requestFailed:(YTKRequest *)request {
_failedRequest = request;
[self toggleAccessoriesWillStopCallBack];
// Stop
for (YTKRequest *req in _requestArray) {
[req stop];
}
// Callback
if ([_delegate respondsToSelector:@selector(batchRequestFailed:)]) {
[_delegate batchRequestFailed:self];
}
if (_failureCompletionBlock) {
_failureCompletionBlock(self);
}
// Clear
[self clearCompletionBlock];
[self toggleAccessoriesDidStopCallBack];
[[YTKBatchRequestAgent sharedAgent] removeBatchRequest:self];
}
- (void)clearRequest {
for (YTKRequest * req in _requestArray) {
[req stop];
}
[self clearCompletionBlock];
}
當所有請求完成并成功，返回所有request，并清除block。里面利用finishCount來判斷是否請求都完成，如果是有一個請求失敗的話，則暫停所有請求，返回失敗回調。
