scala-jdbc连接池和工具类

最新推荐文章于 2024-11-16 15:44:03 发布
最新推荐文章于 2024-11-16 15:44:03 发布
阅读量3k 收藏 8
点赞数
分类专栏： 大数据 文章标签： scala jdbc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16038125/article/details/86682323
版权

连接池

import java.sql.{Connection, DriverManager}
import java.util.{LinkedList, ResourceBundle}

import org.apache.spark.Logging

/**
  * 数据库连接池工具类
  */
object DBConnectionPool extends Logging{
  private val reader = ResourceBundle.getBundle("properties/version_manager_jdbc")
  private val max_connection = reader.getString("max_connection") //连接池总数
  private val connection_num = reader.getString("connection_num") //产生连接数
  private var current_num = 0 //当前连接池已产生的连接数
  private val pools = new LinkedList[Connection]() //连接池
  private val driver = reader.getString("driver")
  private val url = reader.getString("url")
  private val username = reader.getString("username")
  private val password = reader.getString("password")
  /**
    * 加载驱动
    */
  private def before() {
    if (current_num > max_connection.toInt && pools.isEmpty()) {
      println("busyness")
      Thread.sleep(2000)
      before()
    } else {
      Class.forName(driver)
    }
  }
  /**
    * 获得连接
    */
  private def initConn(): Connection = {
    val conn = DriverManager.getConnection(url, username, password)
//    logError(url)
    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)
  }


}

工具类


import java.sql.{CallableStatement, Connection, PreparedStatement, ResultSet, SQLException, Statement, Types}



import scala.collection.mutable.ListBuffer

/**
  *

  * @define

  */
object JdbcHelper {

  private var conn: Connection = null
  private var preparedStatement: PreparedStatement = null
  private var callableStatement: CallableStatement = null


  /**
    * 建立数据库连接
    *
    * @return
    * @throws SQLException
    */
  @throws[SQLException]
  private def getConnection: Connection = {
    conn = DBConnectionPool.getConn()
    conn
  }

  /**
    * 释放连接
    *
    * @param conn
    */
  private def freeConnection(conn: Connection) = {
    try
      DBConnectionPool.releaseCon(conn)
    catch {
      case e: SQLException =>
        e.printStackTrace()
    }
  }

  /**
    * 释放statement
    *
    * @param statement
    */
  private def freeStatement(statement: Statement) = {
    try
      statement.close()
    catch {
      case e: SQLException =>
        e.printStackTrace()
    }
  }

  /**
    * 释放resultset
    *
    * @param rs
    */
  private def freeResultSet(rs: ResultSet) = {
    try
      rs.close()
    catch {
      case e: SQLException =>
        e.printStackTrace()
    }
  }


  /**
    * 释放资源
    *
    * @param conn
    * @param statement
    * @param rs
    */
  def free(conn: Connection, statement: Statement, rs: ResultSet): Unit = {
    if (rs != null) freeResultSet(rs)
    if (statement != null) freeStatement(statement)
    if (conn != null) freeConnection(conn)
  }

  /

  /**
    * 获取PreparedStatement
    *
    * @param sql
    * @throws SQLException
    */
  @throws[SQLException]
  private def getPreparedStatement(sql: String) = {
    conn = getConnection
    preparedStatement = conn.prepareStatement(sql)
  }

  /**
    * 用于查询，返回结果集
    *
    * @param sql
    * sql语句
    * @return 结果集
    * @throws SQLException
    */
  @throws[SQLException]
  def query(sql: String): List[Map[String, Object]] = {
    var rs: ResultSet = null
    try {
      getPreparedStatement(sql)
      rs = preparedStatement.executeQuery
      ResultToListMap(rs)
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    } finally free(conn, callableStatement, rs)
  }


