新普金娱乐网址


从深度神经网络到大体过程

01Python基础_08模块和包数学

Alamofire源码解读序列(十)之体系化(ResponseSerialization)

  • 一月 03, 2019
  • 数学
  • 没有评论

1958年,经省政坛要求,由教育部隶属的蒙彼利埃高校划归安徽省,划归陕西省军事管制后,先导不停开展院系调整,同年即增设了政治、历史、中文3个系。

总结

鉴于文化水平有限,如有错误,还望指出

1956年四月,青海学院总务长、化学系老板刘椽助教到太原察看,得到省、市两级政坛的支撑,确定在南阳市菜王、焦家门、蜜蜂张和兑周三个村征地922亩作为郑大首期建校用地。

为Request添加Timeline属性

extension Request {
    var timeline: Timeline {
        let requestCompletedTime = self.endTime ?? CFAbsoluteTimeGetCurrent()
        let initialResponseTime = self.delegate.initialResponseTime ?? requestCompletedTime

        return Timeline(
            requestStartTime: self.startTime ?? CFAbsoluteTimeGetCurrent(),
            initialResponseTime: initialResponseTime,
            requestCompletedTime: requestCompletedTime,
            serializationCompletedTime: CFAbsoluteTimeGetCurrent()
        )
    }
}

上面的代码为Request添加了提姆(Tim)eline属性,这是一个总计属性,因而在不同的呼吁阶段会获取不同的取值。

新校区眉湖

本篇紧要讲解Alamofire中怎样把服务器再次回到的数据系列化

雷克雅未克大学新校区

亟待序列化

那么问题就来了,在未系列化的底子上应当怎么添加体系化效率?在Alamofire源码解读连串(九)之响应封装(Response)这一篇小说中大家领悟针对连串化的Response有多少个包裹:DataResponse和DownloadResponse。他们都是struct,是端庄的蕴藏设计特性。和DefaultDataResponse,DefaultDownloadResponse最大的两样,其里面多了一个Result的包装。不精晓Result的仇人可以去探视这篇小说Alamofire源码解读类别(五)之结果封装(Result).

所以只要在上方的response方法中添加一个参数就行,这些参数的天职就是形成多少的系列化。此时大家说的矛头就是指可以把响应数据生成Result的功能。因为DataResponse和DownloadResponse的起先化离不开这些参数。

伪代码如下:

dataRequest.request().response(queue 序列化者 回调函数)
downloadRequest.request().response(queue 序列化者 回调函数)

咱俩就此把data和download的哀告每一回都分别来计划,原因是因为这多少个不等的伸手拿到的响应不雷同。download可以从一个URL中获取数据,而data不行。

那么重大来了,体系化者的天职是把多少转换成Result。因而我们可以把这一个连串化者设计成一个类仍然结构体,里边提供一个转换的不二法门就行了。这也是最健康但是的考虑。可是在swift中我们应有转变思维。swift跟oc不等同。

我们不应有把体系化者用一个原则性的靶子封死。这多少个时候就是协商大显身手的时刻了。既然连串化者需要一个函数,那么我们就统筹一个涵盖该函数的商事。这总体的思索应该是从高层到底层的过分的。因而协议就是下面的代码:

/// The type in which all data response serializers must conform to in order to serialize a response.
public protocol DataResponseSerializerProtocol {
    /// The type of serialized object to be created by this `DataResponseSerializerType`.
    associatedtype SerializedObject

    /// A closure used by response handlers that takes a request, response, data and error and returns a result.
    var serializeResponse: (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<SerializedObject> { get }
}

/// The type in which all download response serializers must conform to in order to serialize a response.
public protocol DownloadResponseSerializerProtocol {
    /// The type of serialized object to be created by this `DownloadResponseSerializerType`.
    associatedtype SerializedObject

