技术文章
当前位置:首页 > Java技术文章 > Scala操作Redis使用连接池工具类RedisUtil

Scala操作Redis用连接池工具类RedisUtil详解

  • 发布时间:
  • 作者:码农之家原创
  • 点击:236

这篇文章主要知识点是关于Scala、操作Redis、Scala、Redis、RedisUtil、scala+redis实现分布式锁的示例代码 的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下java相关的电子书

Redis 4.x Cookbook
Redis 4.x Cookbook中文扫描版
  • 类型:Redis实战大小:55.9 MB格式:PDF出版:电子工业出版社作者:黄鹏程 王左非
立即下载

更多Java相关的学习资源可以参阅 Java电子书程序设计电子书 等栏目。

Scala操作Redis使用连接池工具类RedisUtil

本文介绍了Scala 操作Redis,分享给大家,具体如下:

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()
 }

}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

scala+redis实现分布式锁的示例代码

1、redis的底层是单例模式,意思是同一个脚本同一时刻只能有一个线程来执行,利用redis的这个特性来实现分布式锁。

首先实现工具类

package utils
 
import CacheManager
 
/**
 * redis分布式锁
 */
object RedisTool {
 
 //加锁是否成功标志
 val LOCK_SUCCESS:String = "OK"
 
 //即当key不存在时,我们进行set操作;若key已经存在,则不做任何操作;
 val SET_IF_NOT_EXIST:String = "NX"
 
 //意思是我们要给这个key加一个过期的设置,具体时间由第五个参数决定。
 val SET_WITH_EXPIRE_TIME:String = "PX"
 
 val RELEASE_SUCCESS:String = "1"
 
 /**
  *
  * @param lockKey   锁
  * @param requestId  请求标识
  * @param expireTime  超期时间
  * @param isPersist  临时缓存或者永久缓存
  */
 def tryGetDistributedLock(lockKey:String, requestId:String, expireTime:Int,isPersist:Boolean=false){
  CacheManager.redisClientPool.withClient(
   client => {
    //val redisKeyPrefix = CacheManager.getRedisKeyPrefix(isPersist)
    client.select(CacheManager.redisDBNum)
    val result = client.set(lockKey, requestId, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, expireTime)
    var flag = false
    if(LOCK_SUCCESS == result){
     flag = true
    }
    flag
   }
  )
 }
 
 
 /**
  *释放分布式锁
  * @param lockKey   锁
  * @param requestId  请求标识
  * @param expireTime  超期时间
  * @param isPersist  临时缓存或者永久缓存
  * @return
  */
 def releaseDistributedLock(lockKey:String, requestId:String,expireTime: Int = 10,isPersist:Boolean=false) ={
  CacheManager.redisClientPool.withClient(
   client => {
    val redisKeyPrefix = CacheManager.getRedisKeyPrefix(isPersist)
    client.select(CacheManager.redisDBNum)
    //lua脚本也是单例模式,同样也可以保证同一时刻只有一个线程执行脚本
    val lua =
     s"""
       |local current = redis.call('incrBy',KEYS[1],ARGV[1]);
       |if current == tonumber(ARGV[1]) then
       |  local t = redis.call('ttl',KEYS[1]);
       |  if t == -1 then
       |    redis.call('expire',KEYS[1],ARGV[2])
       |  end;
       |end;
       |return current;
      """.stripMargin
    val code = client.scriptLoad(lua).get
    val ret = client.evalSHA(code, List(redisKeyPrefix + lockKey),List(requestId,expireTime))
    val result = ret.get.asInstanceOf[Object].toString
    var flag = false
    if(result == RELEASE_SUCCESS){
     flag = true
    }
    flag
   }
  )
 }
 
}

2、实现CacheManager类

package utils
 
import com.redis.RedisClientPool
/**
 * 
 */
object CacheManager {
 
 val redisClientPool = "dev".equalsIgnoreCase(System.getenv("SCALA_ENV")) match {
  //开发环境
  case true => new RedisClientPool("127.0.0.1", 6379)
  //其他环境
  case false => new RedisClientPool("10.180.x.y", 6379, 8, 0, Some("root"))
 }
 
 val redisDBNum = 10
 
 def getRedisKeyPrefix(isPersist:Boolean) ={
  if(isPersist){
   //永久缓存前缀
   "persist_"
  }else{
   //临时缓存前缀
   "tmp_"
  }
 }
 
}

3、调用锁操作

