scala mysql连接池_Scala 操作Redis使用连接池工具类RedisUtil

package com.zjw.util

import java.util

import org.apache.commons.pool2.impl.GenericObjectPoolConfig

import org.apache.logging.log4j.scala.Logging

import redis.clients.jedis.{Jedis, JedisPool, Response}

import redis.clients.util.Pool

object RedisUtil extends Logging {

private[this] var jedisPool: Pool[Jedis] = _

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

val password = "h-{

val host = "192.168.100.101"

val port = 6379

val timeout = 1000

RedisUtil.init(host, port, timeout, password, 0)

//RedisUtil.set("Time".getBytes(), "2018-09-03 09:00:00".getBytes())

//val result = RedisUtil.get("Time".getBytes())

//println(new String(result))

//val map = Map("name"-> "zhangsan","age"-> "21", "gender"-> "male", "id"-> "519099386")

//RedisUtil.setCols("hash",map)

// val result = RedisUtil.getCols("hash", Array("name", "age", "xx")).map(x => (x._1, new String(x._2)))

// logger.info(result)

val result = RedisUtil.bulkGetCols(Array("hash", "ss"))

logger.info(s"result: ${result}")

}

def init(host: String, port: Int, timeout: Int, password: String, database: Int = 0): Unit = {

jedisPool = new JedisPool(new GenericObjectPoolConfig, host, port, timeout, password, database)

}

def get(key: Array[Byte]): Array[Byte] = {

val jedis = jedisPool.getResource

val result: Array[Byte] = jedis.get(key)

jedis.close()

result

}

def set(key: Array[Byte], value: Array[Byte]): Boolean = {

try {

val jedis = jedisPool.getResource

jedis.set(key, value)

jedis.close()

true

} catch {

case e: Exception => {

logger.error(s"写入数据到Redis出错: ${e}")

false

}

}

}

def getCols(key: String,

cols: Array[String] = Array.empty

): Map[String, Array[Byte]] = {

import scala.collection.JavaConverters._

val jedis = jedisPool.getResource

var map = Map.empty[String, Array[Byte]]

if (cols.length > 0) {

val pipe = jedis.pipelined()

val response = pipe.hmget(key.getBytes(), cols.map(_.getBytes()): _*)

pipe.sync()

map = cols.zip(response.get.asScala).toMap.filter(x => x._2 != null)

pipe.close()

} else {

logger.info(s"key: ${key}")

val tmpMap: util.Map[Array[Byte], Array[Byte]] = jedis.hgetAll(key.getBytes())

map = tmpMap.asScala.toMap.map(x => (new String(x._1), x._2))

}

jedis.close

map

}

def getCols2(

key: String,

cols: Array[String] = Array.empty

): Map[String, Array[Byte]] = {

val jedis = jedisPool.getResource

var map = Map.empty[String, Array[Byte]]

if (cols.length > 0) {

for (col

val value: Array[Byte] = jedis.hget(key.getBytes(), col.getBytes())

if (null != value) {

map = map + (col -> value)

}

}

} else {

logger.info(s"rowkey: ${key}")

val tmpMap: util.Map[Array[Byte], Array[Byte]] = jedis.hgetAll(key.getBytes())

import scala.collection.JavaConverters._

map = tmpMap.asScala.toMap.map(x => (new String(x._1), x._2))

}

jedis.close

map

}

def bulkGetCols(keys: Array[String],

cols: Array[String] = Array.empty

): Map[String, Map[String, Array[Byte]]] = {

import scala.collection.JavaConverters._

var result: Map[String, Map[String, Array[Byte]]] = Map.empty

val jedis = jedisPool.getResource

val pipe = jedis.pipelined

if (cols.length > 0) {

val data = keys.map(x => {

pipe.hmget(x.getBytes(), cols.map(_.getBytes()): _*)

})

pipe.sync

pipe.close

jedis.close

result = keys.zip(data.map(_.get().asScala.toArray).map(cols.zip(_).toMap.filter(null != _._2)))

.toMap.filter(_._2.nonEmpty)

} else {

val data: Array[Response[util.Map[Array[Byte], Array[Byte]]]] = keys.map(x => {

pipe.hgetAll(x.getBytes())

})

pipe.sync

pipe.close

jedis.close

result = keys.zip(data.map(_.get().asScala.map(x => (new String(x._1), x._2)).toMap))

.toMap.filter(_._2.nonEmpty)

}

result

}

def bulkGetCols2(rowkeys: Array[String],

cols: Array[String] = Array.empty

): Map[String, Map[String, Array[Byte]]] = {

val jedis = jedisPool.getResource

var map = Map.empty[String, Map[String, Array[Byte]]]

import scala.collection.JavaConverters._

for (rowkey

var cellMap = Map.empty[String, Array[Byte]]

if (cols.length > 0) {

for (col

val value = jedis.hget(rowkey.getBytes(), col.getBytes())

if (null != value) {

cellMap = cellMap + (col -> value)

}

}

} else {

logger.info(s"rowkey: ${rowkey}")

val tmpMap = jedis.hgetAll(rowkey.getBytes())

cellMap = tmpMap.asScala.toMap.map(x => (new String(x._1), x._2))

}

if (cellMap.nonEmpty) {

map = map + (rowkey -> cellMap)

}

}

jedis.close

map

}

def setCols(

key: String,

fieldValues: Map[String, String]

): Unit = {

import scala.collection.JavaConverters._

val data = fieldValues.map(element => {

(element._1.getBytes(), element._2.getBytes())

}).asJava

val jedis = jedisPool.getResource

jedis.hmset(key.getBytes(), data)

jedis.close()

}

}