转载

使用 Swift 与 Kitura 构建端到端的云应用程序

Kitura 简介

Kitura 是一个轻量级 Web 框架，使您能够轻松地构建具有复杂路由的 Web 服务。它的许多设计灵感来自 Express.js ，后者在特定 URL 路由和可插拔中间件的整体设计上取得了成功。Kitura 采用了这些原则，并扩大了 Swift 的优势，其中一些优势包括：

编译原生代码
类型安全
多种选择
基于核心运算优化技术 (Grand Central Dispatch) 的多道编程

这些功能结合在一起，可以为可扩展和强大的 Web 框架提供基础。

这使得应用程序的移动前端和后端部分都可以采用相同的语言编写。

此外，习惯使用其他路由框架（如，Express、Sinatra 或 Flask）的 Web 开发人员将能够轻松地创建 Web 应用程序或将其转换为 Swift 语言。

创建待办事项应用程序

在本教程中，我们遵循为基于 Web 的待办事项列表 TodoMVC 创建的 API。您可以在 TodoBackend 上查看同一个 API 的许多框架和语言实现。我们将使用 Swift 实现我们自己的版本。如果您想获得已完成项目的源代码，请访问：

Kitura-TodoList

在这个过程中，您将学习：

创建带有 URL 参数的 GET、POST、PUT、DELETE 路由
解析 JSON 消息
在共享资源上处理并发
创建自定义的中间件，允许跨来源请求
1. 设置 Mac 或 Linux 环境来运行 Kitura
  Kitura 应用程序同时支持 Mac OS X 和 Linux 操作系统。由于 Foundation 和 libDispatch 在每个平台上的实现存在一些差异，如果在 Linux 上运行，指令可能稍有不同。
2. 我们将创建一个目录结构：
```
+-- Package.swift   +-- Sources   |   +-- TodoList   |       +-- main.swift   |       +-- Controllers   |           +-- App.swift   |       +-- Models   |           +-- TodoCollection.swift   |           +-- TodoCollectionArray.swift   |           +-- TodoItem.swift
```
  Swift Package Manager 期望以特定的方式实现文件布局。每个 Swift 项目必须有一个名为 Sources 的目录。对于 Sources 内的每个子目录，软件包管理器将构建一个可执行文件或一个 Swift 模块。例如，由于我们的子目录名为 TodoList，里面有一个 main.swift 文件，所以该构建将生成一个 TodoList 可执行文件。我们选择将 TodoCollection 和 TodoItem 放入 Models 中，并将 App.swift 放入 Controllers 中，这只是我们组织代码的方式，而不是 Kitura 或 Swift Package Manager 强制采用的方式。
3. 创建一个 Package.swift 文件：
```
import PackageDescription       let package = Package(       name:"TodoList",       dependencies:[         .Package(url:"https://github.com/IBM-Swift/Kitura-router.git", majorVersion:0),         .Package(url:"https://github.com/IBM-Swift/HeliumLogger.git",   versions:Version(0,0,0)..<Version(0,1,0))       ]   )
```
4. 创建一个 main.swift 文件：
  
  要在您的应用程序中使用 Kitura，需要将核心模块导入 Kitura 项目。Kitura 被组织为一些模块的集合，这使得 Kitura 变得高度可扩展。例如，KituraSys 在 Kitura 项目中提供的所有模块都可以使用的通用实用程序，KituraNet 提供一个 HTTP 服务器实现，而 KituraRouter 为分析和匹配正则表达式提供了支持。
```
import KituraRouter   import KituraNet   import KituraSys
```
  在 main.swift 文件中，我们将设置 Kitura 路由器，以及我们的待办事项集合，然后指示 HTTPServer 侦听端口 8090 上的新连接。
```
///   /// The Kitura router   ///   let router = Router()
```
  我们将在名为 ‘ todos ’ 的共享资源 DAO（Data Access Object，数据访问对象）中存储待办事项。DAO 协议以后将会支持更多强大的数据库。在以后的博客中，我们将会用到使用了这个 TodoColeccion DAO 的 Cloudant。
