Java SBT构建，在编译和运行时从子项目运行主类

我有一个简单的构建工具多项目问题

以下目录结构代表我的java sbt项目：

/project1
/project2
/project3

因此，所有项目都共享一个公共的直接父文件夹。 项目2和3在项目1的build.sbt中引用如下：

.dependsOn(project2, project3)
.aggregate(project2, project3)

lazy val project2 = ProjectRef(file("../project2"), "project2")

lazy val project3 = ProjectRef(file("../project3"), "project3")

这样，project1和其他项目之间就存在依赖关系

在这一点上一切都很好，一切正常

但是现在我想在执行其他任何操作之前执行project2中的main方法。 当我从父级（project1）执行“run”任务时，我希望从project2执行一个特定类的main方法。我该怎么做？ sbt文档解释说：“聚合意味着在聚合项目上运行任务也将在聚合项目上运行它。”

我没有看到我在projet2上的主类被执行。我还将此添加到project2的build.sbt中：

mainClass in (Compile, run) := Some("Main")

projet的目标是在编译时和运行时生成代码。Project2的工作是生成Java和Javascript代码。可以在构建其他项目之前生成

可能吗？如果没有，我将不得不满足于独立于其他项目运行project2

---

=]

如果我有如下所示的结构：

+根目录
+---后端
+---前端

和build.sbt项目类似，如中所示：

lazy val commonSettings = Seq(
  version := "0.1.0-SNAPSHOT",
  scalaVersion := "2.12.1",
  resolvers := allResolvers,
  libraryDependencies := AllLibraryDependencies
)

lazy val client = (project in file("client")).
  //  .enablePlugins(PlayScala)
  settings(commonSettings: _*).
  settings(
    name := "client"
  )
  .aggregate(common, frontend, backend)
  .dependsOn(common, frontend, backend)


lazy val common = (project in file("common")).
  settings(commonSettings: _*).
  settings(
    name := "common"
  )

lazy val frontend = (project in file("frontend")).
  settings(commonSettings: _*).
  settings(
    name := "frontend"
  )
  .aggregate(common)
  .dependsOn(common)

lazy val backend = (project in file("backend")).
  settings(commonSettings: _*).
  settings(
    name := "backend"
  )
  .aggregate(common)
  .dependsOn(common)

`

然后，为了在前端项目中执行一个类，该命令对我有效：

---

sbt“frontend/runMain sample.cluster.transformation.frontend.TransformationFrontendApp 2551”

默认情况下

run/aggregate

为

false

：

sbt:root> inspect run / aggregate
[info] Setting: Boolean = false
[info] Description:
[info]  Configures task aggregation.
[info] Provided by:
[info]  Zero / run / aggregate
[info] Defined at:
[info]  (sbt.Defaults.disableAggregate) Defaults.scala:1920
[info] Delegates:
[info]  run / aggregate
[info]  aggregate
[info]  ThisBuild / run / aggregate
[info]  ThisBuild / aggregate
[info]  Zero / run / aggregate
[info]  Global / aggregate
[info] Related:
[info]  Global / aggregate
[info]  Zero / run / aggregate
[info]  Zero / consoleQuick / aggregate
[info]  dependencyCheckPurge / aggregate
[info]  refinedConsole / dependencyCheckUpdateOnly / aggregate
[info]  refinedConsole / dependencyCheckAggregate / aggregate
[info]  server / dependencyCheckListSettings / aggregate
[info]  Zero / changedInputFiles / aggregate
[info]  refinedConsole / dependencyCheckListSettings / aggregate
[info]  refinedConsole / dependencyCheckPurge / aggregate
[info] ...

因此，

run

任务将不会被聚合

即使将其设置为

true

，也不太可能得到想要的结果，因为聚合任务的顺序尚未定义

创建任务依赖关系是通过相互评估来完成的（正如@akauppi在旧SBT语法中指出的）：

现在，如果您还想在

project1

上调用

run

，它会变得有点棘手

天真的做法是：

lazy val project1 = (project in file("project1")
  .settings(
    Compile / run := {
      (project2 / Compile / run).evaluated
      (project1 / Compile / run).evaluated
    }
  )

但不能保证它会首先运行project2

我还没找到办法让它工作

我尝试使用：

(project2 / Compile / run).flatMap((project1 / Compile / run).toTask("").taskValue

但是您会得到一个非法的动态引用错误

我还尝试：

Def.sequential((server / Compile / run).toTask(""), (Compile / run).toTask("")).value

但这只会在运行时产生一个未定义的设置错误

---

令人惊讶的是，你还没有得到任何建议。你还记得吗，你有办法解决它吗？似乎有一个解决方案：

在Compile@Misael Neto中运行您能做到这一点吗？如果是，怎么做？
Def.sequential((server / Compile / run).toTask(""), (Compile / run).toTask("")).value