Scala 应用程序结构

Question

我现在正在学习 Scala，我想编写一些愚蠢的小应用程序，例如控制台 Twitter 客户端或其他什么。问题是，如何在磁盘上和逻辑上构造应用程序。我了解 python，在那里我只需创建一些带有类的文件，然后将它们导入主模块中，例如 import util.ssh 或 from tweets import Retweet （强烈希望您不介意这些名称，它们仅供参考）。但是我应该如何使用 Scala 来做这些事情呢？另外，我对 JVM 和 Java 没有太多经验，所以我是一个完全的新手。

Answer 1

我不同意 Jens 的观点，尽管不是那么多。

项目布局

我自己的建议是，您在 Maven 的标准目录布局。

以前版本的 SBT（SBT 0.9.x 之前）会自动为您创建它：

dcs@ayanami:~$ mkdir myproject
dcs@ayanami:~$ cd myproject
dcs@ayanami:~/myproject$ sbt
Project does not exist, create new project? (y/N/s) y
Name: myproject
Organization: org.dcsobral
Version [1.0]: 
Scala version [2.7.7]: 2.8.1
sbt version [0.7.4]: 
Getting Scala 2.7.7 ...
:: retrieving :: org.scala-tools.sbt#boot-scala
    confs: [default]
    2 artifacts copied, 0 already retrieved (9911kB/134ms)
Getting org.scala-tools.sbt sbt_2.7.7 0.7.4 ...
:: retrieving :: org.scala-tools.sbt#boot-app
    confs: [default]
    15 artifacts copied, 0 already retrieved (4096kB/91ms)
[success] Successfully initialized directory structure.
Getting Scala 2.8.1 ...
:: retrieving :: org.scala-tools.sbt#boot-scala
    confs: [default]
    2 artifacts copied, 0 already retrieved (15118kB/160ms)
[info] Building project myproject 1.0 against Scala 2.8.1
[info]    using sbt.DefaultProject with sbt 0.7.4 and Scala 2.7.7
> quit
[info] 
[info] Total session time: 8 s, completed May 6, 2011 12:31:43 PM
[success] Build completed successfully.
dcs@ayanami:~/myproject$ find . -type d -print
.
./project
./project/boot
./project/boot/scala-2.7.7
./project/boot/scala-2.7.7/lib
./project/boot/scala-2.7.7/org.scala-tools.sbt
./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt
./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4
./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4/compiler-interface-bin_2.7.7.final
./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4/compiler-interface-src
./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4/compiler-interface-bin_2.8.0.RC2
./project/boot/scala-2.7.7/org.scala-tools.sbt/sbt/0.7.4/xsbti
./project/boot/scala-2.8.1
./project/boot/scala-2.8.1/lib
./target
./lib
./src
./src/main
./src/main/resources
./src/main/scala
./src/test
./src/test/resources
./src/test/scala

因此您可以将源文件放在 myproject/src/main/scala 中作为主程序，或者 myproject/src/test/scala，用于测试。

由于这不再起作用，有一些替代方案：

giter8和sbt.g8

安装giter8，克隆ymasory的sbt.g8 模板并根据您的需要进行调整，然后使用它。例如，请参见下面，使用未经修改的 ymasory 的 sbt.g8 模板。我认为，当您清楚地了解所有项目的需求时，这是开始新项目的最佳选择之一。

