redis常用方法封装

最新推荐文章于 2024-08-06 20:37:27 发布
最新推荐文章于 2024-08-06 20:37:27 发布
阅读量326 收藏 1
点赞数
分类专栏： java redis 文章标签： redis java
216396734 交流群 
JedisUtils.java
package com.youquhd.common.redis;


import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.youquhd.common.utils.StringUtils;
import com.youquhd.modules.sys.entity.User;


import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.exceptions.JedisException;


/**
 * Jedis常用功能
 * @author liucx
 * @email  lxlcx201@163.com
 */


public class JedisUtils {

public static final String PK="pk_";

private static Logger logger = LoggerFactory.getLogger(JedisUtils.class);

private static JedisPool jedisPool =new JedisPool("192.168.3.250");//SpringContextHolder.getBean(JedisPool.class);

/**
* 设置分布式事物锁
* 1、返回0表示锁已经存在，返回1表示获得锁成功
* @param key 
* @param cacheSeconds
* @return 
*/
public static long setNx(String key, int cacheSeconds) {
long value = 0L;
Jedis jedis = null;
try {
jedis = getResource();
value = jedis.setnx(key, "1");
if(cacheSeconds>0) {
jedis.expire(key, cacheSeconds);   //避免死锁
}
} catch (Exception e) {
logger.debug("setNx {} = {}", key, cacheSeconds, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 获取自增id 
* 该方法单机每秒并发在1100左右
* @param key 键
* @return 值
*/
public static long incrementAndGet(String key) {
long value = 0L;
Jedis jedis = null;
try {
jedis = getResource();
value=jedis.incr("increment_"+key);
} catch (Exception e) {
logger.debug("incrementAndGet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 根据key获取缓存
* @param key 键
* @return 值
*/
public static String get(String key) {
String value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
value = jedis.get(key);
value = StringUtils.isNotBlank(value) && !"nil".equalsIgnoreCase(value) ? value : null;
logger.debug("get {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("get {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}


/**
* 设置缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static String set(String key, String value, int cacheSeconds) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.set(key, value);
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("set {} = {}", key, value);
} catch (Exception e) {
logger.warn("set {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}

/**
* 更新缓存时间
* @param key   key值
* @param sessionSeconds  更新多长时间
*/
public static void expire(String key,int sessionSeconds){
Jedis jedis = null;
try {
jedis = getResource();
if (sessionSeconds != 0) {
jedis.expire(key, sessionSeconds);
}
} catch (Exception e) {
logger.warn("set {} = {}", key, sessionSeconds, e);
} finally {
returnResource(jedis);
}
}

/**
* 设置缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static String setObject(String key, Object value, int cacheSeconds) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.set(getBytesKey(key), toBytes(value));
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObject {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObject {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 获取缓存
* @param key 键
* @return 值
*/
public static Object getObject(String key) {
Object value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
value = toObject(jedis.get(getBytesKey(key)));
logger.debug("getObject {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObject {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 设置List缓存，如果该key值原来就 存在，覆盖原来的
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setList(String key, List<String> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
jedis.del(key);
}
result = jedis.rpush(key, (String[])value.toArray());
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setList {} = {}", key, value);
} catch (Exception e) {
logger.warn("setList {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 获取List<String>缓存
* @param key 键
* @return 值
*/
public static List<String> getList(String key) {
List<String> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
value = jedis.lrange(key, 0, -1);
logger.debug("getList {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getList {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 向List缓存中添加值，在list后面追加
* @param key 键
* @param value 值
* @return
*/
public static long listAdd(String key, String... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.rpush(key, value);
logger.debug("listAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("listAdd {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 设置List缓存，如果该key值已经存在，覆盖原来的值
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setObjectList(String key, List<?> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(ObjectUtils.serialize(key))) {
jedis.del(ObjectUtils.serialize(key));
}
for(int i=0;i<value.size();i++){
jedis.rpush(ObjectUtils.serialize(key), ObjectUtils.serialize(value.get(i)));
}
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObjectList {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObjectList {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}


/**
* 向List缓存中添加值，在原来list的后面增加
* @param key 键
* @param value 值
* @return
*/
public static long listObjectAdd(String key, Object... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
for (Object o : value){
jedis.rpush(ObjectUtils.serialize(key), ObjectUtils.serialize(o));
}
logger.debug("listObjectAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("listObjectAdd {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}
/**
* 获取List缓存 start传0 end传-1查询全部
* @param key 
* @param start 列表开始值 从0开始计数 ，（可以是负数，当为负数的时候值列表结尾的偏移量，如-2知道从倒数第二条开始）
* @param end   取列表结尾的数
* @return
*/
public static List<?> getObjectList(String key,int start,int end) {
List<Object> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(ObjectUtils.serialize(key))) {
List<byte[]> list = jedis.lrange(ObjectUtils.serialize(key), start, end);
value = Lists.newArrayList();
for (byte[] bs : list){
value.add(toObject(bs));
}
logger.debug("getObjectList {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObjectList {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}


/**
* 获取缓存
* @param key 键
* @return 值
*/
public static Set<String> getSet(String key) {
Set<String> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
value = jedis.smembers(key);
logger.debug("getSet {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getSet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}

/**
* 获取缓存
* @param key 键
* @return 值
*/
public static Set<Object> getObjectSet(String key) {
Set<Object> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
value = Sets.newHashSet();
Set<byte[]> set = jedis.smembers(getBytesKey(key));
for (byte[] bs : set){
value.add(toObject(bs));
}
logger.debug("getObjectSet {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObjectSet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}

/**
* 设置Set缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setSet(String key, Set<String> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)) {
jedis.del(key);
}
result = jedis.sadd(key, (String[])value.toArray());
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setSet {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}

/**
* 设置Set缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static long setObjectSet(String key, Set<Object> value, int cacheSeconds) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
jedis.del(key);
}
Set<byte[]> set = Sets.newHashSet();
for (Object o : value){
set.add(toBytes(o));
}
result = jedis.sadd(getBytesKey(key), (byte[][])set.toArray());
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObjectSet {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObjectSet {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}

/**
* 向Set缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static long setSetAdd(String key, String... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.sadd(key, value);
logger.debug("setSetAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSetAdd {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}


/**
* 向Set缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static long setSetObjectAdd(String key, Object... value) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
Set<byte[]> set = Sets.newHashSet();
for (Object o : value){
set.add(toBytes(o));
}
result = jedis.rpush(getBytesKey(key), (byte[][])set.toArray());
logger.debug("setSetObjectAdd {} = {}", key, value);
} catch (Exception e) {
logger.warn("setSetObjectAdd {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}


/**
* 获取Map缓存
* @param key 键
* @return 值
*/
public static Map<String, Object> getObjectMap(String key) {
Map<String, Object> value = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
value = Maps.newHashMap();
Map<byte[], byte[]> map = jedis.hgetAll(getBytesKey(key));
for (Map.Entry<byte[], byte[]> e : map.entrySet()){
value.put(StringUtils.toString(e.getKey()), toObject(e.getValue()));
}
logger.debug("getObjectMap {} = {}", key, value);
}
} catch (Exception e) {
logger.warn("getObjectMap {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return value;
}
/**
* 设置Map缓存
* @param key 键
* @param value 值
* @param cacheSeconds 超时时间，0为不超时
* @return
*/
public static String setMap(String key, Map<String, Object> value, int cacheSeconds) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))) {
jedis.del(key);
}
Map<byte[], byte[]> map = Maps.newHashMap();
for (Map.Entry<String, Object> e : value.entrySet()){
map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
}
result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
if (cacheSeconds != 0) {
jedis.expire(key, cacheSeconds);
}
logger.debug("setObjectMap {} = {}", key, value);
} catch (Exception e) {
logger.warn("setObjectMap {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}


/**
* 向Map缓存中添加值
* @param key 键
* @param value 值
* @return
*/
public static String mapPut(String key, Map<String, Object> value) {
String result = null;
Jedis jedis = null;
try {
jedis = getResource();
Map<byte[], byte[]> map = Maps.newHashMap();
for (Map.Entry<String, Object> e : value.entrySet()){
map.put(getBytesKey(e.getKey()), toBytes(e.getValue()));
}
result = jedis.hmset(getBytesKey(key), (Map<byte[], byte[]>)map);
logger.debug("mapObjectPut {} = {}", key, value);
} catch (Exception e) {
logger.warn("mapObjectPut {} = {}", key, value, e);
} finally {
returnResource(jedis);
}
return result;
}


/**
* 移除Map缓存中的值
* @param key 键
* @param value 值
* @return
*/
public static long mapRemove(String key, String mapKey) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.hdel(getBytesKey(key), getBytesKey(mapKey));
logger.debug("mapObjectRemove {}  {}", key, mapKey);
} catch (Exception e) {
logger.warn("mapObjectRemove {}  {}", key, mapKey, e);
} finally {
returnResource(jedis);
}
return result;
}


/**
* 判断Map缓存中的Key是否存在
* @param key 键
* @param value 值
* @return
*/
public static boolean mapExists(String key, String mapKey) {
boolean result = false;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.hexists(getBytesKey(key), getBytesKey(mapKey));
logger.debug("mapObjectExists {}  {}", key, mapKey);
} catch (Exception e) {
logger.warn("mapObjectExists {}  {}", key, mapKey, e);
} finally {
returnResource(jedis);
}
return result;
}

/**
* 删除缓存
* @param key 键
* @return
*/
public static long del(String key) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(key)){
result = jedis.del(key);
logger.debug("del {}", key);
}else{
logger.debug("del {} not exists", key);
}
} catch (Exception e) {
logger.warn("del {}", key, e);
} finally {
returnResource(jedis);
}
return result;
}


/**
* 删除缓存
* @param key 键
* @return
*/
public static long delObject(String key) {
long result = 0;
Jedis jedis = null;
try {
jedis = getResource();
if (jedis.exists(getBytesKey(key))){
result = jedis.del(getBytesKey(key));
logger.debug("delObject {}", key);
}else{
logger.debug("delObject {} not exists", key);
}
} catch (Exception e) {
logger.warn("delObject {}", key, e);
} finally {
returnResource(jedis);
}
return result;
}

/**
* 缓存是否存在
* @param key 键
* @return
*/
public static boolean exists(String key) {
boolean result = false;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.exists(key);
logger.debug("exists {}", key);
} catch (Exception e) {
logger.warn("exists {}", key, e);
} finally {
returnResource(jedis);
}
return result;
}

/**
* 缓存是否存在
* @param key 键
* @return
*/
public static boolean existsObject(String key) {
boolean result = false;
Jedis jedis = null;
try {
jedis = getResource();
result = jedis.exists(getBytesKey(key));
logger.debug("existsObject {}", key);
} catch (Exception e) {
logger.warn("existsObject {}", key, e);
} finally {
returnResource(jedis);
}
return result;
}


/**
* 获取资源
* @return
* @throws JedisException
*/
public static Jedis getResource() throws JedisException {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
// logger.debug("getResource.", jedis);
} catch (JedisException e) {
logger.warn("getResource.", e);
returnBrokenResource(jedis);
throw e;
}
return jedis;
}


/**
* 归还资源
* @param jedis
* @param isBroken
*/
public static void returnBrokenResource(Jedis jedis) {
if (jedis != null) {
jedisPool.returnBrokenResource(jedis);
}
}

/**
* 释放资源
* @param jedis
* @param isBroken
*/
public static void returnResource(Jedis jedis) {
if (jedis != null) {
jedisPool.returnResource(jedis);
}
}


/**
* 获取byte[]类型object
* @param object
* @return
*/
public static byte[] getBytesKey(Object object){
if(object instanceof String){
    return StringUtils.getBytes((String)object);
    }else{
    return ObjectUtils.serialize(object);
    }
}

/**
* 获取byte[]类型Key
* @param key
* @return
*/
public static Object getObjectKey(byte[] key){
try{
return StringUtils.toString(key);
}catch(UnsupportedOperationException uoe){
try{
return JedisUtils.toObject(key);
}catch(UnsupportedOperationException uoe2){
uoe2.printStackTrace();
}
}
return null;
}

/**
* Object转换byte[]类型
* @param key
* @return
*/
public static byte[] toBytes(Object object){
    return ObjectUtils.serialize(object);
}


/**
* byte[]型转换Object
* @param key
* @return
*/
public static Object toObject(byte[] bytes){
return ObjectUtils.unserialize(bytes);
}
}
 ObjectUtils.java

package com.youquhd.common.redis;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;


import org.apache.commons.lang3.StringUtils;


/**
 * @author liucx
 */
public class ObjectUtils extends org.apache.commons.lang3.ObjectUtils {


/**
* 注解到对象复制，只复制能匹配上的方法。
* @param annotation
* @param object
*/
public static void annotationToObject(Object annotation, Object object){
if (annotation != null){
Class<?> annotationClass = annotation.getClass();
Class<?> objectClass = object.getClass();
for (Method m : objectClass.getMethods()){
if (StringUtils.startsWith(m.getName(), "set")){
try {
String s = StringUtils.uncapitalize(StringUtils.substring(m.getName(), 3));
Object obj = annotationClass.getMethod(s).invoke(annotation);
if (obj != null && !"".equals(obj.toString())){
if (object == null){
object = objectClass.newInstance();
}
m.invoke(object, obj);
}
} catch (Exception e) {
// 忽略所有设置失败方法
}
}
}
}
}

/**
* 序列化对象
* @param object
* @return
*/
public static byte[] serialize(Object object) {
ObjectOutputStream oos = null;
ByteArrayOutputStream baos = null;
try {
if (object != null){
if(object instanceof String){
return ((String) object).getBytes();
}
baos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(baos);
oos.writeObject(object);
return baos.toByteArray();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}


/**
* 反序列化对象
* @param bytes
* @return
*/
public static Object unserialize(byte[] bytes) {
ByteArrayInputStream bais = null;
try {
if (bytes != null && bytes.length > 0){
bais = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bais);
return ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}


/** 
     * 序列化 list 集合 
     *  
     * @param list 
     * @return 
     */  
    public static byte[] serializeList(List<?> list) {  
        if (list==null||list.isEmpty()) {  
            return null;  
        }  
        ObjectOutputStream oos = null;  
        ByteArrayOutputStream baos = null;  
        byte[] bytes = null;  
        try {  
            baos = new ByteArrayOutputStream();  
            oos = new ObjectOutputStream(baos);  
            for (Object obj : list) {  
                oos.writeObject(obj);  
            }  
            bytes = baos.toByteArray();  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {
          close(oos);  
              close(baos);
        }  
        return bytes;  
    }  

    /** 
     * 反序列化 list 集合 
     * @param bytes 
     * @return 
     */  
    public static List<?> unserializeList(byte[] bytes) {  
        if (bytes == null) {  
            return null;  
        }  

        List<Object> list = new ArrayList<Object>();  
        ByteArrayInputStream bais = null;  
        ObjectInputStream ois = null;  
        try {  
            // 反序列化  
            bais = new ByteArrayInputStream(bytes);  
            ois = new ObjectInputStream(bais);  
            while (bais.available() > 0) {  
                Object obj = (Object) ois.readObject();  
                if (obj == null) {  
                    break;  
                }  
                list.add(obj);  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            close(bais);  
            close(ois);  
        }  
        return list;  
    }  


    public static void close(Closeable closeable){
    try {
closeable.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
    }

}
lcxfeng
关注
专栏目录
csredis封装_[C#] 使用 StackExchange.Redis 封装属于自己的 RedisHelper
weixin_39911998的博客
12-21 749
目前 .NET 使用访问 Redis 的的类库主流应该是StackExchange.Redis，自己参考网上的文章(也许是吃饱了撑着)，也尝试做出简单的封装。/// /// Redis 助手/// public class RedisHelper{/// /// 连接字符串/// private static readonly string ConnectionString;/// /// re...
jedis常用方法封装
lxlcxlm的专栏
11-21 4481
jedis常用方法封装 static long del(java.lang.Stringkey) 删除缓存 static long delObject(java.lang.Stringkey) 删除缓存 static boolean exists(java.lang.Stringkey) 缓存是否存在 stati...
【Redis】封装Redis工具类
最新发布
qq_39921135的博客
08-06 492
经过前面几节的学习，我们已经解决了缓存使用过程中的各种各样的一些问题，但是我们发现无论是解决缓存穿透还是解决缓存击穿，她们的代码逻辑都是挺复杂的，如果说我们每次开发的时候都要去写这些逻辑，其实开发的成本还是挺高的，所以将来我们一定会将这些解决方案封装成工具。这四个方法你可以认为这个方法是两两配对的，方法一和方法三对应起来，即对应一些常见的、普通的缓存，可以解决缓存穿透、设置TTL过期。因为你封装的这个工具类，它并不知道使用者要操作的数据是什么类型，因此这个方法在使用的时候需要指定类型，然后才能做反序列化。
jedis封装
日日留心的技术专栏
04-23 523
1.jedis 基础属性 public class RedisUtils { private static JedisPool jedisPool; public static final String PREFIX = "0621B4751BC607DAB5EF2F391E4D2B69_"; static Logger logger = Logger.getLogger(RedisUtils.class); private static final String REDI
Redis之Jedis简单封装
cainiao1412的博客
01-07 1600
连接池 Jedis是最常用的Redis客户端之一，它的方法、参数基本与Redis官方指令保持一致，节省了学习API的成本， 因为Java是多线程程序，所以一般要将Jedis对象放到一个连接池中，当每个线程需要进行Redis访问时，从连接池中获取Jedis对象, 代码如下： JedisPool jedisPool = new JedisPool(); Jedis jedis = jedisPool.getResource(); // 业务逻辑... jedis.set("hello", "world"
jedis工具封装
ITzhongzi的博客
02-12 489
配置代码控制 import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; public class JedisPoolUtils { private static JedisPool pool = null; ...
redis基本命令-封装redis常用基本命令.zip
06-06
封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip...
Redis,redis封装核心方法
03-03
Redis常用方法封装核心类；对象序列化和反序列化；RedisSession 用于微信分部署session操作；Redis数据源操作接口；商品Redis 存储查询 针对redis缓存技术进行了封装，对象类型存贮封装了序列化，redis穿透的处理。
封装redis常用基本命令.zip
06-06
本压缩包"封装redis常用基本命令.zip"提供了对Redis常用命令的封装，便于在编程中更便捷地操作Redis。以下将详细阐述Redis的一些核心概念和常用命令。 1. 数据类型： - 字符串（String）：最基础的数据类型，可以...
自己在用的封装Jedis工具
06-07
由于自己的redisTemplate出现不明原因用不了了,网上找了好几天也没找到一个比较好的工具, 所以自己整合了几份,并且做了相关优化, 现在用着比较顺手,从配置文件中读取相关设置, 用的时候直接调setString和getString就可以用, 方便~
redis简单封装
05-16
redis简单封装及技术文档
封装JedisClient.提供API实现对redis的操作
weixin_34168700的博客
08-05 361
需要导包,jedis-2.8.1.jar和博主的序列化工具类SerializeUtils package com.demo.redis; import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.u...
Jedis使用+jedis再封装
guoxinian的专栏
06-04 3860
一 、Redis初始化（RedisStart.class） package com.ciri.cache; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; /**  * Created b
封装redis连接池 ( Jedis )
LZJWXJ树袋熊
08-28 2438
一、由来 java操作redis，常用的是 jedis，，作为一个缓存数据库，或者称之为nosql类型的数据库，，redis也有连接对象， 那么，问题来了，我们通过连接对象访问redis的时候，不应该不断的创建和销毁连接对象， 此时，就用到了redis连接池技术，jedis中提供了jedis pool，但是为了操作方便，我们需要自己实现一下，这种思路和mysql 那些数据库连接池的思路是一摸一...
Redis 指南（4）- jedis工具类的封装
Just game, Have fun.
05-25 3362
原文： http://blog.csdn.net/a67474506/article/details/40660031?utm_source=tuicool在项目maven的pom.xml文件中添加jedis依赖：<dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <versio
对象的序列化和反序列化工具类
CHBSRZF的博客
09-25 570
package com.chb.abc.util; import java.io.*; /** * Created by chb */ public class SerializerUtil { public static byte[] serialize(Object o) throws Exception { ByteArrayOutputStream baos
Jedis连接池的方式封装
Leonnnn2020的博客
05-22 317
Jedis连接池的方式封装
redis(封装jedis)-----面试
weixin_64035205的博客
11-02 340
1.redis数据结构和常用方法
Redis常用命令封装教程与工具下载
资源摘要信息:"Redis是一种开源的、基于内存的高性能键值存储系统，它通常被用作数据库、缓存和消息中间件。Redis支持多种类型的数据结构，如字符串(Strings)、列表(Lists)、集合(Sets)、有序集合(Sorted Sets)、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值