Redis

最新推荐文章于 2021-04-04 17:39:59 发布
最新推荐文章于 2021-04-04 17:39:59 发布
阅读量101 收藏
点赞数
文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51009861/article/details/109082286
版权

1 Redis安装

1.1 解压 Redis安装包

[root@localhost src]# tar -zxvf redis-5.0.4.tar.gz

在这里插入图片描述

1.2 安装Redis

说明:在Redis的根目录中执行命令
命令: 1.make
2.make install
在这里插入图片描述

1.3 修改Redis的配置文件

命令1: 展现行号 :set nu
修改位置1: 注释IP绑定
在这里插入图片描述
修改位置2: 关闭保护模式
在这里插入图片描述
修改位置3: 开启后台启动
在这里插入图片描述

1.4 redis 服务器命令

1.启动命令: redis-server redis.conf
2.检索命令: ps -ef | grep redis
3.进入客户端: redis-cli -p 6379
4.关闭redis: kill -9 PID号 | redis-cli -p 6379 shutdown
在这里插入图片描述

2 关于Redis 配置说明

3.1 关于Redis持久化的说明

redis默认条件下支持数据的持久化操作. 当redis中有数据时会定期将数据保存到磁盘中.当Redis服务器重启时 会根据配置文件读取指定的持久化文件.实现内存数据的恢复.

3.2持久化方式介绍

3.2.1 RDB模式

特点:
1.RDB模式是redis的默认的持久化策略.
2.RDB模式记录的是Redis 内存数据的快照. 最新的快照会覆盖之前的内容 所有RDB持久化文件占用空间更小 持久化的效率更高.
3.RDB模式由于是定期持久化 所以可能导致数据的丢失.

命令:

  1. save 要求立即马上持久化 同步的操作 其他的redis操作会陷入阻塞的状态.
  2. bgsave 开启后台运行 异步的操作 由于是异步操作,所以无法保证rdb文件一定是最新的需要等待.

配置:
1.持久化文件名称:
在这里插入图片描述
2.持久化文件位置
dir ./ 相对路径的写法
dir /usr/local/src/redis 绝对路径写法
在这里插入图片描述
3.RDB模式持久化策略
在这里插入图片描述

2.2.2 AOF模式

特点:
1.AOF模式默认条件下是关闭的,需要用户手动的开启
在这里插入图片描述
2. AOF模式是异步的操作 记录的是用户的操作的过程 可以防止用户的数据丢失
3. 由于AOF模式记录的是程序的运行状态 所以持久化文件相对较大,恢复数据的时间长.需要人为的优化持久化文件

配置:
在这里插入图片描述

2.2.3 关于持久化操作的总结

1.如果不允许数据丢失 使用AOF方式
2.如果追求效率 运行少量数据丢失 采用RDB模式
3.如果既要保证效率 又要保证数据 则应该配置redis的集群 主机使用RDB 从机使用AOF

2.3 关于Redis内存策略

2.3.1 关于内存策略的说明

说明:Redis数据的存储都在内存中.如果一直想内存中存储数据 必然会导致内存数据的溢出.
解决方式:

  1. 尽可能为保存在redis中的数据添加超时时间.
  2. 利用算法优化旧的数据.

2.3.2 LRU算法

特点: 最好用的内存优化算法.
LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。
维度: 时间 T

2.3.3 LFU算法

LFU（least frequently used (LFU) page-replacement algorithm）。即最不经常使用页置换算法，要求在页置换时置换引用计数最小的页，因为经常使用的页应该有一个较大的引用次数。但是有些页在开始时使用次数很多，但以后就不再使用，这类页将会长时间留在内存中，因此可以将引用计数寄存器定时右移一位，形成指数衰减的平均使用次数。
维度: 使用次数

2.3.4 RANDOM算法

随机删除数据

2.3.5 TTL算法

把设定了超时时间的数据将要移除的提前删除的算法.

2.3.6 Redis内存数据优化

