Redis入门

最新推荐文章于 2025-05-12 16:58:03 发布
最新推荐文章于 2025-05-12 16:58:03 发布
阅读量199 收藏
点赞数 2
分类专栏： database 文章标签： redis mac
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_33982232/article/details/88924597
版权

我的环境是macOS + java8 + redis5.0.4
首先要有java8的运行环境, 然后去redis官网上下载最新版本的redis, 我下载的是5.0.4的版本;

一.配置和基础

首先, redis是一种key-value对应的类似于数据库的东西, 但是它是直接存在内存里的而不是像数据库存在硬盘里的, 所以速度比较快, 但是redis会实现持久化是因为它会在重启之类的操作之前用快照的形式存储到硬盘中, 然后使用前再读取到内存中, 所以大概是只适用于一些小数据量快速读写把;

所以在我看来大概redis就是一个读写快速的小型"数据库"吧, 不知道这么理解可不可以, 就姑且先这样吧…

首先在安装好redis之后, 在命令行中使用命令redis-server来打开redis的服务器端服务;
在这里插入图片描述
然后会显示一些基本信息, 比如使用的是6379端口, 进程号之类的, 然后默认这里用的就是本地IP;

然后可以新开一个命令行界面, 然后使用redis-cli命令进入客户端连接界面, 像这样:
在这里插入图片描述
然后就可以进行对redis这个"数据库"进行操作啦

首先, 在redis中有几种基本数据类型;
String（字符串）
List（列表）
Hash（字典）
Set（集合）
Sorted Set（有序集合）
从名字就能看出来这大概是什么了吧;

比如可以这样的命令,

set google http://www.google
append google .com
get google

有很多类似的命令, 具体可以去这个网页查询具体的很多很多命令啦
像list就可以用lpush(left push) rpush(right push)之类的;

二.java连接redis

这里需要使用java的一个库 jedis
这里附上对应的maven代码

<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.1.0-m1</version>
</dependency>

随便测试一下:

Jedis jedis = new Jedis("localhost");
jedis.set("g", "google.com");
jedis.append("g",".baidu.com");
String value = jedis.get("g");
System.out.println(value);

这样来测试

然后这里附上一个
RedisUtil 工具类，封装了 RedisTemplate 这个类，以提供更为便利的 对于 Redis 的访问

来自于 how2J网站

package com.how2java;
 
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.CollectionUtils;
 
/**
 * 基于spring和redis的redisTemplate工具类
 * 针对所有的hash 都是以h开头的方法
 * 针对所有的Set 都是以s开头的方法                    不含通用方法
 * 针对所有的List 都是以l开头的方法
 */