def updateTableInfo(param:String) = {
  var resMap = Map[String,Any]()
  val lockKey = "mdms.MdmsUtils.updateTableInfo"
  //val requestId = UUID.randomUUID().toString().replace("-", "").toUpperCase()
  val flag = RedisTool.releaseDistributedLock(lockKey, "1")
  if(flag){
   try{
    
    //执行你的操作
    resMap = Map("code" -> 200 ,"msg" -> "成功")
   }catch {
    case e:Exception => {
     
     e.printStackTrace()
     resMap = Map("code" -> 200101 ,"msg" -> "执行失败")
    }
   }
   
  }else{
   resMap = Map("code" -> 200102 ,"msg" -> "操作冲突,已经被其他人捷足先登啦。")
  }
  resMap
 }

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持码农之家。

以上就是本次给大家分享的关于Java的全部知识点内容总结,大家还可以在下方相关文章里找到Java IO流之字符缓冲流的实、 WebUploader实现分片断点上传、 swing组件JScrollPane滚动条实、 等java文章进一步学习,感谢大家的阅读和支持。

上一篇:java导出Excel的实例功能详解

下一篇:Spark Streaming算子开发代码讲解

展开 +

收起 -

相关电子书
学习笔记
网友NO.752948

Spring学习笔记之RedisTemplate的配置与使用教程

前言 Spring针对Redis的使用,封装了一个比较强大的Template以方便使用;之前在Spring的生态圈中也使用过redis,但直接使用Jedis进行相应的交互操作,现在正好来看一下RedisTemplate是怎么实现的,以及使用起来是否更加便利 I. 基本配置 1. 依赖 依然是采用Jedis进行连接池管理,因此除了引入 spring-data-redis之外,再加上jedis依赖,pom文件中添加 dependency groupIdorg.springframework.data/groupId artifactIdspring-data-redis/artifactId version1.8.4.RELEASE/version/dependencydependency groupIdredis.clients/groupId artifactIdjedis/artifactId version2.9.0/version/dependency 如果需要指定序列化相关参数,也可以引入jackson,本篇为简单入门级,就不加这个了 2. 配置文件 准备redis相关的配置参数,常见的有host, port, password, timeout…,下面是一份简单的配置,并给出了相应的含义 redis.hostName=127.0.0.1redis.port=6379redis.password=ht……

网友NO.177941

spring boot中各个版本的redis配置问题详析

前言 今天在springboot中使用数据库,springboot版本为2.0.2.RELEASE,通过pom引入jar包,配置文件application.properties中的redis配置文件报错,提示例如 deprecated configuration property 'spring.redis.pool.max-active' ,猜想应该是版本不对,发现springboot在1.4前后集成redis发生了一些变化。 下面截图看下。 一、不同版本RedisProperties的区别 这是springboot版本为1.3.2RELEASE中的RedisProperties配置文件类,从图片中可以看得出来该本的redis配置文件属性有两个内部静态类分别是Pool和Sentinel,七个属性变量。列入我们想在配置文件中设置redis数据库host地址,则可以这样写 spring.redis.host=localhost host为属性,配置连接池的最大连接数 spring.redis.pool.max-active=8 这个是redis在 application.properties 中springboot低版本的配置 # REDIS (RedisProperties)# Redis数据库索引(默认为0)spring.redis.database=0# Redis服务器地址spring.……

网友NO.668700

浅谈Spring Boot中Redis缓存还能这么用

经过Spring Boot的整合封装与自动化配置,在Spring Boot中整合Redis已经变得非常容易了,开发者只需要引入Spring Data Redis依赖,然后简单配下redis的基本信息,系统就会提供一个RedisTemplate供开发者使用,但是今天松哥想和大伙聊的不是这种用法,而是结合Cache的用法。Spring3.1中开始引入了令人激动的Cache,在Spring Boot中,可以非常方便的使用Redis来作为Cache的实现,进而实现数据的缓存。 工程创建 首先创建一个Spring Boot工程,注意创建的时候需要引入三个依赖,web、cache以及redis,如下图: 对应的依赖内容如下: dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-cache/artifactId /dependency dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-data-redis/artifactId /dependency dependency groupIdorg.springframework.boot/groupId artifactIdspring-boot-starter-web/artifactId /depen……

<
1
>

Copyright 2018-2020 xz577.com 码农之家

电子书资源由网友、会员提供上传,本站记录提供者的基本信息及资源来路

鸣谢: “ 码小辫 ” 公众号提供回调API服务、“ 脚本CDN ”提供网站加速(本站寻求更多赞助支持)

版权投诉 / 书籍推广 / 赞助:520161757@qq.com

上传资源(网友、会员均可提供)

查看最新会员资料及资源信息