Alamofire (3) - Request - Moment For Technology

😊😊😊Alamofire thematic directory. Welcome timely feedback and exchange

Alamofire (1) – URLSession prerequisite skill

Alamofire (2) — Background download

Alamofire (3) — Request

Alamofire (4) — Details you need to know

Alamofire (5) — Response

Alamofire (6) — Multiple form uploads

Alamofire (7) — Safety certification

Alamofire (8) — Final Chapter (Network Monitoring & Notifications & Downloader Packaging)

Alamofire Directory through train — Harmonious learning, not impatient!

SesssionManager to SessionDelegate layering was introduced in the previous Alamofire- Background Download! Let me summarize and then start a very important Alamofire module, Request!

I. Summary of SessionManager

SesssionManager is the externally provided manager that has all the functionality of the entire Alamofire.
- requestThe request,Download, upload, stream
- Request header Settings and multiple form header Settings
- sessionDirect external supply, convenient and free handling
- Initialize exposure to facilitate free factory construction, such asURLSessionConfigurationConfiguration mode of
- Retry and adapt requests
- Closures provide externally:backgroundCompletionHandlerThe background download comes back and listens for the closure
- One of the very important points is thatSesssionManager 把 SessionDelegate to a specialized class:SessionDelegate
SessionDelegate URLSessionDelegate, URLSessionTaskDelegate, URLSessionDataDelegate, URLSessionDownloadDelegate, Agent URLSessionStreamDelegate etc.
More interesting: SessionDelegate also provides external closures, meaning that all internal implementations of the delegate can be listened to externally. Of course, all external closures fall into two categories:
- Add closure execution inside the original proxy callback.

Alternatively, if the proxy comes back, the lower proxy delivery is not performed and the external closure callback is performed

Conclusion:SesssionManagerResponsible for creation and managementRequestObjects and their underlying layersNSURLSession

First of all, I will post a very familiar picture to you. Understanding this picture will be very helpful for the following understanding of Request

As you can see from the picture above, our external module isSesssionManagerIt provides a lot of functionality to outside users
But the real implementers of this work are made up ofIOS, Android, front-end, back-end, testingImplementation of!
Which oneiOSFor module tasks, there areHomepage, Discovery, My, SDK, video....Modules need to be implemented, but our project manager may not even know what they are and how to implement them! All of them if all of themSesssionManagerTo implement, obviously coupling is too strong, and the task is messy, does not reflect the effect of a great project layered architecture. So in theiOSTask refinement andSesssionManagerIn between, there is a small manager, right: he knows the details and scheduling. Yes: He canSesssionManagerCoordinate and cooperate. That isRequest

Second, the Request

1. Request parameter encoding

First of all, I would like to explain that Alamofire supports coding formats. The specific format differences are easy to understand according to the name. If you really can’t understand, you can search and fill the gaps by yourself
- URLEncoding
- JSONEncoding
- PropertyListEncoding
let encodedURLRequest = try encoding.encode(originalRequest! , with: parameters) also encode the request through this code

public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
    var urlRequest = try urlRequest.asURLRequest()

    guard let parameters = parameters else { return urlRequest }

    if let method = HTTPMethod(rawValue: urlRequest.httpMethod ?? "GET"), encodesParametersInURL(with: method) {
        guard let url = urlRequest.url else {
            throw AFError.parameterEncodingFailed(reason: .missingURL)
        }

        if var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false), !parameters.isEmpty {
            let percentEncodedQuery = (urlComponents.percentEncodedQuery.map{$0 + "&"}????"") + query(parameters)
            urlComponents.percentEncodedQuery = percentEncodedQuery
            urlRequest.url = urlComponents.url
        }
    } else {
        if urlRequest.value(forHTTPHeaderField: "Content-Type") = =nil {
            urlRequest.setValue("application/x-www-form-urlencoded; charset=utf-8", forHTTPHeaderField: "Content-Type")
        }
        urlRequest.httpBody = query(parameters).data(using: .utf8, allowLossyConversion: false)}return urlRequest
}
Copy the code

Code to consult, here is a summary
First take out the request method, according to different request method, parameter encoding is different
- .get, .head, .deleteThe three methods are to concatenate the parameters directly toURLbehind
- Other requests through the request body (httpBody)
Since our request is ASCII encoded, the first step to percentage-coding is to percentage-code all routes for the current request
Parameter convenient coding, splicing out

private func query(_ parameters: [String: Any]) -> String {
    var components: [(String.String)] = []

    for key in parameters.keys.sorted(by: <) {
        let value = parameters[key]!
        components += queryComponents(fromKey: key, value: value)
    }
    return components.map { "\ [$0)=\ [$1)" }.joined(separator: "&")}Copy the code

