SBT 是 Scala 生态圈里的经典构建工具，虽然很多人觉得 SBT 很复杂，还戏称其为 SB Tool，但其全称确是 Simple Build Tool。

实际上，很多产品（包括像 SBT 这样的工具和技术产品）只有一个打动用户的特性就够了， Triggered Execution 这一特性支持，就可以在一个屏幕上写代码，而在另一个屏幕（或者窗口）实时地获得编译结果反馈，如图 1 所示，参与感十足。

图 1 结合双屏使用SBT的工作场景示意图

当然，SBT 毕竟是一套新的工具体系，与 Maven 或者其他构建工具在配置和使用上还是会有不小的差异，这就意味着，如果我们要使用 SBT 来构建基于 Scala 的 SpringBoot 微服务项目，就需要针对 SBT 的特点做很多定制工作。

探索基于SBT的SpringBoot应用开发模式

SpringBoot 团队围绕 Maven 提供了很多便利和支持，比如我们只要使用 Maven 的继承特性，将 spring-boot-starter-parent 作为当前项目的 parent，就可以直接开发 SpringBoot 微服务项目，代码如下所示：

1. <parent>
2. <groupId>org.springframework.boot</groupId>
3. <artifactId>spring-boot-starter-parent</artifactId>
4. <version>1.3.2.RELEASE</version>
5. </parent>

或者，如果当前要开发的 SpringBoot 微服务项目需要继承其他 parent 项目而不能使用 spring-boot-starter-parent，那么也可以使用 Maven 的依赖引入特性完成一系列 SpringBoot 相关依赖导入：

1. <dependencyManagement>
2. <dependencies>
3. <dependency> <!-- Import dependency management from Spring Boot -->
4. <groupId>org.springframework.boot</groupId>
5. <artifactId>spring-boot-dependencies</artifactId>
6. <version>1.3.2.RELEASE</version>
7. <type>pom</type>
8. <scope>import</scope>
9. </dependency>
10. </dependencies>
11. </dependencyManagement>

当使用 SBT 时，这些围绕 Maven 提供的便利就不复存在了，我们需要搞清楚这些便利背后都发生了什么，才能最终决定如何使用 SBT 进行相应的配置并最终达到相同的目的。

因为 spring-boot-starter-parent 项目只有一个 pom.xml 定义，且其 parent 就是 spring-boot-dependencies，所以，我们先沿着 spring-boot-dependencies 开始寻找端倪。

但是我们发现，spring-boot-dependencies 也只是一个只有 pom.xml 定义的“干瘪”项目，其 pom.xml 中仅仅通过 dependencyManagement 和 pluginManagement 固定了 SpringBoot 项目的一系列依赖和版本号，并无实际有用信息，所以，我们需要回头再从 spring-boot-starter-parent 的 pom.xml 中寻找线索。

不幸的是，spring-boot-starter-parent 也没有提供什么有用的线索，它的 pom.xml 中也是定义了相应的 pluginManagement 来规范依赖和依赖的版本，并在编译期间进行相应资源和配置的过滤。

到了这个地步，我们就只能另寻他途了。不过，既然大部分的 SpringBoot 项目都会从依赖相应的 starter 项目开始，那么，我们可以分析几个 spring-boot-starter-XXX 模块来看看它们有什么共性。

假设我们关联查看了 spring-boot-starter-web、spring-boot-starter-jdbc、spring-boot-starter-actuator 等模块，就会发现，除了这些模块自身特定要提供的依赖，它们都同时依赖如下模块：

1. <dependency>
2. <groupId>org.springframework.boot</groupId>
3. <artifactId>spring-boot-starter</artifactId>
4. </dependency>

而继续追踪下去到 spring-boot-starter 的 pom.xml 定义内部，最终才“柳暗花明又一村”：

1. ...
2. <dependencies>
3. <dependency>
4. <groupId>org.springframework.boot</groupId>
5. <artifactId>spring-boot</artifactId>
6. </dependency>
7. <dependency>
8. <groupId>org.springframework.boot</groupId>
9. <artifactId>spring-boot-autoconfigure</artifactId>
10. </dependency>
11. <dependency>
12. <groupId>org.springframework.boot</groupId>
13. <artifactId>spring-boot-starter-logging</artifactId>
14. </dependency>
15. <dependency>
16. <groupId>org.springframework</groupId>
17. <artifactId>spring-core</artifactId>
18. <exclusions>
19. <exclusion>
20. <groupId>commons-logging</groupId>
21. <artifactId>commons-logging</artifactId>
22. </exclusion>
23. </exclusions>
24. </dependency>
25. <dependency>
26. <groupId>org.yaml</groupId>
27. <artifactId>snakeyaml</artifactId>
28. <scope>runtime</scope>
29. </dependency>
30. </dependencies>
31. ...

