package com.feng;
import com.common.utils.SerializeUtil;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
public class JedisUtil {
@Autowired
protected static JedisPool jedisPool;
private JedisUtil() {}
/**
* 简单的Get
* @param <T>
* @param key
* @param requiredType
* @return
*/
public static <T> T get(String key , Class<T>...requiredType){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] skey = SerializeUtil.serialize(key);
return SerializeUtil.deserialize(jds.get(skey),requiredType);
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return null;
}
/**
* 简单的set
* @param key
* @param value
*/
public static void set(Object key ,Object value){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] skey = SerializeUtil.serialize(key);
byte[] svalue = SerializeUtil.serialize(value);
jds.set(skey, svalue);
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
}
/**
* 过期时间的
* @param key
* @param value
* @param timer （秒）
*/
public static void setex(Object key, Object value, int timer) {
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] skey = SerializeUtil.serialize(key);
byte[] svalue = SerializeUtil.serialize(value);
jds.setex(skey, timer, svalue);
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
}
/**
*
* @param <T>
* @param mapkey map
* @param key map里的key
* @param requiredType value的泛型类型
* @return
*/
public static <T> T getVByMap(String mapkey,String key , Class<T> requiredType){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] mkey = SerializeUtil.serialize(mapkey);
byte[] skey = SerializeUtil.serialize(key);
List<byte[]> result = jds.hmget(mkey, skey);
if(null != result && result.size() > 0 ){
byte[] x = result.get(0);
T resultObj = SerializeUtil.deserialize(x, requiredType);
return resultObj;
}
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return null;
}
/**
*
* @param mapkey map
* @param key map里的key
* @param value map里的value
*/
public static void setVByMap(String mapkey,String key ,Object value){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] mkey = SerializeUtil.serialize(mapkey);
byte[] skey = SerializeUtil.serialize(key);
byte[] svalue = SerializeUtil.serialize(value);
jds.hset(mkey, skey,svalue);
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
}
/**
* 删除Map里的值
* @param mapKey
* @param dkey
* @return
*/
public static Object delByMapKey(String mapKey ,String...dkey){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[][] dx = new byte[dkey.length][];
for (int i = 0; i < dkey.length; i++) {
dx[i] = SerializeUtil.serialize(dkey[i]);
}
byte[] mkey = SerializeUtil.serialize(mapKey);
Long result = jds.hdel(mkey, dx);
return result;
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return new Long(0);
}
/**
* 往redis里取set整个集合
*
* @param <T>
* @param setKey
* @param requiredType
* @return
*/
public static <T> Set<T> getVByList(String setKey,Class<T> requiredType){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] lkey = SerializeUtil.serialize(setKey);
Set<T> set = new TreeSet<T>();
Set<byte[]> xx = jds.smembers(lkey);
for (byte[] bs : xx) {
T t = SerializeUtil.deserialize(bs, requiredType);
set.add(t);
}
return set;
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return null;
}
/**
* 获取Set长度
* @param setKey
* @return
*/
public static Long getLenBySet(String setKey){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
Long result = jds.scard(setKey);
return result;
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return null;
}
/**
* 删除Set
* @param dkey
* @return
*/
public static Long delSetByKey(String key,String...dkey){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
Long result = 0L;
if(null == dkey){
result = jds.srem(key);
}else{
result = jds.del(key);
}
return result;
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return new Long(0);
}
/**
* 随机 Set 中的一个值
* @param key
* @return
*/
public static String srandmember(String key){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
String result = jds.srandmember(key);
return result;
} catch (Exception e){
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return null;
}
/**
* 往redis里存Set
* @param setKey
* @param value
*/
public static void setVBySet(String setKey,String value){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
jds.sadd(setKey, value);
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
}
/**
* 取set
* @param key
* @return
*/
public static Set<String> getSetByKey(String key){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
Set<String> result = jds.smembers(key);
return result;
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return null;
}
/**
* 往redis里存List
* @param listKey
* @param value
*/
public static void setVByList(String listKey,Object value){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] lkey = SerializeUtil.serialize(listKey);
byte[] svalue = SerializeUtil.serialize(value);
jds.rpush(lkey, svalue);
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
}
/**
* 往redis里取list
*
* @param <T>
* @param listKey
* @param start
* @param end
* @param requiredType
* @return
*/
public static <T> List<T> getVByList(String listKey,int start,int end,Class<T> requiredType){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] lkey = SerializeUtil.serialize(listKey);
List<T> list = new ArrayList<T>();
List<byte[]> xx = jds.lrange(lkey,start,end);
for (byte[] bs : xx) {
T t = SerializeUtil.deserialize(bs, requiredType);
list.add(t);
}
return list;
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return null;
}
/**
* 获取list长度
* @param listKey
* @return
*/
public static Long getLenByList(String listKey){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] lkey = SerializeUtil.serialize(listKey);
Long result = jds.llen(lkey);
return result;
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return null;
}
/**
* 删除
* @param dkey
* @return
*/
public static Long delByKey(String...dkey){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[][] dx = new byte[dkey.length][];
for (int i = 0; i < dkey.length; i++) {
dx[i] = SerializeUtil.serialize(dkey[i]);
}
Long result = jds.del(dx);
return result;
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return new Long(0);
}
/**
* 判断是否存在
* @param existskey
* @return
*/
public static boolean exists(String existskey){
Jedis jds = null;
boolean isBroken = false;
try {
jds = jedisPool.getResource();
jds.select(0);
byte[] lkey = SerializeUtil.serialize(existskey);
return jds.exists(lkey);
} catch (Exception e) {
isBroken = true;
e.printStackTrace();
} finally {
returnResource(jds, isBroken);
}
return false;
}
/**
* 释放
* @param jedis
* @param isBroken
*/
public static void returnResource(Jedis jedis, boolean isBroken) {
if (jedis == null)
return;
jedis.close();
}
}
package com.common.utils;
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 net.sf.json.JSONObject;
public class SerializeUtil {
static final Class<?> CLAZZ = SerializeUtil.class;
public static byte[] serialize(Object value) {
if (value == null) {
throw new NullPointerException("Can't serialize null");
}
byte[] rv = null;
ByteArrayOutputStream bos = null;
ObjectOutputStream os = null;
try {
bos = new ByteArrayOutputStream();
os = new ObjectOutputStream(bos);
os.writeObject(value);
os.close();
bos.close();
rv = bos.toByteArray();
} catch (Exception e) {
LoggerUtils.fmtError(CLAZZ,e, "serialize error %s", JSONObject.fromObject(value));
} finally {
close(os);
close(bos);
}
return rv;
}
public static Object deserialize(byte[] in) {
return deserialize(in, Object.class);
}
public static <T> T deserialize(byte[] in, Class<T>...requiredType) {
Object rv = null;
ByteArrayInputStream bis = null;
ObjectInputStream is = null;
try {
if (in != null) {
bis = new ByteArrayInputStream(in);
is = new ObjectInputStream(bis);
rv = is.readObject();
}
} catch (Exception e) {
LoggerUtils.fmtError(CLAZZ,e, "serialize error %s", in);
} finally {
close(is);
close(bis);
}
return (T) rv;
}
private static void close(Closeable closeable) {
if (closeable != null)
try {
closeable.close();
} catch (IOException e) {
LoggerUtils.fmtError(CLAZZ, "close stream error");
}
}
}
相关推荐
由于自己的redisTemplate出现不明原因用不了了,网上找了好几天也没找到一个比较好的工具, 所以自己整合了几份,并且做了相关优化, 现在用着比较顺手,从配置文件中读取相关设置, 用的时候直接调setString和getString就...
在Java应用中，我们通常会创建一个封装了Jedis操作的工具类，以便更方便地管理和使用Redis服务。这个工具类可以包含连接池配置、键值操作、集合操作、有序集合操作、哈希表操作等多种功能，旨在提高代码的复用性和可...
这个工具类封装了与Redis服务器通信的所有逻辑，开发者只需调用相应的方法即可完成数据的读写操作，无需关心连接管理、命令构建等底层细节。这样的设计遵循了单一职责原则，有助于代码的维护和扩展。 例如，我们...
1. **JedisClient**: 这个工具类是对Jedis原生API的封装，简化了与Redis服务器的交互过程。它可能包含了如连接池管理、命令执行、事务处理等功能。开发者可以通过此类直接进行键值操作，如设置和获取字符串、哈希表...
创建一个Jedis操作工具类可以封装常用的操作方法，如设置键值对、获取键值对、删除键、集合操作等，使得代码更加简洁易用。例如： ```java public class RedisUtil { private static JedisPool jedisPool; /...
在Java开发中，为了方便与Redis进行交互，通常会封装一个工具类，本文将详细介绍如何封装一个基于Redis操作字符串的工具类。 在`RedisPoolUtils`这个类中，我们可以看到它是对Jedis或Lettuce等Redis客户端的进一步...
在Java开发中，Redis作为一个...总之，Jedis操作模板类是一个高效、实用的设计，它封装了与Redis交互的细节，提高了代码的可读性和复用性。开发者可以根据实际需求扩展这个模板，实现更复杂的数据操作和更高级的功能。
总之，`JAVA整合JEDIS操作访问Redis的工具类`通过Jedis库实现了与Redis服务器的交互，并通过`CacheUtils`工具类进一步封装了常用操作，降低了使用Redis的门槛。这使得开发者能够更专注于业务逻辑，而不是底层的连接...
`jedis.zip`包含的工具类是为了简化Java程序员与Redis服务器之间的交互，使得操作Redis更加便捷。下面我们将详细探讨这两个关键的类：`JedisTemplate`和`JedisProvider`。 `JedisTemplate`是核心的模板类，它封装了...
可能是最全的Redis静态工具类，拿来即用，随时随地RedisUtils.方法名()存取数据，每个方法都有对应的注释，快速上手！
为了方便地在Java应用中操作Redis，开发者通常会创建一个工具类（Util），封装各种Redis操作方法。这个"java操作redis工具类"就是这样的一个实用组件，它简化了与Redis服务器的交互，使得代码更简洁、易维护。 首先...
Redis Utils工具类是Java开发中常见的一种封装，用于简化与Redis数据库的交互操作。Redis是一种高性能的键值存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。在Java开发中，为了提高代码的可读性和复用...
在Java开发过程中，工具类是不可或缺的一部分，它们封装了常用的操作，提高代码的复用性和可维护性。"java个人开发工具类"集合了开发者在实际项目中可能会频繁使用的功能，比如对Redis的操作、FastDFS客户端接口以及...
首先，`redis工具类`的核心功能在于创建和管理Jedis实例。Jedis对象是与Redis服务器通信的桥梁，但为了防止资源泄露，我们需要正确地管理和关闭这些对象。在工具类中，通常会提供一个静态方法来创建Jedis实例，并在...
1. **连接管理**：Jedis提供了连接池（Connection Pool）功能，通过`JedisPool`类实现，可以有效地管理和复用Redis连接，避免频繁创建和关闭连接带来的开销。使用`JedisPoolConfig`配置连接池参数，如最大空闲连接数...
在这个"java工程常用代码工具类"中，我们可以找到几个关键功能的实现，包括Jedis、FTP上传、JSON格式化、RESTful风格接口以及HTTP工具。下面将分别详细介绍这些知识点。 1. **Jedis**： Jedis是Java语言编写的...
本文将深入剖析Jedis 3.0.0的源码，揭示其在集群和管道模式下的实现机制，帮助读者更好地理解和应用这一强大工具。 一、Jedis概述 Jedis作为Java与Redis之间的桥梁，为开发者提供了简单易用的API，包括字符串、...
Fewyit Redis工具类是为了简化Redis操作而设计的Java库，它封装了各种常见的Redis操作，使得在开发过程中能够更加便捷地与Redis进行交互。下面将详细介绍这个工具类的主要功能及其使用方法。 1. **连接管理** - `...