```
///   /// Setup the database   ///   let todos:TodoCollection = TodoCollectionArray()
```
  创建一个名为 Controllers/App.swift 的文件。在这里，我们将定义一个名为 setupRoutes 的函数，main.swift 文件会调用这个函数来设置我们的路由。我们将用该函数传递对路由器的引用和数据访问对象：
```
///   /// Call a helper function to create routes in App.swift   ///   setupRoutes( router, todos: todos )
```
  最后回到您的 main.swift 文件，设置一个 HTTP 服务器来侦听端口 8090：
```
///   /// Listen to port 8090   ///   let server = HttpServer.listen(8090, delegate: router)       Server.run()
```
5. 设置中间件，解析 setupRoutes 的 App.swift 文件中的客户端请求正文内传入的 JSON：
```
router.use("/*", middleware:BodyParser())
```
  BodyParser 使得路由器能够解析描述列表项目的标题及其位置的 JSON 消息。
6. 创建一个路由，返回一个包含所有的待办事项列表项的 JSON：
  
  Kitura 支持多种 HTTP 方法类型，例如 GET、POST、PUT 和 DELETE。我们用正则表达式 ‘ / ’ 匹配传入的请求，当出现这种匹配时，会调用所提供的闭包。输入到闭包中的参数是请求、响应和下一个元素。请求包含标头信息和正文。响应对象用来序列化输出到客户端的数据、JSON 或纯文本。还可以在这里指定内容类型。方法 ‘ next ’ 是应在处理程序块的最后调用的闭包。通过调用 ‘ next ’，路由器可以继续处理与正则表达式匹配的下一个元素。如果想确保在当前路由后不处理其他匹配的路由，可以省略 next() 调用。
```
router.get("/") {      request, response, next in           let json = JSON(TodoCollectionArray.serialize(todos.getAll()))           response.status(HttpStatusCode.OK).sendJson(json)           next()   }
```
  在这个代码段中，使用 SwiftyJSON 库将待办事项列表的 Dictionary 表示形式转换为 JSON String。如果调用 sendJson()，则会发送该 String，并将响应的标头 ‘ Content-Type ’ 设置为 ‘ application/json ’。
7. 创建一条路由来添加待办事项列表项：
  
  当客户需要添加一个待办事项列表项时，他们会在请求正文中添加一个 JSON 字符串，描述列表项的标题、将列表项插入列表中所需的顺序（位置），以及任务是否已经完成。因此，我们在处理程序中解析 JSON 消息，并获得每个字段：
```
///   /// Add a to-do list item   ///   router.post("/") {       request, response, next in           if let body = request.body {                   if let json = body.asJson() {                       let title = json["title"].stringValue                   let order = json["order"].intValue                   let completed = json["completed"].boolValue                       let newItem = todos.add(title, order: order, completed: completed)                       let result = JSON(newItem.serialize())                       response.status(HttpStatusCode.OK).sendJson(result)                   }           } else {               Log.warning("No body")               response.status(HttpStatusCode.BAD_REQUEST)           }       }
```
  在上述代码中，request.body 将请求的正文作为一个 Optional 返回。如果 Optional 为空，则返回一个 Bad Request 响应。如果正文存在，我们会试图解析 JSON；如果成功解析，则会使用 DAO 将列表项写入数据库，并将新创建的列表项的 TodoItem 返回给客户端。
8. 在 Models/TodoCollection.swift 中创建一个 DAO 协议：
```
protocol TodoCollection {       var count:Int { get }       func clear()       func getAll() -> [TodoItem]       static func serialize(items:[TodoItem]) -> [JSONDictionary]       func add(title:String, order:Int, completed:Bool) -> TodoItem       func update(id:String, title:String?, order:Int?, completed:Bool?)-> TodoItem?       func delete(id:String)   }
```
9. 在 Models/TodoItem.swift 中创建 TodoItem 模型：
  
  对于模型对象，我们需要能够轻松地将结构序列化到 Swift Dictionary。我们创建一个序列化函数来处理这种转换：