public class RedisUtil {
    private RedisTemplate<String, Object> redisTemplate;
     
    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    //=============================common============================
    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key,long time){
        try {
            if(time>0){
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 根据key 获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }
     
    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String ... key){
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }
     
    //============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }
     
    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key,Object value) {
         try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
         
    }
     
    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 递增
     * @param key 键
     * @param by 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta){ 
        if(delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }
     
    /**
     * 递减
     * @param key 键
     * @param by 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta){ 
        if(delta<0){
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta); 
    } 
     
    //================================Map=================================
    /**
     * HashGet
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key,String item){
        return redisTemplate.opsForHash().get(key, item);
    }
     
    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }
     
    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String,Object> map){ 
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String,Object> map, long time){ 
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key,String item,Object value) {
         try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 向一张hash表中放入数据,如果不存在将创建
     * @param key 键
     * @param item 项
     * @param value 值
     * @param time 时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key,String item,Object value,long time) {
         try {
            redisTemplate.opsForHash().put(key, item, value);
            if(time>0){
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 删除hash表中的值
     * @param key 键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item){ 
        redisTemplate.opsForHash().delete(key,item);
    }
     
    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item){
        return redisTemplate.opsForHash().hasKey(key, item);
    }
     
    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item,double by){ 
        return redisTemplate.opsForHash().increment(key, item, by);
    }
     
    /**
     * hash递减
     * @param key 键
     * @param item 项
     * @param by 要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item,double by){ 
        return redisTemplate.opsForHash().increment(key, item,-by); 
    } 
     
    //============================set=============================
    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key){
        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
     
    /**
     * 根据value从一个set中查询,是否存在
     * @param key 键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key,Object value){
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 将数据放入set缓存
     * @param key 键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object...values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
     
    /**
     * 将set数据放入缓存
     * @param key 键
     * @param time 时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key,long time,Object...values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if(time>0) expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
     
    /**
     * 获取set缓存的长度
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key){
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
     
    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object ...values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    //===============================list=================================
     
    /**
     * 获取list缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束  0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key,long start, long end){
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
     
    /**
     * 获取list缓存的长度
     * @param key 键
     * @return
     */
    public long lGetListSize(String key){
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
     
    /**
     * 通过索引 获取list中的值
     * @param key 键
     * @param index 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key,long index){
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
     
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @param time 时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0) expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 根据索引修改list中的某条数据
     * @param key 键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index,Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
     
    /**
     * 移除N个值为value
     * @param key 键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key,long count,Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
     
}

写一个增删改查的测试:

package com.how2java;
 
import java.util.HashMap;
import java.util.Map;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class TestRedis {
     
    public static void main(String[] args) throws Exception {
        ApplicationContext context=new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
 
        RedisUtil redisUtil=(RedisUtil) context.getBean("redisUtil");
         
        //=====================testString======================
        redisUtil.set("name", "how2java");
        System.out.println(redisUtil.get("name"));
        redisUtil.del("name");
        System.out.println(redisUtil.get("name"));
         
        //=====================testNumber======================
        long incr = redisUtil.incr("number", 1);
        System.out.println(incr);
        incr =redisUtil.incr("number", 1);
        System.out.println(incr);
         
        //=====================testMap======================       
        Map<String,Object> map=new HashMap<>();
        map.put("name", "meepo");
        map.put("pwd", "password");
        redisUtil.hmset("user", map);
        System.out.println(redisUtil.hget("user","name"));
    }
     
}
Redis 入门指南.pdf
11-17
本指南将帮助初学者理解 Redis 的基本概念、安装与配置、数据类型以及常用命令，从而快速入门 Redis。 1. **Redis 简介** - Redis 源自意大利程序员 Salvatore Sanfilippo，最初是为了提高网站性能而设计的。 - ...
Redis入门篇
2301_80098154的博客
09-26 1039
Redis是一个key-value的数据库，key一般是String类型，不过value的类型多种多样：Redis为了方便我们学习，将操作不同数据类型的命令也做了分组。
Redis 入门指南
m0_61104769的博客
07-06 1104
这就是本文介绍关于Redis的入门指南，介绍了基本概念、常用命令以及在Java中操作Redis的示例。希望对你理解和使用Redis有所帮助！
超强、超详细Redis入门教程
热门推荐
liqingtx的专栏
03-04 51万+
转载自： http://www.h5min.cn/article/56448.htm 这篇文章主要介绍了超强、超详细Redis入门教程,本文详细介绍了Redis数据库各个方面的知识,需要的朋友可以参考下 【本教程目录】 1.redis是什么 2.redis的作者何许人也 3.谁在使用redis 4.学会安装redis 5.学会启动redis 6.使用redis客户端
Redis入门指南
qimowei的博客
12-21 1248
Redis入门指南一级目录二级目录三级目录一、安装1、通过Homebrew安装Redis2、配置文件3、打开redis-cli命令行客户端二、Redis的数据类型1、String类型1.1 操作2、Hash（哈希）类型2.1 操作3、List类型4、SET类型5、Sorted-Sets类型三、持久化1、两种方式1、RDB2、AOF四、可视化界面软件推荐 一级目录 二级目录 三级目录 因redis偏操作，所以本次读书笔记用叙事风格来描述~ 以前看过redis相关的网课，在51CTO开着倍速看的，尽管会用了，但
Redis入门实战
oyjl__的博客
11-01 1037
缓存就是数据交换的缓存区（称作cache），存储数据的临时地方，一般读写性能较高。浏览器（浏览器缓存）-->tomcat（应用层缓存）--->数据库（数据库缓存）---->cpu缓存和磁盘缓存。
redis入门
Less Is More
01-27 880
redis入门 NoSQL的概述            redis的数据类型 redis的概述            keys的通用操作 redis的安装和使用        redis的特性 jedis的入门            redis的持久化 nosql not only sql 非关系型数据库 为什么需要nosql high performance -高并发读写
Redis入门指南以及完整电子书下载
一个夜猫子的博客
04-24 865
Redis是一个高性能的键值存储系统，它以其出色的性能和低延迟特性而闻名。Redis支持事务、持久化、多种数据结构以及通过复制提供高可用性。Redis是一个功能强大且灵活的内存数据库，适用于需要快速读写操作的场景。通过这篇入门指南，你应该对Redis有了基本的了解。如果您需要进一步探索Redis的高级特性和最佳实践可以下载《Redis入门指南》进行学习。
详细Redis入门教程
once先森的博客
10-29 5928
Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的高性能的日志型、Key-Value数据库，并提供多种语言的API。Redis的出现补偿了memcached这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。
Redis入门概念以及安装
f552126506的博客
07-02 1053
redis的概括和安装配置
REDIS 入门指南pdf
09-03
以下是对 Redis 入门指南的一些关键知识点的详细说明： 1. **Redis 数据类型** - **字符串（String）**：Redis 最基本的数据类型，可以存储字符串、数字等，支持自增、自减操作。 - **哈希（Hash）**：用于存储...
Redis入门到精通最新教学视频
07-26
Redis入门到精通最新教学视频！！！！！！！！！！！！！！！！！！！
Redis入门到精通视频教程
06-17
在本课程中，你将了解Redis是什么、能干什么、如何用，了解NoSQL的使用场景和概念，快速掌握Redis的安装配置、五大数据类型、常用操作命令、Redis持久化、主从复制、事务控制以及用Jedis操作进行Java开发、Redis的高...
Redis入门第二版
01-08
**Redis入门第二版** Redis，全称Remote Dictionary Server，是一个开源的、高性能的键值存储系统，常被用作数据库、缓存和消息中间件。它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等，这使得Redis...
Redis
wjcurry的博客
05-11 675
这样在修改字符串的时候，可以通过 alloc - len 计算出剩余的空间大小，可以用来判断空间是否满足修改需求，如果不满足的话，就会自动将 SDS 的空间扩展至执行修改所需的大小，然后才执行实际的修改操作，所以使用 SDS 既不需要手动修改 SDS 的空间大小，也不会出现前面所说的缓冲区溢出的问题。因此， SDS 的 API 都是以处理二进制的方式来处理 SDS 存放在 buf[] 里的数据，程序不会对其中的数据做任何限制，数据写入的时候时什么样的，它被读取时就是什么样的。
o.redisson.client.handler.CommandsQueue : Exception occured. Channel
最新发布
架构师：通透，才能写出好代码！
05-12 209
在使用Redisson 2.15.2版本时，出现了与Netty通道相关的异常，具体表现为连接Redis服务器时发生错误。通过分析，问题可能源于该版本的jar包存在缺陷。解决方法是升级Redisson到3.16.1版本，替换原有的依赖配置。升级后，问题得到解决，系统恢复正常运行。建议在遇到类似问题时，优先考虑依赖库的版本更新，以修复潜在的bug。
Redis经典面试题
weixin_67807492的博客
05-10 1708
Redis是一个开源的、基于内存的键值存储系统，支持多种数据结构如字符串、哈希、列表、集合和有序集合，常用于缓存、分布式锁和消息队列等场景。Redis的持久化机制包括RDB和AOF，分别通过快照和追加命令文件来保证数据不丢失。Redis集群通过主从复制、哨兵机制和Cluster模式实现高可用性和水平扩展。Redis还提供了多种内存淘汰策略和事务机制，支持原子性操作和乐观锁。性能优化方法包括选择合适的数据结构、减少网络延迟、批量操作和优化持久化策略。
redis
2402_88116813的博客
05-12 319
在idea中对redis添加的字段会经过序列化导致idea无法查询redis中添加的字段,redis中无法查询idea中添加的字段。redis使用前要先声明一下要操作哪种数据存储类型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值