简单的使用Redis写入和查询数据

最新推荐文章于 2024-11-27 15:22:12 发布
最新推荐文章于 2024-11-27 15:22:12 发布
阅读量2.9k 收藏 3
点赞数 2
分类专栏： Redis 文章标签： redis 数据库 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25391785/article/details/126720222
版权
本文介绍了如何使用Spring Boot的ShardingRedisUtil将字典数据分组写入Redis，以及如何根据字典类型查询数据。通过RedisTemplate操作哈希映射和列表，实现高效的数据管理和检索。
摘要由CSDN通过智能技术生成

我们以将字典数据写入Redis中，并查询数据为例

1、查询字典数据并写入Redis中

    @Resource
    private TestMapper testMapper;

    @Resource
    ShardingRedisUtil shardingRedisUtil;

    @Override
    public void testSetRedis() {
        // 获取所有字典信息
        List<TbSysDictInfo> list = testMapper.selectAll();
        // 根据字典类型分组
        Map<String, List<TbSysDictInfo>> distMap = list.stream()
                .collect(Collectors.groupingBy(TbSysDictInfo::getTypeCode));
        // 将数据写入redis
        shardingRedisUtil.hMSet(Dictconstants.DICT_RESULT, distMap);
    }

Dictconstants方法

public class Dictconstants {

    /**
     * 字典结果属性
     */
    public static final String DICT_RESULT = "dict_result_";

}

2、根据字典类型从Redis中查询数据

    @Override
    public List<TbSysDictInfo> testGetRedis(String type) {
        // 根据字典类型获取列表
        Map<String, List<TbSysDictInfo>> distMap = shardingRedisUtil.hMGet(new TypeReference<List<TbSysDictInfo>>() {
        }, Dictconstants.DICT_RESULT, type);
        if (distMap.get(type)!=null){
            return distMap.get(type);
        }else {
            return new ArrayList<>();
        }
    }

3、RedisUtil工具类 ShardingRedisUtil 

这个工具类功能很强大，大家可以自行挖掘


import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.core.Cursor;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ScanOptions;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Component
public class ShardingRedisUtil {

    Logger logger = LoggerFactory.getLogger(this.getClass());

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    private static final int SHARDING_COUNT = 100; //分片数
    private static final int SCAN_COUNT = 1000; //扫描分批数
    private ObjectMapper objectMapper = new ObjectMapper();

    public void hMSet(String key, Map<String, ? extends Object> map) {
        hMSet(key, map, SHARDING_COUNT);
    }

    public <T> Map<String, T> hMGet(TypeReference<T> typeReference, String key, String... field) {
        return hMGet(typeReference, SHARDING_COUNT, key, field);
    }

    public <T> Map<String, T> hMGet(TypeReference<T> typeReference, String key, List<String> fields) {
        if (CollectionUtils.isEmpty(fields)) {
            return null;
        }
        return hMGet(typeReference, key, fields.toArray(new String[1]));
    }

    public long hDel(String key, String... field) {
        return hDel(SHARDING_COUNT, key, field);
    }

    public void hMSet(String key, Map<String, ? extends Object> map, int shardingCount) {
        if (!CollectionUtils.isEmpty(map)) {
            Map<String, Map<String, Object>> tmpMap = new HashMap<>();
            for (Map.Entry<String, ? extends Object> entry : map.entrySet()) {
                String tmpKey = entry.getKey();
                Object tmpValue = entry.getValue();
                int num = Math.abs(tmpKey.hashCode() % shardingCount);
                String hashKey = String.format("%s$%s", key, num);
                tmpMap.computeIfAbsent(hashKey, k -> new HashMap<>()).put(tmpKey, tmpValue);
            }
            for (Map.Entry<String, Map<String, Object>> entry : tmpMap.entrySet()) {
                redisTemplate.opsForHash().putAll(entry.getKey(), entry.getValue());
            }
        }
    }

    public void hMSetToOneGroup(String key, Map<String, Object> map) {
        if (!CollectionUtils.isEmpty(map)) {
            redisTemplate.opsForHash().putAll(key, map);
        }
    }

    public <T> Map<String, T> hMGetfromOneGroup(TypeReference<T> typeReference, String key, String... field) {
        Map<String, T> resultMap = new HashMap<>();
        if (field != null) {
            List<Object> objects = redisTemplate.opsForHash().multiGet(key, Arrays.asList(field));
            List<String> fieldList = new ArrayList<>();
            Collections.addAll(fieldList, field);
            for (int i = 0; i < fieldList.size(); i++) {
                Object o = objects.get(i);
                resultMap.put(fieldList.get(i), o != null ? objectMapper.convertValue(o, typeReference) : null);
            }
        }
        return resultMap;
    }