```
struct TodoItem {       var id:String = ""      var order:Int = 0       var title:String = ""      var completed:Bool = false       var url:String = ""          func serialize() -> JSONDictionary {           var result = JSONDictionary()           result["id"] = id           result["order"] = order           result["title"] = title           result["completed"] = completed           result["url"] = url           return result       }    }
```
10. 在 Models/TodoCollectionArray.swift 中实现 TodoCollection DAO
  
  在我们的实现中，我们不会使用数据库或内存中数据库。我们有一些库可用于集成 Redis 和 CouchDB 。
  
  我们会将列表项存储在内存中的 Dictionary 内。
```
private var _collection = [String:TodoItem]()
```
  由于 Kitura 是多线程的，所以在写入共享对象 TodoColeccion 时要小心谨慎。我们将使用来自 KituraSys 的 Queue 同步处理写入操作。您可以使用以下代码创建一个队列：
```
let writingQueue = Queue(type:.SERIAL, label:"Writing Queue")
```
  在 iOS 上，使用 NSOperationQueue 创建 Queue。由于开源 Swift 还没有提供 NSOperation 和 NSoperationQueue 实现，所以我们将直接调用 libDispatch 库来处理同步和异步操作。目前，Kitura 的线程模型很简单。有一个线程不断侦听新的连接；在已经建立连接时，会再生成出一个线程来处理 ClientRequest。在将来，我们希望能够转移到线程池。
  
  在下面的代码中，我们定义了一个修改集合的闭包，并将它传递给同步队列：
```
func add(title:String, order:Int, completed:Bool) -> TodoItem {               var original:String           original = String(self.idCounter)                       let newItem = TodoItem(id: original,               order: order,               title: title,               completed: false,               url: self.baseURL + "/" + original           )               writingQueue.queueSync() {                   self.idCounter+=1                   self._collection[original] = newItem            }               Log.info("Added /(title)")               return newItem           }
```
  在执行该代码后，我们将返回所创建的帖子的 TodoItem，以便可以将其序列化为 JSON，然后发送回客户端。
  
  要删除与某个 id 匹配的对象：
```
func delete(id:String) {           writingQueue.queueSync() {               self._collection.removeValueForKey(id)           }   }
```
  序列化函数将会遍历 List，并将 TodoItem 列表转换成 Dictionary 列表：
```
static func serialize(items:[TodoItem]) -> [JSONDictionary] {     return items.map { $0.serialize() }   }
```
  实现对后端的跨来源请求
  
  我们将使用托管在 http://todobackend.com 的现有的前端 JavaScript 应用程序。由于该应用程序需要对不同域中运行的后端发出请求，我们需要实现跨来源请求。为此，我们为应用程序中的每条路由都添加了一个响应标头，以返回标头 Access-Control-Allow-Origin:*。路由中间件可以很好地实现此目标，因为我们可以拦截请求，添加这些标头，然后把它提供给为某个特殊的路由和方法注册的处理程序。请注意 next() 调用。该调用很重要，可以让其他路由元素继续进行匹配。
  
  将以下类定义添加到您的 Controllers/App.swift 文件：
```
class AllRemoteOriginMiddleware:RouterMiddleware {       func handle(request:RouterRequest, response:RouterResponse, next:() -> Void) {           response.setHeader("Access-Control-Allow-Origin", value:"*")           response.setHeader("Access-Control-Allow-Headers", value:"accept, content-type")           response.setHeader("Access-Control-Allow-Methods", value:"GET,HEAD,POST,DELETE,OPTIONS,PUT")           next()       }   }       router.use("/*", middleware:AllRemoteOriginMiddleware())
```
  目前，我们正在努力编写一个 Build Script 脚本，让您可以在 Bluemix 和其他平台上快速部署用 Kitura 编写的应用程序。
11. 运行您的服务器：
```
./.build/debug/TodoList
```
  在可执行文件运行并监听 localhost:8090 上的连接后，您可以使用 TodoBackend 网页来测试应用程序。通过向后端提供地址，该页面可以使用实现了 API 的任何后端。在以下地址查看您的待办事项列表：
  
  http://todobackend.com/client/index.html?http://localhost:8090
  
  当完成此操作时，您应该有一个看起来像这样的待办事项列表：