所以，一个 SpringBoot 项目得以成型，如下依赖基本是必备的：

• org.springframework.boot：spring-boot
• org.springframework.boot：spring-boot-autoconfigure
• org.springframework.boot：spring-boot-starter-logging
• org.springframework：spring-core
• org.yaml：snakeyaml

作为 SpringBoot 项目，spring-boot 依赖自然不可少。

• spring-boot-autoconfigure 依赖可以帮助我们进行自动配置，SpringBoot 项目的便利的核心就在于此。
• spring-boot-starter-logging 则配置默认的日志依赖。
• SpringBoot 项目就是一个 Spring 项目，所以 org.springframework：spring-core 也是必备依赖。
• org.yaml：snakeyaml，是运行期依赖，主要提供针对 yml 格式配置文件的支持。

至此，我们基本已经了解了 SpringBoot 项目背后的故事全貌，接下来就要介绍 SBT 了。

构建在 SPRING INITIALIZR 之上的 http://start.spring.io 可以在每次创建新的 SpringBoot 项目的时候提供“脚手架”功能，创建 SBT 项目其实也有这样的“脚手架”工具，即 Typesafe Activator（https://www.typesafe.com/activator/download）。

我们使用 Typesafe Activator 来构建一个新的 SBT 项目，用于构建同样功能的一个汇率查询 Web API 微服务，Typesafe Activator 安装完成后执行如下命令：

1. $ activator new currency-webapi-with-scala-sbt minimal-scala

其中，currency-webapi-with-scala-sbt 为我们要生成的 SBT 项目名，而 minimal-scala 为我们选择要使用的“脚手架”模板项目名。

初始生成的 SBT 项目的构建文件内容如下：

1. name := """currency-webapi-with-scala-sbt"""
2. version := "1.0"scalaVersion:= "2.11.7"
3. // Change this to another test framework if you
4. preferlibraryDependencies += "org.scalatest" %
5. % "scalatest" % "2.2.4" %"test"
6. // Uncomment to use Akka
7. // libraryDependencies += "com.typesafe.akka" %
8. % "akka-actor" % "2.3.11"

我们需要对其进行定制和丰富一些内容：

1. organization := "com.keevol.springboot.chapter5"
2. name := """currency-webapi-with-scala-sbt"""
3. version := "1.0.0-SNAPSHOT"
4. scalaVersion := "2.11.7"
5. resolvers += "Local Maven Repository" at
6. "file://"+Path.userHome.absolutePath+"/.m2/repository"
7. libraryDependencies += "org.springframework.boot" % "spring-boot-starter-web" %
8. "1.3.2.RELEASE"
9. libraryDependencies += "com.keevol.springboot" % "currency-rates-service" % "1.0-SNAPSHOT"
10. // Change this to another test framework if you
11. preferlibraryDependencies += "org.scalatest" %
12. %"scalatest" %
13. "2.2.4" % "test"

因为我们已经了解了 SpringBoot 项目依赖的传递关系，所以，现在只要将 spring-boot-starter-web 作为核心依赖配置到 build.sbt 中，就可以信心满满地着手开发了（毕竟 spring-boot-starter-web 的依赖会一路上接力传递，必需的基础依赖一个都不会少）。

除此之外，currency-rates-service 属于业务依赖，也需要一并遵循 SBT 的配置语法加以配置。因为实例项目是使用本地开发，所以，我们配置了相应的 resolvers 指引 SBT 从本地的 Maven 仓库中加载业务依赖。

实际情况下，大家可以根据需要，将自己公司内部的 Maven 远程仓库或者其他 Maven 仓库也加入进来。

SBT 的项目源码结构与 Maven 的项目源码结构约定基本相同，所以，在 build.sbt 中所有配置完成后，就可以在 src/main/scala 目录下开始编写 scala 代码了：

