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 <- cols) {
        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 <- rowkeys) {
      var cellMap = Map.empty[String, Array[Byte]]
      if (cols.length > 0) {
        for (col <- cols) {
          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()
  }

}