Redis二次封装

于 2021-05-20 16:24:41 发布
阅读量322 收藏 1
点赞数
文章标签： Redis 二次封装
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxiaoscode/article/details/117080997
版权
本文介绍了一个用于操作Redis的Java客户端API及其实现细节。该API提供了丰富的功能，包括设置和获取键值、操作列表和集合等。通过使用JSON序列化库Gson进行数据转换，使得复杂对象的存储变得简单高效。
摘要由CSDN通过智能技术生成

------------------------------------------------------接口START----------------------------------------------------------------

package com.api;
import java.util.List;
import java.util.Map;
import java.util.Set;

public interface IRedisService {
    void delete(String... var1);

    boolean set(String var1, String var2);

    boolean set(String var1, String var2, long var3);

    boolean set(String var1, Object var2);

    boolean set(String var1, Object var2, long var3);

    boolean hSet(String var1, String var2, Object var3);

    String get(String var1);

    Set<String> getKeys(String var1);

    <T> T get(String var1, Class<T> var2);

    <T> T hGet(String var1, String var2, Class<T> var3);

    <T> boolean setList(String var1, List<T> var2);

    <T> List<T> getList(String var1, Class<T> var2);

    <T> Map<String, T> getMap(String var1, Class<T> var2);

    Map<String, String> getMap(String var1);

    void hDelete(String var1, String var2);

    boolean exist(String var1);

    long llen(String var1);

    long lpush(String var1, Object var2);

    long lpush(String var1, Object var2, long var3);

    String lpop(String var1);

    <T> T lpop(String var1, Class<T> var2);

    long rpush(String var1, Object var2);

    long rpush(String var1, Object var2, long var3);

    String rpop(String var1);

    <T> T rpop(String var1, Class<T> var2);

    List<String> lrange(String var1, long var2, long var4);

    <T> List<T> lrange(String var1, long var2, long var4, Class<T> var6);

    void ldel(String var1, int var2);

    long getExpireTime(String var1);
}

------------------------------------------------------接口END----------------------------------------------------------------

------------------------------------------------------接口实现START----------------------------------------------------------------

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.common.util.GSONFloatAdapter;
import com.api.IRedisService;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;
import javax.annotation.Resource;
import org.apache.commons.lang.StringUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

@Component
public class RedisServiceImpl implements IRedisService {
    private Gson gson;
    @Resource
    private RedisTemplate<String, ?> redisTemplate;
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    public RedisServiceImpl() {
        this.gson = (new GsonBuilder()).disableHtmlEscaping().registerTypeAdapter(Float.TYPE, new GSONFloatAdapter()).registerTypeAdapter(Float.class, new GSONFloatAdapter()).create();
    }

    public void delete(String... keys) {
        if (keys != null && keys.length > 0) {
            this.redisTemplate.execute((connection) -> {
                RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
                List<byte[]> lst = new ArrayList();
                String[] var5 = keys;
                int var6 = keys.length;

                for(int var7 = 0; var7 < var6; ++var7) {
                    String key = var5[var7];
                    lst.add(serializer.serialize(key));
                }

                byte[][] bkeys = new byte[lst.size()][];
                lst.toArray(bkeys);
                connection.del(bkeys);
                return null;
            });
        }

    }