1. // CurrencyRateQueryController.scala源码文件
2. package com.mengma.controllers
3. import com.mengma.WebApiResponse
4. import com.keevol.springboot.services.currency.rates.CurrencyPair
5. import com.keevol.springboot.services.currency.rates.CurrencyRateService
6. import com.keevol.springboot.services.currency.rates.ExchangeRate
7. import org.springframework.beans.factory.annotation.Autowired
8. import org.springframework.web.bind.annotation.{RequestMethod, RequestMapping,
9. RestController}
10. @RestController
11. class CurrencyRateQueryController{
12. @Autowired
13. var currencyRateService: CurrencyRateService = _
14. @RequestMapping(value = Array("/"), method = Array(RequestMethod.GET))
15. def quote(symbol: String): WebApiResponse[ExchangeRate] = {
16. val response: WebApiResponse[ExchangeRate] = new WebApiResponse [ExchangeRate]
17. response.setCode(WebApiResponse.SUCCESS_CODE)
18. response.setData(currencyRateService.quote(CurrencyPair.from (symbol)))
19. response
20. }
21. }
22. // CurrencyWebApiBootStrap.scala源码文件
23. package com.mengma.springboot
24. import com.keevol.springboot.services.currency.rates.CurrencyRateRepository
25. import com.keevol.springboot.services.currency.rates.CurrencyRateService
26. import com.keevol.springboot.services.currency.rates.CurrencyRateServiceImpl
27. import org.springframework.boot.SpringApplication
28. import org.springframework.boot.autoconfigure.SpringBootApplication
29. import org.springframework.context.annotation.Bean
30. @SpringBootApplication
31. class CurrencyWebApiBootStrap{
32. @Bean
33. def currencyRateService:CurrencyRateService = {
34. val service: CurrencyRateServiceImpl = new CurrencyRateServiceImpl
35. service.setRateRepository(new CurrencyRateRepository) service
36. }
37. }
38. object CurrencyWebApiBootStrap{
39. def main(args: Array[String]) {
40. SpringApplication.run(classOf[CurrencyWebApiBootStrap], args: _*)
41. }
42. }

开发完成后，运行 sbt run 或者直接通过 sbt”run-main com.keevol.springboot.chapter5.CurrencyWebApiBootStrap”即可启动微服务。

探索基于 SBT 的 SpringBoot 应用发布策略

针对我们基于 SBT 和 Scala 的 SpringBoot 微服务开发完成后，需要发布出去才能发挥其价值，要完成这种类型的项目发布，有几种策略可以考虑。

一种策略是使用 SpringBoot 推荐的可执行 jar 包发布形式，SpringBoot 团队提供的 spring-boot-maven-plugin 默认对这种可执行 jar 包有很好的支持。

但是，对于微服务来说，我们前面说了，不建议采用这种方式，除非零星个别的一些项目，不需要强大体系支撑，仅靠人工就可以满足或者忍受。

不过，如果因为某些因素必须使用 SpringBoot 建议的可执行 jar 包发布形式，那么，可以结合 spring-boot-maven-plugin 的源码和逻辑，并实现一个相应的 SBT 插件即可。

另一种策略是使用 SBT 生态圈中已经形成一定口碑或者说基本上已经是事实标准的方案，比如使用 sbt-native-packager（https://github.com/sbt/sbt-native-packager），通过 sbt-native-packager 这个 SBT 插件，我们可以将当前 SBT 项目发布为 ZIP、TAR、RPM、DEB 甚至 docker 等形式，相对于自己开发一个 SBT 插件完成可执行 jar 包形式的发布，显然直接使用 sbt-native-packager 是更明智的做法。

针对我们基于 SBT 和 Scala 的汇率查询 SpringBoot 微服务，要使用 sbt-native-packager 进行发布，我们只要对项目的 build.sbt 添加少许发布指引就可以了：

1. import sbt._
2. import com.typesafe.sbt.packager.universal.UniversalPlugin.autoImport._
3. import com.typesafe.sbt.packager.MappingsHelper._lazy
4. val root = project in file(".") enablePlugins(JavaAppPackaging)
5. organization := "com.mengma.springboot"\
6. name := """currency-webapi-with-scala-sbt"""
7. version := "1.0.0-SNAPSHOT"
8. scalaVersion := "2.11.7"
9. resolvers += "Local Maven Repository" at "file://"+Path.userHome.absolutePath+"/.m2/repository"
10. libraryDependencies += "org.springframework.boot" % "spring-boot-starter-web" %
11. "1.3.2.RELEASE"
12. libraryDependencies += "com.keevol.springboot" % "currency-rates-service" % "1.0-SNAPSHOT"
13. // Change this to another test framework if you prefer
14. libraryDependencies += "org.scalatest" % %"scalatest" % "2.2.4" % "test"
15. // 发布相关main
16. Class in Compile := Some("com.mengma.springboot.CurrencyWebApiBootStrap") mappings
17. in Universal += file("LICENSE") ->
18. "LICENSE"mappings in Universal ++= directory("config")