volatile-lru 设定了超时时间的数据采用lru算法
2.allkeys-lru 所有的数据采用LRU算法
3.volatile-lfu 设定了超时时间的数据采用lfu算法删除
4.allkeys-lfu 所有数据采用lfu算法删除
5.volatile-random 设定超时时间的数据采用随机算法
6.allkeys-random 所有数据的随机算法
7.volatile-ttl 设定超时时间的数据的TTL算法
8.noeviction 如果内存溢出了 则报错返回. 不做任何操作. 默认值
在这里插入图片描述

3 关于Redis 缓存面试题

问题描述: 由于海量的用户的请求 如果这时redis服务器出现问题 则可能导致整个系统崩溃.
运行速度:

  1. tomcat服务器 150-250 之间 JVM调优 1000/秒
  2. NGINX 3-5万/秒
  3. REDIS 读 11.2万/秒 写 8.6万/秒 平均 10万/秒

3.1 缓存穿透

问题描述: 由于用户高并发环境下访问 数据库中不存在的数据时 ,容易导致缓存穿透.
如何解决: 设定IP限流的操作 nginx中 或者微软服务机制 API网关实现.

3.2 缓存击穿

问题描述: 由于用户高并发环境下, 由于某个数据之前存在于内存中,但是由于特殊原因(数据超时/数据意外删除)导致redis缓存失效. 而使大量的用户的请求直接访问数据库.
俗语: 趁他病 要他命
如何解决:
1.设定超时时间时 不要设定相同的时间.
2.设定多级缓存
在这里插入图片描述

3.3 缓存雪崩

说明: 由于高并发条件下 有大量的数据失效.导致redis的命中率太低.而使得用户直接访问数据库(服务器)导致奔溃,称之为缓存雪崩.
解决方案:
1.不要设定相同的超时时间 随机数
2.设定多级缓存.
3.提高redis缓存的命中率 调整redis内存优化策略 采用LRU等算法.
在这里插入图片描述

4. Redis入门案例

4.1 引入jar包文件

<!--spring整合redis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
        </dependency>

4.2 编辑测试API

 /**
     * 1.测试redis程序链接是否正常
     * 步骤:
     *      1.实例化jedis工具API对象(host:port)
     *      2.根据实例 操作redis  方法就是命令
     *
     * 关于链接不通的说明:
     *      1.检查Linux防火墙
     *      2.检查Redis配置文件修改项
     *          2.1 IP绑定
     *          2.2 保护模式
     *          2.3 后台启动
     *      3.检查redis启动方式  redis-server redis.conf
     *      4.检查IP 端口 及redis是否启动...
     *
     *      */
    @Test
    public void test01(){
        String host = "192.168.126.129";
        int port = 6379;
        Jedis jedis = new Jedis(host,port);
        jedis.set("cgb2006","好好学习 天天向上");
        System.out.println(jedis.get("cgb2006"));

        //2.练习是否存在key
        if(jedis.exists("cgb2006")){
            jedis.del("cgb2006");
        }else{
            jedis.set("cgb2006", "xxxx");
            jedis.expire("cgb2006", 100);
        }
    }

4.3 Redis常见用法

4.3.1 setex学习

/**
     * 2.需求:
     *      1.向redis中插入数据  k-v
     *      2.为key设定超时时间  60秒后失效.
     *      3.线程sleep 3秒
     *      4.获取key的剩余的存活时间.
     *
     *   问题描述: 数据一定会被删除吗??????
     *   问题说明: 如果使用redis 并且需要添加超时时间时 一般需要满足原子性要求.
     *   原子性:   操作时要么成功 要么失败.但是必须同时完成.
     */
    @Test
    public void test02() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129",6379);
        jedis.setex("宝可梦", 60, "小火龙 妙蛙种子");
        System.out.println(jedis.get("宝可梦"));

       /* Jedis jedis = new Jedis("192.168.126.129",6379);
        jedis.set("宝可梦", "小火龙 妙蛙种子");
        int a = 1/0;    //可能会出异常
        jedis.expire("宝可梦", 60);
        Thread.sleep(3000);
        System.out.println(jedis.ttl("宝可梦"));*/
    }

