浅谈Slick（2）－ Slick101：第一个动手尝试的项目

看完Slick官方网站上关于Slick3.1.1技术文档后决定开始动手建一个项目来尝试一下Slick功能的具体使用方法。我把这个过程中的一些了解和想法记录下来和大家一起分享。首先我用IntelliJ-Idea创建了一个scala项目。下一步就是如何选择数据库了。Slick是集成jdbc的更高层的Query编程语言，可以通过jdbc的url、DataSource等来指定目标数据库类型及相关的参数。对应Slick中的具体函数有：

val db = Database.forConfig("mydb")
val db = Database.forURL("jdbc:h2:mem:test1;DB_CLOSE_DELAY=-1", driver="org.h2.Driver")
val db = Database.forDataSource(dataSource: slick.jdbc.DatabaseUrlDataSource)

在Slick的Database配置方面forConfig("confItem")是比较灵活、方便实用的。confItem是resources/application.conf文件里的一个配置项目。Slick是通过typesafe-config来解析配置文件的。forConfig函数用typesafe-config库里的函数载入application.conf文件解析confItem并获取项目里的数据库配置参数，下面是项目中resources/application.conf文件内容：

h2mem {
    url = "jdbc:h2:mem:slickdemo"
    driver = "org.h2.Driver"
    connectionPool = disabled
    keepAliveConnection = true
}

h2 = {
    url = "jdbc:h2:~/slickdemo;mv_store=false;MODE=MSSQLServer;DB_CLOSE_DELAY=-1;AUTO_SERVER=TRUE"
    driver = org.h2.Driver
    connectionPool = disabled
    keepAliveConnection = true
}

mysql {
  driver = "slick.driver.MySQLDriver$"
  db {
    url = "jdbc:mysql://localhost/slickdemo"
    driver = com.mysql.jdbc.Driver
    keepAliveConnection = true
    user="root"
    password=""
    numThreads=
    maxConnections =
    minConnections =
  }
}

mysqldb = {
  dataSourceClass = "com.mysql.jdbc.jdbc2.optional.MysqlDataSource"
  properties {
    user = "root"
    password = ""
    databaseName = "slickdemo"
    serverName = "localhost"
  }
  numThreads =
  maxConnections =
  minConnections =
}

postgres {
  driver = "slick.driver.PostgresDriver$"
  db {
    url = "jdbc:postgresql://127.0.0.1/slickdemo"
    driver = "org.postgresql.Driver"
    connectionPool = HikariCP
    user = "slick"
    password = ""
    numThreads =
    maxConnections =
    minConnections =
  }
}

postgressdb = {
  dataSourceClass = "org.postgresql.ds.PGSimpleDataSource"
  properties = {
    databaseName = "slickdemo"
    user = "slick"
    password = ""
  }
  connectionPool = HikariCP
  numThreads =
  maxConnections =
  minConnections =
}

mssql {
  driver = "com.typesafe.slick.driver.ms.SQLServerDriver$"
  db {
    url = "jdbc:sqlserver://host:port"
    driver = com.microsoft.sqlserver.jdbc.SQLServerDriver
    connectionTimeout =  second
    connectionPool = HikariCP
    user = "slick"
    password = ""
    numThreads =
    maxConnections =
    minConnections =
    keepAliveConnection = true
  }
}

tsql {
  driver = "slick.driver.H2Driver$"
  db = ${h2mem}
}

在我使用的application.conf文件中汇集了一些常用数据库的配置，我一并提供出来。除h2之外其它都没进行测试验证，具体配置参数和方法要参考数据库开发商提供的技术文档。我在这个示范里选用了h2配置：它会在我的用户根目录下创建一个slickdemo.h2.db数据库文件。
好了，选择了数据库，下面我们就来试试使用它。基本流程是这样的：首先在数据库里创建表，跟着写入一些数据，然后再读出显示。整个过程会涉及：表结构schema定义，数据插写Insert，数据读取Query及简单的Query运算方法和数据显示方法。

