Scala对JDBC的一些封装（1）

by 壮衣

JDBC提供一套完善的API来处理数据库编程，利用JDBC我们可以完成数据的插入、查询、更新和删除。
向数据库中插入一条数据：

  case class User(id: Int, username: String, password: String)
  
  val SQL_INSERT_USER = "insert into user (username, password) values (?, ?)"
  
  def addUser(user: User)(conn: Connection): Int = {
    var stmt: PreparedStatement = null
    try {
      stmt = conn.prepareStatement(SQL_INSERT_USER)
      stmt.setString(1, user.username)
      stmt.setString(2, user.password)
      stmt.executeUpdate()
    } catch {
      case e: SQLException => -1
    } finally {
      if(stmt != null) stmt.close()
      if(conn != null) conn.close()
    }
  }

从数据库中查询一条数据

  val SQL_SELECT_USER = "select id, username, password from user where id = ?"

  def getUser(id: Int)(conn: Connection): User = {
    var stmt: PreparedStatement = null
    var rs: ResultSet = null
    try {
      stmt = conn.prepareStatement(SQL_SELECT_USER)
      stmt.setInt(1, id)
      rs = stmt.executeQuery()
      var user: User = null
      if(rs.next()) {
        val id = rs.getInt("id")
        val username = rs.getString("username")
        val password = rs.getString("password")
        user = User(id, username, password)
      }
      user
    } catch {
      case e: SQLException => null
    } finally {
      if(rs != null) rs.close()
      if(stmt != null) stmt.close()
      if(conn != null) conn.close()
    }
  }

我们仔细看下上面两个方法就会发现两者主要的区别就是SQL语句、execute方法调用和返回值不一样，其它的大部分代码都是一样，也就是说为了一个插入和查询操作我们写了大量的模式代码；还有就是上面的代码在遇到异常之后并没有把异常信息带回到返回值中，getUser方法中返回null也会造成类型不安全的问题。针对这两个问题有什么好的解决方案吗？java程序员应该熟悉Spring框架提供了一个SimpleJdbcTemplate的模版来承担资源管理、异常处理和简化代码的工作，也有一些很好的ORM框架可以使用，如MyBatis和Hibernate；那对于Scala语言有什么好的选择呢？当然我们可以选择doobie或者slick等一些持久化框架，但是为什么不自己对JDBC的代码做一些封装呢？我想应该是一件很有趣的事情。

首先我们想一下封装后的API应该是什么样子？怎样做到简练又有很强的表现力？回想一下上面两个方法主要的区别就是SQL语句、execute方法调用和返回值不一样，我们可以从这个三个地方下手，想象一下如下的代码。
向数据库中插入一条数据：

  def addUser1(user: User)(conn: Connection): Either[Exception, Int] = 
    StatementIO("insert into user (username, password) values (?, ?)", 
      List(user.username, user.password)).update.run(conn)

从数据库中查询一条数据：

  def getUser1(id: Int)(conn: Connection): Either[Exception, User] =
    StatementIO("select id, username, password from user where id = ?", List(id))
      .query.unique.run(conn)

可以看到调用封装之后的API，方法的实现变的更加简练明了，两个方法的区别主要体现在SQL语句的不同、调用的是query方法还是update方法和方法返回值不一样，除此之外没有冗余雷同的模式代码；方法的返回值为Either类型，包含了可能的异常或正常时返回值。之前提到的两个问题，该API都可以很好的得到解决。那么现在的问题就是StatementIO是什么样的类型？update方法和query方法是怎么实现的？run方法又是什么？那我们先看下StatementIO类型的实现：

import java.sql.{Connection, ResultSet}

class StatementIO(sql: String, parameters: Seq[Any]) {

  import StatementIO._
  
  import Using._

  def query[A: Mapping]: ConnectionIO[List[A]] = {
    val f = implicitly[Mapping[A]]
    val fa = (conn: Connection) =>
      using(conn.prepareStatement(sql)) {
        stmt =>
          (1 to parameters.size).zip(parameters).foreach {
            case (i, p) => stmt.setObject(i, p)
          }
          using(stmt.executeQuery())(_.rows.map(f))
      }
    ConnectionIO(fa)
  }


  def update: ConnectionIO[Int] = {
    val fb = (conn: Connection) =>
      using(conn.prepareStatement(sql)) {
        stmt => 
          (1 to parameters.size).zip(parameters).foreach {
            case (i, p) => stmt.setObject(i, p)
          }
          stmt.executeUpdate()
      }
    ConnectionIO(fb)
  }
}

