我试图找到一个简单的例子，说明一个人如何在路由器内部向 vapor 示例端点发送请求 http://example.vapor.codes/json，接收响应并将其映射到结构或类。

我在别处看到过 Vapor 2 的示例，但它们不再与 Vapor 3 相关，并且当前的 Vapor 3 beta 文档不清楚。

有点像...

router.get("sample") { req in

  //1. create client
  //2. send get request to sample endpoint at http://example.vapor.codes/json
  //3. handle response and map to a struct or class

}

我的目标是从端点抓取一些东西，将其转换为结构或类并将其显示在叶 View 中。

{"array":[0,1,2,3],"dict":{"lang":"Swift","name":"Vapor"},"number":123,"string":"test"}

这是我认为如何完成的大纲，但我不明白如何将响应和过程处理到结构中，以便我可以在我的 home.leaf 中使用它的 html(我不关心对于叶部分，假设我拥有所有这些的所有配置并已经导入)。

router.get("example"){ req -> Future<View> in

    struct ExampleData: Codable {
        var array : [Int]
        var dict : [String : String]
    }

    return try req.make(Client.self).get("http://example.vapor.codes/json").flatMap(to: ExampleData.self) { res in
        //not sure what to do to set the values of the ExampleData
    }

    return try req.view().render("home", ExampleData())

}

最佳答案

示例代码

我强烈建议您阅读下面的解释，但这是代码。

struct ExampleData: Codable {
    var array : [Int]
    var dict : [String : String]
}

// Register a GET /example route
router.get("example") { req -> Future<View> in
    // Fetch an HTTP Client instance
    let client = try req.make(Client.self)

    // Send an HTTP Request to example.vapor.codes/json over plaintext HTTP
    // Returns `Future<Response>`
    let response = client.get("http://example.vapor.codes/json")

    // Transforms the `Future<Response>` to `Future<ExampleData>`
    let exampleData = response.flatMap(to: ExampleData.self) { response in
        return response.content.decode(ExampleData.self)
    }

    // Renders the `ExampleData` into a `View`
    return try req.view().render("home", exampleData)
}

future

A Future<Expectation>是 Expectation 的包装器.期望可以成功或失败(出现错误)。

Future 类型可以注册在成功完成时执行的回调。我们在这里使用的回调之一是 flatMap .让我们深入了解常规 map ，首先。

如果你map a Future 你改造 future 的成功Expectation并透明地通过错误条件。

let promise = Promise<String>()
let stringFuture = promise.future // Future<String>
let intFuture = stringFuture.map(to: Int.self) { string -> Int in
    struct InvalidNumericString: Error {}

    guard let int = Int(string) else { throw InvalidNumericString() }

    return int // Int
}

intFuture.do { int in
    print("integer: ", int)
}.catch { error in
    print("error: \(error)")
}

如果我们使用有效的十进制整数格式的字符串来完成 promise ，例如 "4"它会打印 integer: 4

promise.complete("4")

如果我们在其中放置任何非数字字符，例如 "abc"它会在 InvalidNumericString 中抛出错误将触发 catch 的错误 block 。

promise.complete("abc")

无论您做什么，map 都会引发错误或 flatMap函数将通过其他转换透明地级联。改造 future 将改造Expectation只有，并且只有在成功的案例中才会被触发。错误案例将从“基础 future ”复制到新改造的 future 。

如果您未完成 promise 而不是完成 promise ，map block 将永远不会被触发并且 AnyError条件将在 catch 中找到而是阻止。

struct AnyError: Error {}
promise.fail(AnyError())

flatMap与上面的例子非常相似。这是一个map尾随闭包返回 Future<Expectation>而不是 Expectation .

所以如果我们将 map block 重写为 flatMap ，虽然不切实际，但我们最终会得到这个:

let intFuture = stringFuture.flatMap(to: Int.self) { string -> Future<Int> in
    struct InvalidNumericString: Error {}

    guard let int = Int(string) else { throw InvalidNumericString() }

    return Future(int) // Int
}

intFuture仍然是Future<Int>因为递归 future 将从 Future<Future<Int>> 展平只是Future<Int> .

内容

response.content.decode bit 读取 Content-Type 并查找默认的 Decoder对于此内容类型。解码后的结构将作为 Future<DecodedStruct> 返回，在这种情况下，这个结构是 ExampleData .

异步返回内容的原因是因为内容可能还没有完全到达 HTTP 响应。这是一个必要的抽象，因为我们可能会收到超过 100MB 的文件，这可能会导致(云)服务器崩溃，而只有少量可用内存。

逻辑

回到原来的路线:

• 先做一个客户
• 向 http://example.vapor.codes/json 提出请求
• 阅读 Future<Response> 中的内容异步
• 将结果异步呈现到 View 中
• 返回Future<View>

框架会理解你正在返回一个 Future<View>并将继续处理其他请求，而不是等待结果。

一旦收到 JSON，该请求将被再次拾取并处理成您的网络浏览器将收到的响应。

Leaf 建立在 TemplateKit 之上，它将异步等待 future 。就像 Vapor 一样，Leaf 和 TemplateKit 会很好地理解 Futures，以至于您可以传递 Future 而不是结构(反之亦然)，并且如果有必要，它们会切换到另一个请求，直到 future 完成。

关于swift - Vapor 3 Beta 端点请求示例，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/48589415/