现在我们先设计表结构schema：

 package com.datatech.learn.slick101
 import slick.driver.H2Driver.api._
 object slick101 {

 /* ----- schema  */
   //表字段对应模版
   case class AlbumModel (id: Long
                    ,title: String
                    ,year: Option[Int]
                    ,artist: String
                    )
   //表结构: 定义字段类型, * 代表结果集字段
   class AlbumTable(tag: Tag) extends Table[AlbumModel](tag, "ALBUMS") {
     def id = column[Long]("ID",O.AutoInc,O.PrimaryKey)
     def title = column[String]("TITLE")
     def year = column[Option[Int]]("YEAR")
     def artist = column[String]("ARTIST",O.Default("Unknown"))
     def * = (id,title,year,artist) <> (AlbumModel.tupled, AlbumModel.unapply)
   }
   //库表实例
   val albums = TableQuery[AlbumTable]

在这个示范里我们确定使用H2数据库，所以需要import H2Driver.api。使用了case class AlbumModel作为库表字段对应模版。这样一是可以规范代码，再就是如果遇到一个宽表有很多列的话可以节省许多重复铺垫及避免无谓错误。

现在需要从库表实例albums产生它的schema，然后转换成一个DBIOAction：

  //创建表动作
 val createTableAction = albums.schema.create

这个createTableAction就是个DBIOAction：一个效果描述。我们必须用具体的实现方式Database.run来运算产生实际效果：

   //数据库实例化
 val db = Database.forConfig("h2")
 def main(args: Array[String]): Unit = {
    val res = db.run(createTableAction).andThen {
        case Success(_) => println("table ALBUMS created.")
        case Failure(e) => println(e.getMessage)
    }
    Await.result(res,  seconds)
 }

db.run返回Future类型。我们是用Future类型的andThen组件来显示运算结果的：

table ALBUMS created.

Process finished with exit code 

如果跟着再运算一次应该会产生重复重建错误：

Exception in thread "main" org.h2.jdbc.JdbcSQLException: Table "ALBUMS" already exists; SQL statement:
Table "ALBUMS" already exists; SQL statement: ...

下面是一个插入数据的动作：

 //插入数据动作
   val insertAlbumsAction =
   albums ++= Seq(
     AlbumModel(, "Keyboard Cat", Some(), "Keyboard Cat's Greatest Hits"),
     AlbumModel(, "Spice Girls", Some(), "Spice"),
     AlbumModel(, "Rick Astley", Some(), "Whenever You Need Somebody"),
     AlbumModel(, "Manowar", None,"The Triumph of Steel"),
     AlbumModel(, "Justin Bieber", Some(),"Believe"))

运算及显示结果：

    val res2 = db.run(insertAlbumsAction).andThen {
       case Success(_) => println("albums inserted.")
       case Failure(e) => println(e.getMessage)
     }
     Await.result(res2,  seconds)
 ---
 table ALBUMS created.
 albums inserted.

 Process finished with exit code 

下面是抽取动作和数据显示函数。我们把新插入的数据再读出来验证插入情况：

//数据抽取动作
  val selectAlbumsAction =
  albums.result
  def printResults[T](fut: Future[Iterable[T]]): Unit =
    Await.result(fut, Duration.Inf).foreach(println)

  val res3 = db.run(selectAlbumsAction)
  printResults(res3)

运算结果：

AlbumModel(,Keyboard Cat,Some(),Keyboard Cat's Greatest Hits)
AlbumModel(,Spice Girls,Some(),Spice)
AlbumModel(,Rick Astley,Some(),Whenever You Need Somebody)
AlbumModel(,Manowar,None,The Triumph of Steel)
AlbumModel(,Justin Bieber,Some(),Believe)

Process finished with exit code 

下面是完整的示范代码：

 package com.datatech.learn.slick101
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
 import scala.concurrent.{Await, Future}
 import scala.util.{Success,Failure}

 import slick.driver.H2Driver.api._
 object slick101 {

   /* ----- schema  */
   //表字段对应模版
   case class AlbumModel(id: Long
                         , artist: String
                         , year: Option[Int]
                         , title: String
                        )

   //表结构: 定义字段类型, * 代表结果集字段
   class AlbumTable(tag: Tag) extends Table[AlbumModel](tag, "ALBUMS") {
     def id = column[Long]("ID", O.AutoInc, O.PrimaryKey)

     def title = column[String]("TITLE")

     def year = column[Option[Int]]("YEAR")

     def artist = column[String]("ARTIST", O.Default("Unknown"))

     def * = (id, artist, year, title) <> (AlbumModel.tupled, AlbumModel.unapply)
   }

   //库表实例
   val albums = TableQuery[AlbumTable]

   //创建表动作
   val createTableAction = albums.schema.create

   //数据库实例化
   val db = Database.forConfig("h2")

   //插入数据动作
   val insertAlbumsAction =
   albums ++= Seq(
     AlbumModel(, "Keyboard Cat", Some(), "Keyboard Cat's Greatest Hits"),
     AlbumModel(, "Spice Girls", Some(), "Spice"),
     AlbumModel(, "Rick Astley", Some(), "Whenever You Need Somebody"),
     AlbumModel(, "Manowar", None,"The Triumph of Steel"),
     AlbumModel(, "Justin Bieber", Some(),"Believe"))

   //数据抽取动作
   val selectAlbumsAction =
   albums.result

   def printResults[T](fut: Future[Iterable[T]]): Unit =
     Await.result(fut, Duration.Inf).foreach(println)

   def main(args: Array[String]): Unit = {

      val res = db.run(createTableAction).andThen {
        case Success(_) => println("table ALBUMS created.")
        case Failure(e) => println(e.getMessage)
      }
      Await.result(res,  seconds)

     val res2 = db.run(insertAlbumsAction).andThen {
       case Success(_) => println("albums inserted.")
       case Failure(e) => println(e.getMessage)
     }
     Await.result(res2,  seconds) 

     val res3 = db.run(selectAlbumsAction)
     printResults(res3)
   }
 }