4.3.2 setnx

/**
     * 3.需求如果发现key已经存在时 不修改数据.如果key不存在时才会修改数据.
     *
     */
    @Test
    public void test03() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129", 6379);
        jedis.setnx("aaaa", "测试nx的方法");
        /*if(jedis.exists("aaa")){
            System.out.println("key已经存在 不做修改");
        }else {
            jedis.set("aaa", "测试数据");
        }*/
        System.out.println(jedis.get("aaaa"));
    }

4.3.3 set 超时时间原子性操作

 /**
     * 需求:
     *  1.要求用户赋值时,如果数据存在则不赋值.  setnx
     *  2.要求在赋值操作时,必须设定超时的时间 并且要求满足原子性 setex
     */
    @Test
    public void test04() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129", 6379);
        SetParams setParams = new SetParams();
        setParams.nx().ex(20);
        jedis.set("bbbb", "实现业务操作AAAA", setParams);
        System.out.println(jedis.get("bbbb"));
    }

4.3.4 list集合练习

  @Test
    public void testList() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129", 6379);
        jedis.lpush("list", "1","2","3");
        System.out.println(jedis.rpop("list"));
    }

4.3.5 redis事务控制

 @Test
    public void testTx() throws InterruptedException {
        Jedis jedis = new Jedis("192.168.126.129", 6379);
        //1.开启事务
        Transaction transaction = jedis.multi();
        try {
            transaction.set("aa", "aa");
            //提交事务
            transaction.exec();
        }catch (Exception e){
            e.printStackTrace();
            //回滚事务
            transaction.discard();
        }
    }

4.4常规锁操作

4.4.1 超卖的原因

在这里插入图片描述

4.4.2 同步锁的问题

说明:同步锁只能解决tomcat内部的问题,不能解决多个tomcat并发问题
在这里插入图片描述

4.4.3 分布式锁机制

思想:
1.锁应该使用第三方操作 ,锁应该公用.
2.原则:如果锁被人正在使用时,其他的用户不能操作.
3.策略: 用户向redis中保存一个key,如果redis中有key表示有人正在使用这把锁 其他用户不允许操作.如果redis中没有key ,则表示我可以使用这把锁.
4.风险: 如何解决死锁问题. 设定超时时间.
在这里插入图片描述

5. SpringBoot整合Redis

5.1 编辑配置文件 redis.pro

说明:由于该配置被其他的项目共同使用,则应该写到jt-common中.
在这里插入图片描述

5.2 编辑配置类

说明: 编辑redis配置类.将Jedis对象交给Spring容器进行管理.

@Configuration
@PropertySource("classpath:/properties/redis.properties")
public class JedisConfig {

    @Value("${redis.host}")
    private String host;
    @Value("${redis.port}")
    private Integer port;
    
    @Bean
    public Jedis jedis(){
        return new Jedis(host,port);
    }
}

5.3 对象与JSON转化 ObjectMapper介绍

5.3.1 简单对象转化

/**
     * 测试简单对象的转化
     */
    @Test
    public void test01() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        ItemDesc itemDesc = new ItemDesc();
        itemDesc.setItemId(100L).setItemDesc("商品详情信息")
                .setCreated(new Date()).setUpdated(new Date());
        //对象转化为json
        String json = objectMapper.writeValueAsString(itemDesc);
        System.out.println(json);

        //json转化为对象
        ItemDesc itemDesc2 = objectMapper.readValue(json, ItemDesc.class);
        System.out.println(itemDesc2.getItemDesc());
    }

5.3.2 集合对象转化

 /**
     * 测试集合对象的转化
     */
    @Test
    public void test02() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        ItemDesc itemDesc = new ItemDesc();
        itemDesc.setItemId(100L).setItemDesc("商品详情信息1")
                .setCreated(new Date()).setUpdated(new Date());
        ItemDesc itemDesc2 = new ItemDesc();
        itemDesc2.setItemId(100L).setItemDesc("商品详情信息2")
                .setCreated(new Date()).setUpdated(new Date());
        List<ItemDesc> lists = new ArrayList<>();
        lists.add(itemDesc);
        lists.add(itemDesc2);
        //[{key:value},{}]
        String json = objectMapper.writeValueAsString(lists);
        System.out.println(json);

        //将json串转化为对象
        List<ItemDesc> list2 = objectMapper.readValue(json, lists.getClass());
        System.out.println(list2);
    }