首先看到StatementIO类型有两个构造参数sql和parameters，分别表示需要执行的SQL和SQL中需要传入的参数。然后看下query方法和update方法的实现，query方法无显示传入参数输出ConnectionIO[List[A]]；update方法无传入参数输出ConnectionIO[Int]。暂时可以先不关心ConnectionIO的实现，我们先看下这两个方法具体都做了些什么，query方法构造了一个函数fa：传入Connection输出List[A]。该函数主要完成查询SQL预编译、参数设置、执行查询和利用函数f对查询结果进行类型转换。最后利用fa构造返回类型ConnectionIO[List[A]]，我们暂时先不关注Mapping类型，只要知道他的作用是将List[String]映射到类型A；update方法构造了一个函数fb：传入Connection输出Int。该函数主要完成更新SQL预编译、参数设置、执行更新。最后利用fb构造返回类型ConnectionIO[Int]。可以看出query方法和update方法并没有真正执行了SQL语句，而是使用SQL语句构造了一个执行SQL语句的函数并使用该函数构造了ConnectionIO类型。现在真是迫不及待的想知道ConnectionIO类型到底是个什么样子，别急我们还得看下类中引用的两个对象：StatementIO和Using。Using在上一篇博文中有介绍，用于资源的自动关闭，那就来看下伴生对象StatementIO的实现吧。

object StatementIO {

  def apply(sql: String, parameters: Seq[Any]): StatementIO = new StatementIO(sql, parameters)

  implicit class ResultSetOp(rs: ResultSet) {

    private val columnLength = rs.getMetaData.getColumnCount

    def columns: List[String]  = (1 to columnLength).map(rs.getMetaData.getColumnLabel).toList

    def rows: List[List[String]] = {
      def loop(rs: ResultSet, lines: List[List[String]]): List[List[String]] =
        if(rs.next()) {
          val line = (1 to columnLength).map(rs.getString).toList
          loop(rs, lines :+ line)
        } else lines
      loop(rs, Nil)
    }
  }
}

伴生对象StatementIO主要做了两件事情，apply方法为StatementIO类型提供更便捷的构造方法。还有就是一个隐式类ResultSetOp，该隐式类为ResultSet类型提供了columns和rows方法，分别获取查询结果的列以及递归获取查询的所有行。我们可以直接对ResultSet类型调用rows方法来获取所有的行，返回结果为List[List[String]]类型。StatementIO类型介绍完了，我们来看下ConnectionIO类型。

class ConnectionIO[A](func: Connection => A) {

  def map[B](fa: A => B): ConnectionIO[B] = {
    val fb = (conn: Connection) => {
      val a = func(conn)
      fa(a)
    }
    new ConnectionIO(fb)
  }

  def flatMap[B](fa: A => ConnectionIO[B]): ConnectionIO[B] = {
    val fb = (conn: Connection) => {
      val a = func(conn)
      fa(a).extract(conn)
    }
    new ConnectionIO(fb)
  }

  def run(conn: Connection): Either[Exception, A] = {
    try Right(func(conn))
    catch {
      case e: Exception => Left(e)
    } finally {
      if(conn != null) conn.close()
    }
  }

  def transact(conn: Connection): Either[Exception, A] = {
    try {
      conn.setAutoCommit(false)
      val res = extract(conn)
      conn.commit()
      Right(res)
    } catch {
      case e: Exception =>
        conn.rollback()
        Left(e)
    } finally {
      if(conn != null) conn.close()
    }
  }

  private[ConnectionIO] def extract(conn: Connection): A = func(conn)

}

ConnectionIO类型实现了map和flatMap方法，用于ConnectionIO类型的自由组合以及使得ConnectionIO类型可以使用for表达式这样的语法糖。ConnectionIO类型有一个构造参数func: Connection => A，代表着要执行的函数，而方法run和transact为实际执行func函数的方法。两者的区别在于run方法传入Connection 直接执行func方法提交连接，异常返回Left[Exception]；正常返回Right[A]。而transact方法不直接提交连接，而是在func方法正常执行后提交连接，异常的情况下回滚事务，可见transact方法适用于需要添加事务的场景。我们再来看下ConnectionIO类型的伴生对象：

object ConnectionIO {

  def apply[A](func: Connection => A): ConnectionIO[A] = new ConnectionIO(func)

  implicit class ConnectionIOOp[A](ca: ConnectionIO[List[A]]) {

    def list: ConnectionIO[List[A]] = ca

    def unique: ConnectionIO[A] = ca.map(_.head)

    def option: ConnectionIO[Option[A]] = ca.map(_.headOption)

  }

}

ConnectionIO伴生对象中apply方法用于方便构造ConnectionIO类型对象，除此之外还有一个隐式类ConnectionIOOp。该类为ConnectionIO[List[A]])提供了3个方法list、unique和option。list方法返回查询的所有结果，unique方法返回查询的第一条结果，假如查询为空方法会抛出异常，option方法也返回查询的第一条结果，假如查询为空的时候返回None，不为空时返回Some(A)。到此封装API两个核心类型StatementIO和ConnectionIO都已经介绍完了，文中也列举了一些简单的例子来展示API如何使用。那面对更加复杂的数据库操作，我们又该如何使用上述API呢？请看下篇博文《Scala对JDBC的一些封装（2）》