#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_ */

#import <Foundation/Foundation.h>NS_ASSUME_NONNULL_BEGINFOUNDATION_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) {-- NSDataYTKResponseSerializerTypeHTTP,-- JSON 对象YTKResponseSerializerTypeJSON,-- NSXMLParserYTKResponseSerializerTypeXMLParser,
};// 请求的优先级
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)successfailure:(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)successfailure:(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;@endNS_ASSUME_NONNULL_END

@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
- (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 请求成功的blockif (strongSelf.successCompletionBlock) {strongSelf.successCompletionBlock(strongSelf);}//7. 把成功和失败的block都设置为nil，避免循环引用
        [strongSelf clearCompletionBlock];});
}

- (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;
}

//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;
}

- (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 triggerif (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;
}

- (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;
}

//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);}}}
}

//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];
}

// 使用类方法创建单例对象
+ (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

//YTKNetworkAgent.m
- (void)addRequest:(YTKBaseRequest *)request {//1. 获取taskNSParameterAssert(request != nil);NSError * __autoreleasing requestSerializationError = nil;//获取用户自定义的requestURLNSURLRequest *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 requestYTKLog(@"Add request: %@", NSStringFromClass([request class]));//2. 将request放入保存请求的字典中，taskIdentifier为key，request为值
    [self addRequestToRecord:request];//3. 开始task
    [request.requestTask resume];
}

//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];}...
}

//YTKNetworkAgent.m
//根据不同请求类型，序列化类型，和请求参数来返回NSURLSessionTask
- (NSURLSessionTask *)sessionTaskForRequest:(YTKBaseRequest *)request error:(NSError * _Nullable __autoreleasing *)error {//1. 获得请求类型（GET，POST等）YTKRequestMethod method = [request requestMethod];//2. 获得请求urlNSString *url = [self buildRequestUrl:request];//3. 获得请求参数id param = request.requestArgument;AFConstructingBlock constructingBlock = [request constructingBodyBlock];//4. 获得request serializerAFHTTPRequestSerializer *requestSerializer = [self requestSerializerForRequest:request];//5. 根据不同的请求类型来返回对应的taskswitch (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];}
}

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

- (YTKRequestMethod)requestMethod {return YTKRequestMethodPOST;
}

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

//YTKNetworkAgent.m
- (NSURLSessionDataTask *)dataTaskWithHTTPMethod:(NSString *)methodrequestSerializer:(AFHTTPRequestSerializer *)requestSerializerURLString:(NSString *)URLStringparameters:(id)parameterserror:(NSError * _Nullable __autoreleasing *)error {return [self dataTaskWithHTTPMethod:method requestSerializer:requestSerializer URLString:URLString parameters:parameters constructingBodyWithBlock:nil error:error];
}//最终返回NSURLSessionDataTask实例
- (NSURLSessionDataTask *)dataTaskWithHTTPMethod:(NSString *)methodrequestSerializer:(AFHTTPRequestSerializer *)requestSerializerURLString:(NSString *)URLStringparameters:(id)parametersconstructingBodyWithBlock:(nullable void (^)(idformData))blockerror:(NSError * _Nullable __autoreleasing *)error {NSMutableURLRequest *request = nil;//根据有无构造请求体的block的情况来获取requestif (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:requestcompletionHandler:^(NSURLResponse * __unused response, id responseObject, NSError *_error) {//响应的统一处理
                               [self handleRequestResult:dataTask responseObject:responseObject error:_error];}];return dataTask;
}

// 优先级的映射// !!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;}}

//YTKNetworkAgent.m
- (void)addRequest:(YTKBaseRequest *)request {//将request实例放入保存请求的字典中，taskIdentifier为key，request为值
  [self addRequestToRecord:request];...}- (void)addRequestToRecord:(YTKBaseRequest *)request {//加锁
    Lock();_requestsRecord[@(request.requestTask.taskIdentifier)] = request;Unlock();
}

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

//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对应的responserequest.responseObject = responseObject;//3. 获取responseObject，responseData和responseStringif ([request.responseObject isKindOfClass:[NSData class]]) {//3.1 获取 responseDatarequest.responseData = responseObject;//3.2 获取responseStringrequest.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不为nilsucceed = 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];});
}

//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];});
}

//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到cacheMetadataFilePathYTKCacheMetadata *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);}}}
}

//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赋给requestrequest.responseData = [NSData dataWithContentsOfURL:url];request.responseString = [[NSString alloc] initWithData:request.responseData encoding:[YTKNetworkUtils stringEncodingWithRequest:request]];[[NSFileManager defaultManager] removeItemAtURL:url error:nil];}//清空requestrequest.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代码，就调用blockif (request.failureCompletionBlock) {request.failureCompletionBlock(request);}//告诉Accessories请求已经停止了
        [request toggleAccessoriesDidStopCallBack];});
}

//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;
}

- (void)start {//如果batch里第一个请求已经成功结束，则不能再startif (_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.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];}//调用批量请求成功的blockif (_successCompletionBlock) {_successCompletionBlock(self);}//清空成功和失败的block
        [self clearCompletionBlock];//调用请求结束的代理
        [self toggleAccessoriesDidStopCallBack];//从YTKBatchRequestAgent里移除当前的batch
        [[YTKBatchRequestAgent sharedAgent] removeBatchRequest:self];}
}

//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];}//调用请求失败的blockif (_failureCompletionBlock) {_failureCompletionBlock(self);}//清空成功和失败的block
    [self clearCompletionBlock];//调用请求结束的代理
    [self toggleAccessoriesDidStopCallBack];//从YTKBatchRequestAgent里移除当前的batch
    [[YTKBatchRequestAgent sharedAgent] removeBatchRequest:self];
}

//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;
}

//在当前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];}
}

//YTKChainRequest.m
- (void)start {//如果第1个请求已经结束，就不再重复start了if (_nextRequestIndex > 0) {YTKLog(@"Error! Chain request has already started.");return;}//如果请求队列数组里面还有request，则取出并startif ([_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.m
//终止当前的chain
- (void)stop {//首先调用即将停止的callback
    [self toggleAccessoriesWillStopCallBack];//然后stop当前的请求，再清空chain里所有的请求和回掉block
    [self clearRequest];//在YTKChainRequestAgent里移除当前的chain
    [[YTKChainRequestAgent sharedAgent] removeChainRequest:self];//最后调用已经结束的callback
    [self toggleAccessoriesDidStopCallBack];
}

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