throughASCIIYou sort it from small to large
queryComponentsThis method code is overly omitted.
- I’m going to take recursive parameters,
- theThe key and the valueTake it out, and then do a percent code.
- Put into the tuple to save, forming a pair of parameters
Let’s add a tuple to an array
The map mapping($0) = \ ($1)
Type a separator between the elements&

Normal methods simply concatenate the URL, such as the POST method, which puts these encoded pairs into the request body. And you have to addContent-TypeThe request header

2. Request internal relationship review

After exploring the parameter encoding of one of the request’s tedious tasks, start analyzing the process inside: URL -> Request -> Task. This process also establishes the binding relationship between task and request

open func request(_ urlRequest: URLRequestConvertible) -> DataRequest {
    var originalRequest: URLRequest?
    do {
        originalRequest = try urlRequest.asURLRequest()
        let originalTask = DataRequest.Requestable(urlRequest: originalRequest!)
        let task = try originalTask.task(session: session, adapter: adapter, queue: queue)
        let request = DataRequest(session: session, requestTask: .data(originalTask, task))

        delegate[task] = request
        if startRequestsImmediately { request.resume() }

        return request
    } catch {
        return request(originalRequest, failedWith: error)
    }
}
Copy the code

Internal createRequestableTo help those belowDataRequestcreateTask“, also a common saying, tasks are layered, and the architecture is clearer
The bindingThe task and the requestWill it be convenient for theSessionDelegateDeliver the task,taskDirect retrieval,requestConvenient direct access
Direct taskrequest.resume()Start the

RequestThe initialization takes advantage of the convenience of enumerations, constructs are created, and related information is saved

May be a lot of partners at this time will have doubts, you are not throughSessionDelegateImplementation proxy, why have one hereDataTaskDelegate

The first thing to understand is that the SessionDelegate is the delegate follower for all sessions, and any proxy will come and respond.
The DataTaskDelegate is the implementor of our specific tedious task, and all of the methods in the DataTaskDelegate are responded to by the SessionDelegate.
To put it bluntly, it is the relationship between the whole and the part
SessionDelegate is the general responder to events, but specific transactions should be assigned to specific people to execute. You can’t have all the code listed here just because the SessionDelegate gets all the responses. Obviously that would lead to confusion. Respond to the general agent and then give professional people to do professional things according to different needs. The coupling is greatly reduced and the architecture is more layered.
There is also an important point about asynchrony: delegate[task] = request to give our SessionDelegate a handy ability to get in time

open func urlSession(
    _ session: URLSession,
    downloadTask: URLSessionDownloadTask,
    didFinishDownloadingTo location: URL)
{
  // Omit attribute closure callback
    if let delegate = self[downloadTask]? .delegateas? DownloadTaskDelegate {
        delegate.urlSession(session, downloadTask: downloadTask, didFinishDownloadingTo: location)
    }
}
Copy the code

This code typically passes through the binding we established earlier, through each proxy callbacktaskFind the correspondingRequestAnd then just pull it out because of the propertyRequestProperty delegate to handle related transactions

func urlSession(
    _ session: URLSession,
    downloadTask: URLSessionDownloadTask,
    didFinishDownloadingTo location: URL)
{
    temporaryURL = location

    guard
        let destination = destination,
        let response = downloadTask.response as? HTTPURLResponse
    else { return }

    let result = destination(location, response)
    let destinationURL = result.destinationURL
    let options = result.options

    self.destinationURL = destinationURL

    do {
        if options.contains(.removePreviousFile), FileManager.default.fileExists(atPath: destinationURL.path) {
            try FileManager.default.removeItem(at: destinationURL)
        }

        if options.contains(.createIntermediateDirectories) {
            let directory = destinationURL.deletingLastPathComponent()
            try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
        }
        try FileManager.default.moveItem(at: location, to: destinationURL)
    } catch {
        self.error = error
    }
}
Copy the code

Transfer storage address after file download, file processing related and error condition
The above is the most typical heavy disgusting operation, is certainly not need to beSessionDelegateAll you need to know!

The process from SessionManager -> Request is explicitly delivered directly, but implicitly via the delegate response: SessionDelegate -> the delegate of the specific Request. See here, don’t you feel very cool! A good framework will always give you a big boost in terms of thinking, and we often have ugly couplings and communication issues. Then surely the design idea of Alamofire can bring you certain enlightenment!

Just ask who else is there right now? 45 degrees up in the sky, damn it! My charm with no place to put it!

Alamofire (3) — Request

I. Summary of SessionManager

Second, the Request

1. Request parameter encoding

2. Request internal relationship review

Related Posts

Alamofire source learning (five): four subclasses of Request

S03E10: Use matrix to manipulate the relative motion of “puppet” objects

OpenGL – Draw a square that can be moved by arrow keys