5.4 编辑工具API

package com.jt.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jt.pojo.ItemDesc;
import org.springframework.util.StringUtils;

public class ObjectMapperUtil {

    /**
     * 1.将用户传递的数据转化为json串
     * 2.将用户传递的json串转化为对象
     */
    private static final ObjectMapper MAPPER = new ObjectMapper();

     //1.将用户传递的数据转化为json串
    public static String toJSON(Object object){

        if(object == null) {
            throw new RuntimeException("传递的数据为null.请检查");
        }

        try {
            String json = MAPPER.writeValueAsString(object);
            return json;
        } catch (JsonProcessingException e) {
            //将检查异常,转化为运行时异常
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }

    //需求: 要求用户传递什么样的类型,我返回什么样的对象  泛型的知识
    public static <T> T toObj(String json,Class<T> target){
        if(StringUtils.isEmpty(json) || target ==null){
            throw new RuntimeException("参数不能为null");
        }
        try {
           return  MAPPER.readValue(json, target);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
}

5.5 商品分类的缓存实现

5.5.1 实现步骤

1.定义Redis中的key key必须唯一不能重复. 存 取 key = “ITEM_CAT_PARENTID::70”
2.根据key 去redis中进行查询 有数据 没有数据
3.没有数据 则查询数据库获取记录 之后将数据保存到redis中 方便后续使用.
4.有数据 表示用户不是第一次查询 可以将缓存数据直接返回即可.

5.5.2 编辑ItemCatController

在这里插入图片描述

5.5.3 编辑ItemCatService

@Override
    public List<EasyUITree> findItemCatListCache(Long parentId) {
        //0.定义公共的返回值对象
        List<EasyUITree> treeList = new ArrayList<>();
        //1.定义key
        String key = "ITEM_CAT_PARENTID::"+parentId;
        //2.检索redis服务器,是否含有该key

        //记录时间
        Long startTime = System.currentTimeMillis();
        if(jedis.exists(key)){
            //数据存在
            String json = jedis.get(key);
            Long endTime = System.currentTimeMillis();
            //需要将json串转化为对象
            treeList = ObjectMapperUtil.toObj(json,treeList.getClass());
            System.out.println("从redis中获取数据 耗时:"+(endTime-startTime)+"毫秒");
        }else{
            //3.数据不存在  查询数据库
            treeList = findItemCatList(parentId);
            Long endTime = System.currentTimeMillis();
            //3.将数据保存到缓存中
            String json = ObjectMapperUtil.toJSON(treeList);
            jedis.set(key, json);
            System.out.println("查询数据库 耗时:"+(endTime-startTime)+"毫秒");
        }
        return treeList;
    }

5.5.4 使用Redis的速度差

在这里插入图片描述

6. AOP实现Redis缓存

6.1 自定义缓存注解

问题: 如何控制 哪些方法需要使用缓存? cacheFind()
解决方案: 采用自定义注解的形式 进行定义,如果 方法执行需要使用缓存,则标识注解即可.
关于注解的说明:
1.注解名称 : cacheFind
2.属性参数 :
2.1 key: 应该由用户自己手动添加 一般添加业务名称 之后动态拼接形成唯一的key
2.2 seconds: 用户可以指定数据的超时的时间

@Target(ElementType.METHOD) //注解对方法有效
@Retention(RetentionPolicy.RUNTIME)  //运行期有效
public @interface CacheFind {

    public String preKey();          //用户标识key的前缀.
    public int seconds() default 0;  //如果用户不写表示不需要超时. 如果写了以用户为准.
}

在这里插入图片描述

6.2 编辑CacheAOP

package com.jt.aop;

import com.jt.anno.CacheFind;
import com.jt.config.JedisConfig;
import com.jt.util.ObjectMapperUtil;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import java.lang.reflect.Method;
import java.util.Arrays;

@Aspect     //我是一个AOP切面类
@Component  //将类交给spring容器管理
public class CacheAOP {

    @Autowired
    private Jedis jedis;

    /**
     * 切面 = 切入点 + 通知方法
     *        注解相关 + 环绕通知  控制目标方法是否执行
     *
     *  难点:
     *      1.如何获取注解对象
     *      2.动态生成key  prekey + 用户参数数组
     *      3.如何获取方法的返回值类型
     */
    @Around("@annotation(cacheFind)")
    public Object around(ProceedingJoinPoint joinPoint,CacheFind cacheFind){
        Object result = null;
        try {
            //1.拼接redis存储数据的key
            Object[] args = joinPoint.getArgs();
            String key = cacheFind.preKey() +"::" + Arrays.toString(args);

            //2. 查询redis 之后判断是否有数据
            if(jedis.exists(key)){
                //redis中有记录,无需执行目标方法
                String json = jedis.get(key);
                //动态获取方法的返回值类型   向上造型  向下造型
                MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
                Class returnType = methodSignature.getReturnType();
                result = ObjectMapperUtil.toObj(json,returnType);
                System.out.println("AOP查询redis缓存");
            }else{
                //表示数据不存在,需要查询数据库
                result = joinPoint.proceed();  //执行目标方法及通知
                //将查询的结果保存到redis中去
                String json = ObjectMapperUtil.toJSON(result);
                //判断数据是否需要超时时间
                if(cacheFind.seconds()>0){
                    jedis.setex(key,cacheFind.seconds(),json);
                }else {
                    jedis.set(key, json);
                }
                System.out.println("aop执行目标方法查询数据库");
            }

        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return result;
    }

}
娟娟的学习小仓库
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis学习：安装，配置，idea中测试redis和编辑API工具实现传输的数据转成json并转成对象+AOP实现Redis
weixin_47742346的博客
10-13 552
1. Redis学习 =========== 0.1还原程序 0.1.1 修改YML配置文件 0.1.2 修改pro图片路径 0.1.3 修改Nginx配置文件 0.1.4 修改hosts文件 1.1 缓存机制 说明:使用缓存可以有效的降低用户访问物理设备的频次.快速从内存中获取数据,之后返回给用户,同时需要保证内存中的数据就是数据库数据. 思考: 1.缓存的运行环境应该在内存中.(快) 2.使用C语言开发缓存 3.缓存应该使用什么样的数据结构呢--------K-V结构 一般采用String类型居
Redis-1
yuke98727的博客
05-12 288
1、NoSQL了解 2、Redis概述 单线程+多路IO rediskey操作命令 3、Redis常用数据类型 1）String 2）List 3）set 4)Hash
Redis数据库的安装使用
qq_43330631的博客
09-20 248
http://www.capabcv.com/resumedownload/339.html 学习网址 https://www.w3cschool.cn/redis/ Redis简介 NoSQL not only sql Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。 它支持字符串、哈希表、列表、集合、有序集合，位图，hyperlo...
redis-windows-7.0.11
05-05
Redis是一种开源的内存数据结构存储系统，它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等。Redis可以用作数据库、缓存和消息中间件。Redis在性能、可扩展性和灵活性方面表现出色，因此被广泛应用于Web...
delphi 读写Redis
06-28
delphi 读写Redis
redis 6.0 windows 版本
02-15
看到网上的 redis windows 版本下载资源 一个就几十积分 ，老子很生气，自己编译的，给个辛苦钱，谢谢下载
若依前后端分离版去redis版/无redis版本
11-07
基于前后端分离的应用，无论是否使用Redis，都需要考虑如何进行数据的存储和缓存。下面我将分别介绍基于Redis和无Redis的两种版本的特点。 基于Redis的版本 特点 缓存处理：Redis作为内存数据库可以用来缓存频繁访问...
redis7.2.3-windows
11-15
Windows下Redis，版本是7.2.3。
redis-1
程序员的每一天的博客
06-08 332
Redis的储存的类型 string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型） push/pop、add/remove及取交集并集和差集及更丰富的操作，都是原子性的操作 数据的缓存都是在内存中的 区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。 string（字符串） string是最简单的类型，你可以理解成与Memcached一模一样的类型，一
Redis-1-基础
qq_22648091的博客
04-04 457
一、数据类型 1. 数据类型的基本介绍 二、Redis 的认证连接 // 在配置文件中找到以下配置项，大约在第 `500` 行 shell> vi /etc/redis/6379.conf requirepass mypassword mypassword 就是密码了，更改好后重启服务 使用设置好的密码认证 // 使用 auth 进行密码认证 127.0.0.1:6379> info NOAUTH Authentication required. 127.0.0.1:6379> au
Redis(1)---介绍
weixin_43410352的博客
05-08 232
一.redis产生背景 传统关系型数据库满足不了日益增长的高读写需求；由于数据库的持久化数据主要面向的是磁盘，而磁盘的读写比较慢，在一般的管理系统上，由于不存在高并发，因此往往不需要瞬间大量读写数据的要求。 二.redis作用 redis作用就是缓存这些数据，而它是缓存在cpu中，都知道读取cpu中的数据速度是极高的，这样就提高了速度。它有两个使用场景 1.缓存常用数据。2.在高速读写的场合使用它...
redis-1.基础命令
顺利的博客
01-05 171
1、keys（查询Redis所有key） 查询单个key keys pattern :获取所有与pattern 匹配的key。*表示任意一个或多个字符；？表示一个字符 例如：现在有 key value name zhaowei list1 [a b c d] set1 [e m n d] username zhaowei 需求一：找出所有包含name的k...
Redis 1：简介
该怎么解释？我懒得解释
05-14 672
导读：在今日开讲的项目中，用到了redis数据库。老听大家在说，我都不知道是个啥玩意儿。然后这两天在准备知识分享的事儿，我先大概了解了解，然后讲的时候，能有点共鸣。所以，本篇博客，是在自己跟读完MVA的一集Redis视频，自己浅显总结的一个基本内容。在下一篇博客，会介绍一下其基本使用。 一、概念 Redis is an open source (BSD licensed), in-me
Redis-1 简介与安装配置
夜空中最亮的星
01-25 122
Redis-1 简介与安装配置 ****************** 如有侵权请提示删除 ******************* 为什么用 NoSQL NoSQL代表 MongDB、 Redis、Memcache 关系型数据库与NoSQL的区别 RDBMS 高度组织化结构化数据 结构化查询语言（SQL） 数据和关系都存储在单独的表中。 数据操纵语言，数据定义语言 严格的一致性 基础事务 ACID 关系型数据库遵循ACID规则 NoSQL 代表着不仅仅是SQL 没有声明性查询语言 没有预定义
Redis的IDEA操作——Jedis-API
攻城狮Kevin
03-07 1998
测试环境是：Redis的配置文件redis.conf已修改完毕，存放在myredis/目录下 目录 一、测试Jedis连通Redis 二、Jedis-API（5种数据类型） 一、测试Jedis连通Redis 首先导入依赖，这里用的2.9.0版本 &lt;dependency&gt; &lt;groupId&gt;redis.clients&lt;/groupI...
Redis源码学习 - Redis命令 get
努力推石头的西西弗斯
04-08 692
get命令的实现是t_string.c中的getCommand函数。 void getCommand(redisClient *c) { getGenericCommand(c); } int getGenericCommand(redisClient *c) { robj *o; // 尝试从数据库中取出键 c->argv[1] 对应的值对象 // 如果...
Redis linux
最新发布
06-05
Redis是一个开源的、高性能的键值存储数据库，通常用于缓存、会话管理和数据结构存储。在Linux环境下，Redis作为服务可以轻松部署和管理。下面是Redis在Linux中的一些关键信息： 1. 安装：你可以使用包管理器（如...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值