封装Redis

最新推荐文章于 2024-08-21 22:38:14 发布
最新推荐文章于 2024-08-21 22:38:14 发布
阅读量280 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/manhengwei/article/details/122056817
版权 
RedisWrapperImpl
package com.jdl.lomir.chint.core.cache.impl;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jd.jim.cli.Cluster;
import com.jdl.lomir.chint.core.cache.IRedisWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class RedisWrapperImpl<T> implements IRedisWrapper<T> {

    private static final String LOG_PREFIX = "[Redis Wrapper]: ";

    private final ObjectMapper JSON = new ObjectMapper();

    @Resource
    private Cluster cluster;

    @Override
    public Boolean exists(String key) {
        return this.cluster.exists(key);
    }

    @Override
    public String get(String key) {
        String value = this.cluster.get(key);
        log.debug("{}[get {}] << result: [{}]", LOG_PREFIX, key, value);
        return value;
    }

    @Override
    public void set(String key, String value) {
        this.cluster.set(key, value);
        log.debug("{}[set {}] >> value: [{}]", LOG_PREFIX, key, value);
    }
    public void set(String key,Object value){
        this.set(key,value);
        log.debug("{}[set {}] >> value: [{}]", LOG_PREFIX, key, value);
    }
    @Override
    public void setex(String key, String value, long num, TimeUnit timeUnit) {
        this.cluster.setEx(key, value, num, timeUnit);
        log.debug("{}[setex {}] >> value: [{}], ex: [{}], unit: [{}]", LOG_PREFIX, key, value, num, timeUnit.toString());
    }

    @Override
    public Long lpush(String key, String body) {
        Long result = this.cluster.lPush(key, body);
        log.debug("{}[lpush {}] >> result: [{}], value [{}]", LOG_PREFIX, key, result, body);
        return result;
    }

    public Long rpush(String key, String body) {
        Long result = this.cluster.rPush(key, body);
        log.debug("{}[rpush {}] >> result: [{}], value [{}]", LOG_PREFIX, key, result, body);
        return result;
    }

    @Override
    public Boolean hset(String name, String key, String value) {
        Boolean result = this.cluster.hSet(name, key, value);
        log.debug("{}[hset {} {}] >> result: [{}], value: [{}]", LOG_PREFIX, name, key, result, value);
        return result;
    }

    @Override
    public String hget(String name, String key) {
        String value = this.cluster.hGet(name, key);
        log.debug("{}[hget {} {}] << value: [{}]", LOG_PREFIX, name, key, value);
        return value;
    }

    @Override
    public Long hdel(String name, String key) {
        Long result = this.cluster.hDel(name, key);
        //todo : 这里打日志是为了更好的监控围栏网点的删除 如果后期有频繁调用的需求  可将日志改成debug 并在删除围栏网点处加好日志
        log.info("{}[hdel {} {}] >> result: [{}]", LOG_PREFIX, name, key,result);
        return result;
    }

    @Override
    public Set<String> hkeys(String name) {
        Set<String> keys = this.cluster.hKeys(name);
        try {
            log.debug("{}[hkeys {}] << value: [{}]", LOG_PREFIX, name, JSON.writeValueAsString(keys));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return keys;
    }

    @Override
    public List<String> hvals(String name) {
        List<String> values = this.cluster.hVals(name);
        try {
            log.debug("{}[hvals {}] << value: [{}]", LOG_PREFIX, name, JSON.writeValueAsString(values));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return values;
    }

    @Override
    public Map<String, String> hgetall(String name) {
        Map<String, String> values = this.cluster.hGetAll(name);
        try {
            log.debug("{}[hgetall {}] << value: [{}]", LOG_PREFIX, name, JSON.writeValueAsString(values));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return values;
    }

    @Override
    public long llen(String key) {
        if (key == null || key.length() < 1) {
            log.warn("{}[llen] key is blank", LOG_PREFIX);
            return 0;
        }
        Long count = this.cluster.lLen(key);
        log.debug("{}[llen {}] << value: [{}]", LOG_PREFIX, key, count);
        return count == null ? 0 : count.longValue();
    }

    @Override
    public List<String> lrange(String key, long start, long end) throws Exception {
        if (key == null || key.length() < 1) {
            log.warn("{}[lrange] key is blank", LOG_PREFIX);
            return null;
        }
        List<String> list = this.cluster.lRange(key, start, end);
        log.debug("{}[lrange {}] << value: [{}], start: [{}], end: [{}]", LOG_PREFIX, key, start, end);
        return list;
    }

    @Override
    public String lpop(String key) throws Exception {
        if (key == null || key.length() < 1) {
            log.warn("{}[lpop] key is blank", LOG_PREFIX);
            return null;
        }
        String result = this.cluster.lPop(key);
        log.debug("{}[lpop {}] << value: [{}]", LOG_PREFIX, key, result);
        return result;
    }

    @Override
    public String rpop(String key) {
        if (key == null || key.length() < 1) {
            log.warn("{}[rpop] key is blank", LOG_PREFIX);
            return null;
        }
        String result = this.cluster.rPop(key);
        log.debug("{}[rpop {}] << value: [{}]", LOG_PREFIX, key, result);
        return result;
    }

    @Override
    public Long del(String key) {
        Long result = this.cluster.del(key);
        log.info("{}[del {}] >> result: [{}]", LOG_PREFIX, key, result);
        return result;
    }

    @Override
    public Long sadd(String key, String... member) {
        Long result = this.cluster.sAdd(key, member);
        try {
            log.debug("{}[sadd {}] >> result: [{}], value: [{}]", LOG_PREFIX, key, result, JSON.writeValueAsString(member));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return result;
    }

    @Override
    public Long srem(String key, String... member) {
        Long result = this.cluster.sRem(key, member);
        try {
            log.debug("{}[srem {}] >> result: [{}], value: [{}]", LOG_PREFIX, key, result, JSON.writeValueAsString(member));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return result;
    }

    @Override
    public Long scard(String key) {
        Long result = this.cluster.sCard(key);
        log.debug("{}[scard {}] << value: [{}]", LOG_PREFIX, key, result);
        return result;
    }

    @Override
    public Set<String> smembers(String key) {
        Set<String> members = this.cluster.sMembers(key);
        try {
            log.debug("{}[smembers {}] << value: [{}]", LOG_PREFIX, key, JSON.writeValueAsString(members));
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return members;
    }

    @Override
    public Boolean sismember(String key, String member) {
        Boolean result = this.cluster.sIsMember(key, member);
        log.debug("{}[sismember {}] << result: [{}]", LOG_PREFIX, key, result);
        return result;
    }

    @Override
    public Long decrBy(String key, long integer) {
        Long result = this.cluster.decrBy(key, integer);
        log.debug("{}[decrBy {}] << result: [{}], decrement: [{}]", LOG_PREFIX, key, result, integer);
        return result;
    }

    @Override
    public Long decr(String key) {
        Long result = this.cluster.decr(key);
        log.debug("{}[decr {}] << result: [{}]", LOG_PREFIX, key, result);
        return result;
    }

    @Override
    public Long incrBy(String key, long integer) {
        Long result = this.cluster.incrBy(key, integer);
        log.debug("{}[incrBy {}] << result: [{}], increment: [{}]", LOG_PREFIX, key, result, integer);
        return result;
    }

    @Override
    public Long incr(String key) {
        Long result = this.cluster.incr(key);
        log.debug("{}[incr {}] << result: [{}]", LOG_PREFIX, key, result);
        return result;
    }

    @Override
    public Boolean expire(String key, long num, TimeUnit timeUnit) {
        Boolean result = this.cluster.expire(key, num, timeUnit);

        log.debug("{}[expire {}] << result: [{}], ex: [{}], unit: [{}]", LOG_PREFIX, key, result, num, timeUnit.toString());
        return result;
    }

    @Override
    public boolean persist(String key){
        Boolean result=this.cluster.persist(key);
        log.debug("{}[persist {}] << result: [{}]", LOG_PREFIX, key, result);
        return result;
    }

    @Override
    public Long hlen(String key) {
        Long result = this.cluster.hLen(key);
        log.debug("{}[hlen {}] << result: [{}]", LOG_PREFIX, key, result);
        return result;
    }


    @Override
    public Boolean hexists(String key, String field) {
        Boolean result = this.cluster.hExists(key, field);
        log.debug("{}[hexists {}] << result: [{}], field: [{}]", LOG_PREFIX, key, result, field);
        return result;
    }

    @Override
    public Long hincrby(String key, String field, Integer value) {
        Long result = this.cluster.hIncrBy(key, field, value);
        log.debug("{}[hincrby {}] << result: [{}], field: [{}], increment: [{}]", LOG_PREFIX, key, result, field, value);
        return result;
    }

    @Override
    public List<String> hMGet(String key, String... fields){
        return this.cluster.hMGet(key, fields);
    }

    @Override
    public Long lrem(String key, long count, String value) {
        return this.cluster.lRem(key, count, value);
    }

    @Override
    public void ltrim(String key, long begin, long end) {
        this.cluster.lTrim(key, begin, end);
    }

    @Override
    public Boolean lock(String key, String value, long timeout) {
        if (cluster != null && StringUtils.isNotBlank(key) && StringUtils.isNotBlank(value)) {
            try {
                if (cluster.setNX(key, value)) {
                    cluster.expire(key, timeout, TimeUnit.SECONDS);
                    return true;
                }
                Long ttl = cluster.ttl(key);
                if (ttl < 0L) {
                    cluster.expire(key, timeout, TimeUnit.SECONDS);
                }
            } catch (Exception var6) {
                return false;
            }
            return false;
        } else {
            return false;
        }
    }

    @Override
    public Boolean unlock(String key) {
        if (cluster != null && StringUtils.isNotBlank(key)) {
            Boolean returnValue = false;
            try {
                Long delNumber = cluster.del(key);
                return delNumber == 1L;
            } catch (Exception var4) {
                return returnValue;
            }
        } else {
            return false;
        }
    }

    @Override
    public Long ttl(String key) {
        return cluster.ttl(key);
    }

    @Override
    public Boolean zadd(String key, double score, String value) {
        Boolean result = this.cluster.zAdd(key, score, value);
        log.debug("{}[zadd {}] >> result: [{}], score: [{}], value: [{}]", LOG_PREFIX, key, result, score, value);
        return result;
    }

    @Override
    public Set<String> zrange(String key, long start, long end) {
        return this.cluster.zRange(key, start, end);
    }
}


IBaseCacheWrapper
/**
 * Project Name:preseparate-service
 * File Name:IBaseCacheWrapper.java
 * Package Name:com.jd.bluedragon.preseparate.cache
 * Date:Nov 8, 20133:29:31 PM
 * Copyright (c) 2013, www.jd.com All Rights Reserved.
 */

package com.jdl.lomir.chint.core.cache;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * @Description:<br/>
 * @author hubert <br/>
 * @date: Nov 8, 2013 3:29:31 PM
 */
public interface IBaseCacheWrapper {

    void set(String key, String value);

    void setex(String key, String value, long num, TimeUnit timeUnit);

    String get(String key);

    Long del(String key);

    Long decrBy(String key, long integer);

    Long decr(String key);

    Long incrBy(String key, long integer);

    Long incr(String key);

    Boolean hset(String name, String key, String value);

    String hget(String name, String key);

    Long hdel(String name, String key);

    Set<String> hkeys(String name);

    List<String> hvals(String name);

    Map<String, String> hgetall(String name);

}

IRedisWrapper
package com.jdl.lomir.chint.core.cache;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;


public interface IRedisWrapper<T> extends IBaseCacheWrapper{

    public Long lpush(String key, String body);

    public Long rpush(String key, String body);

    public String lpop(String key) throws Exception;

    public String rpop(String key);

    public void ltrim(String key, long begin, long end);

    public Long lrem(String key, long count, String value);

    public List<String> lrange(String key, long start, long end) throws Exception;

    public long llen(String key);

    Long sadd(String key, String... member);

    Long srem(String key, String... member);

    Long scard(String key);

    Set<String> smembers(String key);

    Boolean sismember(String key, String member);

    public Boolean expire(String key, long num, TimeUnit timeUnit);

    boolean persist(String key);

    public Long hlen(String key);

    public Boolean exists(String key);

    public Long hdel(String key, String field);

    public Boolean hexists(String key, String field);

    public String hget(String key, String field);

    public Map<String, String> hgetall(String key);

    public Boolean hset(String key, String field, String value);

    Long hincrby(String key, String field, Integer value);

    public List<String> hMGet(String key, String... fields);

    public Boolean lock(String key, String value, long timeout);

    public Boolean unlock(String key);

    public Long ttl(String key);

    public Boolean zadd(String key, double score, String value);

    public Set<String> zrange(String key, long start, long end);
}

ᅟᅟᅟᅟᅟ
关注
redis简单封装
05-16
redis简单封装及技术文档
springboot 集成封装redis工具类redisUtils和单元测试
09-13
文章是redisUtils工具类的封装，和基于springboot环境的单元测试； 文中封装了redis的众多方法，希望对您有所帮助。
redis封装
iteye_10704的博客
11-29 145
import java.util.ArrayList; import java.util.List; import org.apache.log4j.Logger; import redis.clients.jedis.JedisPoolConfig; import redis.clients.jedis.JedisShardInfo; import redis.client...
04、Redis实战：封装工具
最新发布
u012011912的博客
08-21 640
方法2：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题。方法1：将任意Java对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间。方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题。方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题。方法5：根据指定的Key查询缓存，并反序列化为指定类型，需要利用互斥锁解决缓存击穿问题。
redis的封装
qq_32615575的博客
02-18 140
const redis = require('redis') const { REDIS_CONF } = require('../conf/db.js') // 创建客户端 const redisClient = redis.createClient(REDIS_CONF.port, REDIS_CONF.host) redisClient.on('error', err => { console.error(err) }) function set(key, val) { ...
redis接口封装
hugufei的博客
09-29 1053
一、redis接口package cn.com.frame.redis;import java.util.List; import java.util.Map; import java.util.Set;public interface Redis {/********************************通用API***********************************
Redis工具类封装
m0_46628950的博客
07-03 238
Redis工具类封装
redis基本命令-封装redis常用基本命令.zip
06-06
封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip封装redis常用基本命令.zip...
go语言学习 - 封装redis常用基本命令.zip
06-06
"Go语言学习 - 封装Redis常用基本命令.zip"这个压缩包文件显然是为了教授如何使用Go语言来操作Redis。首先，我们需要理解Go语言中的网络编程和数据库连接概念。Go语言的net包提供了创建TCP、UDP等网络连接的能力，这...
封装redis常用基本命令.zip
06-06
本压缩包"封装redis常用基本命令.zip"提供了对Redis常用命令的封装，便于在编程中更便捷地操作Redis。以下将详细阐述Redis的一些核心概念和常用命令。 1. 数据类型： - 字符串（String）：最基础的数据类型，可以...
Qt封装Redis接口
11-03
本文将深入探讨如何在Qt中封装Redis接口，以及如何利用这种结合来实现点对点的消息队列和多对多的发布/订阅通信。 首先，我们来看"qredis.cpp"和"qredis.h"这两个文件。它们通常分别包含了Qt封装的Redis客户端的...
redis集中处理函数封装
11-28
该脚本文件将redis数据库处理数据的函数集中进行封装,方便使用.
redis封装类
06-20
java项目使用redis封装一些方法和一些初始化数据，如初始化连接池等
Java操作Redis实例，操作封装
07-11
Jedis Java操作Redis实例代码 向Redis保存对象、查询对象、代码封装 客户端连接资源管理 等等
redis常用方法封装
11-21
redis代码封装，保函jedis 操作list map set等，都带有详细注释
hredis-win32封装以及封装类的DEMO
04-12
本代码含已经编译好的hredis-win32库,可以直接在VC下使用,并且封装好类,可以直接调用redis,非常方便.
Redis之方法封装
qq_43654581的博客
12-03 982
Redis之方法封装
redis缓存（redis缓存工具封装篇）
Mrs_DongDong的博客
09-08 999
缓存(Cache),就是数据交换的缓冲区,俗称的缓存就是缓冲区内的数据例 1 : Static final ConcurrentHashMap < K , V > map = new ConcurrentHashMap < >();本地用于高并发例 2 : static final Cache < K , V > USER_CACHE = CacheBuilder . newBuilder() . build();用于redis等缓存。（参考黑马redis）
简单封装Redis类
lsy90的博客
05-04 483
两个文件 test.php Re.class.php Re.class.php采用单列模式保证一个入口  只有一次连接  避免资源浪费 <?php //redis操作封装类 class Re{ private static $redis; public $handle; //redis链接 private function __construct(
Java封装Redis泛型操作教程
2. 数据类型操作：封装Redis支持的各种数据类型（如字符串String、列表List、集合Set、有序集合Sorted Set和哈希表Hash）的API。 3. 事务处理：提供Redis事务的高级封装，可能包括 MULTI、EXEC、WATCH 等命令。 4. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值