scala數據庫工具類

scala的數據庫連接池，基於mysql

import java.util.concurrent.ConcurrentHashMap
import com.jolbox.bonecp.{ BoneCPConfig, BoneCP }
import java.util.ResourceBundle
import java.util.LinkedList
import java.sql.DriverManager
import java.sql.Connection

/**
 * 數據庫連接池工具類
 * 語言：scala
 * 時間：2016-07-09
 */
object DBConnectionPool {
  private val reader = ResourceBundle.getBundle("connection")
  private val max_connection = reader.getString("jeecg.max_connection") //連接池總數
  private val connection_num = reader.getString("jeecg.connection_num") //產生連接數
  private var current_num = 0 //當前連接池已產生的連接數
  private val pools = new LinkedList[Connection]() //連接池
  private val driver = reader.getString("jeecg.driver")
  private val url = reader.getString("jeecg.url")
  private val username = reader.getString("jeecg.username")
  private val password = reader.getString("jeecg.password")
 /**
  * 加載驅動
  */
  private def before() {
    if (current_num > max_connection.toInt && pools.isEmpty()) {
      print("busyness")
      Thread.sleep(2000)
      before()
    } else {
      Class.forName(driver)
    }
  }
  /**
   * 獲得連接
   */
  private def initConn(): Connection = {
    val conn = DriverManager.getConnection(url, username, password)
    conn
  }
  /**
   * 初始化連接池
   */
  private def initConnectionPool(): LinkedList[Connection] = {
    AnyRef.synchronized({
      if (pools.isEmpty()) {
        before()
        for (i <- 1 to connection_num.toInt) {
          pools.push(initConn())
          current_num += 1
        }
      }
      pools
    })
  }
  /**
   * 獲得連接
   */
  def getConn():Connection={
     initConnectionPool()
     pools.poll()
  }
  /**
   * 釋放連接
   */
  def releaseCon(con:Connection){
    pools.push(con)
  }
  
}

配置文件

#數據庫連接池配置文件
jeecg.driver=org.gjt.mm.mysql.Driver
jeecg.url=jdbc\:mysql\://0.0.0.0\:3306/jeecg?useUnicode=true&characterEncoding=utf-8
jeecg.username=root
jeecg.password=****
jeecg.max_connection=8
jeecg.connection_num=10

dao類

import java.sql.ResultSet
import java.sql.PreparedStatement
import java.sql.Connection
import java.sql.Statement
/**
 * 數據操作工具類
 * 語言：scala
 * 時間：2016-07-09
 */
private[org] abstract class BaseDao[T](conn: Connection) {
  /**
   * 插入數據
   * @param sql SQL語句
   * @param params 參數列表
   * @param convert 主鍵轉換方法
   * @return 轉換結果
   */
  protected def insert[T](sql: String, params: Array[Any])(convert: ResultSet => T) = {
    val pstmt = conn prepareStatement (sql, Statement.RETURN_GENERATED_KEYS)
    setParameters(pstmt, params)
    pstmt.executeUpdate
    val rs = pstmt.getGeneratedKeys
    rs.next
    convert(rs)
  }

  /**
   * 更新數據
   * @param sql SQL語句
   * @param params 參數列表
   * @return 影響行數
   */
  protected def update(sql: String, params: Array[Any]) = createStatement(sql, params).executeUpdate

  /**
   * 查詢對象
   * @param sql SQL語句
   * @param params 參數列表
   * @param convert 結果集轉換方法
   * @return 泛型對象
   */
  protected def queryForObject[T](sql: String, params: Array[Any])(convert: ResultSet => T) = {
    val rs = query(sql, params)
    if (rs.next) {
      val result = convert(rs)
      if (rs.next) {
        val ex = new ResultsTooManyException
        throw ex
      } else Some(result)
    } else None
  }

  /**
   * 查詢對象列表
   * @param sql SQL語句
   * @param params 參數列表
   * @param convert 結果集轉換方法
   * @return 泛型對象列表
   */
  protected def queryForList[T](sql: String, params: Array[Any])(convert: ResultSet => T) = {
    val rs = query(sql, params)
    var results = List[T]()
    while (rs.next) { results = results :+ convert(rs) }
    results
  }

  /**
   * 查詢對象映射
   * @param sql SQL語句
   * @param params 參數列表
   * @param convert 結果集轉換方法
   * @return 泛型對象映射
   */
  protected def queryForMap[K, V](sql: String, params: Array[Any])(convert: ResultSet => (K, V)) = {
    val rs = query(sql, params)
    var results = Map[K, V]()
    while (rs.next) { results += convert(rs) }
    results
  }

  /**
   * 查詢
   * @param sql SQL語句
   * @param params 參數列表
   */
  private def query(sql: String, params: Array[Any]) = createStatement(sql, params).executeQuery

  /**
   * 創建聲明
   * @param sql SQL語句
   * @param params 參數列表
   */
  private def createStatement(sql: String, params: Array[Any]) = {
    val pstmt = conn prepareStatement sql
    setParameters(pstmt, params)
    pstmt
  }

  /**
   * 插入參數
   * @param pstmt 預編譯聲明
   * @param params 參數列表
   */
  private def setParameters(pstmt: PreparedStatement, params: Array[Any]) {
    for (i <- 1 to params.length) { pstmt setObject (i, params(i - 1)) }
  }

}

/**
 * 結果值讀取器
 */
object ResultValueGetter {

  /**
   * 查詢結果值
   * @param rs 結果集
   * @param getResult 獲得單個值結果的方法
   * @return 值
   */
  def getResultValue[T](rs: ResultSet)(getResult: ResultSet => T) = {
    val result = getResult(rs)
    if (rs.wasNull) None else Some(result)
  }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colNum 列號
   */
  def getStringValue(rs: ResultSet, colNum: Int) = getResultValue(rs) { _ getString colNum }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colNum 列號
   */
  def getIntValue(rs: ResultSet, colNum: Int) = getResultValue(rs) { _ getInt colNum }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colNum 列號
   */
  def getLongValue(rs: ResultSet, colNum: Int) = getResultValue(rs) { _ getLong colNum }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colNum 列號
   */
  def getDoubleValue(rs: ResultSet, colNum: Int) = getResultValue(rs) { _ getDouble colNum }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colNum 列號
   */
  def getBooleanValue(rs: ResultSet, colNum: Int) = getResultValue(rs) { _ getBoolean colNum }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colNum 列號
   */
  def getTimestampValue(rs: ResultSet, colNum: Int) = getResultValue(rs) { _ getTimestamp colNum }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colName 列名
   */
  def getStringValue(rs: ResultSet, colName: String) = getResultValue(rs) { _ getString colName }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colName 列名
   */
  def getIntValue(rs: ResultSet, colName: String) = getResultValue(rs) { _ getInt colName }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colName 列名
   */
  def getLongValue(rs: ResultSet, colName: String) = getResultValue(rs) { _ getLong colName }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colName 列名
   */
  def getDoubleValue(rs: ResultSet, colName: String) = getResultValue(rs) { _ getDouble colName }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colName 列名
   */
  def getBooleanValue(rs: ResultSet, colName: String) = getResultValue(rs) { _ getBoolean colName }

  /**
   * 獲得字符串結果的值
   * @param rs 結果集
   * @param colName 列名
   */
  def getTimestampValue(rs: ResultSet, colName: String) = getResultValue(rs) { _ getTimestamp colName }

}

/**
 * 結果太多異常
 */
class ResultsTooManyException extends Exception("Returned too many results.") {}