Korrekte Verwendung des URLRequestConvertible von Alamofire

Großen Fragen. Lassen Sie uns brechen Sie diese einzeln.

Was ist die richtige Verwendung von URLRequestConvertible in der realen Welt API?

Den URLRequestConvertible - Protokoll ist eine einfache Möglichkeit, um sicherzustellen, die ein bestimmtes Objekt erstellen können, die eine gültige NSURLRequest. Es gibt nicht wirklich einen strikten Satz von Regeln oder Richtlinien existieren, zwingt Sie zur Verwendung dieses Protokolls in einer bestimmten Art und Weise. Es ist nur eine Bequemlichkeit-Protokoll zu ermöglichen, andere Objekte zu speichern Zustand benötigt, um richtig zu erstellen, die NSURLRequest. Einige weitere Informationen in Bezug auf Alamofire finden hier.

Sollte ich ein Router pro Endpunkt?

Definitiv nicht. Das würde die Niederlage der ganze Zweck der Verwendung eines Enum. Swift Enum-Objekte sind erstaunlich leistungsfähig, sodass Sie teilen eine große Menge an gemeinsamen Staat, und wechseln Sie auf die Teile, die tatsächlich anders. Die Erstellung eines NSURLRequest mit etwas so einfaches wie das folgende ist wirklich mächtig!

let URLRequest: NSURLRequest = Router.ReadUser("cnoon")

Ich kann nicht herausfinden, warum enum wird verwendet für Gebäude-router? Warum benutzen wir keine Klasse mit statischen Methoden?

Enum wird verwendet, weil es ist sehr viel präziser Ausdruck mehrerer verwandter Objekte unter einem gemeinsamen interface. Alle Methoden sind geteilt zwischen den Fällen. Wenn Sie statische Methoden, Sie müsste eine statische Methode für jeden einzelnen Fall für jede Methode. Oder Sie verwenden würde eine Obj-C Stil enum innerhalb des Objekts. Hier ein kurzes Beispiel, was ich meine.

enum Router: URLRequestConvertible {
    static let baseURLString = "http://example.com"

    case CreateUser([String: AnyObject])
    case ReadUser(String)
    case UpdateUser(String, [String: AnyObject])
    case DestroyUser(String)

    var method: Alamofire.HTTPMethod {
        switch self {
        case .CreateUser:
            return .post
        case .ReadUser:
            return .get
        case .UpdateUser:
            return .put
        case .DestroyUser:
            return .delete
        }
    }

    var path: String {
        switch self {
        case .CreateUser:
            return "/users"
        case .ReadUser(let username):
            return "/users/\(username)"
        case .UpdateUser(let username, _):
            return "/users/\(username)"
        case .DestroyUser(let username):
            return "/users/\(username)"
        }
    }
}

Um die Methode, die von jedem der verschiedenen Endpunkte können Sie die gleiche Methode, die zimmerreserviereung, ohne das Sie übergeben alle Parameter, die definieren, welche Art von Endpunkt die Sie suchen, es ist schon erledigt der Fall, Sie wählen.

let createUserMethod = Router.CreateUser.method
let updateUserMethod = Router.UpdateUser.method

Oder wenn Sie wollen, um den Pfad, gleiche Art der Anrufe.

let updateUserPath = Router.UpdateUser.path
let destroyUserPath = Router.DestroyUser.path

Versuchen wir nun den gleichen Ansatz mit statischen Methoden.

struct Router: URLRequestConvertible {
    static let baseURLString = "http://example.com"

    static var method: Method {
        //how do I pick which endpoint?
    }

    static func methodForEndpoint(endpoint: String) -> Method {
        //but then I have to pass in the endpoint each time
        //what if I use the wrong key?
        //possible solution...use an Obj-C style enum without functions?
        //best solution, merge both concepts and bingo, Swift enums emerge
    }

    static var path: String {
        //bummer...I have the same problem in this method too.
    }

    static func pathForEndpoint(endpoint: String) -> String {
        //I guess I could pass the endpoint key again?
    }

    static var pathForCreateUser: String {
        //I've got it, let's just create individual properties for each type
        return "/create/user/path"
    }

    static var pathForUpdateUser: String {
        //this is going to get really repetitive for each case for each method
        return "/update/user/path"
    }

    //This approach gets sloppy pretty quickly
}

HINWEIS: Wenn Sie haben nicht viele Eigenschaften oder Funktionen, die Schalter auf die Fälle, dann ein enum nicht präsentieren viele Vorteile gegenüber einem struct. Es ist einfach ein alternativer Ansatz, der mit verschiedenen syntaktischen Zucker.

Enums können maximieren Zustand und die Wiederverwendung von code. Die zugehörigen Werte können Sie auch tun, einige wirklich wichtige Dinge wie die Gruppierung von Objekten, die sind etwas ähnlich, aber haben unglaublich unterschiedliche Anforderungen...wie NSURLRequest Schöpfung.

Was ist die richtige Art und Weise zu konstruieren Parameter für enum Fällen um die Lesbarkeit zu verbessern? (hatte zu Brei das man zusammen)

Das ist eine tolle Frage. Sie haben bereits verlegt, die aus zwei möglichen Optionen. Lassen Sie mich noch einen Dritten, der Ihre Anforderungen anpassen können ein bisschen besser.

case CreateUser(username: String, firstName: String, lastName: String, email: String)
case ReadUser(username: String)
case UpdateUser(username: String, firstName: String, lastName: String, email: String)
case DestroyUser(username: String)