    /// A closure used by response handlers that takes a request, response, url and error and returns a result.
    var serializeResponse: (URLRequest?, HTTPURLResponse?, URL?, Error?) -> Result<SerializedObject> { get }
}

SerializedObject定义了要系列化后的对象类型,这么写的缘由也是因为前面体系成Data,JOSN,String等等的需求。在回来类别者的问题上,只要实现了这个协议就行,序列者应该是一个存储属性,用系列化函数作为参数来起始化:

/// A generic `DataResponseSerializerType` used to serialize a request, response, and data into a serialized object.
public struct DataResponseSerializer<Value>: DataResponseSerializerProtocol {
    /// The type of serialized object to be created by this `DataResponseSerializer`.
    public typealias SerializedObject = Value

    /// A closure used by response handlers that takes a request, response, data and error and returns a result.
    public var serializeResponse: (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<Value>

    /// Initializes the `ResponseSerializer` instance with the given serialize response closure.
    ///
    /// - parameter serializeResponse: The closure used to serialize the response.
    ///
    /// - returns: The new generic response serializer instance.
    public init(serializeResponse: @escaping (URLRequest?, HTTPURLResponse?, Data?, Error?) -> Result<Value>) {
        self.serializeResponse = serializeResponse
    }
}

/// A generic `DownloadResponseSerializerType` used to serialize a request, response, and data into a serialized object.
public struct DownloadResponseSerializer<Value>: DownloadResponseSerializerProtocol {
    /// The type of serialized object to be created by this `DownloadResponseSerializer`.
    public typealias SerializedObject = Value

    /// A closure used by response handlers that takes a request, response, url and error and returns a result.
    public var serializeResponse: (URLRequest?, HTTPURLResponse?, URL?, Error?) -> Result<Value>

    /// Initializes the `ResponseSerializer` instance with the given serialize response closure.
    ///
    /// - parameter serializeResponse: The closure used to serialize the response.
    ///
    /// - returns: The new generic response serializer instance.
    public init(serializeResponse: @escaping (URLRequest?, HTTPURLResponse?, URL?, Error?) -> Result<Value>) {
        self.serializeResponse = serializeResponse
    }
}