    public <T> Map<String, T> hMGet(TypeReference<T> typeReference, int shardingCount, String key, String... field) {
        Map<String, T> resultMap = new HashMap<>();
        if (field != null) {
            for (Map.Entry<String, List<String>> entry : separateToMap(shardingCount, key, field).entrySet()) {
                List<String> fieldList = entry.getValue();
                List<Object> objects = redisTemplate.opsForHash().multiGet(entry.getKey(), new ArrayList<>(fieldList));
                for (int i = 0; i < fieldList.size(); i++) {
                    Object o = objects.get(i);
                    resultMap.put(fieldList.get(i), o != null ? objectMapper.convertValue(o, typeReference) : null);
                }
            }
        }
        return resultMap;
    }

    /**
     * 扫描key前缀，获取key的所有redis缓存
     *
     * @param keyPattern
     * @param <T>
     * @return
     */
    public <T> Map<String, T> hMGet(TypeReference<T> typeReference, String keyPattern) {
        return hMGet(typeReference, SHARDING_COUNT, keyPattern);
    }

    /**
     * 扫描key前缀，获取key的所有redis缓存
     *
     * @param keyPattern
     * @param <T>
     * @return
     */
    public <T> Map<String, T> hMGet(TypeReference<T> typeReference, int shardingCount, String keyPattern) {
        Map<String, T> resultMap = new HashMap<>();
        if (StringUtils.isNoneBlank(keyPattern)) {
            try {
                for (int num = 0; num < shardingCount; num++) {
                    String hashKey = String.format("%s$%s", keyPattern, num);
//                    Cursor<Map.Entry<Object, Object>> cursor = redisTemplate.opsForHash().scan(hashKey, ScanOptions.scanOptions().count(SCAN_COUNT).build());
//                    while (cursor.hasNext()) {
//                        Map.Entry<Object, Object> next = cursor.next();
//                        Object field = next.getKey();
//                        Object value = next.getValue();
//                        if (field != null && value != null) {
//                            resultMap.put(field.toString(), objectMapper.convertValue(value, typeReference));
//                        }
//                    }
//                    cursor.close();
                    resultMap.putAll(hMGetTargetKey(typeReference,hashKey));
                }
            } catch (Exception e) {
                logger.error("扫描redis获取hashKey所有缓存异常", e);
            }
        }
        return resultMap;
    }

    /**
     * 扫描key前缀，获取key的所有redis缓存
     *
     * @param key
     * @param <T>
     * @return
     */
    public <T> Map<String, T> hMGetTargetKey(TypeReference<T> typeReference, String key) {
        Map<String, T> resultMap = new HashMap<>();
        if (StringUtils.isNoneBlank(key)) {
            try {
                Cursor<Map.Entry<Object, Object>> cursor = redisTemplate.opsForHash().scan(key, ScanOptions.scanOptions().count(SCAN_COUNT).build());
                while (cursor.hasNext()) {
                    Map.Entry<Object, Object> next = cursor.next();
                    Object field = next.getKey();
                    Object value = next.getValue();
                    if (field != null && value != null) {
                        resultMap.put(field.toString(), objectMapper.convertValue(value, typeReference));
                    }
                }
                cursor.close();
            } catch (Exception e) {
                logger.error("扫描redis获取hashKey所有缓存异常", e);
            }
        }
        return resultMap;
    }


    public Long hDel(int shardingCount, String key, String... field) {
        long count = 0;
        if (field != null) {
            for (Map.Entry<String, List<String>> entry : separateToMap(shardingCount, key, field).entrySet()) {
                count += redisTemplate.opsForHash().delete(entry.getKey(), entry.getValue().toArray());
            }
        }
        return count;
    }

    private Map<String, List<String>> separateToMap(int shardingCount, String key, String[] field) {
        Map<String, List<String>> tmpMap = new HashMap<>();
        for (String s : field) {
            if (StringUtils.isNotBlank(s)) {
                int num = Math.abs(s.hashCode() % shardingCount);
                String hashKey = String.format("%s$%s", key, num);
                tmpMap.computeIfAbsent(hashKey, k -> new ArrayList<>()).add(s);
            }
        }
        return tmpMap;
    }

    public void listSet(String key, List list) {
        if (!CollectionUtils.isEmpty(list)) {
            redisTemplate.opsForList().rightPushAll(key, list);
        }
    }

    public long listSize(String key) {
        return redisTemplate.opsForList().size(key);
    }

