Scala 使用sbt和Akka微内核运行应用程序

我可以在我的项目中使用这两种方法吗

以前我只有对象扩展

App

trait，但自从我开始使用

Microkernel

以来，我需要类扩展

Bootable

trait

假设我有这样的东西：

lazy val backend = (project in file("backend"))
  .enablePlugins(AkkaAppPackaging)
  .enablePlugins(UniversalPlugin)
  .settings(
    name := "backend",
    mainClass in Compile := Some("backend.Backend"),
    libraryDependencies ++= Dependencies.backend,
    javaOptions in run ++= Seq("-Djava.library.path=./sigar"),
    fork in run := true)
  .dependsOn(api)
  .aggregate(api)

class Backend extends Bootable {

      val system = ActorSystem("mobile-cluster")

      def startup() = {
        FactorialBackend startOn system
      }

      def shutdown() = {
        system.shutdown()
      }
    }

object Backend extends App {

      val system = ActorSystem("application")

      FactorialBackend startOn system
    } 

和后端类，如下所示：

lazy val backend = (project in file("backend"))
  .enablePlugins(AkkaAppPackaging)
  .enablePlugins(UniversalPlugin)
  .settings(
    name := "backend",
    mainClass in Compile := Some("backend.Backend"),
    libraryDependencies ++= Dependencies.backend,
    javaOptions in run ++= Seq("-Djava.library.path=./sigar"),
    fork in run := true)
  .dependsOn(api)
  .aggregate(api)

class Backend extends Bootable {

      val system = ActorSystem("mobile-cluster")

      def startup() = {
        FactorialBackend startOn system
      }

      def shutdown() = {
        system.shutdown()
      }
    }

object Backend extends App {

      val system = ActorSystem("application")

      FactorialBackend startOn system
    } 

我无法使用

sbt run

启动应用程序（有一个错误是关于缺少静态main方法），但它可以与微核一起工作，当我运行

sbt stage

并使用生成的脚本启动下一个应用程序时，它可以正常工作

当我使用这样的东西时：

lazy val backend = (project in file("backend"))
  .enablePlugins(AkkaAppPackaging)
  .enablePlugins(UniversalPlugin)
  .settings(
    name := "backend",
    mainClass in Compile := Some("backend.Backend"),
    libraryDependencies ++= Dependencies.backend,
    javaOptions in run ++= Seq("-Djava.library.path=./sigar"),
    fork in run := true)
  .dependsOn(api)
  .aggregate(api)

class Backend extends Bootable {

      val system = ActorSystem("mobile-cluster")

      def startup() = {
        FactorialBackend startOn system
      }

      def shutdown() = {
        system.shutdown()
      }
    }

object Backend extends App {

      val system = ActorSystem("application")

      FactorialBackend startOn system
    } 

我可以用

sbt“project backend”“run”

启动应用程序，但微内核不再工作了

我能用它做什么？ 我应该用微核和sbt或单独的构建配置来启动应用程序吗

我需要有一个使用微内核的应用程序的生产版本，我还想在使用sbt进行开发的过程中运行和调试我的应用程序

---

我尝试使用相同的类或对象来扩展App和Bootable trait，或者将sbt.build配置为对Microkernel和

sbt run进行单独配置，但没有任何帮助。
一个解决方案是创建另一个模块，将可引导类放在那里并添加额外的构建配置：

lazy val backend = (project in file("backend"))
  .settings(
    name := "backend",
    libraryDependencies ++= Dependencies.backend,
    javaOptions in run ++= Seq("-Djava.library.path=./sigar"),
    // this enables custom javaOptions
    fork in run := true)
  .dependsOn(api)
  .aggregate(api)

lazy val boot = (project in file("boot"))
  .enablePlugins(AkkaAppPackaging)
  .enablePlugins(UniversalPlugin)
  .settings(
    name := "boot",
    mainClass in Compile := Some("com.example.Boot"),
    libraryDependencies ++= Dependencies.backend,
    // this enables custom javaOptions
    fork in run := true)
  .dependsOn(backend)
  .aggregate(api, backend)

现在我可以跑步了

sbt "project backend" "run"

及

我认为你不需要两个模块

您可以使用以下命令运行微内核

sbt“项目后端”“运行主akka.kernel.main后端”
通过sbt控制台执行以下说明：

runMain akka.kernel.Main Backend

这是一个很好的解决方案。我首先想到了一个附带的对象，它使用
App
扩展了
Bootable
类，然后执行
startup
方法，如果在引导部分没有太多内容，这是一个很好的解决方案。顺便说一句，感谢您尝试我的激活器：）