使用scalikejdbc操作数据库（二）使用连接池增删改查

前言

在（一）我们已经能通过配置文件来创建了数据库的连接池，本章我们将来接着通过连接池来进行数据库的增删改查。

只操作一个数据库的curd

对于增删改查的使用我们直接上代码

ConnectionPool.singleton("jdbc:...","user","password")
case class User(id: Int, name: String)

val users = DB readOnly { session =>
  session.list("select * from user") { rs =>
  User(rs.int("id"), rs.string("name"))
  }
}

DB autoCommit { session =>
  session.update("insert into user values (?,?)", 123, "Alice")
}

DB localTx { session =>
    session.update("insert into user values (?,?)", 123, "Alice")
 }

上述代码是通过ConnectionPool.singleton()的方式来创建连接池的，使用这种方式创建连接池之后就可以直接使用DB来调用readOnly 、autoCommit 、localTx 等方法。这种方式有一点是比较坑的是DB在调用readOnly 和localTx 方法的时候，默认是在使用完之后把链接关闭的，对于batch提交的操作在第一个批次执行完之后，链接就被关闭了。所以对于批次插入的使用需要用autoCommit 。autoCommit 默认是不会关闭链接的。需要注意的是我们在插入完成后需要手动关闭链接。

DB  autoCommit { implicit session =>
        SQL(s"${esql}").batch(data: _*).apply()
}

除了上述的DBSession的方式，scalikejdbc还提供了SQL类来执行你的sql，不过最后仍然是调用的是上述DBSession的方法。

ConnectionPool.singleton("jdbc:...","user","password")
case class User(id: Int, name: String)

val users = DB readOnly { implicit session =>
  SQL("select * from user").map { rs =>
    User(rs.int("id"), rs.string("name"))
  }.list.apply()
}

DB autoCommit { implicit session =>
  SQL("insert into user values (?,?)").bind(123, "Alice").update.apply()
}

DB localTx { implicit session =>
  SQL("insert into user values (?,?)").bind(123, "Alice").update.apply()
}

需要操作多个数据库的curd

在第一章中我们提到过在实际的项目中我们可能会在一个程序中操作多个数据库的情况，这时候在按上述方式执行数据的操作的话就可能会出问题。第一个问题是创建连接池的时候，ConnectionPool.singleton()后边创建的池子会把之前的池子覆盖

def singleton(dataSource: DataSourceConnectionPool): Unit = {
    add(DEFAULT_NAME, dataSource)
    log.debug("Registered singleton connection pool : " + get().toString())
  }

def add(name: Any, dataSource: DataSourceConnectionPool) = {
    // NOTE: cannot pass ExecutionContext from outside due to overload issue
    // (multiple overloaded alternatives of method add define default arguments.)
    val oldPoolOpt: Option[ConnectionPool] = pools.get(name)
    // register new pool or replace existing pool
    pools.synchronized {
      pools.update(name, dataSource)
      // wait a little because rarely NPE occurs when immediately accessed.
      Thread.sleep(100L)
    }
    // asynchronously close the old pool if exists
    oldPoolOpt.foreach(pool => abandonOldPool(name, pool))
  }

private[this] def abandonOldPool(name: Any, oldPool: ConnectionPool)(
    implicit
    ec: ExecutionContext = DEFAULT_EXECUTION_CONTEXT
  ) = {
    scala.concurrent.Future {
      if (GlobalSettings.loggingConnections) {
        log.debug("The old pool destruction started. connection pool : " + get(name).toString())
      }
      var millis = 0L
      while (millis < 60000L && oldPool.numActive > 0) {
        Thread.sleep(100L)
        millis += 100L
      }
      oldPool.close()
      if (GlobalSettings.loggingConnections) {
        log.debug("The old pool is successfully closed. connection pool : " + get(name).toString())
      }
    }
  }

可以看到，前一个池子会被关闭，这样就会导致在后续需要使用前一个池子对应的数据库连接时而报错。所以，比较合理的方式就是按照第一章的方式创建多个数据库对应的连接池。第一章传送门
第二个问题就是在使用上述的DB readOnly 等方法的时候也会出现错误。因为如果使用的是ConnectionPool.singleton()方式创建连接池，那么有效的连接池是最近一次被创建的数据库的连接池，即使使用了第一章的方式，每个数据库都创建一个对应的连接池，但是DB在使用的时候默认调用的是name为default的连接池。这时候可以使用DB(conn)的方式操作。

DB(conn) localTx { implicit session =>
  SQL(s"${esql}").batch(data: _*).apply()
}

这时候需要哪个数据库的链接，就传入对应池子取出的链接操作即可。

以上就是通过scalikejdbc对数据进行的增删改查的操作。下一章附上完整的操作代码。

欢迎对技术感兴趣的小伙伴一起交流学习，批评指正^^