如何使用 Swift、Foursquare API 及 Realm 构建一款 Coffee Shop 应用

class ViewController: UIViewController, MKMapViewDelegate, CLLocationManagerDelegate

func locationManager(manager: CLLocationManager, didUpdateToLocation newLocation: CLLocation, fromLocation oldLocation: CLLocation) {      if let mapView = self.mapView {          let region = MKCoordinateRegionMakeWithDistance(newLocation.coordinate, distanceSpan, distanceSpan)          mapView.setRegion(region, animated: true)      }  }

这个方法又在做什么呢？

• 首先，方法名是 locationManager:didUpdateToLocation:fromLocation 。这个方法使用了命名参数，说明他的方法名会随着参数名的不同而不同（变量在方法内部）。简言之，这个方法有三个参数：调用该方法的 location manager，最新的 GPS 坐标，上一次的 GPS 坐标。
• 在方法内部，先使用可选绑定对 self.mapView 解包。当 self.mapView 不为 nil 时， mapView 变量就是它解包以后的值，然后执行 if 条件中的对应语句。
• 在 if 语句中，根据新的 GPS 坐标与之前定义的 distanceSpan 两个值，计算得到 region 值。这句代码创建了一个以 newLocation 为中心，500 * 500 的一个矩形区域（500 就是 distanceSpan 的值）。
• 最后，调用 map view 的 setRegion 方法。 animation 参数设为 true ，这样 region 改变就会有动画。换句话说：地图可能会有平移或缩放操作，所以要保证他每次都能显示 500 * 500 的区域。

最后一件事，为了让用户同意地理位置授权，你需要在 Xcode 中设置一个特别的授权请求。这个请求要用一句话涵盖为什么要获取用户地理位置。iPhone 会在申请授权时，弹框显示这句话（即在调用 requestAlwaysAuthorization() 方法时）。

配置请求的步骤如下：

1. 在工程目录中打开 info.plist 文件。
2. 右键点击列表，选择 Add Row。
3. 在 key 列，填入 NSLocationAlwaysUsageDescription 。
4. 在 type 列，将类型改为 String 。
5. 在 value 列，填入 We need to get your location! （译者注：这个 value 就是申请授权并弹框时，显示给用户的文本）

运行程序

现在，让我们运行一下程序。确保你选择了相应的 iPhone Simulator，运行快捷键 Command - R 。第一次运行 App ，会弹出是否允许获取地理位置的授权框，选择 Allow，如下图。

当我们点击了 Allow 以后，map view 好像并没有更新位置。这是因为模拟器没有 GPS ，所以…我们需要模拟一下：

当 app 在模拟器上跑起来以后，在以下两种方式中，选择一种进行配置：

• iPhone Simulator: Debug -> Location -> Apple.
• Xcode: Debug -> Simulate Location -> [随便选一个]

当你选择了一个地理位置后，map view 就会定位到对应位置，并缩放到合适的大小。（译者注：可能定位这一步会有点慢，map 半天没有更新或没有图像出来，等等就好了）

搞定了吗？完美！

从 Foursquare 上读取地理信息

你以为到这一步就完了吗？其实并没有，还会有更有趣的事情！我们还需要使用 Das Quadrat 来读取 Foursquare 上的数据，然后用 Realm 将数据存入本地。

在使用 Foursquare 的 API 之前，首先需要到开发者中心注册这个 app 。这个步骤很简单。（译者注：如果只是练习，没必要去注册，直接使用作者提供的 Client ID 和 Client Secret 即可）

• 首先，确保你有一个 Foursquare 账号，没有可以去注册一个： foursquare.com 。
• 然后，进入 developer.foursquare.com ，点击顶部蓝色菜单栏中的 My Apps 。
• 接着，点击右边绿色的 new app 按钮。
• 接着，填写以下信息：
  • App Name： Coffee
  • Download / Welcome page URL: http://example.com
  </li>
• 最后，点击保存
</ul>

保存以后，网页自动跳转到了你创建的 app 页面。记录下 Client ID 和 Client Secret ，之后会用到。（译者注：作者提供的 Client ID 和 Client Secret 在后面的代码里有提供）



构建 Foursquare API 连接

OK，下面开始连接 Foursquare API 。这里我们会用到单例模式。我们要做的部分用单例模式简直是完美。

单例是一个类的实例，它在整个 app 生命周期中，只允许有一份拷贝。所以你不能去创建第二个实例。为什么要使用单例呢？虽然单例的使用饱受争议，但是它有一个明显的优势：可以避免对外部资源发起并发连接。

设想一下。如果对网站同时发起两个请求，并且他们会写入同一个特定的文件，会发送什么呢？这样就很有可能读到脏数据，除非网站知道这两个请求发起的先后顺序。

而单例就能确保只有 app 的一部分能访问外部资源。在单例中，有很多种实现方式能保证没有请求冲突存在。将请求加入队列并添加依赖就是其中一种解决方案。这又是一个很大的主题，本文不进行讲解。

不扯了，继续实现：

• 在工程目录中，右键点击 Coffee 文件夹。
• 选择 New File。
• 选择 iOS -> Source 中的 Swift File ，点击继续。
• 文件命名为 CoffeeAPI.swift ，确认 target 中的 Coffee 是选中状态，选择和其他 swift 文件统计目录，点击 Create ，保存文件。

Whoah，新文件里面空空如也！让我们来加点料吧。在 import 代码的后面，添加以下代码：

import QuadratTouch  import MapKit  import RealmSwift

</div>

然后，添加：

struct API {      struct notifications {          static let venuesUpdated = "venues updated"      }  }

</div>

代码很简洁对吧。首先，你正确地引入了一些需要的库（Quadrat, MapKit, Realm），然后使用 struct 创建了一个名为 venuesUpdated 的静态常量。之后，通过以下方式访问该变量：

API.notifications.venuesUpdated

</div>

