Wie man einen Wert von Alamofire zurückgibt

Mache ich url-Aufrufe, die durch eine API, die ich erstellt mit swift wie folgt:

class API {

  let apiEndPoint = "endpoint"
  let apiUrl:String!
  let consumerKey:String!
  let consumerSecret:String!

  var returnData = [:]

  init(){
    self.apiUrl = "https://myurl.com/"
    self.consumerKey = "my consumer key"
    self.consumerSecret = "my consumer secret"
  }

  func getOrders() -> NSDictionary{
    return makeCall("orders")
  }

  func makeCall(section:String) -> NSDictionary{

    let params = ["consumer_key":"key", "consumer_secret":"secret"]

    Alamofire.request(.GET, "\(self.apiUrl)/\(self.apiEndPoint + section)", parameters: params)
        .authenticate(user: self.consumerKey, password: self.consumerSecret)
        .responseJSON { (request, response, data, error) -> Void in
            println("error \(request)")
            self.returnData = data! as NSDictionary
    }
    return self.returnData
  }

}

Nenne ich diese API in mein UITableViewController zum Auffüllen der Tabelle mit SwiftyJSON Bibliothek. Aber mein returnData von der API, das ist immer leer. Es gibt kein problem mit Alomofire Anrufe, wie kann ich erfolgreich abrufen Wert. Mein problem ist, wie soll ich tragen diese data über meinen Tisch view controller?

var api = API()
api.getOrders()
println(api.returnData) // returnData is empty

Kommentar zu dem Problem

In keinem Zusammenhang zu deiner ursprünglichen Frage, ich bin überhaupt nicht zuversichtlich, wie bist du mit dem consumer-key und das secret (bist du mit dem Alamofire authenticate - Prozess, aber dabei etwas merkwürdiges mit den Parametern). Es ist wohl eine oder die andere. Es ist eine Funktion Ihres web-service-API, so können wir nicht beantworten, hier, aber dies ist sicherlich nicht korrekt. Kommentarautor: Rob

Es ist, wie die service-API, die ich verwenden soll. Dokumentation schlägt vor, die übergabe der Schlüssel und das Geheimnis, wie Benutzername und Kennwort für die basic-Authentifizierung. Kommentarautor: u54r

OK, wenn es wirklich die Standardauthentifizierung verwendet, dann verwenden Sie die authenticate Funktion, aber was ist dann der Zweck der params Wörterbuch? Hey, was auch immer funktioniert, aber es scheint neugierig zu machen, sowohl authenticate übergeben und auth-details wieder, die als Parameter an die Abfrage... Kommentarautor: Rob

InformationsquelleAutor der Frage u54r | 2014-12-09

Als mattt Punkte aus, Alamofire ist die Rückgabe von Daten asynchron über eine completionHandler Muster, so müssen Sie das gleiche tun. Sie können nicht nur return den Wert sofort, sondern Sie stattdessen verwenden möchten Void zurück geben und stattdessen einen Abschluss-handler-Schließung Muster.

In Swift 3 und Alamofire 4, das Aussehen könnte:

func getOrders(completionHandler: @escaping (NSDictionary?, Error?) -> ()) {
    makeCall("orders", completionHandler: completionHandler)
}

func makeCall(_ section: String, completionHandler: @escaping (NSDictionary?, Error?) -> ()) {
    let params = ["consumer_key":"key", "consumer_secret":"secret"]

    Alamofire.request("\(apiUrl)/\(apiEndPoint + section)", parameters: params)
        .authenticate(user: consumerKey, password: consumerSecret)
        .responseJSON { response in
            switch response.result {
            case .success(let value):
                completionHandler(value as? NSDictionary, nil)
            case .failure(let error):
                completionHandler(nil, error)
            }
    }
}

Dann, wenn Sie es aufrufen möchten, verwenden Sie diese completionHandler parameter (in nachfolgende Schließung, wenn Sie wollen):

let api = API()
api.getOrders() { responseObject, error in
    //use responseObject and error here

    print("responseObject = \(responseObject); error = \(error)")
    return
}

// but don't try to use them here

InformationsquelleAutor der Antwort Rob

10

Aus der Alamofire README (Hervorhebung Hinzugefügt):

Vernetzung in Alamofire erfolgt asynchron. Asynchrone Programmierung kann eine Quelle der frustration für Programmierer, die nicht mit dem Konzept, aber es gibt sehr gute Gründe, es zu tun auf diese Weise.

