Jedis操作redis常用方法集锦

最新推荐文章于 2023-09-06 18:09:06 发布
最新推荐文章于 2023-09-06 18:09:06 发布
阅读量219 收藏
点赞数
分类专栏： redis 文章标签： redis jedis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42246822/article/details/115533574
版权
该代码段展示了使用Jedis进行Redis操作的抽象类，包括获取、设置、删除键值对，处理哈希、列表、集合、有序集合等数据结构，以及哨兵模式下的操作。主要功能有获取单个值、哈希所有值、序列化反序列化、队列数据处理、缓存过期时间设置等。
摘要由CSDN通过智能技术生成

使用Jedis操作redis常用的方法汇总：

public abstract class RedisCacheTemplate {

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

    public abstract Jedis getJedis();

    public abstract Jedis getSentinelJedis();

    public Map<String, String> hgetAll(String key) {
        Jedis jedis = getJedis();
        try {
            Map<String, String> value = jedis.hgetAll(key);
            return value;
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public <T> T get(String key, Class<T> clazz) {
        Jedis jedis = getJedis();
        try {
            String value = jedis.get(key);
            if (clazz.newInstance() instanceof String) {
                return (T) value;
            }
            return JsonUtil.parseObject(value, clazz);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public <T> T getSentinel(String key, Class<T> clazz) {
        Jedis jedis = getSentinelJedis();
        try {
            String value = jedis.get(key);
            if (clazz.newInstance() instanceof String) {
                return (T) value;
            }
            return JsonUtil.parseObject(value, clazz);
        } catch (Exception e) {
            logger.error("getSentinel key:{},error msg:{},error:{}", key, e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public <T> List<T> getList(String key, Class<T> clazz) {
        Jedis jedis = getJedis();
        try {
            return JsonUtil.parseArray(jedis.get(key), clazz);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public <T> List<T> getListFromQueue(String key, Integer number, Class<T> clazz) {
        Jedis jedis = getJedis();
        try {
            Pipeline pipeline = jedis.pipelined();
            Response<List<String>> responses = pipeline.lrange(key, 0, number - 1);
            pipeline.ltrim(key, number, -1);
            pipeline.sync();
            if (responses != null) {
                List<String> list = responses.get();
                return JSONObject.parseArray(list.toString(), clazz);
            }
        } catch (Exception e) {
            logger.error("redis 获取队列数据异常:" + e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    /**
     * 获取缓存值列表
     *
     * @param key
     * @param clazz
     * @return
     */
    @Override
    public <T> Map<String, List<T>> getMapArray(String key, Class<T> clazz) {
        Jedis jedis = getJedis();
        try {
            Map<String, JSONArray> maps = this.get(key, Map.class);
            Map<String, List<T>> conventResult = null;
            if (maps != null && maps.size() > 0) {
                conventResult = new HashMap<>(maps.size());
                Iterator<String> iterator = maps.keySet().iterator();
                String mapKey;
                while (iterator.hasNext()) {
                    mapKey = iterator.next();
                    List<T> arrays = JsonUtil.parseArray(maps.get(mapKey).toJSONString(), clazz);
                    conventResult.put(mapKey, arrays);
                }
            }
            return conventResult;
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    /**
     * 获取缓存值列表
     *
     * @param key
     * @param clazz
     * @return
     */
    @Override
    public <T> Map<String, T> getMap(String key, Class<T> clazz) {
        Jedis jedis = getJedis();
        try {
            Map<String, JSONObject> maps = this.get(key, Map.class);
            Map<String, T> conventResult = null;
            if (maps != null && maps.size() > 0) {
                conventResult = new HashMap<>(maps.size());
                Iterator<String> iterator = maps.keySet().iterator();
                String mapKey;
                while (iterator.hasNext()) {
                    mapKey = iterator.next();
                    if (clazz == String.class) {
                        conventResult.put(mapKey, (T) maps.get(mapKey));
                    } else {
                        conventResult.put(mapKey, JsonUtil.parseObject(maps.get(mapKey).toJSONString(), clazz));
                    }
                }
            }
            return conventResult;
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public <T> void set(String key, T value, Integer timeout) {
        Jedis jedis = getJedis();
        try {
            String data = "";
            if (value instanceof String) {
                data = (String) value;
            } else {
                data = JsonUtil.toString(value);
            }
            jedis.setex(key, timeout, data);

        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    //20200927 add by jzy 将redis单点改为哨兵模式
    @Override
    public <T> void setSentinel(String key, T value, Integer timeout) {
        Jedis jedis = getSentinelJedis();
        try {
            String data = "";
            if (value instanceof String) {
                data = (String) value;
            } else {
                data = JsonUtil.toString(value);
            }
            jedis.setex(key, timeout, data);
            logger.info("setSentinel key:{},timeout:{},data:{}", key, timeout, data);
        } catch (Exception e) {
            logger.error("setSentinel key:{},error msg:{},error:{}", key, e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    /**
     * 储存缓存值
     *
     * @param key
     * @param value
     */
    @Override
    public <T> void set(String key, T value) {
        Jedis jedis = getJedis();
        try {
            String data = "";
            if (value instanceof String) {
                data = (String) value;
            } else {
                data = JsonUtil.toString(value);
            }
            jedis.set(key, data);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    /**
     * 20200927 add by jzy 将redis单点改为哨兵模式
     * 储存缓存值
     *
     * @param key
     * @param value
     */
    @Override
    public <T> void setSentinel(String key, T value) {
        Jedis jedis = getSentinelJedis();
        try {
            String data = "";
            if (value instanceof String) {
                data = (String) value;
            } else {
                data = JsonUtil.toString(value);
            }
            jedis.set(key, data);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public void remove(String key) {
        Jedis jedis = getJedis();
        try {
            jedis.del(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    //20200927 add by jzy 将redis单点改为哨兵模式
    @Override
    public void removeSentinel(String key) {
        Jedis jedis = getSentinelJedis();
        try {
            jedis.del(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public void removeLike(String key) {
        Jedis jedis = getJedis();
        try {
            Set<String> keys = jedis.keys(key + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                jedis.del(keys.toArray(new String[keys.size()]));
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public Boolean exists(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.exists(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return false;
    }

    //20200927 add by jzy 将redis单点改为哨兵模式
    @Override
    public Boolean existsSentinel(String key) {
        Jedis jedis = getSentinelJedis();
        try {
            return jedis.exists(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return false;
    }

    @Override
    public Long getSequence(String key) {
        Jedis jedis = getJedis();
        try {
            // 超时时间为1小时
            int timeout = 3600;
            Long seq = jedis.incr(key);
            jedis.expire(key, timeout);
            // 14位日期+4位数字
            StringBuilder builder = new StringBuilder();
            builder.append(DateUtil.getNow(DateUtil.longFormat));
            builder.append(StringUtils.leftPad(String.valueOf(seq), 4, '0'));

            return Long.valueOf(builder.toString());
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public String sPop(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.spop(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public void sAdd(String key, String... item) {
        Jedis jedis = getJedis();
        try {
            jedis.sadd(key, item);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public Long sCard(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.scard(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public Set<String> sMembers(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.smembers(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return new HashSet<>();
    }

    @Override
    public byte[] getByte(byte[] key) {
        Jedis jedis = getJedis();
        try {
            return jedis.get(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public void lPush(String key, String value) {
        Jedis jedis = getJedis();
        try {
            jedis.lpush(key, value);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public void rPush(String key, String value) {
        Jedis jedis = getJedis();
        try {
            jedis.rpush(key, value);
        } catch (Exception e) {
            logger.error("队列添加数据失败:" + e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public void rPushSentinel(String key, String value) {
        Jedis jedis = getSentinelJedis();
        try {
            jedis.rpush(key, value);
        } catch (Exception e) {
            logger.error("队列添加数据失败:" + e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public <T> void rPushList(List<T> value, String key) {
        if (CollectionUtils.isEmpty(value)) {
            return;
        }
        Jedis jedis = getJedis();
        try {
            Pipeline pipeline = jedis.pipelined();
            for (T v : value) {
                pipeline.rpush(key, JSONObject.toJSONString(v));
            }
            pipeline.sync();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public String lPop(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.lpop(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public Long lLen(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.llen(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public Long incr(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.incr(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public Long incrSentinel(String key) {
        Jedis jedis = getSentinelJedis();
        try {
            return jedis.incr(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public Long decr(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.decr(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public void expire(String key, int seconds) {
        Jedis jedis = getJedis();
        try {
            jedis.expire(key, seconds);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public void expireSentinel(String key, int seconds) {
        Jedis jedis = getSentinelJedis();
        try {
            jedis.expire(key, seconds);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public void expireBytesKey(byte[] key, int expire) {
        Jedis jedis = getJedis();
        try {
            jedis.expire(key, expire);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
    }

    @Override
    public Long pTtl(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.pttl(key);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public String lIndex(String key, Long index) {
        Jedis jedis = getJedis();
        try {
            return jedis.lindex(key, index);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        } finally {
            if (jedis != null) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public Long incr(String key, Integer num) {
        Jedis jedis = getJedis();
        try {
            return jedis.incrBy(key, num);
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public Set<String> keyLike(String key) {
        Jedis jedis = getJedis();
        try {
            Set<String> keys = jedis.keys("*" + key + "*");
            return keys;
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
        return null;
    }

    @Override
    public Long geoAdd(String key, Double lng, Double lat, String member) {
        Jedis jedis = getJedis();
        try {

            return jedis.geoadd(key, lng, lat, member);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }

    }

    @Override
    public List<GeoCoordinate> geoPos(String key, String... member) {
        Jedis jedis = getJedis();
        try {
            List<GeoCoordinate> list = jedis.geopos(key, member);
            return list;
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Double geoDist(String key, String startMember, String endMember) {
        Jedis jedis = getJedis();
        try {
            return jedis.geodist(key, startMember, endMember);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public List<GeoRadiusResponse> geoRadius(String key, double longitude, double latitude, double radius) {
        Jedis jedis = getJedis();
        try {
            GeoRadiusParam param = GeoRadiusParam.geoRadiusParam();
            param.withCoord();
            param.withDist();
            return jedis.georadius(key, longitude, latitude, radius, GeoUnit.M, param);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public List<GeoRadiusResponse> geoRadiusMember(String key, String member, double radius) {
        Jedis jedis = getJedis();
        try {
            return jedis.georadiusByMember(key, member, radius, GeoUnit.M);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public List<String> geoHash(String key, String... members) {
        Jedis jedis = getJedis();
        try {
            return jedis.geohash(key, members);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Long zRem(String key, String... members) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrem(key, members);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Long zAdd(String key, Double score, String member) {
        Jedis jedis = getJedis();
        try {
            return jedis.zadd(key, score, member);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Set<String> zRange(String key, long start, long end) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrange(key, start, end);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Set<Tuple> zRangeWithScores(String key, long start, long end) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrangeWithScores(key, start, end);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Set<Tuple> zRangeByScoreWithScores(String key, double min, double max) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrangeByScoreWithScores(key, min, max);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Set<String> zRangeByScore(String key, double min, double max) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrangeByScore(key, min, max);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Long zRemRangeByScore(String key, double min, double max) {
        Jedis jedis = getJedis();
        try {
            return jedis.zremrangeByScore(key, min, max);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Long addNewString(String key, String value) {
        Jedis jedis = getJedis();
        try {
            return jedis.setnx(key, value);
        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public Long addHashMap(String key, String field, String value) {
        Jedis jedis = getJedis();
        try {
            return jedis.hset(key, field, value);

        } catch (Exception e) {
            throw e;
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }

    @Override
    public void delKeys(List<String> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        String[] idArr = ids.toArray(new String[0]);
        Jedis jedis = getJedis();
        try {
            jedis.del(idArr);
        } catch (Exception e) {
            logger.error("删除redis key 异常:", e);
        } finally {
            if (null != jedis) {
                jedis.close();
            }
        }
    }
}
JobsTribe
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
(Redis操作) Jedis常用方法
yapengliu的博客
09-13 194
//创建连接 private static final String ADDR = "192.168.220.10"; private static final int PORT = 6379; private static final int TIMEOUT = 2000; private static JedisPool jedisPool = new JedisPool(ADDR, PORT); private static JedisPoolConf...
Redis使用之Jedis操作redis
JAVAzhang88的博客
12-21 180
使用Java操作Redis需要jedis-2.1.0.jar。 导入依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.1.0</version><!--版本号可根据实际情况填写--> </dependency> 示例： package
Redis存储List类型数据
热门推荐
Bainily_Wu的博客
10-11 5万+
Redis存储支持的类型没有object，虽然有支持list，但是它只支持list&lt;String&gt;。 现在有两个方法存储对象与泛型。 1、用序列化与反序列化。 2、json   本文采用的是json格式来存储object类型。 废话不多说，直接上代码 public class redisTest｛ /** *使用redis自带的工具类 *也可以自己...
常见的Jedis方法
FlowingRiver
05-15 1083
返回值为1表示设置成功，0表示字段已存在。返回值为1表示设置成功，0表示键不存在或没有设置过期时间。：检查指定键是否存在，返回值为true表示存在，false表示不存在。：设置键的过期时间，单位为秒。返回值为1表示设置成功，0表示键不存在。：设置键值对，如果键已经存在，则覆盖原有值。：删除哈希表中一个或多个字段，返回值为成功删除的字段数量。：批量获取哈希表中指定字段的值，返回值为List类型。：获取有序集合中指定区间的成员，返回值为Set类型。：删除键值对，返回值为删除成功的键的数量。
Jedis使用教程完整版
daobuxinzi的博客
07-01 1万+
概述 Jedis是Redis官方推荐的Java连接开发工具。要在Java开发中使用好Redis中间件，必须对Jedis熟悉才能写成漂亮的代码。这篇文章不描述怎么安装Redis和Reids的命令，只对Jedis的使用进行对介绍。 1. 基本使用 Jedis的基本使用非常简单，只需要创建Jedis对象的时候指定host，port, password即可。当然，Jedis对象又很多构造方法，都大同小异，只是对应和Redis连接的socket的参数不一样而已。 Jedis jedis = ne
Jedis常用方法
Java陈小白
12-18 3560
转载：原文地址 一、Redis Client介绍 1.1、简介 Jedis Client是Redis官网推荐的一个面向java客户端，库文件实现了对各类API进行封装调用。 Jedis源码工程地址：https://github.com/xetorthio/jedis 1.2、使用 Redis Client最好选用与服务端对应的版本，本例中使用Redis 2.8.19客户端使用jedis -2.6....
Jedis的常用操作
weixin_41864357的博客
09-15 3385
转载至： https://blog.csdn.net/meaijojo/article/details/82903553 一、jedis jedis 是 redis推荐的java客户端。通过Jedis我们可以很方便地使用java代码的方式，对redis进行操作。jedis使用起来比较简单，它的操作方法与redis命令相类似。对于初次使用redis的人来说，上手更快，更能适应。jedis在github上的下载地址为https://github.com/xetorthio/jedis 。本例子使用maven，需
Jedis操作redis代码示例
04-26
以上只是Jedis库中部分常用的操作。实际上，Jedis还支持更多高级特性，如发布订阅、事务处理、管道等。通过深入学习和实践，开发者可以充分利用Redis的特性，提高应用程序的性能和效率。 在实际应用中，需要注意的...
redis博客总集-jedis连接redis的所有操作
09-18
Jedis是Java语言中使用Redis的一个常用客户端库，提供了丰富的API来执行各种Redis操作。本篇文章将详细探讨如何使用Jedis连接Redis并进行各种操作。 首先，要使用Jedis，你需要在项目中引入其依赖。在`pom.xml`文件...
Java通过Jedis操作Redis
01-21
而Java作为广泛使用的编程语言，通过Jedis库与Redis进行交互，实现了对Redis丰富的操作功能。本文将深入探讨如何使用Java和Jedis来操作Redis，涉及Redis的基本数据类型、主从复制以及事务处理。 首先，让我们了解...
JAVA整合JEDIS操作访问Redis的工具类
10-27
总之，`JAVA整合JEDIS操作访问Redis的工具类`通过Jedis库实现了与Redis服务器的交互，并通过`CacheUtils`工具类进一步封装了常用操作，降低了使用Redis的门槛。这使得开发者能够更专注于业务逻辑，而不是底层的连接...
redis常用方法封装
11-21
在Java开发中，Jedis是连接Redis的客户端库，它提供了丰富的API来操作Redis的各种数据结构，如字符串、哈希、列表、集合、有序集合等。本封装主要关注了以下几个方面的内容： 1. **Jedis连接管理**： - 初始化...
Jedis常用方法API
Coder
05-15 1777
一、引入jedis包 二、创建 jedis对象 三、键操作： 四、字符串操作： 五、整数和浮点数操作： 六、列表（List）操作： 七、集合（Set）操作： 八、哈希（Hash）操作： 九、有序集合（Zsort）操作： 十、排序操作： ...
使用Jedis操作Redis
少说话,多做事!
03-12 764
Redis是一个开源的Key-Value数据缓存，和Memcached类似。 Redis多种类型的value，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。 Jedis 是 Redis 官方首选的 Java 客户端开发包。 //连接redis ，redis的默认端口是6379 Jedis jedi
Jedis的基本操作方法
游王子的博客
10-20 4012
一、Jedis介绍 jedis 是 redis推荐的java客户端。通过Jedis我们可以很方便地使用java代码的方式，对redis进行操作。jedis使用起来比较简单，它的操作方法与redis命令相类似。对于初次使用redis的人来说，上手更快，更能适应。本例子使用maven，需要添加如下依赖： <!-- https://mvnrepository.com/arti...
Jedis的常用方法（不断更新ing）
最新发布
m0_61771461的博客
09-06 336
hset(String key, String field, String value)：设置哈希表中指定字段的值。hmset(String key, Map<String, String> map)：批量设置哈希表中的字段值。set(String key, String value)：设置键值对，如果键已经存在，则覆盖原有值。exists(String key)：检查指定键是否存在，返回值为true表示存在，false表示不存在。del(String key)：删除键值对，返回值为删除成功的键的数量。
redis指定数据库
weixin_42246822的博客
03-06 4223
redis指定数据库的方法
Jedis操作与Redis配置：实战Java对象持久化
6. **常用操作**： - Redis支持多种数据结构，如字符串、哈希、列表、集合和有序集合。Jedis提供了对应的API来操作这些数据结构，比如`SET`, `GET`, `HSET`, `LPUSH`等。 7. **性能与缓存**： - Redis以其低延迟...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值