我们首先通过 import 引入相应的依赖，然后声明当前项目以 Java 应用（JavaAppPackaging）的形式发布（不是 Scala 应用类型是因为编译完运行期都是 Java 字节码的形式），最后通过 mainClass 来指定启动类是哪一个，以及应该将哪些其他文件或者目录打入发布包之中。

在执行发布命令之前，我们还有最后一步要做，就是将 sbt-native-packager 添加为当前项目的依赖，在 SBT 项目结构下，这需要我们在当前项目根目录下新建 project/plugins.sbt 文件，然后添加如下内容：

1. resolvers += "Typesafe repository" at
2. "http://repo.typesafe.com/typesafe/releases/"resolvers +=
3. Resolver.url("fix-sbt-plugin-releases",
4. url("https://dl.bintray.com/sbt/sbt-plugin-releases"))(Resolver.ivyStylePatterns)addMavenResolverPluginaddSbtPlugin("com.typesafe.sbt"
5. % "sbt-native-packager" % "1.0.0")

之后，build.sbt 才可以依赖到 sbt-native-packager 并且编译成功，现在，只要我们运行 sbt universal：packageBin 命令，就可以在 target/universal 目录下获得一个 zip 形式的发布安装包 currency-webapi-with-scala-sbt-1.0.0-SNAPSHOT.zip，安装包格式包含以下内容：

• 自动生成启动脚本的 bin 目录。
• 存放了项目所有依赖的 lib 目录。
• 以及在 build.sbt 中通过 mapping 添加的一系列希望打包的文件和目录。

当然，zip 不是微服务发布的理想形式，但基于 RPM 和 DEB 等发布包需要依赖复杂的本地环境准备，故此，这里为了示例的简化，使用 zip 发布形式来说明如何使用 sbt-native-packager，以轻松愉快的心情完成基于 SBT 和 Scala 的 SpringBoot 项目发布。

关于如何准备 RPM、DEB 等发布包的编译环境，以及如何配置 sbt-native-packager 使之相应的将当前项目发布为 RPM、DEB 等形式，可以参考 sbt-native-packager 插件的网站文档（http://www.scala-sbt.org/sbt-native-packager/index.html）。

最后一种策略（或许还有）我认为是最适合微服务的终极发布策略，即外部化（Externalization）的发布策略。

无论是在 Maven 项目的 pom.xml 中定义和使用 spring-boot-maven-plugin，还是在 SBT 项目的构建配置中定义和使用 sbt-native-packager 插件，本质上都是一种将通用逻辑分散到一个个单独项目中的做法，如果只是小团队以及少量项目，这样做是没有太大问题的。

而一旦规模膨胀（对于微服务来说，数量、发布频度等指标规模膨胀很正常），加上人员流动、时机错配等一系列的变化因素，这种通用逻辑最终很可能会在这些一个个离散的项目中被“玩坏”，造成发布的成品千差万别，完全背离标准化的微服务这一理想轨道，进而带来整体微服务交付链路上的一系列不必要的负累。

所以，为了避免“该标准化的地方却使用个性化”所可能引发的一系列问题，我们应该将这些发布和部署逻辑从单一项目中剥离出来，即外部化掉（Externalize it），将这些逻辑以发布和部署平台的形式抽象和固化，从而将原来因为各种因素导致的不确定性最大化地转变成确定性。

发布和部署平台是外部化的最终成果，每个 SpringBoot 微服务项目，不管你使用的是什么语言开发，也不管你使用的什么构建工具，只要你想用并且能帮助你提高开发效率，在开发阶段尽管用即可。

一旦项目要发布，直接将发布请求对接发布和部署平台。对于 SpringBoot 项目的开发者来说，发布和部署平台是访问接口（Interface）；而对于发布和部署平台的开发者来说，则是服务提供方。服务提供方可以灵活替换和升级：

如果你的 SpringBoot 项目是使用 Maven 作为构建工具，那么，发布和部署平台实现层会自动感知并构建发布。

如果你的 SpringBoot 项目是使用 SBT 作为构建工具，那么，发布和部署平台实现层也会自动感知并构建发布。

如果组织内部当前的微服务体系是基于 RPM 标准统一发布形式，那么，所有 SpringBoot 项目不管你使用什么构建工具，都将以 RPM 标准形式发布。

如果组织内部要实现 DevOps 体系的升级换代（比如 docker），那么，只要发布和部署平台实现层进行变更和升级即可，SpringBoot 项目的开发者无须感知，发布和部署平台起到了很好的抽象和防火墙效果。

所以，对于一个拥有成熟微服务体系的组织来说，将发布等通用逻辑外部化到发布和部署平台，应该是最合适，也是目前最终极的策略。