$ g8 ymasory/sbt
project_license_url [http://www.gnu.org/licenses/gpl-3.0.txt]:
name [myproj]:
project_group_id [com.example]:
developer_email [[email protected]]:
developer_full_name [John Doe]:
project_license_name [GPLv3]:
github_username [johndoe]:

Template applied in ./myproj

$ tree myproj
myproj
├── build.sbt
├── LICENSE
├── project
│   ├── build.properties
│   ├── build.scala
│   └── plugins.sbt
├── README.md
├── sbt
└── src
    └── main
        └── scala
            └── Main.scala

4 directories, 8 files

np 插件

使用 softprops 的 np 插件 进行 sbt。在下面的示例中，插件在 ~/.sbt/plugins/build.sbt 上配置，其设置在 ~/.sbt/np.sbt 上，使用标准sbt 脚本。如果您使用paulp的sbt-extras，您需要将这些东西安装在~/.sbt中正确的Scala版本子目录下，因为它为每个Scala版本使用单独的配置。在实践中，这是我最常使用的一种。

$ mkdir myproj; cd myproj
$ sbt 'np name:myproj org:com.example'
[info] Loading global plugins from /home/dcsobral/.sbt/plugins
[warn] Multiple resolvers having different access mechanism configured with same name 'sbt-plugin-releases'. To avoid conflict, Remove duplicate project resolvers (`resolvers`) or rename publishing resolver (`publishTo`).
[info] Set current project to default-c642a2 (in build file:/home/dcsobral/myproj/)
[info] Generated build file
[info] Generated source directories
[success] Total time: 0 s, completed Apr 12, 2013 12:08:31 PM
$ tree
.
├── build.sbt
├── src
│   ├── main
│   │   ├── resources
│   │   └── scala
│   └── test
│       ├── resources
│       └── scala
└── target
    └── streams
        └── compile
            └── np
                └── $global
                    └── out

12 directories, 2 files

mkdir

您可以简单地使用 mkdir 创建它：

$ mkdir -p myproj/src/{main,test}/{resource,scala,java}
$ tree myproj
myproj
└── src
    ├── main
    │   ├── java
    │   ├── resource
    │   └── scala
    └── test
        ├── java
        ├── resource
        └── scala

9 directories, 0 files

源布局

现在，关于源布局。 Jens 建议遵循 Java 风格。好吧，Java 目录布局是 Java 中的一个要求。 Scala 没有相同的要求，因此您可以选择遵循或不遵循它。

如果您确实遵循它，假设基础包是 org.dcsobral.myproject，那么该包的源代码将放在 myproject/src/main/scala/org/dcsobral/myproject 中/，对于子包依此类推。

偏离该标准的两种常见方法是：

• 省略基本包目录，只为子包创建子目录。

  例如，假设我有包 org.dcsobral.myproject.model、org.dcsobral.myproject.view 和 org.dcsobral.myproject .controller，那么目录将是 myproject/src/main/scala/model、myproject/src/main/scala/view 和 myproject /src/main/scala/controller.

• 把所有东西放在一起。在这种情况下，所有源文件都将位于 myproject/src/main/scala 内。这对于小型项目来说已经足够了。事实上，如果没有子项目，则与上面相同。

这涉及目录布局。

文件名

接下来，我们来谈谈文件。在 Java 中，做法是将每个类分隔在自己的文件中，文件的名称将遵循类的名称。这在 Scala 中也足够好了，但你必须注意一些例外情况。

首先，Scala 有 object，而 Java 没有。同名的类和对象被视为同伴，这有一些实际意义，但仅如果它们位于同一个文件中。因此，将伴生类和对象放在同一个文件中。

其次，Scala 有一个称为密​​封类（或特征）的概念，它将子类（或实现对象）限制为在相同的文件。这样做主要是为了创建具有模式匹配和详尽检查的代数数据类型。例如：

sealed abstract class Tree
case class Node(left: Tree, right: Tree) extends Tree
case class Leaf(n: Int) extends Tree

scala> def isLeaf(t: Tree) = t match {
     |     case Leaf(n: Int) => println("Leaf "+n)
     | }
<console>:11: warning: match is not exhaustive!
missing combination           Node

       def isLeaf(t: Tree) = t match {
                             ^
isLeaf: (t: Tree)Unit

如果 Tree 不是 sealed，那么任何人都可以扩展它，从而使编译器无法知道匹配是否详尽。无论如何，密封的类都放在同一个文件中。

另一种命名约定是命名包含包对象（对于该包）package.scala 的文件。

导入东西

最基本的规则是同一包中的东西可以互相看到。因此，将所有内容放在同一个包中，您无需关心什么看到什么。

但Scala也有相对的引用和导入。这需要一些解释。假设我的文件顶部有以下声明：

package org.dcsobral.myproject
package model

以下所有内容都将放入包 org.dcsobral.myproject.model 中。此外，不仅该包内的所有内容都将可见，而且 org.dcsobral.myproject 内的所有内容也将可见。如果我只是声明package org.dcsobral.myproject.model，那么org.dcsobral.myproject将不可见。

规则非常简单，但一开始可能会让人有点困惑。这条规则的原因是相对进口。现在考虑该文件中的以下语句：

import view._

此导入可能是相对的 - 所有导入都可以是相对的，除非您使用 _root_. 作为前缀。它可以引用以下包：org.dcsobral.myproject.model.view、org.dcsobral.myproject.view、scala.view和java.lang.view。它还可以引用 scala.Predef 内名为 view 的对象。或者它可能是引用名为 view 的包的绝对导入。

如果存在多个这样的包，它将根据一些优先规则选择一个。如果你需要导入其他东西，你可以将导入变成绝对导入。

此导入使 view 包内的所有内容（无论它在哪里）在其范围内可见。如果它发生在 class 和 object 或 def 内部，那么可见性将仅限于此。由于._（通配符），它会导入所有内容。

另一种选择可能如下所示：

package org.dcsobral.myproject.model
import org.dcsobral.myproject.view
import org.dcsobral.myproject.controller

在这种情况下，包 view 和 controller 将可见，但您必须明确命名它们使用它们时：

def post(view: view.User): Node =

或者您可以使用进一步的相对导入：

import view.User

import 语句还允许您重命名内容，或导入除某些内容之外的所有内容。有关更多详细信息，请参阅相关文档。

所以，我希望这能回答你所有的问题。

Answer 2

Scala 支持并鼓励 Java /JVM 的包结构，并且几乎适用相同的建议：

• 在目录结构中镜像包结构。这在 Scala 中不是必需的，但它有助于找到
• 使用反向域作为包前缀的方法。对我来说，这意味着一切都从 de.schauderhaft 开始。使用对您有意义的东西，如果您没有自己的域，
• 则仅将顶级类放在一个文件中（如果它们很小且密切相关）。否则坚持每个文件一个类/对象。例外：伴生对象与类位于同一文件中。密封类的实现进入同一文件。
• 如果您的应用程序不断增长，您可能希望拥有诸如层和模块之类的内容，并在包结构中镜像这些内容，因此您可能拥有如下所示的包结构：..。 <可选子包>。
• 对包、模块或层级别没有循环依赖