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

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

1. 创建带有 URL 参数的 GET、POST、PUT、DELETE 路由
2. 解析 JSON 消息
3. 在共享资源上处理并发
4. 创建自定义的中间件，允许跨来源请求
   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)..<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,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,completed:Bool) -> TodoItem { 
         
        var original:String 
        original = String(self.idCounter) 
         
        let newItem = TodoItem(id: original,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 文件：

       点击查看代码清单

       目前，我们正在努力编写一个 Build Script 脚本，让您可以在 Bluemix 和其他平台上快速部署用 Kitura 编写的应用程序。

   11. 运行您的服务器：

       ./.build/debug/TodoList

       在可执行文件运行并监听 localhost:8090 上的连接后，您可以使用 TodoBackend 网页来测试应用程序。通过向后端提供地址，该页面可以使用实现了 API 的任何后端。在以下地址查看您的待办事项列表：

       http://todobackend.com/client/index.html?http://localhost:8090

       当完成此操作时，您应该有一个看起来像这样的待办事项列表：

• 上一篇：Hello，服务端 Swift下一篇：Swift: 你好, UIKit!