Ios Moya/Alamofire-具有相同密钥的URL编码参数

我正在使用Swift框架构建网络层，它构建在

目前，我正在尝试使用具有相同密钥的URL编码参数发送请求

i、 e.

http://some-site/request?param=v1¶m=v2¶m=v3

我已经尝试过像这样将这些参数分组到Set、NSSet或Array中，但没有任何帮助来实现所需的结果

[“param”：[“v1”、“v2”、“v3”]

[“param”：Set（数组并行：“v1”、“v2”、“v3”）]

莫亚或阿拉莫菲尔本人将非常感谢任何帮助

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

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
    /* ... */
})

let endpointsClosure={（目标：ApiRouter）->中的端点
设endpoint=endpoint(
URL:target.baseURL.URLByAppendingPathComponent（target.path）.absoluteString！，
sampleResponse:EndpointSampleResponse.Success（200，{target.sampleData}），
方法：target.method，
参数：target.parameters，
参数编码：参数编码（目标）
)
切换目标{
case.XAuth：
返回端点
违约：
让token=“一些token”
返回endpoint.endpointByAddingHTTPHeaderFields（[“授权”：“承载者：\（令牌）”]））
}
}
func parameterEncoding（目标：ApiRouter）->Moya.parameterEncoding{
切换目标{
case.XAuth：
return.JSON
案例.请求：
return.URL
}
}
让apiProvider=MoyaProvider（endpointsClosure:endpointsClosure）
请求（ApiRouter.SomeRequest）（参数：[“v1”、“v2”、“v3”]，完成：{（数据、状态码、响应、错误）在
/* ... */
})

谢谢。
您可以使用format创建字符串并将其作为请求URL传递：


希望这有帮助！
所以我找到了一个非常简单和明显的解决方案。
在阅读公司文档时，我发现：

由于没有发布关于如何编码集合类型的规范，Alamofire遵循的惯例是，对于数组值（foo[]=1&foo[]=2），将[]附加到键上，对于嵌套的字典值（foo[bar]=baz），将键用方括号括起来

因此，对于这种情况，有一个自定义参数编码选项，该选项采用闭包方式，您可以实际指定自己希望参数如何形成的实现

同样的问题，同样的答案。
Moya是个好主意，但我实际上觉得，经过一些思考，我们可以使用Swift构建一个网络抽象层，而无需太多代码

我们的目标是：


灵活性，能够高效地编辑或添加新端点
可读性，一眼就知道我们的API是如何工作的
代码安全性，带有类型化参数，允许我们期望从Xcode获得的所有预编译好处（完成、验证）
易于调试，意味着能够在web请求前后插入日志

以下是我在一次采访中得到的结果：

公共类API{
公共静态let baseURL:字符串=”http://colourlovers.com/api"
公共枚举终结点{
外壳颜色（字符串）
大小写选项板（字符串）
大小写模式（字符串）
公共var方法：阿拉莫菲尔方法{
切换自身{
箱子，颜色，
.调色板，
.模式：
返回Alamofire.Method.GET
}
}
公共变量路径：字符串{
切换自身{
案例。颜色：
返回baseURL+“/colors”
案例.选项板：
返回baseURL+“/选项板”
案例.模式：
返回baseURL+“/patterns”
}
}
公共变量参数：[字符串：AnyObject]{
var参数=[“格式”：“json”]
切换自身{
大小写颜色（let关键字）：
参数[“关键字”]=关键字
打破
案例.选项板（let关键字）：
参数[“关键字”]=关键字
打破
case.Patterns（let关键字）：
参数[“关键字”]=关键字
打破
}
返回参数
}
}
公共静态func请求(
端点：API.Endpoints，
completionHandler:Response->Void）
->请求{
让请求=Manager.sharedInstance.request(
endpoint.method，
endpoint.path，
参数：endpoint.parameters，
编码：.URL，
标题：无
).responseJSON{中的响应
if（response.result.error）！=nil{
DDLogError（“\n请指定，您的API是“GET”或“POST”"？@SohilR.Memon是GET Request你能发布一些代码吗？你能展示一下你用来test@SohilR.Memon编码什么？！听着，我需要做的是，使用Moya框架发送带有相同密钥的URL参数的GET请求。将您的想法与任何网络和服务器隔离开来，用字符串来考虑这个问题。我n最后，我需要获取此URL字符串
http://some-site/request?param=v1¶m=v2¶m=v3
。它与POST和其他内容无关，只需使用Moya或Alamofire框架使用相同的参数键简单地获取请求。你们知道如何实现这一点吗？所以你们没有使用Moya？我喜欢这个想法。在我工作的当前项目中，network层很有用。应用程序不应该直接接触Alamofire
。额外的网络层可以获得更大的灵活性，但会增加更多的复杂性。什么时候不使用Moya是个好主意？除了使用Moya，还有其他选择吗？有很多libs，你的名字：）你可以使用Alamofire或NSURLSession创建你自己的包装器，这与Moya非常相似，它来自Thoughtbot。事实上，网络层通常是相同的，所以你可以看看它是如何工作的，然后创建你自己的：）@Voronv我看了一下。还有一些东西
String url: String = String(format: "http://some-site/request?param=%@&param=%@&param=%@", v1, v2, v3)

public class API {

public static let baseURL: String = "http://colourlovers.com/api"

public enum Endpoints {

    case Colors(String)
    case Palettes(String)
    case Patterns(String)

    public var method: Alamofire.Method {
        switch self {
        case .Colors,
             .Palettes,
             .Patterns:
            return Alamofire.Method.GET
        }
    }

    public var path: String {
        switch self {
        case .Colors:
            return baseURL+"/colors"
        case .Palettes:
            return baseURL+"/palettes"
        case .Patterns:
            return baseURL+"/patterns"
        }
    }

    public var parameters: [String : AnyObject] {
        var parameters = ["format":"json"]
        switch self {
        case .Colors(let keywords):
            parameters["keywords"] = keywords
            break
        case .Palettes(let keywords):
            parameters["keywords"] = keywords
            break
        case .Patterns(let keywords):
            parameters["keywords"] = keywords
            break
        }
        return parameters
    }
}

public static func request(
    endpoint: API.Endpoints,
    completionHandler: Response<AnyObject, NSError> -> Void)
    -> Request {

        let request =  Manager.sharedInstance.request(
            endpoint.method,
            endpoint.path,
            parameters: endpoint.parameters,
            encoding: .URL,
            headers: nil
            ).responseJSON { response in

                if (response.result.error) != nil {
                    DDLogError("\n<----\n" + response.result.error!.description)
                    completionHandler(response)
                } else {
                    DDLogInfo("\n<----\n" + response.response!.description)
                    completionHandler(response)
                }
        }
        DDLogInfo("\n---->\n" + request.description)
        return request
    }
}