    public <T> Map<String, List<T>> listGet(String prefix, TypeReference<T> typeReference) {
        Map<String, List<T>> result = new ConcurrentHashMap<>();
        Set<String> setKeys = redisTemplate.keys(prefix + "*");
        setKeys.parallelStream().forEach(hashKey -> {
            try {
                List<T> list = listGet(typeReference, hashKey);
                result.put(hashKey, list);
            } catch (Exception e) {
                logger.error("获取hashKey为" + hashKey + "的redis缓存列表失败", e);
            }
        });
        return result;
    }

    public <T> List<T> listGet(TypeReference<T> typeReference, String key) {
        List<T> resultList = new LinkedList<>();
        long size = redisTemplate.opsForList().size(key);
        for (int index = 0; index < size; index = index + 1000) {
            List<Object> objList = new ArrayList<>();
            try {
                objList = redisTemplate.opsForList().range(key, index, 1000);
                objList.forEach(obj->{
                    resultList.add(objectMapper.convertValue(obj, typeReference));
                });
            } catch (Exception e) {
                logger.error(ExceptionUtils.getStackTrace(e));
            }
        }
        return resultList;
    }

    public void listDeleteOneList(String key) {
        deleteKey(key);
    }


    public Long listDel(String key, long count, Object value) {
        return redisTemplate.opsForList().remove(key, count, value);
    }

    public boolean deleteKey(String key) {
        return redisTemplate.delete(key);
    }

    public Set<String> getKeys(String pattern) {
        return getKeys(pattern, 10, TimeUnit.SECONDS);
    }

    public Set<String> getKeys(String pattern, int timeout, TimeUnit timeUnit) {
        Set<String> keys = new HashSet<>();
        CompletableFuture<Set<String>> getRedisKeysFuture = CompletableFuture.supplyAsync(() -> {
            try {
                return redisTemplate.keys(pattern);
            } catch (Exception e) {
                logger.error("获取redis中包含{}的key失败：", pattern, e);
                return null;
            }
        }).whenComplete((result, ex) -> {
            if (result != null) {
                keys.addAll(result);
            }
        });
        try {
            getRedisKeysFuture.get(timeout, timeUnit);
        } catch (Exception e) {
            logger.error("获取redis中包含{}的key超时：", pattern, e);
        }
        return keys;

    }

    public void strSet(String key, String value) {
        redisTemplate.opsForValue().set(key, value);
    }

    public void strSet(String key, String value, long timeout, TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }


    public String strGet(String key) {
        Object object = redisTemplate.opsForValue().get(key);
        if (object != null) {
            return object.toString();
        }
        return null;
    }

    public void expire(String key, long timeout, TimeUnit unit) {
        redisTemplate.expire(key, timeout, unit);
    }

    public void hLSetToOneGroup(String key, List<Object> list) {
        if (!CollectionUtils.isEmpty(list)) {
            redisTemplate.opsForList().leftPushAll(key, list);
        }
    }

    public <T> List<T> hLGetFromOneGroup(TypeReference<T> typeReference, String key) {
        List<T> result = new ArrayList<>();
        if (StringUtils.isNotBlank(key)) {
            long size = Optional.ofNullable(redisTemplate.opsForList().size(key)).orElse(0L);
            List<Object> objects = redisTemplate.opsForList().range(key, 0, size);
            if (!CollectionUtils.isEmpty(objects)) {
                for (Object o : objects) {
                    result.add(o != null ? objectMapper.convertValue(o, typeReference) : null);
                }
            }
        }
        return result;
    }

    public void setTypeAdd(String key, Object value) {
        redisTemplate.opsForSet().add(key, value);
    }

    public void setTypeAddAll(String key, Set<Object> value) {
        redisTemplate.opsForSet().add(key, value.toArray(new Object[1]));
    }

    public Set setTypeGet(String key) {
        return redisTemplate.opsForSet().members(key);
    }


    public boolean setTypeContain(String key, String value) {
        return redisTemplate.opsForSet().isMember(key, value);
    }
}

4、Redis链接配置工具类


import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

@Configuration
@ConditionalOnProperty(name = "spring.redis.host")
public class RedisConfiguration {

    @Value("${spring.redis.host}")
    private String host ;

    @Value("${spring.redis.port}")
    private int port ;

    @Value("${spring.redis.password}")
    private String password ;

    @Value("${spring.redis.timeout:3000}")
    private int timeout ;

    @Value("${redis.jedisPoolConfig.maxActive:300}")
    private int maxActive ;

    @Value("${redis.jedisPoolConfig.maxIdle:100}")
    private int maxIdle ;

