scala 操作数据库的方法

Scala操作数据库的方法

Scala是一门面向对象的静态类型编程语言，和Java一样，也是常用语言之一。Scala在Java语言基础上融入了面向对象和函数式编程的特性，并且Scala具有更为简洁的语法设计，在Java编写的代码中，依赖于Hibernate、Mybatis等ORM框架将内存中的类实例映射到数据库中，而Scala语言一般会使用Slick框架来进行数据库操作。

1. 配置依赖

Scala访问数据库，需要导入需要的依赖包。

libraryDependencies += "com.typesafe.slick" %% "slick" % "3.3.3"
libraryDependencies += "com.typesafe.slick" %% "slick-hikaricp" % "3.3.3"
libraryDependencies += "mysql" % "mysql-connector-java" % "5.1.47"

2. 建立连接

使用Database.forConfig方法连接数据库，这里以MySQL为例。

import slick.jdbc.MySQLProfile.api._
import scala.concurrent.ExecutionContext.Implicits.global

val db = Database.forConfig("mysql")//里面mysql就是application.conf里面写的名字

3. 定义表结构

通过定义case class来定义表结构:

case class User(id: Long, name: String, age: Int)

并且定义对应的表的Table类:

class UserTable(tag: Tag) extends Table[User](tag, "user") {
  def id = column[Long]("id", O.PrimaryKey, O.AutoInc)
  def name = column[String]("name")
  def age = column[Int]("age")
  def * = (id, name, age) <> (User.tupled, User.unapply)
}

4. CRUD操作

使用Slick进行CRUD操作非常简单，只需要组合使用Slick提供的语法即可。

（1）创建表

根据定义好的Table类，使用Slick提供的createIfNotExists().run方法进行建表：

val userTable = TableQuery[UserTable]
db.run(userTable.schema.createIfNotExists)

（2）插入数据

使用+=操作符插入数据：

val user = User(1L, "John Doe", 25)
val insertAction = userTable += user
db.run(insertAction).map { count =>
  println(s"inserted $count rows")
}

（3）查询数据

使用result.headOption查询数据：

val queryAction = userTable.filter(_.id === 1L).result.headOption
db.run(queryAction).map { userOpt =>
  userOpt match {
    case Some(user) => println(user)
    case None => println("no result")
  }
}

（4）更新数据

使用update操作更新数据：

val updateAction = userTable.filter(_.id === 1L).map(_.age).update(32)
db.run(updateAction).map { count =>
  println(s"updated $count rows")
}

（5）删除数据

使用delete操作删除数据：

val deleteAction = userTable.filter(_.id === 1L).delete
db.run(deleteAction).map { count =>
  println(s"deleted $count rows")
}

5. 完整示例

下面是一个完整的示例，演示了如何使用Slick进行数据库操作。

import slick.jdbc.MySQLProfile.api._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration.Duration

case class User(id: Long, name: String, age: Int)

class UserTable(tag: Tag) extends Table[User](tag, "user") {
  def id = column[Long]("id", O.PrimaryKey, O.AutoInc)
  def name = column[String]("name")
  def age = column[Int]("age")
  def * = (id, name, age) <> (User.tupled, User.unapply)
}

object Main {
  val db = Database.forConfig("mysql")
  val userTable = TableQuery[UserTable]

  // 建表
  def createTable() = {
    val action = userTable.schema.createIfNotExists
    Await.result(db.run(action), Duration.Inf)
  }

  // 插入数据
  def insertData() = {
    val user = User(1L, "John Doe", 25)
    val action = userTable += user
    Await.result(db.run(action), Duration.Inf)
  }

  // 查询数据
  def queryData() = {
    val action = userTable.filter(_.id === 1L).result.headOption
    val userOpt = Await.result(db.run(action), Duration.Inf)
    userOpt match {
      case Some(user) => println(user)
      case None => println("no result")
    }
  }

  // 更新数据
  def updateData() = {
    val action = userTable.filter(_.id === 1L).map(_.age).update(32)
    val count = Await.result(db.run(action), Duration.Inf)
    println(s"updated $count rows")
  }

  // 删除数据
  def deleteData() = {
    val action = userTable.filter(_.id === 1L).delete
    val count = Await.result(db.run(action), Duration.Inf)
    println(s"deleted $count rows")
  }

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

    insertData()

    queryData()

    updateData()

    deleteData()

    db.close()
  }
}

这是一个使用Slick进行简单数据库操作的例子，Scala在数据库操作上的代码结构和Java有所不同，但是使用起来却更为简单直观，而且代码量也比Java少不少。