  /**
    * 用于带参数的查询，返回结果集
    *
    * @param sql
    * sql语句
    * @param paramters
    * 参数集合
    * @return 结果集
    * @throws SQLException
    */
  @throws[SQLException]
  def query(sql: String, paramters: Any*): List[Map[String, Object]] = {
    var rs: ResultSet = null
    try {
      getPreparedStatement(sql)
      var i = 0
      while ( {
        i < paramters.length
      }) {
        preparedStatement.setObject(i + 1, paramters(i))

        {
          i += 1;
          i - 1
        }
      }
      rs = preparedStatement.executeQuery
      ResultToListMap(rs)
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    } finally free(conn, callableStatement, rs)
  }


  /**
    * 返回单个结果的值，如count\min\max等等
    *
    * @param sql
    * sql语句
    * @return 结果集
    * @throws SQLException
    */
  @throws[SQLException]
  def getSingle(sql: String): Any = {
    var result: Any = null
    var rs: ResultSet = null
    try {
      getPreparedStatement(sql)
      rs = preparedStatement.executeQuery
      if (rs.next) result = rs.getObject(1)
      result
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    } finally free(conn, callableStatement, rs)
  }

  /**
    * 返回单个结果值，如count\min\max等
    *
    * @param sql
    * sql语句
    * @param paramters
    * 参数列表
    * @return 结果
    * @throws SQLException
    */
  @throws[SQLException]
  def getSingle(sql: String, paramters: Any*): Any = {
    var result: Any = null
    var rs: ResultSet = null
    try {
      getPreparedStatement(sql)
      var i = 0
      while ( {
        i < paramters.length
      }) {
        preparedStatement.setObject(i + 1, paramters(i))

        {
          i += 1;
          i - 1
        }
      }
      rs = preparedStatement.executeQuery
      if (rs.next) result = rs.getObject(1)
      result
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    } finally free(conn, callableStatement, rs)
  }

  /**
    * 用于增删改
    *
    * @param sql
    * sql语句
    * @return 影响行数
    * @throws SQLException
    */
  @throws[SQLException]
  def update(sql: String): Int = try {
    getPreparedStatement(sql)
    preparedStatement.executeUpdate
  } catch {
    case e: SQLException =>
      throw new SQLException(e)
  } finally free(conn, callableStatement, null)

  /**
    * 用于增删改（带参数）
    *
    * @param sql
    * sql语句
    * @param paramters
    * sql语句
    * @return 影响行数
    * @throws SQLException
    */
  @throws[SQLException]
  def update(sql: String, paramters: Any*): Int = try {
    getPreparedStatement(sql)
    var i = 0
    while ( {
      i < paramters.length
    }) {
      preparedStatement.setObject(i + 1, paramters(i))

      {
        i += 1;
        i - 1
      }
    }
    preparedStatement.executeUpdate
  } catch {
    case e: SQLException =>
      throw new SQLException(e)
  } finally free(conn, callableStatement, null)

