Three steps to write an iOS network request library yourself

Code example: https://github.com/johnlui/Swift-On-iOS/blob/master/BuildYourHTTPRequestLibrary

Open source project: Pitaya, an HTTP request library suitable for uploading large files: https://github.com/johnlui/Pitaya

In this series of articles, we will try to build our own network request library using NSURLSession technology.

Introduction to NSURLSession

NSURLSession is a new network request interface introduced in iOS7, which was introduced in detail in WWDC2013. Here is a slide describing its structure:

When the application is in the foreground, NSURLSession is no different from NSURLConnection, but Background Session is more flexible after the program switches to the background.

Try NSURLSession

Preparation

Create a new single-page application called BuildYourHTTPRequestLibrary and place a button called Request in the center of the page:

Drag and bind the Touch Up Inside event:

Using NSURLSession

Fill the mainButtonBeTapped function with the following code:

 @IBAction func mainButtonBeTapped(sender: AnyObject) {
 let session = NSURLSession.sharedSession()
 let request = NSURLRequest(URL: NSURL(string: "http://baidu.com" )!)
 let task = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in
 let string = NSString(data: data, encoding: NSUTF8StringEncoding)
 println(string)
 })
 task.resume()
 } 
 

Successful use!

Feeling Asynchronous

asynchronous

Rewrite the code of the mainButtonBeTapped function:

 @IBAction func mainButtonBeTapped(sender: AnyObject) {
 let session = NSURLSession.sharedSession()
 let request = NSURLRequest(URL: NSURL(string: "http://baidu.com" )!)
 let task = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in
 println( "just wait for 5 seconds!" )
 sleep( 5 )
 let string = NSString(data: data, encoding: NSUTF8StringEncoding)
 println(string)
 })
 task.resume()
 }

Try again. There is a five-second interval between the two prints. The main thread is not blocked, proving that NSURLSession is executed asynchronously.

block

Try clicking it multiple times and we can see it execute every five seconds until all are finished.

NSURLSession uses an "asynchronous blocking" model, that is, all requests enter thread 2# for execution after being issued, and are executed in blocking queue mode within thread 2#.

#p#

Open source project: Pitaya, an HTTP request library suitable for uploading large files: https://github.com/johnlui/Pitaya

In this chapter, we will try to use a class to encapsulate our previous code, and try to add the function of dynamically adding HTTP parameters (params), and then encapsulate a powerful interface.

[[135519]]

Basic package

Basic preparation

Create a new empty Swift file, name it Network.swift, write a Network class in it, and then write a static method request():

 class Network{
 static func request() {
 let session = NSURLSession .sharedSession()
 let request = NSURLRequest (URL: NSURL(string: "http://baidu.com")!)
 let task = session .dataTaskWithRequest(request, completionHandler: { (data, response, error) - > Void in
 println("just wait for 5 seconds!")
 sleep(5)
 let string = NSString (data: data, encoding: NSUTF8StringEncoding)
 println(string)
 })
 task.resume()
 }
 }

Modify the button function in ViewController:

 @IBAction func mainButtonBeTapped(sender: AnyObject) {
 Network.request()
 }

Run the project and click the button. The effect is the same as before.

Custom HTTP method and URL

Modify the request() method and pass in the HTTP method and URL:

 static func request(method: String, url: String) {
 let session = NSURLSession.sharedSession()
 let request = NSMutableURLRequest(URL: NSURL(string: url)!)
 request.HTTPMethod = method
 let task = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in
 println( "just wait for 5 seconds!" )
 sleep( 5 )
 let string = NSString(data: data, encoding: NSUTF8StringEncoding)
 println(string)
 })
 task.resume()
 }

Modify the previous function call:

 @IBAction func mainButtonBeTapped(sender: AnyObject) {
 Network.request( "GET" , url: "http://baidu.com" )
 }

Run the project and click the button. The effect is the same as before.

Use closures to handle request results

Functions are first-class citizens in Swift. Closures can be used as function parameters and return values, which is very powerful. Next, we use closures to process the return value of network requests. Modify the request() method and pass in a closure:

 static func request(method: String, url: String, callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let session = NSURLSession.sharedSession()
 let request = NSMutableURLRequest(URL: NSURL(string: url)!)
 request.HTTPMethod = method
 let task = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in
 callback(data: data, response: response, error: error)
 })
 task.resume()
 }

Use closures to process results in the previous function call:

 @IBAction func mainButtonBeTapped(sender: AnyObject) {
 Network.request( "GET" , url: "http://baidu.com" ) { (data, response, error) -> Void in
 println( "just wait for 5 seconds!" )
 sleep( 5 )
 let string = NSString(data: data, encoding: NSUTF8StringEncoding)
 println(string)
 }
 }

