Scala 如何为SBT中的所有子项目设置默认依赖项？

试图了解如何设置SBT。为我的所有子项目设置默认依赖项的正确方法是什么

我尝试了这个，但是我的子项目没有获得任何依赖项（它们下载得很好）

然后，根据我的想法，我尝试了以下方法。成功了，但这不是我所期望的。为所有子项目设置默认依赖项难道没有更简单的方法吗

import sbt._  

class MyProjects(info: ProjectInfo) extends DefaultProject(info)
{
  val projA = project("projA", "ProjectA", new Proj(_))
  val projB = project("projB", "ProjectB", new Proj(_))

  val akkaRepo = "Akka maven2 repo" at "http://www.scalablesolutions.se/akka/repository/"
  val multiversRepo = "Multiverse maven2 repo" at "http://multiverse.googlecode.com/svn/maven-repository/releases/"
  val guiceyFruitRepo = "GuiceyFruit Maven2 repo" at "http://guiceyfruit.googlecode.com/svn/repo/releases/"
  val jBossRepo = "JBoss maven2 repo" at "https://repository.jboss.org/nexus/content/groups/public/"

  class Proj(info:ProjectInfo) extends DefaultProject(info){
    val junit = "junit" % "junit" % "4.5" % "test"
    val scalatest = "org.scalatest" % "scalatest" % "1.2" % "test"
    val akka = "se.scalablesolutions.akka" % "akka-core_2.8.0" % "0.10"
  }
}

---

编辑：应该指出使用Akka有一个简单的方法，但只是说明了我的观点。

使用继承和混合：

import sbt._

class ModularProject(info: ProjectInfo) extends DefaultProject(info){

    lazy val childProject = project("projA", "ProjectA", 
        new DefaultProject(_)   
            with Repositories 
            with GlobalDependencies
            with AkkaDependencies)

    trait Repositories{
        lazy val akkaRepo = "Akka maven2 repo" at 
        "http://www.scalablesolutions.se/akka/repository/"
        lazy val multiversRepo = "Multiverse maven2 repo" at 
        "http://multiverse.googlecode.com/svn/maven-repository/releases/"
        lazy val guiceyFruitRepo = "GuiceyFruit Maven2 repo" at 
        "http://guiceyfruit.googlecode.com/svn/repo/releases/"
        lazy val jBossRepo = "JBoss maven2 repo" at 
        "https://repository.jboss.org/nexus/content/groups/public/"
    }

    trait GlobalDependencies{
        lazy val junit = "junit" % "junit" % "4.5" % "test"
        lazy val scalatest = "org.scalatest" % "scalatest" % "1.2" % "test"
    }

    trait AkkaDependencies{
        lazy val akka = "se.scalablesolutions.akka" % "akka-core_2.8.0" % "0.10"
    }       

}

---

通常的解决方案是将每个子项目的依赖项放在一个类中，就像处理Proj类一样。通常每个子项目需要一个类，因为它们通常具有唯一的依赖关系

如果您是懒惰的，则可以声明具有串联依赖项的类：

object Dependencies {
    ....
    lazy val jodaTime = "joda-time" % "joda-time" % ...
    lazy val scalaTime = "org.scala-tools" % "time" % ...
    lazy val redis = "com.redis" % "redisclient" % ...
}

val xBase = project("x-base", "x-base", new DefaultProject(_) {
    val jodaTime = Dependencies.jodaTime
    val scalaTime = Dependencies.scalaTime
  })

val xY = project("x-y", "x-y", new DefaultProject(_) { val redis = Dependencies.redis }, xBase)

在上面的示例中（对于产品x），

xY

模块依赖于

xBase

模块

---

Dependencies对象使模块中的依赖项易于重用。

此后发生了很大变化，使用sbt 0.13.x，现在可以在根项目中使用

项目/RootBuild.scala

为所有子项目设置默认依赖项，该根项目聚合了

其他子项目（然后他们将设置分辨率委托给）如下所示：

import sbt._
import Keys._

object RootBuild extends Build {
  override lazy val settings = super.settings ++
    Seq(resolvers += "Akka maven2 repo" at "http://www.scalablesolutions.se/akka/repository/")
}

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

设置了
解析器后，子项目也将设置它

[root]> resolvers
[info] a/*:resolvers
[info]  List(Akka maven2 repo: http://www.scalablesolutions.se/akka/repository/)
[info] b/*:resolvers
[info]  List(Akka maven2 repo: http://www.scalablesolutions.se/akka/repository/)
[info] root/*:resolvers
[info]  List(Akka maven2 repo: http://www.scalablesolutions.se/akka/repository/)

根项目的
build.sbt
如下所示：

import sbt._
import Keys._

object RootBuild extends Build {
  override lazy val settings = super.settings ++
    Seq(resolvers += "Akka maven2 repo" at "http://www.scalablesolutions.se/akka/repository/")
}

lazy val root = project in file(".") aggregate (a, b)

lazy val a = project dependsOn b

lazy val b = project

请查阅sbt的官方文件，了解相关信息

但是，还有另一种（更好的？）方法来定义具有作用域的公共配置

使用上面的
RootBuild.scala
build定义和
build.sbt
，我在这个build中使用
来确定整个构建的范围设置，构建配置最终在多项目设置中有两个默认的
解析器

[root]> resolvers
[info] a/*:resolvers
[info]  List(Akka maven2 repo: http://www.scalablesolutions.se/akka/repository/, JBoss maven2 repo: https://repository.jboss.org/nexus/content/groups/public/)
[info] b/*:resolvers
[info]  List(Akka maven2 repo: http://www.scalablesolutions.se/akka/repository/, JBoss maven2 repo: https://repository.jboss.org/nexus/content/groups/public/)
[info] root/*:resolvers
[info]  List(Akka maven2 repo: http://www.scalablesolutions.se/akka/repository/, JBoss maven2 repo: https://repository.jboss.org/nexus/content/groups/public/)

这与聚合无关，而是在生成级别定义设置，然后项目将其委托给该级别。通常，最好使用正常的Scala重用机制在每个项目上声明设置。@MarkHarrah您刚才提出了一个有效的观点，使我将答案改为包含
此生成
。这是怎么回事他现在的样子？只需使用标准的Scala重用机制。例如，在val中定义一系列常见设置，并将它们添加到每个项目中。通过这种方式学习的概念更少。我需要一个简单的要点来确保我理解了这个想法。我希望获得额外的指导。这是根项目中的.Scala和子项目中的.sbt defs的混合吗暗示更多的
\uuu.scala
文件，它们包含
val blablaSetting=Seq（）
。您只需导入并使用它们。SBT构建是“scala项目”，因此任何代码重用技术都以与普通代码相同的方式应用于构建。