新普金娱乐网址


无问西东,坚定前行

水下图像增强相关算法的一个简小结。

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

  • 八月 31, 2018
  • 数学
  • 没有评论

本篇主要讲解Alamofire中如何拿服务器返回的数额序列化

数学 1

前言

及前的文章不同,
在这无异于首被,我怀念由程序的筹划层次上解读ResponseSerialization这个文件。更直观的去追究该功能是什么样一步一步实现的。当然,有一个坏的地方,跟数学题目同,我们先知情了结果,因此就是一个都解结果推到过程的题材。

当之前Alamofire的源码解读文章被,我们曾经明白了:对于响应感兴趣的Request类型是DataRequest和DownloadRequest。我们下面所有的计划性还是对当下点儿个档次的请求的。

郑州大学新校区

切莫序列化的统筹

咱俩事先打最简便的政工着手。如果本身倡导了一个请,我得要了解要的结果,那么即便会见来下面这样的伪代码:

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。

河南因只来一样所211工高校,却尚无同所教育部直属高校。其实读书郑州大学校史,就见面发觉郑州大学既于建校之初就是教育部直属高校。

消序列化

那问题便来了,在非序列化的基础及应当什么补充加序列化功能?在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
    }

1952年,我国拟前苏联本着全国高校院有关进行调整,计划用立即在青岛办学之山东大学迁到郑州,筹建新的河南大学,却盖种种原因,山东大学未能迁到郑州,而是搬掉了济南。其实全好知道,山东省什么舍得吃历史悠久的山东大学迁移向省外。

扩展

其实,代码到了此,基本的力量已经成功了80%。如果要是拿data序列成string,只需要创造一个data序列者就哼了,但是这么的计划用起老辛苦,因为还要写序列成Result的函数,这些函数往往还是一样的,要么把这些函数提前定义出来,要么拿这些函数封装起来。

本Alamofire的规划,是把这些函数封装起来的。你可以这么使用:

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

经特色的函数来抱序列化后的response。

1954年教育部决定于山东大学、北京大学、吉林大学、东北大学当高校抽调师资,在郑州设一所新大学。其原因据说是为将河南大学迁移向郑州的方案未能履行。

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

1954年9月15日,郑州大学先是到新生和教职员工、省市党政军领导、高教部代表和兄弟学校领导一起一千余口,共同欢庆郑州大学落地。

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

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可能是字典,也可能是数组。

郑州大学新校区

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

1956年2月,中央大学规划会议达到正式确定以筹划之初大学命名也“郑州大学”,设数学、物理、化学3个相关,由中国科学院学部委员嵇文甫任负责人,龚依群、王岳也符合负责人等成员做筹建委员会。

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]

1956年4月,山东大学总务长、化学系主任刘椽教授交郑州观,得到看、市两层政府之支撑,确定以郑州市菜王、焦家门、蜜蜂张和兑现周四个村子征地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添加了Timeline属性,这是一个乘除属性,因此在不同的要阶段会拿走不同之取值。

1956年8月,郑州大学当教育部直属高校,经教育部同意,数理化3单相关正式向全国征召,并出于原本中国科学院院长郭沫若先生题写了校名。

总结

是因为文化水平有限,如产生左,还为指出

1957年大学路西侧数理化三息息相关的办公室教学楼和高校路的左生活区建成,即今郑州大学南校区。

链接

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

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

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

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

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

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

Alamofire源码解读系列(七)之网监督(NetworkReachabilityManager)
简书—–博客园

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

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

1958年,经省政府数学要求,由教育部直属的郑州大学划归河南省,划归河南省管理后,开始频频开展院相关调整,同年即增设了政治、历史、中文3独相关。

1959年,在天津大学、大连工学院(大连理工大学前身)、武汉大学等兄弟学校的赞助下,增设了土建、机械、水利同电机4只有关。

数学 3

新校区南门

1960年,学校增设了外语系,后进步为外语学院。

1961年,原郑州师范学院并入。郑州师范学院最早可追溯到1902年当开封前营门原游击衙署成立的河南大学堂中等教育片与河南优级师范学堂,并非现在的郑州师范学院。

1962年,河南省用物理所并入郑州大学,然而以地理系并入当时之开封师范学院,后来底河南大学。

1963年,郑州大学土建、水利、机械、电机四个有关调入新组建的郑州工学院,后发展为郑州工业大学,又吃2000年联到新的郑州大学。

1991年,中国率先所世界联合办学的综合性大学黄河大学并学校。该黄河大学与现行的黄河科技学院没少关系。

数学 4

初校区钟楼

1992年,河南体育专科学校并学校。

2000年7月10日,郑州大学同郑州工业大学、河南医科大学合组建新郑州大学,并筹建位于高新区的初校区,发展为今天底主校区。

2004年2月27日,教育部和河南省人民政府签署协议,共同建设郑州大学,正式成举国率先所省部共建高校。

2011年,郑州大学变成24所中国研究生院院长联席会扩大高校之一,并正式建立研究生院。

数学 5

初校区图书馆

郑州大学或与河南工业大学、郑州轻工业学院暨河南农业大学当高校合作以高新区建立了河南省国家大学科技园,并于郑州大学东门立了郑州大学科技园。

最近郑州大学腾飞高速,频频出现在各国大传媒页面及。

校的科研团队研发来了神舟飞船航天服的面纱,为载人航天科技做出了宏伟贡献,据说也国省科研经费数千万。

郑州大学的读书人遍世界各地,成立了大街小巷校友会,关注母校发展,积极为该校发展献计或者捐款成立各种奖金与财力,并衷心祝愿母校越来越来,早日步入世界一流大学的行!

数学 6

初校区眉湖

相关文章

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