Run the project and click the button. The effect is the same as before.

Dynamically add Params

GET method

Under the GET method, params is directly attached to the end of the URL after being url-encoded and sent to the server. Modify the request() method and pass in a params dictionary:

 static func request(method: String, url: String, params: Dictionary = Dictionary(), callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 ... ...
 }

To process params, we steal the params processing function from Alamofire. If it is a GET method, then add the processed params to the end of the URL. The complete code of the Network class is as follows:

 class Network{
 static func request(method: String, url: String, params: Dictionary = Dictionary(), callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let session = NSURLSession.sharedSession() 
 
 var newURL = url
 if method == "GET" {
 newURL += "?" + Network().buildParams(params)
 } 
 
 let request = NSMutableURLRequest(URL: NSURL(string: newURL)!)
 request.HTTPMethod = method 
 
 let task = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in
 callback(data: data, response: response, error: error)
 })
 task.resume()
 } 
 
 // Three functions stolen from Alamofire  
 func buildParams(parameters: [String: AnyObject]) -> String {
 var components: [(String, String)] = []
 for key in sorted(Array(parameters.keys), [(String, String)] {
 var components: [(String, String)] = []
 if let dictionary = value as? [String: AnyObject] {
 for (nestedKey, value) in dictionary {
 components += queryComponents( "\(key)[\(nestedKey)]" , value)
 }
 } else   if let array = value as? [AnyObject] {
 for value in array {
 components += queryComponents( "\(key)" , value)
 }
 } else {
 components.extend([(escape(key), escape( "\(value)" ))])
 } 
 
 return components
 }
 func escape(string: String) -> String {
 let legalURLCharactersToBeEscaped: CFStringRef = ":&=;+!@#$()',*"  
 return CFURLCreateStringByAddingPercentEscapes(nil, string, nil, legalURLCharactersToBeEscaped, CFStringBuiltInEncodings.UTF8.rawValue) as String
 }
 }

Modify the previous function call:

 @IBAction func mainButtonBeTapped(sender: AnyObject) {
 Network.request( "GET" , url: "http://pitayaswift.sinaapp.com/pitaya.php" , params: [ "get" : "Network" ]) { (data, response, error) -> Void in
 let string = NSString(data: data, encoding: NSUTF8StringEncoding)
 println(string)
 }
 }

http://pitayaswift.sinaapp.com/pitaya.php is the server code I deployed for testing, which will directly return ooxx in ?get=ooxx. Run the project and click the button to see the effect:

POST method

There are several protocols to choose from under the POST method. There is no file upload here, so we use the simpler application/x-www-form-urlencoded method to send the request. Add some code to the request() method:

 static func request(method: String, url: String, params: Dictionary = Dictionary(), callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let session = NSURLSession.sharedSession() 
 
 var newURL = url
 if method == "GET" {
 newURL += "?" + Network().buildParams(params)
 } 
 
 let request = NSMutableURLRequest(URL: NSURL(string: newURL)!)
 request.HTTPMethod = method 
 
 if method == "POST" {
 request.addValue( "application/x-www-form-urlencoded" , forHTTPHeaderField: "Content-Type" )
 request.HTTPBody = Network().buildParams(params).dataUsingEncoding(NSUTF8StringEncoding)
 } 
 
 let task = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in
 callback(data: data, response: response, error: error)
 })
 task.resume()
 }

Modify the previous function call:

 @IBAction func mainButtonBeTapped(sender: AnyObject) {
 Network.request( "POST" , url: "http://pitayaswift.sinaapp.com/pitaya.php" , params: [ "post" : "Network" ]) { (data, response, error) -> Void in
 let string = NSString(data: data, encoding: NSUTF8StringEncoding)
 println(string)
 }
 }

Use POST to send a request, and the server will also return the value of the key post. Run the project and click the button. The result is the same as the previous GET method.

At this point, the interface encapsulation is completed!

#p#

Open source project: Pitaya, an HTTP request library suitable for uploading large files: https://github.com/johnlui/Pitaya

In this article, we will work together to reduce the coupling of the previous code and use the adapter pattern to implement a network API independent of the underlying structure to create a real network request "library".

Reduce coupling

How to reduce coupling

The current clear soup noodle style code is easy to understand, but the function is single and the code is messy. Let's analyze the use process of NSURLSession:

Constructing NSURLRequest

Determine the URL

Determine the HTTP method (GET, POST, etc.)

Adding specific HTTP headers

Filling HTTP Body

Drive the session.dataTaskWithRequest method to start the request

Specific implementation

