scala - 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 库，该库会自动反射(reflect)您的数据库架构并创建一个包含数据库中所有模型的文件。

该文档专门针对 slick-codegen : http://slick.lightbend.com/doc/3.1.0/code-generation.html

但我会为您分解它，使其变得更容易。对于 postgres 来说，执行此操作的方法如下:

1. 通过在 build.sbt 中添加以下行，将 slick-codegen 添加到您的库依赖项: libraryDependencies += "com.typesafe.slick"%% "slick-codegen"% "3.1.0"
2. 确保您的数据库在 postgres 的任何端口(假设为 5432)上运行，并在 build.sbt 中包含适当的 postgresql 驱动程序

3. 在您的项目中创建以下 scala 文件(您可以右键单击该文件以在 IntelliJ 中运行，或者如果您不使用 IntelliJ，则可能必须将其更改为可执行的 Scala 文件。人们也找到了一种方法在编译时通过 sbt 本身运行它，但我不会深入讨论):

   
对象 SlickCodeGen {
def main(args: Array[String]): 单位 = {
slick.codegen.SourceCodeGenerator.main(
数组(“slick.jdbc.PostgresProfile”，
“org.postgresql.Driver”，
DATABASE_URL,
DIRECTORY_TO_PLACE_FILE，
包裹，
用户名，
密码)
)
}
}


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. 创建此文件后，您可以轻松地利用案例类(如您想要的那样)，一个示例是当您需要向计算机表添加新行时，您可以简单地执行以下操作计算机 += ComputerRow(...)

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

总结一下，

1. slick-codegen 可以从数据库自动生成您的 scala 类，或者在本例中通过运行 Computer.schema 来相反。
2. slick 对 scala 非常友好(案例类、monad 操作)
3. 不错的样板，但确实可以在您的应用程序中使用，也可以自定义，并且所有表格都可以在一个文件中创建或根据您的需要分开。

我认为使用 Slick 不会出错。