Scala 操作 Redis-RedisUtil

╰半橙微兮° 2022-05-14 09:00 439阅读 0赞

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-{<Fc!yJL87_Zkc8S"
        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()
      }
    
    }