Moya / Alamofire - 具有相同键的URL编码参数 [英] Moya/Alamofire - URL encoded params with same keys

问题描述

我正在使用 Moya Swift框架来构建基于 Alamofire 。

I'm using Moya Swift framework for networking layer which is constructed on top of Alamofire.

目前，我正在尝试发送请求具有相同键的URL编码参数。

Currently, I'm trying to send request with URL encoded parameters that have same keys.

ie http：// some-site / request？param = v1& param = v2& param = v3

I我们已经尝试将这些参数分组为Set或NSSet或Array，但没有任何帮助可以达到预期的结果。

I've already tried to group these params into Set or NSSet or Array like this but nothing helps to achieve desired result.

[param： [v1，v2，v3]];

[param：Set（ arrayLite：v1，v2，v3）]

任何帮助都可以通过Moya或Alamofire本身获得。

Any help would be appreciated either with Moya or with Alamofire itself.

编辑：下面是一些示例代码，提供基本想法：

Here is some sample code to give basic idea:

Api路由器设置

import Moya

// MARK:- Enum Declaration

enum ApiRouter {
    case XAuth(login: String, password: String)
    case SomeRequest(params: [String])
}

// MARK:- Moya Path

extension ApiRouter: MoyaPath {
    var path: String {
        switch self {
        case .XAuth:
            return "/authorization"
        case .SomeRequest:
            return "/some-request"
        }
    }
}

// MARK:- Moya Target

extension ApiRouter: MoyaTarget {
    private var base: String {
        return "http://some-site"
    }
    var baseURL: NSURL {
        return NSURL(string: base)!
    }

    var parameters: [String: AnyObject] {
        switch self {
        case .XAuth(let login, let password):
            return [
                "email": login,
                "password": password
            ]
        case .SomeRequest(let params):
            return [
                "params": params
            ]
    }

    var method: Moya.Method {
        switch self {
        case .XAuth:
            return .POST
        case .SomeRequest,
            return .GET
        }
    }

    var sampleData: NSData {
        switch self {
        case .XAuth:
            return "{}".dataUsingEncoding(NSUTF8StringEncoding)
        case .ServiceRequests:
            return "{}".dataUsingEncoding(NSUTF8StringEncoding)
        }
    }
}

Api提供商设置

    let endpointsClosure = { (target: ApiRouter) -> Endpoint<ApiRouter> in
    let endpoint = Endpoint<ApiRouter>(
        URL: target.baseURL.URLByAppendingPathComponent(target.path).absoluteString!,
        sampleResponse: EndpointSampleResponse.Success(200, { target.sampleData }),
        method: target.method,
        parameters: target.parameters,
        parameterEncoding: parameterEncoding(target)
    )
    switch target {
    case .XAuth:
        return endpoint
    default:
        let token = "some-token"
        return endpoint.endpointByAddingHTTPHeaderFields(["Authorization": "Bearer: \(token)"])
    }
}

func parameterEncoding(target: ApiRouter) -> Moya.ParameterEncoding {
    switch target {
    case .XAuth:
        return .JSON
    case .SomeRequest:
        return .URL
    }
}

let apiProvider = MoyaProvider(endpointsClosure: endpointsClosure)

apiProvider.request(ApiRouter.SomeRequest(params: ["v1", "v2", "v3"], completion: { (data, statusCode, response, error) in
    /* ... */
})

谢谢。

推荐答案

所以我找到了一个非常简单明了的解决方案。
阅读 Alamofire 的文档，我发现了这一点：

So I found a solution which is actually pretty simple and obvious. Reading Alamofire's documentation I found this:

由于没有关于如何编码集合类型的已发布规范，Alamofire遵循将[]附加到数组值的键的约定（foo [] = 1& foo [] = 2） ，并附加方括号包围的键，用于嵌套字典值（foo [ba r] = baz）。

Since there is no published specification for how to encode collection types, Alamofire follows the convention of appending [] to the key for array values (foo[]=1&foo[]=2), and appending the key surrounded by square brackets for nested dictionary values (foo[bar]=baz).

因此，对于这种情况，自定义 ParameterEncoding 选项，它可以实际指定您希望如何形成参数的实现。

So, for this cases there's Custom ParameterEncoding option which takes closure where you can actually specify your own implementation of how you want parameters to be formed.

这里的答案是同一个问题。

Here's the same question with the same answer.

这篇关于Moya / Alamofire - 具有相同键的URL编码参数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！