  @discardableResult
    public func response<T: DataResponseSerializerProtocol>(
        queue: DispatchQueue? = nil,
        responseSerializer: T,
        completionHandler: @escaping (DataResponse<T.SerializedObject>) -> Void)
        -> Self
    {
        delegate.queue.addOperation {
            /// 这里就调用了responseSerializer保存的系列化函数,函数调用后会得到result
            let result = responseSerializer.serializeResponse(
                self.request,
                self.response,
                self.delegate.data,
                self.delegate.error
            )

            /// 这里一定要记得,DataResponse是一个结构体,是专门为了纯存储数据的,这里是调用了结构体的初始化方法创建了一个新的DataResponse实例
            var dataResponse = DataResponse<T.SerializedObject>(
                request: self.request,
                response: self.response,
                data: self.delegate.data,
                result: result,
                timeline: self.timeline
            )

            dataResponse.add(self.delegate.metrics)

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

        return self
    }



   @discardableResult
    public func response<T: DownloadResponseSerializerProtocol>(
        queue: DispatchQueue? = nil,
        responseSerializer: T,
        completionHandler: @escaping (DownloadResponse<T.SerializedObject>) -> Void)
        -> Self
    {
        delegate.queue.addOperation {
            let result = responseSerializer.serializeResponse(
                self.request,
                self.response,
                self.downloadDelegate.fileURL,
                self.downloadDelegate.error
            )

            var downloadResponse = DownloadResponse<T.SerializedObject>(
                request: self.request,
                response: self.response,
                temporaryURL: self.downloadDelegate.temporaryURL,
                destinationURL: self.downloadDelegate.destinationURL,
                resumeData: self.downloadDelegate.resumeData,
                result: result,
                timeline: self.timeline
            )

            downloadResponse.add(self.delegate.metrics)

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

        return self
    }

1961年,原喀布尔药科大学并入。汉密尔顿科技高校最早可追溯到1902年在永州前营门原游击衙署成立的四川大学堂中等教育部分以及甘肃优级师范学堂,并非现在的曼海姆理工大学。

不体系化的筹划

俺们先从最简便易行的事情起头。假诺我倡导了一个伸手,我自然希望知晓请求的结果,那么就会有下边这样的伪代码:

dataRequest.request().response{ ResponseObj in }
downloadRequest.request().response{ ResponseObj in }

上边的伪代码中的response函数是请求的回调函数,ResponseObj是对服务器重返的数额的一个浮泛。这就完事了最基本的要求。

默认情形下我们或许希望回调函数会在主线程调用,不过对于某些特定的机能,还是应当扩大对多线程的匡助,由此大家把上边的代码做一下扩张:

dataRequest.request().response(queue 回调函数)
downloadRequest.request().response(queue 回调函数)

给response函数增添一个参数,那些参数用来决定回调函数会在哪个线程被调用。这里的回调函数会给我们一个急需的结果,在Alamofire中,DataRequest对应的结果是DefaultDataResponse,DownloadRequest对应的结果是DefaultDownloadResponse。

所以,我们把上边的伪代码还原成Alamfire中的函数就是:

@discardableResult
    public func response(queue: DispatchQueue? = nil, completionHandler: @escaping (DefaultDataResponse) -> Void) -> Self {
        delegate.queue.addOperation {
            (queue ?? DispatchQueue.main).async {
                var dataResponse = DefaultDataResponse(
                    request: self.request,
                    response: self.response,
                    data: self.delegate.data,
                    error: self.delegate.error,
                    timeline: self.timeline
                )

                dataResponse.add(self.delegate.metrics)

                completionHandler(dataResponse)
            }
        }

        return self
    }

 @discardableResult
    public func response(
        queue: DispatchQueue? = nil,
        completionHandler: @escaping (DefaultDownloadResponse) -> Void)
        -> Self
    {
        delegate.queue.addOperation {
            (queue ?? DispatchQueue.main).async {
                var downloadResponse = DefaultDownloadResponse(
                    request: self.request,
                    response: self.response,
                    temporaryURL: self.downloadDelegate.temporaryURL,
                    destinationURL: self.downloadDelegate.destinationURL,
                    resumeData: self.downloadDelegate.resumeData,
                    error: self.downloadDelegate.error,
                    timeline: self.timeline
                )

                downloadResponse.add(self.delegate.metrics)

                completionHandler(downloadResponse)
            }
        }

        return self
    }

这三个函数都是把先创建Response对象,然后把这一个操作放入到delegate的体系中,当呼吁完成后再举行那么些operation。

1957年大学路西侧数理化三系的办公室教学楼和大学路的东生活区建成,即现在科钦大学南校区。

responsePropertyList

responsePropertyList跟responseData的套路一模一样,就不把全副的代码弄过来了,以免浪费篇幅,大家应有关注什么依据options:
PropertyListSerialization.ReadOptions,response: HTTPURLResponse?,data:
Data?,error: Error?拿到Result<Any>。

/// Returns a plist object contained in a result type constructed from the response data using
    /// `PropertyListSerialization` with the specified reading options.
    ///
    /// - parameter options:  The property list reading options. Defaults to `[]`.
    /// - parameter response: The response from the server.
    /// - parameter data:     The data returned from the server.
    /// - parameter error:    The error already encountered if it exists.
    ///
    /// - returns: The result data type.
    public static func serializeResponsePropertyList(
        options: PropertyListSerialization.ReadOptions,
        response: HTTPURLResponse?,
        data: Data?,
        error: Error?)
        -> Result<Any>
    {
        guard error == nil else { return .failure(error!) }

        if let response = response, emptyDataStatusCodes.contains(response.statusCode) { return .success(NSNull()) }

        guard let validData = data, validData.count > 0 else {
            return .failure(AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength))
        }

        do {
            let plist = try PropertyListSerialization.propertyList(from: validData, options: options, format: nil)
            return .success(plist)
        } catch {
            return .failure(AFError.responseSerializationFailed(reason: .propertyListSerializationFailed(error: error)))
        }
    }

1954年3月15日,克赖斯特彻奇高校先是届新生及教人士工、省市党政军领导、高教部代表及兄弟高校领导共一千余人,共同欢庆温尼伯高校落地。

responseData

responseData是把多少连串化为Data类型。也就是Result<Data>。

生成DataRequest的类别者:

 /// Creates a response serializer that returns the associated data as-is.
    ///
    /// - returns: A data response serializer.
    public static func dataResponseSerializer() -> DataResponseSerializer<Data> {
        /// 可以看出这么写也是可以的,这个方法要做分解才能理解,不然很容易让人迷惑,DataResponseSerializer的初始化需要一个ResponseSerializer函数,那么这个函数是什么呢?就是大括号内部的这个闭包,我们通过下边的代码就得到了一个DataResponseSerializer,这个DataResponseSerializer内部保存着一个函数,函数的作用就是根据参数,最终解析出Result<Data>
//        return DataResponseSerializer { (_, response, data, error) -> Result<Data> in
//            return Request.serializeResponseData(response: response, data: data, error: error)
//        }
        return DataResponseSerializer { _, response, data, error in
            return Request.serializeResponseData(response: response, data: data, error: error)
        }
    }

实现DataRequest的responseData函数:

 /// Adds a handler to be called once the request has finished.
    ///
    /// - parameter completionHandler: The code to be executed once the request has finished.
    ///
    /// - returns: The request.
    /// 这个方法就很好裂解了 ,设置一个回调,当请求完成调用,
    @discardableResult
    public func responseData(
        queue: DispatchQueue? = nil,
        completionHandler: @escaping (DataResponse<Data>) -> Void)
        -> Self
    {
        return response(
            queue: queue,
            responseSerializer: DataRequest.dataResponseSerializer(),
            completionHandler: completionHandler
        )
    }

生成DownloadRequest的系列者:

/// Creates a response serializer that returns the associated data as-is.
    ///
    /// - returns: A data response serializer.
    public static func dataResponseSerializer() -> DownloadResponseSerializer<Data> {
        return DownloadResponseSerializer { _, response, fileURL, error in
            guard error == nil else { return .failure(error!) }

            guard let fileURL = fileURL else {
                return .failure(AFError.responseSerializationFailed(reason: .inputFileNil))
            }

            do {
                let data = try Data(contentsOf: fileURL)
                return Request.serializeResponseData(response: response, data: data, error: error)
            } catch {
                return .failure(AFError.responseSerializationFailed(reason: .inputFileReadFailed(at: fileURL)))
            }
        }
    }

实现DataRequest的responseData函数:

 /// Adds a handler to be called once the request has finished.
    ///
    /// - parameter completionHandler: The code to be executed once the request has finished.
    ///
    /// - returns: The request.
    @discardableResult
    public func responseData(
        queue: DispatchQueue? = nil,
        completionHandler: @escaping (DownloadResponse<Data>) -> Void)
        -> Self
    {
        return response(
            queue: queue,
            responseSerializer: DownloadRequest.dataResponseSerializer(),
            completionHandler: completionHandler
        )
    }

下边的代码中值得注意的是:初始化连串者需要的是一个函数,只要把这一个函数看做是一个参数,就能领略怎么会这样写。那么我们更应该关注的是上面的函数,它表达了何等依照response:
HTTPURLResponse?, data: Data?, error:
Error?拿到Result<Data>。也是体系化Data的中坚措施:

    /// Returns a result data type that contains the response data as-is.
    ///
    /// - parameter response: The response from the server.
    /// - parameter data:     The data returned from the server.
    /// - parameter error:    The error already encountered if it exists.
    ///
    /// - returns: The result data type.
    public static func serializeResponseData(response: HTTPURLResponse?, data: Data?, error: Error?) -> Result<Data> {
        guard error == nil else { return .failure(error!) }

        if let response = response, emptyDataStatusCodes.contains(response.statusCode) { return .success(Data()) }

        guard let validData = data else {
            return .failure(AFError.responseSerializationFailed(reason: .inputDataNil))
        }

        return .success(validData)
    }

1962年,江西省行使物理所并入福州大学,可是将地理系并入当时的眉山医科大学,后来的黑龙江大学。

前言

和后面的篇章不同,
在这一篇中,我想从程序的计划层次上解读ResponseSerialization那么些文件。更直观的去探索该功效是哪些一步一步实现的。当然,有一个不佳的地点,跟数学题目同样,大家先行知道了结果,由此这是一个已知结果推到过程的问题。

在在此以前Alamofire的源码解读著作中,大家早已通晓了:对于响应感兴趣的Request类型是DataRequest和DownloadRequest。我们上边所有的宏图都是对准那六个体系的哀求的。

全校的科研协会研发出了神舟飞船航天服的面罩,为载人航天科技做出了高大进献,据说为国家节约科研经费数千万。

emptyDataStatusCodes

如果HTTP response code 是204或者205,就表示Data为nil。

/// A set of HTTP response status code that do not contain response data.
private let emptyDataStatusCodes: Set<Int> = [204, 205]

1954年教育部说了算从江西高校、迪拜大学、安徽大学、东复旦学等高校抽调师资,在泗水设立一所新大学。其缘由据说是因为将海南高校迁往伊丽莎白港的方案未能执行。

responseJSON

responseJSON跟responseData的老路一模一样,就不把方方面面的代码弄过来了,以免浪费篇幅,大家应有关爱什么遵照options:
JSONSerialization.ReadingOptions,response: HTTPURLResponse?,data:
Data?,error: Error?拿到Result<Any>。

 /// Returns a JSON object contained in a result type constructed from the response data using `JSONSerialization`
    /// with the specified reading options.
    ///
    /// - parameter options:  The JSON serialization reading options. Defaults to `.allowFragments`.
    /// - parameter response: The response from the server.
    /// - parameter data:     The data returned from the server.
    /// - parameter error:    The error already encountered if it exists.
    ///
    /// - returns: The result data type.
    public static func serializeResponseJSON(
        options: JSONSerialization.ReadingOptions,
        response: HTTPURLResponse?,
        data: Data?,
        error: Error?)
        -> Result<Any>
    {
        guard error == nil else { return .failure(error!) }

        if let response = response, emptyDataStatusCodes.contains(response.statusCode) { return .success(NSNull()) }

        guard let validData = data, validData.count > 0 else {
            return .failure(AFError.responseSerializationFailed(reason: .inputDataNilOrZeroLength))
        }

        do {
            let json = try JSONSerialization.jsonObject(with: validData, options: options)
            return .success(json)
        } catch {
            return .failure(AFError.responseSerializationFailed(reason: .jsonSerializationFailed(error: error)))
        }
    }

此间之所以拔取Any,是因为JSON可能是字典,也恐怕是数组。

图片 1

responseString

responseString跟responseData的套路一模一样,就不把全体的代码弄过来了,以免浪费篇幅,我们应该关注怎么着依据encoding:
String.Encoding?,response: HTTPURLResponse?,data: Data?,error:
Error?拿到Result<String>。

/// Returns a result string type initialized from the response data with the specified string encoding.
    ///
    /// - parameter encoding: The string encoding. If `nil`, the string encoding will be determined from the server
    ///                       response, falling back to the default HTTP default character set, ISO-8859-1.
    /// - parameter response: The response from the server.
    /// - parameter data:     The data returned from the server.
    /// - parameter error:    The error already encountered if it exists.
    ///
    /// - returns: The result data type.
    public static func serializeResponseString(
        encoding: String.Encoding?,
        response: HTTPURLResponse?,
        data: Data?,
        error: Error?)
        -> Result<String>
    {
        guard error == nil else { return .failure(error!) }

        if let response = response, emptyDataStatusCodes.contains(response.statusCode) { return .success("") }

        guard let validData = data else {
            return .failure(AFError.responseSerializationFailed(reason: .inputDataNil))
        }

        var convertedEncoding = encoding

        if let encodingName = response?.textEncodingName as CFString!, convertedEncoding == nil {
            convertedEncoding = String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(
                CFStringConvertIANACharSetNameToEncoding(encodingName))
            )
        }

        let actualEncoding = convertedEncoding ?? String.Encoding.isoLatin1

        if let string = String(data: validData, encoding: actualEncoding) {
            return .success(string)
        } else {
            return .failure(AFError.responseSerializationFailed(reason: .stringSerializationFailed(encoding: actualEncoding)))
        }
    }

下面的代码中涉嫌了字符串编码的学识,有趣味的情侣可以自己摸索资料。

图片 2

扩展

其实,代码到了这边,基本的效用已经完结了80%。倘诺要把data体系成string,只需要创立一个data系列者就好了,可是这样的计划性用起来很麻烦,因为还要书写连串成Result的函数,这一个函数往往都是一致的,要么把那么些函数提前定义出来,要么把这一个函数封装起来。

依照Alamofire的计划性,是把这一个函数封装起来的。你可以如此使用:

dataRequest.request().responseString(queue 回调函数)
dataRequest.request().responseJSON(queue 回调函数)

经过特色的函数来得到体系化后的response。

图片 3

链接

Alamofire源码解读系列(一)之概述和使用
简书—–博客园

Alamofire源码解读连串(二)之错误处理(AFError)
简书—–博客园

Alamofire源码解读系列(三)之文告处理(Notification)
简书—–博客园

Alamofire源码解读系列(四)之参数编码(ParameterEncoding)
简书—–博客园

Alamofire源码解读序列(五)之结果封装(Result)
简书—–博客园

Alamofire源码解读连串(六)之Task代理(TaskDelegate)
简书—–博客园

Alamofire源码解读连串(七)之网络监控(NetworkReachabilityManager)
简书—–博客园

Alamofire源码解读体系(八)之安全策略(ServerTrustPolicy)
简书—–博客园

Alamofire源码解读序列(九)之响应封装(Response)
简书—–博客园

1991年,中国率先所中外联合办学的综合性大学长江高校并入高校。该多瑙河高校和现在的黄河科学技术高校从未简单关系。

1959年,在突佛罗伦萨城高校、洛桑理大学(达累斯萨Lamb农业大学前身)、罗利高校等兄弟学校的佑助下,增设了土建、机械、水利和电动机4个系。

近来火奴鲁鲁大学发展连忙,频频现身在各大传媒页面上。

雷克雅未克大学新校区

二〇一一年,泗水大学成为24所中国大学生院参谋长联席会扩充大学之一,并规范确立研究生院。

1956年十一月,核心大学规划会议上专业确定将筹划的新大学命名为“热那亚大学”,设数学、物理、化学3个系,由中国科大学学部委员嵇文甫任负责人,龚依群、王岳为副负责人等成员结合筹建委员会。

1960年,高校增设了外语系,后提高为外语高校。

新校区南门

图片 4

2000年八月10日,得梅因高校与布尔萨传媒大学、吉林师范大学统一组建新乌鲁木齐高校,并筹建位于高新区的新校区,发展为前日的主校区。

塞维普罗维登斯大学的文人全体世界各地,创建了四面八方校友会,关注母校发展,积极为母校发展出谋划策或者捐款创建各样奖金和本金,并衷心祝愿母校越来越来,早日步入世界一级大学的行列!

浙江因为只有一所211工程高校,却不曾一所教育部直属大学。其实读书墨西卡利大学校史,就会意识萨尔瓦多高校现已在建校之初就是教育部附设大学。

新校区体育场馆

1956年六月,内罗毕高校当作教育部附设大学,经教育部同意,数理化3个系正式向全国征集,并由原中国科大学局长郭沫若先生题写了校名。

图片 5

新校区钟楼

马拉加大学或者与青海外国语大学、汉诺威轻财经高校和吉林体育大学等大学合作在高新区创制了海南省国家高校科技园,并在麦迪逊高校东门树立了卡托维兹大学科技园。

1952年,我国效法前苏联对全国高校院系举行调整,计划将及时在克利夫兰办学的浙江大学迁到宿雾,筹建新的四川大学,却因为各种原因,江苏大学未能迁到纳闽,而是搬回了盐湖城。其实完全能够知道,广东省咋样舍得让历史悠久的江西高校迁往省外。

2004年十一月27日,教育部与江西省人民政党签约协议,共同建设合肥大学,正式成为全国首先所省部共建大学。

1963年,昆明大学土建、水利、机械、电机三个系调入新组建的阿拉木图法高校,后发展为海法交通大学,又于2000年合并到新的温尼伯高校。

图片 6

1992年,海南体育专科高校合并高校。

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图