    public boolean set(String key, String value) {
        boolean result = (Boolean)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            connection.set(serializer.serialize(key), serializer.serialize(value));
            return true;
        });
        return result;
    }

    public boolean set(String key, String value, long expireTime) {
        boolean result = (Boolean)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            connection.set(serializer.serialize(key), serializer.serialize(value));
            connection.expire(serializer.serialize(key), expireTime);
            return true;
        });
        return result;
    }

    public boolean set(String key, Object value) {
        if (value != null) {
            String str = this.gson.toJson(value);
            return this.set(key, str);
        } else {
            return false;
        }
    }

    public boolean set(String key, Object value, long expireTime) {
        if (value != null) {
            String str = this.gson.toJson(value);
            return this.set(key, str, expireTime);
        } else {
            return false;
        }
    }

    public boolean hSet(String key, String field, Object value) {
        boolean result = (Boolean)this.redisTemplate.execute((connection) -> {
            if (value == null) {
                return false;
            } else {
                String str;
                if (value.getClass() == String.class) {
                    str = (String)value;
                } else {
                    str = this.gson.toJson(value);
                }

                RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
                connection.hSet(serializer.serialize(key), serializer.serialize(field), serializer.serialize(str));
                return true;
            }
        });
        return result;
    }

    public String get(String key) {
        String result = (String)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            byte[] value = connection.get(serializer.serialize(key));
            return (String)serializer.deserialize(value);
        });
        return result;
    }

    public Set<String> getKeys(String keyLike) {
        return this.stringRedisTemplate.keys(keyLike);
    }

    public <T> T get(String key, Class<T> clz) {
        String json = this.get(key);
        return StringUtils.isNotBlank(json) ? this.gson.fromJson(json, clz) : null;
    }

    public <T> T hGet(String key, String field, Class<T> clz) {
        String result = (String)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            byte[] value = connection.hGet(serializer.serialize(key), serializer.serialize(field));
            return (String)serializer.deserialize(value);
        });
        if (StringUtils.isNotBlank(result)) {
            return clz == String.class ? result : this.gson.fromJson(result, clz);
        } else {
            return null;
        }
    }

    public <T> boolean setList(String key, List<T> list) {
        return this.set(key, (Object)list);
    }

    public <T> List<T> getList(String key, Class<T> clz) {
        String json = this.get(key);
        if (!StringUtils.isNotBlank(json)) {
            return null;
        } else {
            List datalist = (List)this.gson.fromJson(json, List.class);
            List<T> list = new ArrayList();
            Iterator var6 = datalist.iterator();

            while(var6.hasNext()) {
                Object data = var6.next();
                String str = this.gson.toJson(data);
                T t = this.gson.fromJson(str, clz);
                list.add(t);
            }

            return list;
        }
    }

    public <T> Map<String, T> getMap(String key, Class<T> clz) {
        Map<String, T> resultMap = this.hGetAll(key, clz);
        return resultMap == null ? null : resultMap;
    }

    public Map<String, String> getMap(String key) {
        Map<String, String> resultMap = this.hGetAll(key, (Class)null);
        return resultMap == null ? null : resultMap;
    }

    private <T> Map hGetAll(String key, Class<T> clz) {
        Map<byte[], byte[]> map = (Map)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            Map<byte[], byte[]> mapByte = connection.hGetAll(serializer.serialize(key));
            return mapByte;
        });
        if (null == map) {
            return null;
        } else {
            Map resultMap = new HashMap(map.size());
            Iterator<Entry<byte[], byte[]>> iterator = map.entrySet().iterator();
            String mapKey = "";
            String mapValue = "";
            Entry entry;
            if (null != clz) {
                while(iterator.hasNext()) {
                    entry = (Entry)iterator.next();
                    mapKey = new String((byte[])entry.getKey());
                    mapValue = new String((byte[])entry.getValue());
                    resultMap.put(mapKey, this.gson.fromJson(mapValue, clz));
                }
            } else {
                while(iterator.hasNext()) {
                    entry = (Entry)iterator.next();
                    mapKey = new String((byte[])entry.getKey());
                    mapValue = new String((byte[])entry.getValue());
                    resultMap.put(mapKey, mapValue);
                }
            }

            return resultMap;
        }
    }

    public void hDelete(String key, String field) {
        this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            connection.hDel(serializer.serialize(key), new byte[][]{serializer.serialize(field)});
            return null;
        });
    }

    public boolean exist(String key) {
        Assert.notNull(key, "key can not be null!");
        boolean result = (Boolean)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            return connection.exists(serializer.serialize(key));
        });
        return result;
    }

    public long llen(String key) {
        Assert.notNull(key, "key can not be null!");
        long result = (Long)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            return connection.lLen(serializer.serialize(key));
        });
        return result;
    }

    public long lpush(String key, Object value) {
        Assert.notNull(key, "key can not be null!");
        Assert.notNull(value, "value can not be null!");
        String str = this.gson.toJson(value);
        return (Long)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            return connection.lPush(serializer.serialize(key), new byte[][]{serializer.serialize(str)});
        });
    }

    public long lpush(String key, Object value, long expireTime) {
        Assert.notNull(key, "key can not be null!");
        Assert.notNull(value, "value can not be null!");
        String str = this.gson.toJson(value);
        return (Long)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            long push = connection.lPush(serializer.serialize(key), new byte[][]{serializer.serialize(str)});
            connection.expire(serializer.serialize(key), expireTime);
            return push;
        });
    }

    public String lpop(String key) {
        Assert.notNull(key, "key can not be null!");
        return (String)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            byte[] value = connection.lPop(serializer.serialize(key));
            return (String)serializer.deserialize(value);
        });
    }

    public <T> T lpop(String key, Class<T> clz) {
        String json = this.lpop(key);
        return StringUtils.isNotBlank(json) ? this.gson.fromJson(json, clz) : null;
    }

    public long rpush(String key, Object value) {
        Assert.notNull(key, "key can not be null!");
        Assert.notNull(value, "value can not be null!");
        String str = this.gson.toJson(value);
        return (Long)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            return connection.rPush(serializer.serialize(key), new byte[][]{serializer.serialize(str)});
        });
    }

    public long rpush(String key, Object value, long expireTime) {
        Assert.notNull(key, "key can not be null!");
        Assert.notNull(value, "value can not be null!");
        String str = this.gson.toJson(value);
        return (Long)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            long push = connection.rPush(serializer.serialize(key), new byte[][]{serializer.serialize(str)});
            connection.expire(serializer.serialize(key), expireTime);
            return push;
        });
    }

    public String rpop(String key) {
        Assert.notNull(key, "key can not be null!");
        return (String)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            byte[] value = connection.rPop(serializer.serialize(key));
            return (String)serializer.deserialize(value);
        });
    }

    public <T> T rpop(String key, Class<T> clz) {
        String json = this.rpop(key);
        return StringUtils.isNotBlank(json) ? this.gson.fromJson(json, clz) : null;
    }

    public List<String> lrange(String key, long start, long end) {
        Assert.notNull(key, "key can not be null!");
        return (List)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            List<byte[]> bytes = connection.lRange(serializer.serialize(key), start, end);
            List<String> resultList = new ArrayList(bytes.size());
            bytes.forEach((b) -> {
                resultList.add(new String(b));
            });
            return resultList;
        });
    }

    public <T> List<T> lrange(String key, long start, long end, Class<T> clz) {
        Assert.notNull(key, "key can not be null!");
        Assert.notNull(clz, "clz can not be null!");
        return (List)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            List<byte[]> bytes = connection.lRange(serializer.serialize(key), start, end);
            List<T> resultList = new ArrayList(bytes.size());
            bytes.forEach((b) -> {
                resultList.add(this.gson.fromJson(new String(b), clz));
            });
            return resultList;
        });
    }

    public void ldel(String key, int pace) {
        Assert.notNull(key, "key can not be null!");
        Assert.isTrue(pace > 0, "pace must greater than zero!");
        this.redisTemplate.executePipelined((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            long size = this.llen(key);
            if (size <= 0L) {
                return null;
            } else {
                byte[] deleteFlag = serializer.serialize("delete");

                for(int i = 1; (long)i < size; i += pace + 1) {
                    connection.lSet(serializer.serialize(key), (long)i, deleteFlag);
                }

                connection.lRem(serializer.serialize(key), size, deleteFlag);
                return null;
            }
        });
    }

    public long getExpireTime(String key) {
        return (Long)this.redisTemplate.execute((connection) -> {
            RedisSerializer<String> serializer = this.redisTemplate.getStringSerializer();
            return connection.pTtl(serializer.serialize(key), TimeUnit.SECONDS);
        });
    }
}