In Fällen, In denen Sie die damit verbundenen Werte, ich glaube, es kann hilfreich sein, fügen Sie explizite Namen für alle Werte der Tupel. Diese wirklich hilft, bauen im Kontext. Der Nachteil ist, dass Sie dann deklarieren Sie diese Werte in Ihre switch-Anweisungen so gerne.

static var method: String {
    switch self {
    case let CreateUser(username: username, firstName: firstName, lastName: lastName, email: email):
        return "POST"
    default:
        return "GET"
    }
}

Während dies gibt Ihnen eine schöne, konsistente Rahmen, es wird ziemlich ausführlich. Das sind Ihre drei Möglichkeiten, in dem moment, in Swift, welches ist das richtige verwenden, hängt von Ihrem Anwendungsfall.

Update

Mit der Veröffentlichung von ?? Alamofire 4.0 ??, die URLRequestConvertible können jetzt VIEL klüger und können auch werfen. Wir haben Hinzugefügt volle Unterstützung in Alamofire für die Handhabung von ungültigen requests und Generierung sinnvoll, Fehler, die durch die response-Handler. Dieses neue system dokumentiert, die im detail in unserem README.

InformationsquelleAutor der Antwort cnoon

Habe ich einen Weg gefunden, mit ihm zu arbeiten, habe ich mir eine Klasse mit dem Router:
Erben von Klassen aus einer Anfrage

Datei anfordern.swift

class request{

    func login(user: String, password: String){
        /*use Router.login(params)*/
    }
    /*...*/
    enum Router: URLRequestConvertible {
        static let baseURLString = "http://example.com"
        static let OAuthToken: String?

        case Login([String: AnyObject])
        /*...*/

        var method: Alamofire.Method {
            switch self {
            case .Login:
                return .POST
            /*...*/
        }

        var path: String {
            switch self {
            case .Login:
                return "/login"
            /*...*/
            }
        }

        var URLRequest: NSURLRequest {
            switch self {
                case .Login(let parameters):
                    return Alamofire.ParameterEncoding.URL.encode(mutableURLRequest, parameters: parameters).0
                /*...*/
                default:
                    return mutableURLRequest
            }
        }
    }
}

Datei requestContacts.swift

class requestContacts: api{

    func getUser(id: String){
        /*use Router.getUser(id)*/
    }
    /*...*/

    enum Router: URLRequestConvertible {

        case getUser(id: String)
        case setUser([String: AnyObject])

        var method: Alamofire.Method {
            switch self {
                case .getUser:
                    return .GET
                case .setUser:
                    return .POST
                /*...*/
            }
        }

        var path: String {
            switch self {
            case .getUser(id: String):
                return "/user\(id)/"
            case .setUser(id: String):
                return "/user/"
            /*...*/
            }
        }
        //MARK: URLRequestConvertible

        var URLRequest: NSURLRequest {
            //use same baseURLString seted before
            let URL = NSURL(string: Router.baseURLString)!
                let mutableURLRequest = NSMutableURLRequest(URL: URL.URLByAppendingPathComponent(path))
                mutableURLRequest.HTTPMethod = method.rawValue

            if let token = Router.OAuthToken {
                mutableURLRequest.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
            }
            switch self {
                /*...*/
                case .setUser(let parameters):
                    return Alamofire.ParameterEncoding.URL.encode(mutableURLRequest, parameters: parameters).0
                default: //for GET methods, that doesent need more
                    return mutableURLRequest
            }
        }
    }
}

so der Sohn-Klasse erhalten paramethers der Router von der Mutter, und Sie können sogar die Route.login in irgendeiner Sohn.
immer noch, weiß nicht, ob es ist ein Weg, um eine kurze URLRequest, so dass ich nicht brauchen, um die Parameter wieder und wieder

InformationsquelleAutor der Antwort David Alejandro Londoño Mejía

Typen die Annahme der URLRequestConvertible Protokoll kann verwendet werden, zum erstellen von URL-Anfragen.

Hier ist ein Beispiel, genommen von http://www.raywenderlich.com

public enum ImaggaRouter : URLRequestConvertible{

  static let baseURL = "http://api.imagga.com/v1"
  static let authenticationToken = "XAFDSADGDFSG DAFGDSFGL"

  case Content, Tags(String), Colors(String)

  public var URLRequest: NSMutableURLRequest {
    let result: (path: String, method: Alamofire.Method, parameters: [String: AnyObject]) = {
      switch self {
      case .Content:
        return ("/content", .POST, [String: AnyObject]())
      case .Tags(let contentID):
        let params = [ "content" : contentID ]
        return ("/tagging", .GET, params)
      case .Colors(let contentID):
        let params = [ "content" : contentID, "extract_object_colors" : NSNumber(int: 0) ]
        return ("/colors", .GET, params)
      }
    }()

    let URL = NSURL(string: ImaggaRouter.baseURL)!
    let URLRequest = NSMutableURLRequest(URL: URL.URLByAppendingPathComponent(result.path))
    URLRequest.HTTPMethod = result.method.rawValue
    URLRequest.setValue(ImaggaRouter.authenticationToken, forHTTPHeaderField: "Authorization")
    URLRequest.timeoutInterval = NSTimeInterval(10 * 1000)

    let encoding = Alamofire.ParameterEncoding.URL
    return encoding.encode(URLRequest, parameters: result.parameters).0
  }
}

und wir können das ImmageRouter wie die folgenden:

Alamofire.request(ImaggaRouter.Tags(contentID))
      .responseJSON{ response in

InformationsquelleAutor der Antwort Abo3atef