Play 框架和自动生成的演变

Question

我喜欢使用 Play 引导项目！ Ebean，内存数据库：当我需要一个新模型时，进化会自动生成，这太棒了。

我正在学习Play Scala，Ebean和Scala之间缺乏支持

它可以工作，.enablePlugins(PlayScala, PlayEbean) 但不支持将案例类作为 Ebean 模型。

我想知道，你知道一个 ORM 吗：

• 自动生成给定模型类的 mysql 或 postgresql 架构
• 对 Scala 友好（尤其是案例类）
• 简约样板（this 是一个 Ebean 模型，不需要像任何存储库那样的其他文件）

我认为 slick 或 JPA 不会产生进化？我试过了，但没有成功。

PS：使用案例类，您可以从/到 json 获得隐式读取器和写入器，这也很棒。

Answer 1

我认为答案中提到的 Slick ORM 绝对是这里的方法。

Slick ORM 在 scala 中效果很好，因为您可以在这个特定的 ORM 中使用诸如 filter、map 和其他功能范式之类的操作。另一方面，slick 有很棒的文档，你可以从这个链接中看到：

http://slick.lightbend.com/doc/3.1.0/

假设您对 ORM 开放，我们可以轻松地继续使用 slick-codegen 库，它会自动反映您的数据库架构并创建一个包含数据库中所有模型的文件。

文档专门在 slick-codegen 上： http://slick.lightbend.com/doc/3.1.0/code-generation.html

但我会为你分解它以使其更容易。 postgres 的方法如下：

1. 将slick-codegen 添加到您的库依赖项中，方法是在您的 build.sbt 中添加以下行：libraryDependencies += "com.typesafe.slick" %% "slick-codegen" % "3.1.0"
2. 确保您的数据库在 postgres 的任何端口（比如说 5432）上运行，并在 build.sbt 中包含适当的 postgresql 驱动程序

3. 在您的项目中创建以下 scala 文件（您可以右键单击以在 IntelliJ 中运行，或者如果您不使用 IntelliJ，则可能需要将其更改为可执行的 Scala 文件。人们还想出了一种方法来运行它在编译期间通过 sbt 本身，但我不会进入）：

   object SlickCodeGen { def main(args: Array[String]): Unit = { slick.codegen.SourceCodeGenerator.main( Array("slick.jdbc.PostgresProfile", "org.postgresql.Driver", DATABASE_URL, DIRECTORY_TO_PLACE_FILE, PACKAGE, USERNAME, PASSWORD) ) } }

4. 运行 scala 文件后，您将在之前指定的目录和包中看到一个名为 Tables.scala 的新文件。

5. 该文件包含最少且唯一必要的组件，例如，对于您在链接中显示的 Computer 之类的表，将生成从数据库到案例类的隐式转换，并且可能看起来像如下（仅用于演示目的，但如果样板太多，文件的长度将大致相同）：

   package
   // AUTO-GENERATED Slick data model
   /** Stand-alone Slick data model for immediate use */
   object Tables extends {
     val profile = slick.jdbc.PostgresProfile
   } with Tables
   
   /** Slick data model trait for extension, choice of backend or usage in the cake pattern. (Make sure to initialize this late.) */
   trait Tables {
     val profile: slick.jdbc.JdbcProfile
     import profile.api._
     import slick.model.ForeignKeyAction
     // NOTE: GetResult mappers for plain SQL are only generated for tables where Slick knows how to map the types of all columns.
     import slick.jdbc.{GetResult => GR}
   
     /** DDL for all tables. Call .create to execute. */
     lazy val schema
       : profile.SchemaDescription = Computer.schema 
     @deprecated("Use .schema instead of .ddl", "3.0")
     def ddl = schema
   
     case class ComputerRow(name: String,
                            introduced: Date,
                            discontinued: Date,
                            company: Company)
   
     /** GetResult implicit for fetching ComputerRow objects using plain SQL queries */
     implicit def GetResultComputerRow(implicit e0: GR[String],
                                      e1: GR[Date],
                                      e2: GR[Company]): GR[ComputerRow] =
       GR { prs =>
         import prs._
         ComputerRow.tupled(
           (<<[String],
            <<[Date],
            <<[Date],
            <<[Company]))
       }
   
     /** Table description of table computer. Objects of this class serve as prototypes for rows in queries. */
     class Computers(_tableTag: Tag)
         extends profile.api.Table[ComputerRow](_tableTag,
                                               None,
                                               "computer") {
       def * =
         (name, introduced, discontinued, company) <> (ComputerRow.tupled, ComputerRow.unapply)
   
       /** Maps whole row to an option. Useful for outer joins. */
       def ? =
         (Rep.Some(name),
          Rep.Some(introduced),
          Rep.Some(discontinued),
          Rep.Some(company).shaped.<>(
           { r =>
             import r._;
             _1.map(
               _ =>
                 ComputerRow.tupled(
                   (_1.get, _2.get, _3.get, _4.get)))
           },
           (_: Any) =>
             throw new Exception("Inserting into ? projection not supported.")
         )
   
       /** Database column name SqlType(text) */
       val name: Rep[String] = column[String]("name", O.PrimaryKey)
   
       /** Database column introduced SqlType(date) */
       val firstName: Rep[Date] = column[Date]("introduced")
   
       /** Database column discontinued SqlType(date) */
       val lastName: Rep[Date] = column[Date]("discontinued")
   
       /** Database column company SqlType(text) */
       val gender: Rep[Company] = column[Company]("company")
     }
   
     /** Collection-like TableQuery object for table Computer */
     lazy val Computer = new TableQuery(tag => new Computer(tag))
   }
   

   6. 创建此文件后，您可以轻松地利用案例类（如您所愿），例如，当您需要在计算机表中添加新行时，您可以简单地执行 Computer += ComputerRow(...)

请注意，此处的 ComputerRow 是一个案例类。

总结一下，

1. slick-codegen 可以从数据库中自动生成你的 scala 类，或者在这种情况下运行 Computer.schema 反过来。
2. slick 对 Scala 非常友好（案例类、monad 操作）
3. 不错的样板，但真正用于您的应用程序，也可以自定义，所有表可以在一个文件中创建或根据您的需要分开。

我认为这里的 Slick 不会出错。