Statt der Sperrung der Ausführung zu warten, bis eine Antwort vom server, wird ein callback angegeben ist, behandeln die Antwort, sobald es empfangen. Das Ergebnis einer Anfrage ist nur innerhalb des Gültigkeitsbereichs einer response handler. Jede Ausführung abhängig von der Reaktion oder vom server empfangenen Daten muss getan werden, innerhalb einer handler -.

InformationsquelleAutor der Antwort mattt

Folgenden ist der vollständige Fluss für die Durchführung der 'Login Action' mit Alamofire und Swift.

Alamofire v3.3
Swift-2.2
Xcode 7.3

Habe ich verwendet GCD und MBProgressHUD für meine eigene Bequemlichkeit. Umgestalten und nutzen, wie Sie möchten 🙂

func loginBtnTapped(sender: AnyObject) {

    MBProgressHUD.showHUDAddedTo(self.view, animated: true)

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {

        let loginInfo : Dictionary<String,AnyObject> = ["email":"[email protected]","password":"abc123"]

        self.loginUser(loginInfo) { responseObject, error in

            print("\(responseObject) \n  \(error) ")

            //Parsing JSON Below
            let status = Int(responseObject?.objectForKey("status") as! String)
            if status == 1 {
                //Login Successfull...Move To New VC
            }
            else {
                print(responseObject?.objectForKey("message"))! as! String)
            }
            return
        }
        dispatch_async(dispatch_get_main_queue()) {
            MBProgressHUD.hideHUDForView(self.view, animated: true)
        }
    }

}


func loginUser(parameters:NSDictionary, completionHandler: (NSDictionary?, NSError?) -> ()) {

    self.postRequest("http://qa.company.com/project/index.php/user/login",
                     paramDict: parameters as? Dictionary<String, AnyObject>,
                     completionHandler: completionHandler)
}

func postRequest(urlString: String, paramDict:Dictionary<String, AnyObject>? = nil,
                 completionHandler: (NSDictionary?, NSError?) -> ()) {

    Alamofire.request(.POST, urlString, parameters: paramDict)
        .responseJSON { response in
            switch response.result {
            case .Success(let JSON):
                completionHandler(JSON as? NSDictionary, nil)
            case .Failure(let error):
                completionHandler(nil, error)
            }
    }

}

InformationsquelleAutor der Antwort n.by.n

Parsen einer json mit Swifty JSON, hier ist, wie ich bin, es zu tun.

Für @Jenita _Alice4Real

func uploadScans(parameters: [String: AnyObject], completionHandler: (AnyObject?, NSError?) -> ()) {
    makePostCall(CommonFunctions().getSaveSKUDataUrl(), parameters: parameters,completionHandler: completionHandler)
}

func makePostCall(url: String, parameters: [String: AnyObject], completionHandler: (AnyObject?, NSError?) -> ()) {
    Alamofire.request(.POST, url, parameters: parameters)
        .responseJSON { response in
            switch response.result {
                case .Success(let value):
                    completionHandler(value, nil)
                case .Failure(let error):
                    completionHandler(nil, error)
            }
    }
}

uploadScans(params) { responseObject, error in
    let json = JSON(responseObject!)
}

InformationsquelleAutor der Antwort kishorer747

Details

xCode 9.1, Swift 4

Features:

Leicht lesbaren code
Bereit Vorlagen (es ist einfach zu fügen Sie mehr Anfragen)
Embedded-Lösung mit asynchroner Datenverarbeitung
Voller Beispiele

Probe 1

Zurückgeben von Daten mithilfe von Schließung

Data1.searchRequest(term: "jack johnson") { json, error  in
     print(error ?? "nil")
     print(json ?? "nil")
     print("Update views")
}

Vollständige Probe 1

Daten Klasse

import Alamofire

class Data1 {

    static fileprivate let queue = DispatchQueue(label: "requests.queue", qos: .utility)
    static fileprivate let mainQueue = DispatchQueue.main

    fileprivate class func make(request: DataRequest, closure: @escaping (_ json: [String: Any]?, _ error: Error?)->()) {
        request.responseJSON(queue: Data1.queue) { response in

            //print(response.request ?? "nil")  //original URL request
            //print(response.response ?? "nil") //HTTP URL response
            //print(response.data ?? "nil")     //server data
            //print(response.result ?? "nil")   //result of response serialization

            switch response.result {
            case .failure(let error):
                Data1.mainQueue.async {
                    closure(nil, error)
                }

            case .success(let data):
                Data1.mainQueue.async {
                    closure((data as? [String: Any]) ?? [:], nil)
                }
            }
        }
    }

    class func searchRequest(term: String, closure: @escaping (_ json: [String: Any]?, _ error: Error?)->()) {
        let request = Alamofire.request("https://itunes.apple.com/search?term=\(term.replacingOccurrences(of: " ", with: "+"))")
        Data1.make(request: request) { json, error in
            closure(json, error)
        }
    }
}