Create another NetworkManager class under Network, set URL, params, files, etc. as member variables, and initialize them in the constructor:

 class NetworkManager { 
 
 let method: String!
 let params: Dictionary let callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void 
 
 let session = NSURLSession.sharedSession()
 let url: String!
 var request: NSMutableURLRequest!
 var task: NSURLSessionTask! 
 
 init(url: String, method: String, params: Dictionary = Dictionary(), callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 self.url = url
 self.request = NSMutableURLRequest(URL: NSURL(string: url)!)
 self.method = method
 self.params = params
 self.callback = callback
 }
 }

Afterwards, the above analysis

1. Determine the URL

2. Determine the HTTP method (GET, POST, etc.)

3. Add specific HTTP headers

4. Fill in the HTTP Body

Encapsulate the first three steps into one function, encapsulate the last step into one function, and then encapsulate the code that drives session.dataTaskWithRequest into one function:

 func buildRequest() {
 if self.method == "GET" && self.params.count > 0 {
 self.request = NSMutableURLRequest(URL: NSURL(string: url + "?" + buildParams(self.params))!)
 } 
 
 request.HTTPMethod = self.method 
 
 if self.params.count > 0 {
 request.addValue( "application/x-www-form-urlencoded" , forHTTPHeaderField: "Content-Type" )
 }
 }
 func buildBody() {
 if self.params.count > 0 && self.method != "GET" {
 request.HTTPBody = buildParams(self.params).nsdata
 }
 }
 func fireTask() {
 task = session.dataTaskWithRequest(request, completionHandler: { (data, response, error) -> Void in
 self.callback(data: data, response: response, error: error)
 })
 task.resume()
 }

Then use a unified method to drive the above three functions to complete the request:

 func fire() {
 buildRequest()
 buildBody()
 fireTask()
 }

At the same time, don't forget the three parse params functions stolen from Alamofire, and put them in this class. So far, the work of reducing coupling is basically completed, and then we start to encapsulate the "network API".

Encapsulating "network API" using the adapter pattern

Understanding the Adapter Pattern

The adapter pattern is a design pattern that is easy to understand: my app needs a function to get the string returned by a URL. I currently choose Alamofire, but the developing Pitaya looks good. I want to replace it with Pitaya in the future, so I encapsulate a layer of my own network interface to shield the underlying details. When the time comes, I only need to modify this class, and there is no need to go deeper into the project to change so many interface calls.

The adapter pattern sounds high-sounding, but it is actually a design pattern that we use very commonly in daily coding.

Do it!

Modify the code of the Network class to:

 class Network{
 static func request(method: String, url: String, params: Dictionary = Dictionary(), callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let manager = NetworkManager(url: url, method: method, params: params, callback: callback)
 manager.fire()
 }
 }

Done!

Encapsulating multi-level interfaces

Interface without params:

 static func request(method: String, url: String, callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let manager = NetworkManager(url: url, method: method, callback: callback)
 manager.fire()
 }

Two get interfaces (with and without params):

 static func get(url: String, callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let manager = NetworkManager(url: url, method: "GET" , callback: callback)
 manager.fire()
 }
 static func get(url: String, params: Dictionary, callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let manager = NetworkManager(url: url, method: "GET" , params: params, callback: callback)
 manager.fire()
 }

Two post interfaces (with and without params):

 static func post(url: String, callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let manager = NetworkManager(url: url, method: "POST" , callback: callback)
 manager.fire()
 }
 static func post(url: String, params: Dictionary, callback: (data: NSData!, response: NSURLResponse!, error: NSError!) -> Void) {
 let manager = NetworkManager(url: url, method: "POST" , params: params, callback: callback)
 manager.fire()
 }

Test interface

Modify the calling code in ViewController to test the multi-level API:

 @IBAction func mainButtonBeTapped(sender: AnyObject) {
 let url = "http://pitayaswift.sinaapp.com/pitaya.php"   
 
 Network.post(url, callback: { (data, response, error) -> Void in
 println( "POST 1 request successful" )
 })
 Network.post(url, params: [ "post" : "POST Network" ], callback: { (data, response, error) -> Void in
 let string = NSString(data: data, encoding: NSUTF8StringEncoding) as! String
 println( "POST 2 request successful " + string)
 }) 
 
 Network.get(url, callback: { (data, response, error) -> Void in
 println( "GET 1 request successful" )
 })
 Network.get(url, params: [ "get" : "POST Network" ], callback: { (data, response, error) -> Void in
 let string = NSString(data: data, encoding: NSUTF8StringEncoding) as! String
 println( "GET 2 request successful " + string)
 }) 
 
 Network.request( "GET" , url: url, params: [ "get" : "Request Network" ]) { (data, response, error) -> Void in
 let string = NSString(data: data, encoding: NSUTF8StringEncoding) as! String
 println( "Request successful " + string)
 }
 }

Run the project and click the button to see the effect:

Multi-level API encapsulation is successful!

[Editor: chenqingxiang TEL: (010) 68476606]