接着，键入：

class CoffeeAPI  {      static let sharedInstance = CoffeeAPI()      var session:Session?  }

</div>

以上代码的作用：

• 告诉 Xcode 编译器，当前类名为 CoffeeAPI 。这是一个单独的 Swift 类，没有继承 NSObject 。
• 声明一个静态常量 sharedInstance ，类型为 CoffeeAPI 。这个 sharedInstance 只有 CoffeeAPI 类才能访问，并且在 app 启动的时候就已经被初始化了。
• 声明一个类型为 Session? 的可选变量 session （该类型包含在 Das Quadrat 中）。

之后，我们访问 Coffee API 单例的方式都将是 CoffeeAPI.sharedInstance 。你可以在任何地方，通过这种方式访问单例，并且，访问的都是同一个对象，这也正是单例的一大特点。

接着，需要写一个构造器。给当前类添加以下代码：

init()  {      // Initialize the Foursquare client      let client = Client(clientID: "...", clientSecret: "...", redirectURL: "")        let configuration = Configuration(client:client)      Session.setupSharedSessionWithConfiguration(configuration)        self.session = Session.sharedSession()  }

</div>

构造器是一个会在类实例化的时候调用的方法。这也是实例化时，系统自动调用的第一个方法。

还记得之前在 Foursquare 开发者网站上复制的 Client ID 和 Client Secret 吗？粘贴到下面代码中。可以先不填 redirectURL 参数。向下面这样：

let client = Client(clientID: "X4I3CFADAN4MEB2TEVYUZSQ4SHSTXSZL34VNP4CJHSJGLKPV", clientSecret: "EDOLJK3AGCOQDRKVT2GK5E4GECU42UJUCGGWLTUFNEF1ZXHB", redirectURL: "")

</div>

OK，继续。复制下面的代码，粘贴在 CoffeeAPI 类外面（即最后的大括弧的后面）。

extension CLLocation  {      func parameters() -> Parameters      {          let ll      = "\(self.coordinate.latitude),\(self.coordinate.longitude)"          let llAcc   = "\(self.horizontalAccuracy)"          let alt     = "\(self.altitude)"          let altAcc  = "\(self.verticalAccuracy)"          let parameters = [              Parameter.ll:ll,              Parameter.llAcc:llAcc,              Parameter.alt:alt,              Parameter.altAcc:altAcc          ]          return parameters      }  }

</div>

这又是什么呢？这是一个 extension ，可以给当前类扩展其他的方法（译者注：关于 extension 的知识点，可以查看 SwiftGG 翻译组的其他文章： 扩展基础知识 。延伸到程序结构设计方面，还有进阶的Mixins 比继承更好）。无需创建新的类，就可以给 CLLocation 类扩展一个名为 parameters() 的方法。每次使用 CLLocation 的实例时，这个 extension 就会被加载，你可以通过实例来调用 parameters 方法，即使这个方法没包含在原生的 MapKit 中。

注意：不要混淆 Swift 中 extension 和编程术语 extend 。前者是给基类添加新的方法，后者意思是父类与子类间的继承关系。

parameter 方法返回一个 Parameters 的实例对象。 Parameters 是一个字典，里面包含了一些参数信息（ GPS 坐标和精度）。（译者注： Parameters 是在 Session.swift 中定义的 typealias ，完整定义为： public typealias Parameters = [String:String] ）。

给 Foursquare 发送请求

接下来，让我们从 Foursquare 获取数据吧。Foursquare 内部有一个 HTTP REST API 可以返回 JSON 数据。幸运的是，我们不需要知道这些，因为 Das Quadrat 库已经帮我们搞定了一切。

从 Foursquare 请求数据就和调用 session 里的属性一样简单，同时请求数据使用的是该属性里很多方法中的一个。这个方法返回一个 Task 的实例对象，即异步后台任务的引用。我们可以用闭包的形式实现，代码大致如下：

let searchTask = session.venues.search(parameters)      {          (result) -> Void in            // Do something with "result"      }

</div>

session 里的地理属性包含了与 Foursquare API 通讯的所有 venues 信息。你提供的这个 search 方法是带有参数（上段代码中的 parameters ）的，还有第二个闭包作为参数，该闭包会在 search 方法完成后执行。同时，该方法会返回一个耗时的后台 Task 引用。你可以在任务完成之前用它来停止，或着在你代码的其他地方用它检查进度。

OK，现在来看看下面这个方法。复制并粘贴到你的代码里，即放在初始构造函数的后面，但在 CoffeeAPI 这个类的右括号前面。接下来，我们会看到这个方法的用途。

func getCoffeeShopsWithLocation(location:CLLocation)  {      if let session = self.session      {          var parameters = location.parameters()          parameters += [Parameter.categoryId: "4bf58dd8d48988d1e0931735"]          parameters += [Parameter.radius: "2000"]          parameters += [Parameter.limit: "50"]            // Start a "search", i.e. an async call to Foursquare that should return venue data          let searchTask = session.venues.search(parameters)              {                  (result) -> Void in                    if let response = result.response                  {                      if let venues = response["venues"] as? [[String: AnyObject]]                      {                          autoreleasepool                              {                                  let realm = try! Realm()                                  realm.beginWrite()                                    for venue:[String: AnyObject] in venues                                  {                                      let venueObject:Venue = Venue()                                        if let id = venue["id"] as? String                                      {                                          venueObject.id = id                                      }                                        if let name = venue["name"] as? String                                      {                                          venueObject.name = name                                      }                                        if  let location = venue["location"] as? [String: AnyObject]                                      {                                          if let longitude = location["lng"] as? Float                                          {                                              venueObject.longitude = longitude                                          }                                            if let latitude = location["lat"] as? Float                                          {                                              venueObject.latitude = latitude                                          }                                            if let formattedAddress = location["formattedAddress"] as? [String]                                          {                                              venueObject.address = formattedAddress.joinWithSeparator(" ")                                          }                                      }                                        realm.add(venueObject, update: true)                                  }                                    do {                                      try realm.commitWrite()                                      print("Committing write...")                                  }                                  catch (let e)                                  {                                      print("Y U NO REALM ? \(e)")                                  }                          }                            NSNotificationCenter.defaultCenter().postNotificationName(API.notifications.venuesUpdated, object: nil, userInfo: nil)                      }                  }          }            searchTask.start()      }  }

</div>

这么多代码，你能从里面分辨出它完成的 5 个主要的任务吗？

1. 配置并启动 API 请求。
2. 使用闭包实现请求的 Completion handler。
3. 解析请求返回的数据，并开启 Realm 事务来处理。
4. 使用 for-in 循环遍历所有的地理数据。
5. 在 Completion handler 的最后发送通知。

接下来，让我们一行行的来解释一下：

设置请求的准备动作

首先，使用可选绑定检查 self.session 是否为空。如果非空的话，常量 session 会被赋值解包后的值。

接着， location 的 parameters() 方法被调用。你问这个 location 是从哪里来的？你可以看下 getCoffeeShopsWithLocation 方法后面的那个参数。每次你调用这个方法，你也必须传入一个 location 参数，并检查传入的参数是不是你之前写的。

最后，我们添加了一个新的数据项到 parameters 字典。该数据项使用 Parameter.categoryId 作为 key ，字符串 4bf58dd8d48988d1e0931735 作为 value 。这个字符串就是之前 Foursquare 上 Coffeeshops 目录的编号，因此，没什么特殊的。

配置请求

接着，让我们来配置真正的请求。获取 session 的 venues ，并开始搜寻这个 venues 。该方法有两个参数：你刚才创建的 parameters 字典和闭包。现在使用的闭包的形式叫尾随闭包（ trailing closure ）。它作为该方法的最后一个参数，没有采用圆括号括起来的形式，而是将它写在方法外部并用大括号括起来。这是个很耗时的方法，因此，我们并没有让它自动开始执行，而是在本方法的末尾再执行。

书写闭包

接着，我们进到闭包里去看看。值得注意的一点是，尽管这些代码看上去连续的，但是它们不会一个一个按你看到的顺序执行。该闭包会在搜寻任务完成后执行。当数据从 HTTP API 返回到应用中时，代码会从 let searchTask … 这行执行到 searchTask.start() 这行，接着会跳到 if let response = … 这行。

闭包的格式是这样的： (result) -> Void in 。 result 作为闭包里的参数是可以拿到值的，并且该闭包没有返回值（ Void ）。这一点和普通的方法有点相似。

解析数据

接着，我们使用了 if 可选绑定：

• 如果 result.response 非空，就将其赋值给常量 response ，并继续执行 if 条件内的语句。
• 如果 response[“venues”] 非空，并且可以转换成 [[String: AnyObject]] 类型。

这个类型转换可以确保我们拿到的是正确的类型。如果转换失败，即可选绑定失败，就不会执行 if 条件内的语句。这个方法有一石二鸟的效果：检查对应的值是否为空，同时尝试将数据转换成合适的类型。

你能说一下 venues 的类型是什么吗？首先它是一个数组，每个元素是字典类型，每个字典是以 String 类型为 key ， AnyObject 类型为 value 。

自动释放内存

接着，我们开启了一个自动释放池。自动释放池本身就是一个很大的话题。你知道 iPhone 是如果进行内存管理的吗？

本质上来说，内存里的对象在没有被使用时，会在某个时间点从内存里被移除。有点类似垃圾回收，但还是有点区别的。当自动释放池里的一个变量被释放时，这个变量就和这个自动释放池紧紧联系在一起了。当这个自动释放池自己要被释放时，在内的所有变量的内存也会一起被释放。这个有点像，对内存释放的批处理。

为什么要这么做呢？因为，可以通过创建自己的自动释放池，来帮助 iPhone 系统管理内存。我们在处理数以百计的地理对象时，如果没有放在自己的自动释放池里，内存就会被未释放的内存拥塞了。而，能释放这些内存的时间点是在该方法结束的时候。因此，你在冒着用光内存的风险操作（自动释放的机理导致不会立马释放无用的内存）。使用自己创建的自动释放池，你就可以影响内存释放的时间点并能避免被内存不足困扰。（译者注：ARC 下，在方法内创建的临时变量，系统都会自动加上 __strong 修饰符，并在出该变量作用域时，进行 release 。所以，一般在处理有大量的临时变量的方法时，会自己加上 autoreleasepool ，提前释放已经不用的临时变量，及时释放内存。）

开启 Realm

接着，你用 let realm = try! Realm() 这样一行代码初始化了一个 Realm 对象。你在从 Realm 获取数据之前肯定需要有一个 Realm 对象。 try! 关键字是 Swift 的一种错误处理。用了这个关键字，我们其实声明了：当前不会处理来自 Realm 的错误。虽然这样的做法对生产环境来说并不推荐，但是可以让我们的代码变得相当简单。

开启事务处理

接下来，调用 Realm 实例方法 beginWrite 。其实这代码开启了一个事务。让我们先来谈谈效率的问题。以下哪种方式更高效：

• 创建一个文件指针，打开文件，写入 1x 数据到文件里，关闭文件，再重复之前的步骤直到写入 50x 数据。
• 创建一个文件指针，打开文件，写入 50x 数据到文件里，关闭文件。

确切地说，当然是后者更高效。和其他数据库系统一样， Realm 也是把数据存储在文本文件里的。文件处理就意味着：操作系统（ operation system ， OS ）需要打开着文件，赋予程序写入权限，并让程序可以一个字节一个字节的向文件里写入数据。

你需要使用打开一次文件，一次写入 50 个 Realm 对象的方式，而不是一次次的写入文件。因为，每个对象之间非常相似，它们可以被连续地写入。这种方式更快一点，其实这就是事务。

为了完整性，如果事务中的一次写入失败了，那么所有的写入都会失败。这种机制其实来源于银行和账户：如果你写入了 50 个事务到一个分类账簿，而其中的一个（比如，账上没有钱）被证明是错误的，但是你又不能找出来。你必须阻止这种“污染”整个账簿的行为。这时候使用事务就再好不过了，成功都写入，失败都回滚，这样的方式也能减少数据出错的风险。

遍历地理数据

OK，现在来看看 for-in 循环。你已经可选绑定上面创建了 venues 变量。在 for-in 循环遍历整个数组时，每次循环里都是数组中的一个元素： venue 。

首先，创建了一个 Venue 类型的 venueObject 变量。这行代码暂时会报错，因为现在还没有一个类叫 Venue 。你等会就会添加这个类的，因此先放一边吧。

接着，一系列的可选绑定来了。每个可选绑定都尝试去访问 venue 的键值对（ key-value pair ），同时尝试将其转换成合适的类型。举个例子，当 venue 包含一个键 id ，并尝试转换成 String 类型，假如成功的话，会将 venueObject 的 id 属性赋值给它。

location 的可选绑定看上去复杂一点，但是其实一点也不复杂。仔细看，你会发现 lat 、 lng 、 formattedAddress 这些都是 location 的一部分 key （并不是 venue 的）。它们其实在数据结构中是属于同一层的。

接下来，是 for-in 循环最后一行代码： realm.add(venueObject, update: true) 。这行代码会把 venueObject 添加到 Realm，并写入到数据库（仍然是以事务的形式写入）。方法中的第二个参数 update 表示：当对应传入的对象已经存在，就用新数据覆盖掉之前写入的数据。之后，你会发现每个 Venue 对象都有一个唯一的编号，所以 Realm 可以根据编号知道对象已经存在。

错误处理

OK，现在 Realm 已经将事务中所有要写入的数据保存起来了，接下来将尝试写入到 Realm 数据库。这一步当然也有可能出错了。庆幸的是，这里可以使用 Swift 的错误处理机制。步骤如下：

1. 尝试执行可能出错的操作。
2. 如果出错，就抛出错误。
3. 操作的调用者抓住对应错误。
4. 进行错误处理。

在大多数语言里，这种机制以 try-catch 闻名，但是 Swift 称它为 do-catch （同时，也将 do-while 重命名为 repeat-while ）。你的代码大概是这样子的：

do {      try realm.commitWrite()      print("Committing write...")  }  catch (let e)  {      print("Y U NO REALM ? \(e)")  }

</div>

realm.commitWrite() 这行代码就是在尝试执行可能出错的操作。同时，这行代码前面写了 try 。回到你之前写 try! 的地方， try! 会摒弃错误。（译者注： try! 表示禁用错误传递，如果抛出错误，那么程序崩溃。一般用于，你知道这个步骤不会出错的情况。关于错误处理，可以看 SwiftGG 翻译组翻译的 Swift 官方文档： 错误处理 ）。

当在 do { } 代码块里产生错误的时候， catch 代码块就会执行。它只有一个参数， let e ，它会包含异常的具体信息。在后面的代码块里，我们将具体的错误信息打印出来。当程序运行过程中出现错误了，打印的信息就会告诉我们错误到底是由什么异常引起的。

这里的这个错误处理是很基础的。设想一下，一个错误处理很完善的系统，不仅仅需要抓住出错信息，还要对错误信息进行一下处理。举个例子，当你写数据到文件，而磁盘满了的时候，你就需要弹窗让用户知道磁盘已经满了。在较早版本的 Swift 中，处理错误比现在更艰难，而且如果你不处理得当，程序就崩溃了。

Swift 的错误处理或多或少还是加强了。你要不处理错误，要不摒弃掉错误，但是不管怎么样也不能忽视错误。处理错误可以让你的代码更健壮，因此，养成多使用 do-catch 处理错误的习惯，而不是使用 try! 来摒弃错误。

OK，该方法中还有最后两行代码，第一行如下：

NSNotificationCenter.defaultCenter().postNotificationName(API.notifications.venuesUpdated, object: nil, userInfo: nil)

</div>

这行代码会给整个应用中监听它的地方发送一个通知。这实际上是应用中的通知机制，可以高效的将事件传递到应用中的不同位置。考虑到你刚从 Foursquare 获取到新数据，你可能要去更新显示数据的 table view ，也可能要更新代码的其他部分。通知是完成这个操作最好的方式了。

请牢记，通知会一直保留在发送它的那个线程上。如果你在主线程外（比如，发送通知的线程）更新你的 UI ，你的应用就会崩溃并抛出错误。

注意到这行代码里的硬编码 API.notifications.venuesUpdated 了吗？本来我们可以写成 "venuesUpdated" 的字符串， 而不是 API.notifications.venuesUpdated 。使用硬编码的编译时常量能让你的代码更安全。如果你出错，编译器会报错。但是，如果你使用字符串的方式，拼写错 "venuesUpdated" ，编译器就不会报错了。

最后，闭包外的这行代码：

searchTask.start()

</div>

再次注意，这行代码会在 let searchTask … 后执行，且和上面一大段闭包是独立的。这行代码到底是干什么的呢？现在，我们已经设置好请求，配置好所有需要的参数，这行代码就是让这个搜寻任务启动起来。

Das Quadrat 发送一条消息到 Foursquare ，等待数据的返回，然后就执行了处理数据的闭包。懂了吧？

暂时把这些代码放一边，因为接下来我们要写 Venue 对象了。

编写 Realm Venue 对象

你知道 Realm 酷在什么地方吗？它整个代码结构是很简短的。本质上来说，你只需要一个类文件就可以写 Realm 了。你创建了一系列的实例对象，把它们写到 Realm 文件中，然后 BAM！你已经完成了你自己的本地数据库。

Realm 有一系列很赞的特性，比如排序、过滤以及支持 Swift 数据类型。你再也不需要在 table view 里使用 Core Data 的 NSFetchedResultsController 来加载成千上万的对象。Realm 也有它自己的数据浏览器。

OK，接下来该写 Realm Venue 对象了。步骤如下：

• 右击 Xcode 中 Project Navigator 的 Coffee 这个文件夹。
• 点击 New File … ，从 iOS -> Source 目录选择 Swift 文件，并点击 Next 。
• 将新建的文件命名为 Venue.swift ，并确保选中了 Coffee 这个 target 。
• 最后，点击 Create 完成创建。

好吧，又是一个无内容的文件。这个文件将会包含 Realm 的 Venue 对象的代码。

首先导入正确的库。在 Foundation 的导入代码添加如下代码：

import RealmSwift  import MapKit

</div>

接着，键入如下代码：

class Venue: Object  {    }

</div>

这就为 Venue 新建了一个类。其中，这个冒号表示当前类继承自 Object 类。这其实是面向对象编程（ Object Oriented Programming ）中父类和子类之间的继承关系。此处代码就是将 Venue 类继承自 Object 类。

简单来说，作为一个子类会自动将父类的所有方法和属性拷贝到自己的类中。值得注意的是，这和我们之前使用的 extension 是不一样的，它是为现有的类添加新的方法，而没有创建一个独立的新类。

接着，将以下代码拷贝到该类中，记得要添加在大括号的范围内：

dynamic var id:String = ""  dynamic var name:String = ""    dynamic var latitude:Float = 0  dynamic var longitude:Float = 0    dynamic var address:String = ""

</div>

这些句子是什么意思呢？就是为这个类添加了 5 个属性。你可以像使用 CoffeeAPI 的代码那样，使用这些属性为类实例添加数据。

属性中的 dynamic 关键字可以确保该属性能被 Objective-C 运行时访问。这本身是另外一个主题，但是我们先假设 Swift 的代码和 Objective-C 代码在各自的 “沙盒” 里运行。在 Swift 2.0 之前，所有的 Swift 代码都是运行在 Objective-C 运行时里，但是现在 Swift 已经有自己的运行时了。我们用 dynamic 关键字修饰属性，就可以让 Objective-C 运行时访问到这个属性，因为 Realm 需要在内部用到该属性。

每个属性都是 String 或 Float 类型。 Realm 本身支持一些变量类型，包括 NSData 、 NSDate 、 Int 、 Float 、 String 等等。

接下来，在 address 属性下面添加以下代码：

var coordinate:CLLocation {      return CLLocation(latitude: Double(latitude), longitude: Double(longitude));  }

</div>

这个属性的值要计算后才会有。它不能保存到 Realm 里，因为它的类型没有包含在 Realm 本身支持的类型中。这个属性保存的是表达式的结果值。它就像一个方法，但是接着它就可以用属性来访问了。以上属性返回的是一个 CLLocation 实例对象，它有 latitude 和 longitude 两个属性。

这种使用方法很便利，因为我们只需要访问 venueObject.coordinate 就能获得对应类型的实例，而不用我们自己创建。

OK，接下来，粘贴以下代码到最后的代码块下面：

override static func primaryKey() -> String?  {      return "id";  }

</div>

这是一个新出现的方法，它重写了父类 Object 的方法。这个自定义方法可以返回一个 Realm 的主键（ primary key ）。主键就是唯一标识。每个 Realm 数据库中的对象有且仅有一个唯一的值作为主键，就像一个村庄里的房子必须有且仅有一个唯一的地址一样。

Realm 会用主键去区分一个个不同的对象，并确定当前这个对象是否唯一。

该方法的返回值类型为 String，因此我们就可以返回主键对应的属性名或者返回 nil （不使用主键的情况）。

Realm 对象的属性（比如， id 和 name ）类似于电子表格里的列。方法返回的主键返回值即是每一列的名字，其实就是 id 。

现在，我们需要按 Command-B 来编译当前应用，并确保没有报错。我们没必要运行当前的应用，因为我们没有改变前端的展示代码。取而代之的是，我们只要检查编译应用时候是否有报错。如果你这时候去查看 CoffeeAPI.swift 文件，之前关于 venueObject 的错误已经不存在了。

在 Map View 中展示地理数据

OK，现在让我们来处理下载下来的数据吧。你将要把它们放入之前创建的 map view 里以注释（annotation）的形式展示。

首先，切换到 ViewController.swift 文件。检查用来在 map view 上显示用户位置的代码。

接着，在文件的最上部，添加如下的导入语句：

import RealmSwift

</div>

接着，在类的最上部，添加以下这些属性：

var lastLocation:CLLocation?  var venues:Results?

</div>

你需要 RealmSwift 库来支持你使用 Realm，并且你需要这两个属性分别处理位置和地理数据。

接下来，定位到文件中的 locationManager:didUpdateToLocation:fromLocation 方法。在该方法的右大括号后面，粘贴以下代码：

func refreshVenues(location: CLLocation?, getDataFromFoursquare:Bool = false)  {      if location != nil      {          lastLocation = location      }        if let location = lastLocation      {          if getDataFromFoursquare == true          {              CoffeeAPI.sharedInstance.getCoffeeShopsWithLocation(location)          }            let realm = try! Realm()            venues = realm.objects(Venue)            for venue in venues!          {              let annotation = CoffeeAnnotation(title: venue.name, subtitle: venue.address, coordinate: CLLocationCoordinate2D(latitude: Double(venue.latitude), longitude: Double(venue.longitude)))                mapView?.addAnnotation(annotation)          }      }  }

</div>

Whoah，好长的方法，它是怎么执行的呢？

让我们从 location 的两行判断语句说起吧。第一行检查了 location 是否非空，第二行使用可选绑定检查了 lastLocation 属性是否非空。

虽然这两行代码看上去很相似，但是其实干的事情是不同的。让我们退一步想想。检查以下陈述是否是真实的：

• 应用中的所有位置数据都来源于 locationManager:didUpdateToLocation:fromLocation 方法。即，该方法是唯一一个能获取到 CLLocation 实例（数据来自 GPS 硬件数据）的地方。
• refreshVenues 方法需要一个位置作为参数，该参数可能为空。
• refreshVenues 方法可能会在没有可用的位置时被调用。比如，在代码里，一个与位置数据方法没有联系的地方就调用 refreshVenues 方法。

最后一句陈述很重要。其实也很简单：因为我们不一定要在获取到最新地理位置（ locationManager:didUpdateToLocation:fromLocation ）时，才进行位置保存，所以，我们需要将保存位置的功能单独封装出来（封装为 refreshVenues 方法）。

因此，每次调用 refreshVenues 方法时，如果 lastLocation 属性非空的话，我们会将 location 参数保存起来。然后，我们会用可选绑定检查 lastLocation 是否为空。 if 语句只会在有值的时候执行，因此我们可以 100% 确定 if 语句里的代码块肯定会包含一个有效的 GPS 位置信息！

当然，前提是 refreshVenues 方法确实获取到了位置数据。你肯定要确保它是非空的。如果你还是不太理解的话，可以重新读一下上一段内容。这样的代码非常优雅，而且这样的编码还可以确保你的应用数据是安全的且仍然是解耦的。

OK， refreshVenues 方法里的下一行代码讲了什么呢？该代码块里使用了 CoffeeAPI 单例来从 Foursquare 请求数据：

if getDataFromFoursquare == true  {      CoffeeAPI.sharedInstance.getCoffeeShopsWithLocation(location)  }

</div>

这段代码只会在 getDataFromFoursquare 这个变量为 true 的时候执行。这是一种简单的使用 CoffeeAPI 请求数据方式。你要事先监听 CoffeeAPI 里的通知，才能在获取数据完成的时候，得到状态的更新。我们会在稍后实现该功能。

在请求数据之后，是以下代码：

let realm = try! Realm()  venues = realm.objects(Venue)

</div>

这些代码看上去是不重要的，但是代码的主体却是在这几句上。首先，实例化 Realm 。然后，所有从 Realm 获取来的 Venue 类的对象都保存到 venues 这个属性里。该属性的类型是 Results? ，该类型是以 Venue 实例为元素的数组。

最后，for-in 循环遍历 venues ，并将每个元素以注释（annotation）的样式添加到 map view 里。这段代码很可能会报出错误，但我们将会解决掉它的。

创建注释（Annotation）类

创建注释类，需要以下步骤：

1. 右击 Coffee 文件夹，选择 New File … 。
2. 从 iOS -> Source 目录里选择 Swift 文件并点击 Next 。
3. 将该 Swift 文件命名为 CoffeeAnnotation ，并点击 Create 。

然后，将以下代码粘贴到该文件里：

import MapKit    class CoffeeAnnotation: NSObject, MKAnnotation  {      let title:String?      let subtitle:String?      let coordinate: CLLocationCoordinate2D        init(title: String?, subtitle:String?, coordinate: CLLocationCoordinate2D)      {          self.title = title          self.subtitle = subtitle          self.coordinate = coordinate            super.init()      }      }

</div>

这些代码很简单：

• 你新建了一个名叫 CoffeeAnnotation 的类，它继承自 NSObject 且遵循 MKAnnotation 协议。最后遵循协议的这个部分很重要，要想使用注释，必须要遵循这个 MKAnnotation 协议。
• 接着，创建了一大串属性。这些属性是由协议决定的，是类的一部分。
• 最后，还创建了构造器方法。该方法初始化了类的属性。

切换回 ViewController.swift 文件，是不是发现原来 CoffeeAnnotation 那里的错误已经消失了？

接下来，添加以下的方法到 ViewController 这个类中。这个方法可以确保添加到地图的注释能被显示出来。

func mapView(mapView: MKMapView, viewForAnnotation annotation: MKAnnotation) -> MKAnnotationView?  {      if annotation.isKindOfClass(MKUserLocation)      {          return nil      }        var view = mapView.dequeueReusableAnnotationViewWithIdentifier("annotationIdentifier")        if view == nil      {         view = MKPinAnnotationView(annotation: annotation, reuseIdentifier: "annotationIdentifier")      }        view?.canShowCallout = true        return view  }

</div>

类似于 table view，map view 也用可重用的实例来让地图上的 pin 显示更平滑。以上代码大概是以以下的步骤展开：

• 首先，检查 annotation 是不是用户的当前位置。
• 接着，在重用队列中取出 pin （并赋值给 view 变量）。
• 然后，如果没有 pin 在重用队列中，就创建一个新的。
• 接着，设置 pin 允许显示 callout（一块小小的用来显示信息的简介）。
• 最后，返回 view 。

值得注意的是，这方法是代理模式的一部分。你之前设置了 map view 的代理为 self 。因此，当 map view 准备显示 pin 时，都会调用代理中的 mapView:viewForAnnotation: 方法，应用才能执行到你刚定义的代码。

代理是一种很不错的自定义代码的方式，它不用重载整个类。

回应地理数据的通知

好的，现在让我们把这一切都整理一下。在之前，我们在 ViewController.swift 的 viewDidLoad 方法里添加了以下这行代码：

NSNotificationCenter.defaultCenter().addObserver(self, selector: Selector("onVenuesUpdated:"), name: API.notifications.venuesUpdated, object: nil)

</div>

这行代码会告诉通知中心（ notification center ）， self （当前类）正在监听名为 API.notifications.venuesUpdated 的通知。当发出通知的时候， ViewController 类的 onVenuesUpdated: 方法就会被调用。

添加以下方法到 ViewController 类里：

func onVenuesUpdated(notification:NSNotification)  {      refreshVenues(nil)  }

</div>

看看这里到底发生了什么吧：

• 当从 Foursquare 接收到返回的位置数据时， refreshVenues 方法就会被调用。
• 该方法没有包含位置数据，也没有提供 getDataFromFoursquare 参数。如果没有传入参数，就默认是 false ，因此没有向 Foursquare 请求数据。如果传入参数，那么就会再次发起请求，请求结束又会调用该方法，这样就会导致死循环。
• 本质上来说，从 Foursquare 返回的数据会触发相应方法，从而将注释画到 map view 上去。

关于代码，还有一个很重要的部分。添加如下代码到 locationManager:didUpdateToLocation:fromLocation: 方法里。

refreshVenues(newLocation, getDataFromFoursquare: true)

</div>

这行添加后大概是这样子的：

if let mapView = self.mapView  {      let region = MKCoordinateRegionMakeWithDistance(newLocation.coordinate, distanceSpan, distanceSpan)      mapView.setRegion(region, animated: true)        refreshVenues(newLocation, getDataFromFoursquare: true)  }

</div>

这些代码是怎么回事呢？简单来说：调用 refreshVenues 方法获取用户的 GPS 位置。同时，也用 API 向 Foursquare 请求数据。本质上来说，用户每次移动到新的位置都会向 Foursquare 请求数据。由于设置了间隔 50m 就更新，并且注册了通知，所以地图能正常更新。

运行应用并验证一下。是不是很酷？



在 Table View 里显示地理数据

现在，map view 已经能正常显示了。接着我们将会把同样的地理数据显示到 table view 中。实现起来也是很简单直接的。

首先，添加实例属性和 outlet 到 ViewController 。在 mapView 属性下面添加如下的定义：

@IBOutlet var tableView:UITableView?

</div>

接着，切换到 Main.storyboard ，选中 View Controller Scene。将 table view 与 IBOutlet 关联。

与以 self.mapView 可选绑定相同的方法，添加如下的代码到 ViewController.swift 的 viewWillAppear: 方法里。

if let tableView = self.tableView  {      tableView.delegate = self      tableView.dataSource = self  }

</div>

并将当前的类遵循以下的协议：

UITableViewDataSource, UITableViewDelegate

</div>

接着，再添加两个代理中的方法：

func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int  {      return venues?.count ?? 0  }    func numberOfSectionsInTableView(tableView: UITableView) -> Int  {      return 1  }

</div>

这两个方法是 table view delegate 协议中方法的一部分。第一个方法确定了 table view 有多少个 cell，而第二个方法确定了 table view 有多少个 section。注意到代码中的 ?? 了吗？它是空和运算符（nil-coalescing operator）（译者注：如果对空和运算符有什么不理解的话，可以查看 中文版官方文档 的说明）。即，如果 venues 是空的话，使用 0 作为默认值。

接着，添加以下方法到 ViewController 类：

func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell  {      var cell = tableView.dequeueReusableCellWithIdentifier("cellIdentifier");        if cell == nil      {          cell = UITableViewCell(style: UITableViewCellStyle.Subtitle, reuseIdentifier: "cellIdentifier")      }        if let venue = venues?[indexPath.row]      {          cell!.textLabel?.text = venue.name          cell!.detailTextLabel?.text = venue.address      }        return cell!  }

</div>

大部分都是易懂的代码。大致步骤如下：

• 从重用队列中取出一个 cell。
• 如果没有 cell 存在，就以 Subtitle 的样式创建一个新的 cell 。
• 如果 venues 数组的第 indexPath.row 个元素存在，就赋值给常量 venue 。使用该数据去填充 cell 的 textLabel 和 detailTextLabel 。
• 返回 cell 。

和 map view 的类似， 当 table view 需要一个 table cell 的时候，就会调用 tableView:cellForRowAtIndexPath: 方法。你可以使用该方法来自定义你的 table view cell。这比写个子类简单多了。

接下来，是 table view 的最后一个方法。把一些方法添加到 ViewController 类中：

func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath)  {      if let venue = venues?[indexPath.row]      {          let region = MKCoordinateRegionMakeWithDistance(CLLocationCoordinate2D(latitude: Double(venue.latitude), longitude: Double(venue.longitude)), distanceSpan, distanceSpan)              mapView?.setRegion(region, animated: true)      }  }

</div>

当用户点击 cell 时，就会调用这个代理方法。代码的内容是比较简单的：当 venues 数组的第 indexPath.row 个元素存在时，使用它去填充该数据项所在区域的 map view。换句话说，把点击的项显示到 map view 的中心。

现在唯一剩下的事情就是，当通知事件发生时，及时地刷新 table view 数据。当数据更新时，你就想要把它们显示出来。

在第二个 if 条件判断的末尾，添加以下这行代码到 refreshVenues: 方法。定位到 if let location = lastLocation 这行代码，在该语句的有括号后面，添加如下代码：

tableView?.reloadData()

</div>

OK，现在检查一下应用能否运行。使用 Command-R 编译并运行后验证结果。如果所有的设置都正确的话，地理数据会在 table view 中显示出来。



基于位置过滤地理数据

OK，现在有个奇怪的现象，即 table view 显示了所有的数据。如果你在应用中点击过日本，然后点了旧金山，仍然会将日本的咖啡店显示在 table view 里。

我们当然不想要这样。因此，让我们使用一些 Realm 的小魔法只让准确的数据显示。

首先，把 ViewController 类中的 venues 属性改变一下。不再使用 Results? ，而是设置为：

var venues:[Venue]?

</div>

两者之间的区别，只是类型不同而已。之前那种是包含 Venue 对象的 Results 实例。它是 Realm 的一部分。而第二种新的类型是 Venue 实例的数组。

最大的区别是懒加载。Realm 在加载需要使用的数据时很高效，比如你的代码访问 Realm 数据。不幸的是，Realm 并不支持对属性计算后排序的特性。因此，我们需要加载所有从 Realm 获取的数据，并执行自己定义的过滤操作。通常你会使用 Realm 来处理数据检索（使用延迟加载），并给它一个过滤器。这次暂不考虑使用这种方法。

OK，还记得这两行代码吗？

let realm = try! Realm()  venues = realm.objects(Venue)

</div>

用以下的代码段来代替以上两行代码：

let (start, stop) = calculateCoordinatesWithRegion(location)    let predicate = NSPredicate(format: "latitude < %f AND latitude > %f AND longitude > %f AND longitude < %f", start.latitude, stop.latitude, start.longitude, stop.longitude)    let realm = try! Realm()    venues = realm.objects(Venue).filter(predicate).sort {       location.distanceFromLocation($0.coordinate) <; location.distanceFromLocation($1.coordinate)  }

</div>

接着，在 ViewController 类里添加一下方法。

func calculateCoordinatesWithRegion(location:CLLocation) -> (CLLocationCoordinate2D, CLLocationCoordinate2D)  {      let region = MKCoordinateRegionMakeWithDistance(location.coordinate, distanceSpan, distanceSpan)        var start:CLLocationCoordinate2D = CLLocationCoordinate2D()      var stop:CLLocationCoordinate2D = CLLocationCoordinate2D()        start.latitude  = region.center.latitude  + (region.span.latitudeDelta  / 2.0)      start.longitude = region.center.longitude - (region.span.longitudeDelta / 2.0)      stop.latitude   = region.center.latitude  - (region.span.latitudeDelta  / 2.0)      stop.longitude  = region.center.longitude + (region.span.longitudeDelta / 2.0)        return (start, stop)  }

</div>

OK，这方法也没什么特别的。只是一些基本的数学计算，把 CLLocation 实例基于区域的距离转换成左上和右下两个坐标。

第一行代码创建了基于位置和距离的区域。接着，设置好位置和它们的经纬度。这些值是根据中心的坐标计算出来的。最后，该方法返回一个元组：两个有序的变量。

可以把任意顺序的类型组合成元组（译者注：如果对元组有什么不理解的话，可以查看 中文版官方文档 的相应说明）。圆括号里的变量有特定的顺序，且是不可变的数组。

OK，回到我们的过滤器代码（译者注：位于上上段代码）。让我们一行一行来解读。

• 首先，创建了两个常量， start 和 stop 。它们是 calculateCoordinatesWithRegion: 方法的返回结果。该方法返回的是一个元组，由 start 和 stop 组成。 calculateCoordinatesWithRegion: 方法的功能就是返回当前用户的地理位置。
• 接着，创建了一个 predicate 变量。 NSPredicate 是一个过滤器，它可以适用于数组，序列（译者注：也可以理解为元组）等等。 predicate 变量定义了一个范围， venues 数组里的 GPS 坐标必须落在该范围内。它主要是用于过滤 Realm 的数据（下一行代码会过滤）。值得注意的是，该 predicate 变量假设 GPS 数据是平面的，虽然地球明显是球体的。现在暂时这样假设是没事的，但是当你在南极点或北极点附近使用本应用去寻找咖啡店时就会出问题。
• 接下来，让我们来剖析一下 realm 对象获取数据的那部分内容。所有方法都是有关联的，也就意味着每次方法调用都用到了前一个方法调用的结果。
  • 首先，创建了一个 realm 变量来保存 Realm 的引用对象。
  • 接着， Venue 的所有对象都被懒加载： objects(Venue) 。
  • 接着，过滤器（ predicate ）来过滤这些对象。Realm 可以快速的处理过滤，而且它并不是所有的对象都过滤，而只是过滤能访问到的对象。
  • 接着，调用 Swift 本地的排序算法。这里的 sort 并不是 Realm 的那部分，Realm 的排序算法叫 sorted 。换句话说，这部分没用上 Realm。该排序算法会访问所有的 Realm 对象，也就意味着它们都会被加载进内存，这里也没用上 Realm 的懒加载特性。该排序算法只有一个参数：一个确定两个无序对象顺序的闭包。通过返回 true 或 false ，来标识闭包里两个对象比较后的关系。在上面那段代码里，前后顺序是基于离用户位置的距离的。这也是坐标属性派上用场的地方。其中， $0 和 $1 是两个无序对象的缩写。从根本上来说，该方法将地理数据以用户位置距离远近进行排序（距离越近，排在越前面）。
  </li> </ul>

  就说到这里吧。以上是的代码量比较大，但是效率很高。 Realm 优化的特性，方法链（method chaining）以及 Swift 本地的排序算法可以让一大票地理数据按特定的顺序保存。而且，还有一个很炫酷的事情：随着你的移动，它会随时更新。

  就这样了！用 Command-R 来看看应用的效果吧。干的漂亮！

  

  注意：不幸的是，当你在 Xcode 里模拟 GPS 坐标时，从 Foursquare 获取的数据可能会少的可怜。假如你想要获得更多数据的话，你可以去除 CoffeeAPI 中硬编码的部分，或者把地点模拟到有更多咖啡店的位置。

  你对本教程有什么想法呢？留下你的留言和想法吧。

  最后再安利一波。你可以从 GitHub reinderdevries/CoffeeGuide 上下载所有源代码和 Xcode 项目。

  本文由 SwiftGG 翻译组翻译，已经获得作者翻译授权，最新文章请访问http://swift.gg。

  </div>

  来自： http://swift.gg/2015/12/29/foursquare-realm-swift/

相关经验

•  如何使用 Swift、Foursquare API 及 Realm 构建一款 Coffee Shop 应用
•  UmbrellaWeather 使用 Swift 编写的一款天气应用
•  使用Swift为Android构建代码
•  使用API网关构建微服务