UIViewController

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        //Do any additional setup after loading the view, typically from a nib.

        Data1.searchRequest(term: "jack johnson") { json, error  in
            print(error ?? "nil")
            print(json ?? "nil")
            print("Update views")
        }
    }
}

Probe 2

Zurückgeben von Daten mithilfe von Delegaten

//....
var data = Data2()
data.delegate = self
data.searchRequest(term: "jack johnson")
//....

extension ViewController: Data2Delegate {
    func searchRequest(response json: [String : Any]?, error: Error?) {
        print(error ?? "nil")
        print(json ?? "nil")
        print("Update views")
    }
}

Vollständige Probe 2

Daten Klasse

import Alamofire

protocol Data2Delegate: class {
    func searchRequest(response json: [String: Any]?, error: Error?)
}

class Data2 {

    fileprivate let queue = DispatchQueue(label: "requests.queue", qos: .utility)
    fileprivate let mainQueue = DispatchQueue.main

    weak var delegate: Data2Delegate?

    fileprivate func make(request: DataRequest, closure: @escaping (_ json: [String: Any]?, _ error: Error?)->()) {
        request.responseJSON(queue: queue) { response in

            //print(response.request ?? "nil")  //original URL request
            //print(response.response ?? "nil") //HTTP URL response
            //print(response.data ?? "nil")     //server data
            //print(response.result ?? "nil")   //result of response serialization

            switch response.result {
            case .failure(let error):
                self.mainQueue.async {
                    closure(nil, error)
                }

            case .success(let data):
                self.mainQueue.async {
                    closure((data as? [String: Any]) ?? [:], nil)
                }
            }
        }
    }

    func searchRequest(term: String) {
        let request = Alamofire.request("https://itunes.apple.com/search?term=\(term.replacingOccurrences(of: " ", with: "+"))")
        make(request: request) { json, error in
            self.delegate?.searchRequest(response: json, error: error)
        }
    }
}

UIViewController

import UIKit

class ViewController: UIViewController {
    private var data = Data2()
    override func viewDidLoad() {
        super.viewDidLoad()
        //Do any additional setup after loading the view, typically from a nib.

        data.delegate = self
        data.searchRequest(term: "jack johnson")
    }
}

extension ViewController: Data2Delegate {
    func searchRequest(response json: [String : Any]?, error: Error?) {
        print(error ?? "nil")
        print(json ?? "nil")
        print("Update views")
    }
}

Probe 3

Zurückgeben von Daten mithilfe von PromiseKit

_ = data.searchRequest(term: "jack johnson").then { response in
      print(response.error ?? "nil")
      print(response.json ?? "nil")
      print("Update views")
      return .void
}

Vollständige Probe 3

Daten-Klasse
import Alamofire
import PromiseKit

class Data3 {

    fileprivate let queue = DispatchQueue(label: "requests.queue", qos: .utility)
    fileprivate let mainQueue = DispatchQueue.main

    fileprivate func make(request: DataRequest) -> Promise<(json:[String: Any]?, error: Error?)> {
         return Promise { fulfill, reject in
            request.responseJSON(queue: queue) { response in

                //print(response.request ?? "nil")  //original URL request
                //print(response.response ?? "nil") //HTTP URL response
                //print(response.data ?? "nil")     //server data
                //print(response.result ?? "nil")   //result of response serialization

                switch response.result {
                    case .failure(let error):
                        self.mainQueue.async {
                            fulfill((nil, error))
                        }

                    case .success(let data):
                        self.mainQueue.async {
                            fulfill(((data as? [String: Any]) ?? [:], nil))
                        }
                }
            }
        }
    }

    func searchRequest(term: String) -> Promise<(json:[String: Any]?, error: Error?)> {
        let request = Alamofire.request("https://itunes.apple.com/search?term=\(term.replacingOccurrences(of: " ", with: "+"))")
        return make(request: request)
    }
}

extension AnyPromise {

    class var void: AnyPromise {
        return AnyPromise(Promise<Void>())
    }
}

UIViewController

import UIKit
import PromiseKit

class ViewController: UIViewController {
    private var data = Data3()
    override func viewDidLoad() {
        super.viewDidLoad()
        //Do any additional setup after loading the view, typically from a nib.

        _ = data.searchRequest(term: "jack johnson").then { response in
            print(response.error ?? "nil")
            print(response.json ?? "nil")
            print("Update views")
            return .void
        }
    }
}

InformationsquelleAutor der Antwort Vasily Bodnarchuk

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.