    @Value("${redis.jedisPoolConfig.minIdle:1}")
    private int minIdle ;

    @Value("${redis.jedisPoolConfig.maxWait:5000}")
    private int maxWait ;

    @Value("${spring.redis.database:0}")
    private int database;

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
//        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    @Bean
    public JedisPool JedisPoolFactory() {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(maxActive);
        poolConfig.setMaxIdle(maxIdle);
        poolConfig.setMinIdle(minIdle);
        poolConfig.setMaxWaitMillis( maxWait);
        JedisPool jedisPool =  new JedisPool(poolConfig,host,port,timeout,password,database);
        return jedisPool;
    }
}

5、配置文件内容

spring:
  redis:
    host: localhost
    port: 6379
    #password:

flink实战--数据写入redis（redisSink）
阿华田的博客
01-14 1万+
简介 通过flink操作redis其实我们可以通过传统的redis连接池Jpools进行redis的相关操作，但是flink提供了专门操作redis的Redis Sink，使用起来更方便，而且不用我们考虑性能的问题，接下来将主要介绍Redis Sink如何使用。 RedisSink简介 Redis Sink 提供用于向Redis发送数据的接口的类。接收器可以使用三...
将数据写入redis
weixin_41453111的博客
03-19 5852
导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> ...
Redis中存储结构化数据
最新发布
m0_64132144的博客
11-27 413
针对车企的业务背景，考虑到需要频繁查询不同车系的信息，以及车系信息包含多个维度（如品牌ID、车型ID、车型名称等），采用Redis中的。车企有多个品牌系列信息，每个品牌有不同的系列（车型）名称和ID，而这些信息的查询频率较高。每次查询不仅可能是基于品牌查询，还可能是基于车型ID查询，因此，将这些品牌和车型信息存储到Redis缓存中，能够有效减少对数据库的访问，提升查询效率。如果在车企的数据中，某个品牌下可能包含多个车系，而车系又可以有多个子车系，可能需要使用嵌套结构来表示这些层级关系。API进行快速查找。
redis写入数据命令
计算机毕业论文源码，学生个人网页制作html源码。贴近用户做网络推广和互联网优化。
11-13 903
如何将redis中的值写入数据库 简而言之，Redis是一种强大的key-value数据库，之所以强大有两点：响应速度快(所以数据内存存储，只在必要时写入磁盘)，特性丰富(支持多种数据类型，以及各类型上的复杂操作)。 事实上，Redis的一个重要特性就是它并非通常意义上的数据库，虽然称之为数据库是因为它可以为你存储和维...
Redis入门从这里开始（文末有惊喜）
zuoninger的专栏
10-29 938
第1章　初识Redis 本章主要内容 Redis与其他软件的相同之处和不同之处 Redis的用法 使用Python示例代码与Redis进行简单的互动 使用Redis解决实际问题 Redis是一个远程内存数据库，它不仅性能强劲，而且还具有复制特性以及为解决问题而生的独一无二的数据模型。Redis提供了5种不同类型的数据结构，各式各样的问题都可以很自然地映射到这些...
向redis中写入大量的数据
h111121111111的博客
02-06 4923
往redis中写入大量的数据 1.编写Python脚本，生成redis命令 redis_info.py #!/usr/bin/python for i in range(5000000): #循环的数量 print 'set name'+str(i),'hello'+str(i) #str(i)将int类型转换为str类型，否则不能进行字符串拼接 2.运行python脚本输出到redis_comm.txt文件中 python redis_info.py > redis_comm.tx
将数据写入Redis
m0_63727139的博客
04-19 370
因为我们单方面的只把对象转成字节数组还不行，因为没有规则的字节数组我们是没办法把对象的本来面目还原回来的，所以我们必须在把对象转成字节数组的时候就制定一种规则。而我们进行跨平台存储和网络传输的方式就是IO，而我们的IO支持的数据格式就是字节数组。就是我们把房子运输到了目的地以后，根据图纸把一块块砖头还原成房子原来面目的过程。就是我把房子拆成一个个的砖块放到车子里，然后留下一张房子原来结构的图纸，把字节序列还原为对象的过程称为反序列化。写入和读出的时候的序列化和反序列化。3、调用Spring封装好的类。
Redis数据操作（redis入门）
DLNU_HT的成长之路
07-14 2819
一、字符串类型在redis里面有一个特别重要的命令“keys”，可以进行全部数据的列出。 1.设置新的数据：set username-dlnu hello; 2.取得对应的数据：get username-dlnu;     .如果在进行数据查询的时候没有对应的key的内容，则返回的是“nil”。     .在数据取得的时候没有"*"的通配符，只有"keys"的命令才提供这个操作。  3.清空仓库...
使用Redis有序集合实现IP归属地查询详解
09-09
同时，Redis提供了丰富的客户端库，使得在多种编程语言中使用此方案变得简单易行。 总的来说，利用Redis有序集合实现IP归属地查询是一种高效且灵活的方法，它充分利用了Redis的内存数据结构优势，减少了对磁盘IO的...
redis写入查找
yiweiwei516的博客
08-17 540
redis
数据库并发入门学习笔记，怎么写入redis的数据，配置缓存。
qq_45411727的博客
04-01 1812
1. 高并发的设计思路 简单理解为服务器能抗住多少用户访问量。 普通笔记本支持100个并发量，很明显学校的访问都扛不住。 大量用户访问时，数据库压力过大容易崩溃，考虑中间做一个redis缓存，读完数据库的数据写入redis一份，下次不用读到数据库，降低数据库的压力。 redis也有问题。微服务部署到tomcat并发量也就200，不能支持大量用户同时访问，所以配置到nginx上，好点的并发10w。 nginx也有缺陷，只能部署点静态html，不支持jsp，用OpenResty，动态读取redis的数据。 O
Redis对简单数据的操作
qq_44194174的博客
10-08 66
Redis缓存入门 Redis 相关参考网址如下所示： Bootnb 相关：https://www.runoob.com/redis/redis-tutorial.html Redis 官网：https://redis.io/ 源码地址：https://github.com/redis/redis Redis 在线测试：http://try.redis.io/ Redis 命令参考：http://doc.redisfans.com/ Redis初始操作 启动redis服务 Docker 环境下的启动(do
Redis-数据写入(持久化)
互联网知识分享
05-03 651
持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘，实际操作过程是fork一个子进程，先将数据集写入临时文件，写入成功后，再替换之前的文件，用二进制压缩存储。持久化是以日志的形式记录服务器所处理的每一个写、删除操作文件中可以看到详细的操作记录出现是为了弥补RDB的不足（数据的不一致性,比如并发的情况下），所以它采用日志的形式来记录每个写操作，并追加到文件中，Redis 重启的会根据日志文件的内容将写指令从前到后执行一次以完成数据的恢复工作。在60秒内，如果10000个key发生变化，执行RDB；
redis的读取与写入数据
Fyfdf的博客
09-01 923
使得应用程序能够在需要快速访问数据时从 Redis 获取数据，而在需要持久性和复杂查询时从 MySQL 获取数据。Redis 可以轻松处理高并发的读取请求，因为它的响应时间非常短。这种分层的数据存储和缓存策略有助于提高应用程序的性能和可伸缩性。，可以显著减少从mysql中的读取次数，从而加快读取操作。因为redis的数据存在内存中，所以读取时速度快，通过。,这种架构将 Redis 和 MySQL 结合起来，可以提高用户体验，使用户感觉应用程序更加流畅和快速。通过减少数据库的读取负载，减轻了数据库的压力。
redis写入过程
weixin_36888525的博客
08-11 119
如何实现Redis写入过程 Redis是一种高性能的键值存储系统，被广泛应用于缓存、会话管理等场景。对于刚入行的小白来说，理解Redis的写入过程是非常重要的一步。本文将重点讲解Redis写入的流程，并提供相应的代码示例，确保你能顺利实现Redis的写入操作。 Redis写入流程 下面的表格展示了Redis写入的主要步骤：...
Redis 命令
you_fathe的博客
02-07 1570
Redis 背景，命令，应用
Redis写入和读取对象数据
热门推荐
qq_36677358的博客
12-04 1万+
Redis由于存入的数据类型有限,一般主要为字符串,通过key-value来存储数据,那么怎么通过Redis来写入和读取对象信息呢 写入数据 1.json方式 该方式使用Gson工具把对象转为字符串 static void write(){ //创建连接Redis的对象 Jedis jedis = new Jedis("localhost",6379); //设置...
Redis 高频数据类型使用详解
congge
08-08 3850
Redis 高频数据类型使用详解
redis数据简单数据操作
yzyggu的博客
03-21 195
基本的使用参照表： string hash list set zset 设置 set key value hset key field value lpush key value1 value2 … sadd key member1 member2 … zadd key score1 member1 score2 member2 … 删 del key1 key2 … hde...
关于redis写入
weixin_34006468的博客
03-19 434
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

菜鸟进军大神陆

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

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

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

打赏作者

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

抵扣说明：

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

余额充值