------------------------------------------------------接口实现END---------------------------------------------------------------

------------------------------------------------------接口实现GSON适配器START---------------------------------------------------------------

package com.common.util;

import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.JsonSyntaxException;
import java.lang.reflect.Type;

public class GSONFloatAdapter implements JsonSerializer<Float>, JsonDeserializer<Float> {
    public GSONFloatAdapter() {
    }

    public Float deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        if (!"".equals(json.getAsString()) && !"null".equals(json.getAsString())) {
            try {
                return json.getAsFloat();
            } catch (NumberFormatException var5) {
                throw new JsonSyntaxException(var5);
            }
        } else {
            return 0.0F;
        }
    }

    public JsonElement serialize(Float src, Type typeOfSrc, JsonSerializationContext context) {
        return new JsonPrimitive(src);
    }
}

------------------------------------------------------接口实现GSON适配器END---------------------------------------------------------------

柠檬不萌c
关注
springboot整合redis并进行二次封装步骤
m0_49382941的博客
09-29 423
【代码】springboot整合redis并进行二次分装步骤。
对RedisTemplate接口二次封装成自定义工具接口
weixin_30287169的博客
11-09 139
开发过程中，经常使用redis数据库存储。 一般都是依赖注入redisTemplate，然后调用redisTemplate的api进行接口功能实现。 但是，如果对redisTemplate自带的API不熟悉，每次都要重新查找筛选，很是麻烦。所以，自己干脆整理了一个接口。将常用的一些redis功能封装到这个接口中，以后自己只要是用这个，就不需要那么麻烦的去查redisTemplate的API了。...
RedisTemplate的封装使用
happy-vicky的博客
04-16 3966
1.RedisService的工具类import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.*; import org.springframework.stereotype.Service; import java.io.Serializab...
redisTemplate封装成redisUtils和分布式锁实现
06-18
redisTemplate封装成redisUtils和分布式锁实现,亲测可用
Jedis使用+jedis再封装
guoxinian的专栏
06-04 3863
一 、Redis初始化（RedisStart.class） package com.ciri.cache; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; /**  * Created b
C++ Redis mset二进制数据接口封装方案
12-22
C++ Redis mset 二进制数据接口封装方案 　需求 　C++中使用hiredis客户端接口访问redis； 　需要使用mset一次设置多个二进制数据 　以下给出三种封装实现方案； 　简单拼接方案 　在redis-cli中，mset的语法...
repackaged_redis_for_JCoder:项目对py-redis进行了二次封装，增加了易用性。（JCoder专供）
04-01
《Python中的Redis二次封装——repackaged_redis_for_JCoder详解》 在Python的开发中，Redis作为一种高效的数据存储和缓存系统，被广泛应用于各种场景。然而，原生的`py-redis`库虽然功能强大，但其API设计可能对于...
如何进行Redis数据库二次封装调用，直接获取实时数据值及时间戳
最新发布
09-19
Redis数据库的二次封装通常是为了简化开发者的操作，使其能够更方便地在应用程序中访问和管理Redis的数据。以下是基本步骤： 1. 安装依赖：首先，你需要引入适合你项目的Redis客户端库，例如Python中的`redis`模块...
java 二次封装jedis，无需配置，开箱即用。easyJedis-1.0.1.jar
09-09
对于jedis的二次封装，所有方法都从简调用，jar包引入到项目，默认构造器会扫描配置文件，读取redis参数，也可以通过构造器自定义参数，所有的异常处理，类型转换和锁控制都处理好了，还有对于map，bean对象，数组的二次封装，开箱即用，方法参数极简易懂。
SpringBoot 自动配置 (2) - 自己写个 Starter 二次封装 spring-boot-starter-data-redis
O_o
05-10 2754
依托自动配置原理, 把 Redis 的工具以及配置等等一切封装成 Starter.
Go-基于redisgo进行了封装代码量减少
08-13
基于redigo的封装，写入好配置文件后，在任何地方随时调用，使用起来更简单，代码更优雅 支持和redigo同时使用
自己对redisTemplet进行封装
矩阵Matrix
08-19 187
代码如下,懂的不需多言! import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Service; import org.springframework.util.CollectionUtils; import java.util.List; im
redis接口的二次封装
幽雨雨幽
05-11 1617
先看一下官方的调用示例代码：local redis = require "resty.redis" local red = redis:new() red:set_timeout(1000) -- 1 sec local ok, err = red:connect("127.0.0.1", 6379) if not ok then ngx.say("failed to connect:...
Jedis封装工具类
风行天下
04-13 625
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; ...
Redis命令中心
Romantic_sir的博客
10-25 452
Redis命令大全：http://www.redis.cn/commands.html 1. 什么是Redis Redis是由意大利人Salvatore Sanfilippo（网名：antirez）开发的一款内存高速缓存数据库。Redis全称为：RemoteDictionaryServer（远程数据服务），该软件使用C语言编写，Redis是一个key-value存储系统，它支持丰富的...
Go实战--golang中使用redis(redigo和go-redis/redis这个已测试)
gb4215287的博客
02-24 8686
自己做测试了没有问题，虚拟机连不上可以把包下载到本地。版权声明：本文为博主原创文章，未经博主允许不得转载。 http://blog.csdn.net/wangshubo1989/article/details/75050024目录(?)[-]何为rediswindows安装redis开源库redigo的使用开源库go-redisredis的使用生命不止，继续 go go go !!!以前介绍过go...
Go-Redis中client接口
课前的博客
09-13 2355
golang redis
Java操作Redis——Jedis的API
zhoushimiao1990的博客
08-20 1372
首先看一下java如何链接redis Maven： <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.0.1...
go redis 封装，简单使用
秋天的博客
10-19 4118
go redis 集合操作--sadd redis的go语言包，我们使用官方推荐的redigo，https://github.com/garyburd/redigo 安装redigo $ go get github.com/garyburd/redigo 带密码的redis操作 package main import ( "log" "github.com/gar...
Redis基本命令封装教程与工具包
封装Redis常用基本命令的ZIP文件，可能包含了一系列预先设定的脚本和命令集合，用于简化和自动化常见的Redis操作任务。" 知识点详细说明: 1. Redis简介 Redis全称为Remote Dictionary Server，是一个开源的高性能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柠檬不萌c

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值