  /**
    * 插入值后返回主键值
    *
    * @param sql
    * 插入sql语句
    * @return 返回结果
    * @throws Exception
    */
  @throws[SQLException]
  def insertWithReturnPrimeKey(sql: String): Any = {
    var rs: ResultSet = null
    var result: Object = null
    try {
      conn = getConnection
      preparedStatement = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)
      preparedStatement.execute
      rs = preparedStatement.getGeneratedKeys
      if (rs.next) result = rs.getObject(1)
      result
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    }
  }

  /**
    * 插入值后返回主键值
    *
    * @param sql
    * 插入sql语句
    * @param paramters
    * 参数列表
    * @return 返回结果
    * @throws SQLException
    */
  @throws[SQLException]
  def insertWithReturnPrimeKey(sql: String, paramters: Any*): Any = {
    var rs: ResultSet = null
    var result: Object = null
    try {
      conn = getConnection
      preparedStatement = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)
      var i = 0
      while ( {
        i < paramters.length
      }) {
        preparedStatement.setObject(i + 1, paramters(i))

        {
          i += 1;
          i - 1
        }
      }
      preparedStatement.execute
      rs = preparedStatement.getGeneratedKeys
      if (rs.next) result = rs.getObject(1)
      result
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    }
  }

  //

  /**
    * 获取CallableStatement
    *
    * @param procedureSql
    * @throws SQLException
    */
  @throws[SQLException]
  private def getCallableStatement(procedureSql: String) = {
    conn = getConnection
    conn.prepareCall(procedureSql)
  }


  /**
    * 存储过程查询
    * 注意outNames和outOracleTypes的顺序要对应 顺序按存储过程的参数顺序排列
    *
    * @param procedureSql
    * @param ins            输入参数数组
    * @param outNames       输出参数名称
    * @param outOracleTypes 输出参数类型
    * @return
    *
    */
  @throws[SQLException]
  def callableQuery(procedureSql: String, ins: Array[Object], outNames: Array[String], outOracleTypes: Array[Int]): Map[String, Object] = {

    val listBuffer = new ListBuffer[Object]

    try {
      callableStatement = getCallableStatement(procedureSql)

      var count = 0

      for (i <- 0 until ins.length) {
        count = count + 1
        callableStatement.setObject(count, ins(i))
      }

      for (j <- 0 until outOracleTypes.length) {
        count = count + 1
        callableStatement.registerOutParameter(count, outOracleTypes(j))
      }

      callableStatement.execute()

      count = count - outOracleTypes.length
      for (i <- 0 until outOracleTypes.length) {
        count = count + 1
        listBuffer.append(callableStatement.getObject(count))
      }
      outNames.zip(listBuffer.toList).toMap
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    }
    finally free(conn, callableStatement, null)
  }


  /**
    * 调用存储过程，查询单个值
    *
    * @param procedureSql
    * @return
    * @throws SQLException
    */
  @throws[SQLException]
  def callableGetSingle(procedureSql: String): Any = {
    var result: Any = null
    var rs: ResultSet = null
    try {
      rs = getCallableStatement(procedureSql).executeQuery
      while ( {
        rs.next
      }) result = rs.getObject(1)
      result
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    } finally free(conn, callableStatement, rs)
  }

  /**
    * 调用存储过程(带参数)，查询单个值
    *
    * @param procedureSql
    * @return
    * @throws SQLException
    */
  @throws[SQLException]
  def callableGetSingle(procedureSql: String, paramters: Any*): Any = {
    var result: Any = null
    var rs: ResultSet = null
    try {
      callableStatement = getCallableStatement(procedureSql)
      var i = 0
      while ( {
        i < paramters.length
      }) {
        callableStatement.setObject(i + 1, paramters(i))

        {
          i += 1;
          i - 1
        }
      }
      rs = callableStatement.executeQuery
      while ( {
        rs.next
      }) result = rs.getObject(1)
      result
    } catch {
      case e: SQLException =>
        throw new SQLException(e)
    } finally free(conn, callableStatement, rs)
  }

  @throws[SQLException]
  def callableWithParamters(procedureSql: String): Any = try {
    callableStatement = getCallableStatement(procedureSql)
    callableStatement.registerOutParameter(0, Types.OTHER)
    callableStatement.execute
    callableStatement.getObject(0)
  } catch {
    case e: SQLException =>
      throw new SQLException(e)
  } finally free(conn, callableStatement, null)

  /**
    * 调用存储过程，执行增删改
    *
    * @param procedureSql
    * 存储过程
    * @return 影响行数
    * @throws SQLException
    */
  @throws[SQLException]
  def callableUpdate(procedureSql: String): Int = try {
    callableStatement = getCallableStatement(procedureSql)
    callableStatement.executeUpdate
  } catch {
    case e: SQLException =>
      throw new SQLException(e)
  } finally free(conn, callableStatement, null)

  /**
    * 调用存储过程（带参数），执行增删改
    *
    * @param procedureSql
    * 存储过程
    * @param parameters
    * @return 影响行数
    * @throws SQLException
    */
  @throws[SQLException]
  def callableUpdate(procedureSql: String, parameters: Any*): Int = try {
    callableStatement = getCallableStatement(procedureSql)
    var i = 0
    while ( {
      i < parameters.length
    }) {
      callableStatement.setObject(i + 1, parameters(i))

      {
        i += 1;
        i - 1
      }
    }
    callableStatement.executeUpdate
  } catch {
    case e: SQLException =>
      throw new SQLException(e)
  } finally free(conn, callableStatement, null)


  @throws[SQLException]
  private def ResultToListMap(rs: ResultSet) = {

    val list = new ListBuffer[Map[String, Object]]

    while (rs.next) {
      val map = new scala.collection.mutable.HashMap[String, Object]
      val md = rs.getMetaData
      for (i <- 1 until md.getColumnCount) {
        map.put(md.getColumnLabel(i), rs.getObject(i))
      }
      list.append(map.toMap)
    }
    list.toList
  }


  def main(args: Array[String]): Unit = {
    //        val list = query("select * from POL_BEN_PLAN_CFG")
    //        for (e <- list) {
    //          println(e)
    //        }

//    val startVersionMap = VersionManager.verStartIf("20181106", "spark_ifrs17_mp_ind_aio")
//    println(startVersionMap.toString())
//
//    val endVersionMap = VersionManager.verEndIf(startVersionMap, JobConstants.P_RUN_FLAG_SUCCESS, "success")
//    println(endVersionMap.toString())

  }

}
scala spark mysql连接池 工具类 和一些简单的使用 不断丰富中
yy的博客
05-14 511
概述 两种 一种是scala jdbc写入mysql 一种是spark dataset直接写入spark 期间遇到ssl driver 甚至时间戳相差13h等问题都记录了解决方案. 目录 部分代码 使用案例 def updateMysqlSD(BUSINESS_TYPE:Int, DATA_TYPE:Int, TOTAL_COUNT:Long, STATS_DATA:String = dealDayFormatWith_)={ val conn = getConnectio.
scala连接mysql工具类_scala 封装jdbc的常用操作，自动关闭数据库的连接资源
weixin_42566451的博客
01-25 356
Scala中貌似没有try-with的概念，在Java中则可以使用try-with自动释放连接资源，如：输入输出流、数据库连接。在Scala中如果想要实现自动释放数据库的连接资源时，需要自己封装。借鉴网上大神的博客，给大家分享一下我自己的Scala jdbc操作工具类。case class CloseAble[A def map[B](f: A => B): B =try f(a)final...
scala-jdbc:一个小的库，使使用JDBC数据库变得非常容易
05-30
Scala-jdbc 一个小型库，可以更轻松地使用 JDBC 数据库。 亲： 小图书馆， 少量众所周知的依赖项（typesafe-config、commons-dbcp、scala-arm 和您选择的 JDBC 驱动程序）， 对只想做Java/Scala 程序员来说非常容易上手， 如果您想创建React式应用程序或高级功能（如异步/流），请使用 ，不要使用此库。 依赖 要包括JDBC库，请将以下行添加到build.sbt文件中： resolvers += "dnvriend at bintray" at "http://dl.bintray.com/dnvriend/maven" libraryDependencies += "com.github.dnvriend" %% "scala-jdbc" % "1.0.0" 用法 配置： 将以下内容放在您的applicatio
scala连接mysql工具类_【Scala】Scala使用scalikejdbc工具连接MySQL(推荐)
weixin_42512474的博客
01-18 205
package com.ruozeimport scalikejdbc._import scalikejdbc.config._object ScalalikeJdbc{def main(args:Array[String]):Unit = {//默认加载db.default.*配置信息DBs.setupAll()1.通过scalikejdbc查询user表所有的数据,封装进对象中val memb...
JDBC学习笔记（四）--JdbcUtil工具类的底层实现、解决 java.sql.SQLException: Operation not allowed after ResultSet closed
最新发布
2301_76890677的博客
11-16 832
解决方案：封装思维配置文件。
Scala---JDBC
shall潇の菜园
04-27 313
【前提：将mysql jar包导入到工程目录下，并且在Mysql中创建好对应的库和表】 文章目录一、原版二、隐式类封装 表结构如下： 其实和之前的JDBC一样的步骤： 创建驱动 建立连接 编写sql 预处理 执行 一、原版 import java.sql.{Connection, DriverManager} class ScalaJdbc{ private var driver:String = "com.mysql.jdbc.Driver" private var url:String
JDBC(连接池) -- 02(I)
weixin_33738982的博客
10-07 59
自定义连接池一： 1.sun提供了一个连接池接口 javax.sql.DataSource。 2.定义连接池MyDataSource实现接口DataSource。 3.使用集合LinkedList<Connection> pool存放多个连接对象。LinkedList移除添加操作效率高。连接对象还是和以前一样调用工具类JDBCUtils里的getCon...
scala 链接 jdbc
子清的博客
10-29 177
package mysqlstu import java.sql.{Connection, DriverManager, PreparedStatement, ResultSet} object MysqlDemo { private val driver="com.mysql.jdbc.Driver" private val url="jdbc:mysql://192.168.83.100:3306/scalademo" private val username="root" pr
jdbc连接池工具类
qq_36943809的博客
12-11 166
import Day01.Text03.JdbcUtils; import com.alibaba.druid.pool.DruidDataSourceFactory; import javax.sql.DataSource; import java.io.IOException; import java.sql.Connection; import java.sql.ResultSet; im...
JDBC连接池的工具类
ruiguang21的博客
01-10 567
package com.yanshu.utils; import java.io.IOException; import java.io.InputStream; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.DriverManager; import java.sq
JDBC连接池与工具类的使用
loveyouluobin的博客
04-26 1844
JDBC连接池与工具类总结 1.连接池概述 用池来管理Connection,这样可以重复使用Connection,有了池,所以我们就不用自己来创建Connection,而是通过池来获取Connection对象,当使用完Connection后,调用Connection的close()方法也不会真的关闭Connection, 而是把Connection归还给池,池就可以再利用这个Connecti...
一个 scala jdbc 库，需要 spring-jdbc
06-02
3. **数据源管理**：Spring 可以配置多种数据源，包括连接池，如 HikariCP、C3P0 或 Apache Commons DBCP，以提高性能和资源利用率。 4. **批处理**：Spring JDBC 支持 JDBC 批处理，可以有效地执行一组 SQL 语句，...
scala数据库工具类
weixin_33912246的博客
07-09 260
scala的数据库连接池，基于mysql import java.util.concurrent.ConcurrentHashMap import com.jolbox.bonecp.{ BoneCPConfig, BoneCP } import java.util.ResourceBundle import java.util.LinkedList import java.sql....
使用scala写一个jdbc
qq_34566673的博客
09-16 325
准备： 先在数据库中创建好库，表，导入测试的数据 库名为mydemo，表名为userinfos 表有三个字段：userid，username，birthday scala的操作： 1.创建实体类用于接收从数据库中获取的数据 case class UserInfos(var userid:Int,var username:String,var birthday:String) 2.创建BaseDao连接数据库执行操作 object BaseDao{ //创建连接对象 def getConnection(
JDBC方式连接MySQL、Oracle、Hive、Spark等，通用工具类（Scala版）
GulfMoon
08-14 1941
通过JDBC方式连接MySQL、Oracle、Hive、Spark等数据库，对返回的结果进行处理，方便后续使用；在创建连接时使用了池化技术，保证高效。
Scala的JDBC操作
jiandanbuguo的博客
10-30 1524
scala对JDBC的操作与Java的类似，这里以连接mysql为例 如果新建的的maven项目，直接在xml文件中配置以下代码即可，版本号可根据自己的mysql版本调整 <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-con
Scala连接jdbc
qq_40333693的博客
11-04 163
新建Scala项目MysqlDemo object MysqlDemo { private val driver = "com.mysql.jdbc.Driver" private val url = "jdbc:mysql://192.168.134.104/scalademo" //scalademo数据库要已存在 private val username = "root" private val password = "ok" private var connection: Connection =
JDBC连接sqlserver与mysql
06-01
在实际开发中，推荐使用数据库连接池（如HikariCP、C3P0或Apache DBCP）管理数据库连接，提高效率并避免资源泄露。此外，为了增强代码的健壮性和安全性，应考虑使用`PreparedStatement`来防止SQL注入，并使用try-...
Scala 简单实现数据库连接池
ncqingchuan1976的专栏
02-02 1156
数据库连接池 JDBC Scala
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猿与禅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值