05_2023_Redis_redis缓存(cache)_基本使用

已于 2023-02-07 14:57:44 修改
阅读量464 收藏
点赞数
分类专栏： Redis 文章标签： redis 缓存 java
于 2023-02-07 14:50:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w7635122886/article/details/128917339
版权

1，什么是缓存

在这里插入图片描述
数据库发生改变，Redis还没及时更新，那么从缓存内取到的数据就会出错，就是数据一致性问题

2，添加查询商品详情缓存

我们通过这个接口查询到的数据有很多，我们希望在此做个Redis缓存数据，提供查询速度

在这里插入图片描述

2.1 pom文件

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.8.0</version>
        </dependency>

        <!--Redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.4.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.1</version>
        </dependency>
        <!--逆向工程需要模板引擎-->
        <dependency>
            <groupId>org.freemarker</groupId>
            <artifactId>freemarker</artifactId>
            <version>2.3.28</version>
        </dependency>

        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.2</version>
        </dependency>

        <!-- mybatis-plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <!--<version>3.0.5</version>-->
            <version>3.5.1</version>
        </dependency>

        <!-- 代码自动生成器依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.5.1</version>
        </dependency>

        <!-- mysql连接 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.21</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

2.2 配置文件

server:
  port: 18083

spring:
  application:
    name: springboot_redis_cache
  datasource:
    type: com.zaxxer.hikari.HikariDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/java_pro?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&serverTimezone=UTC
    username: root
    password: Root-123
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    lettuce:
      pool:
        max-active: 8 #最大连接数
        max-idle: 8 #最大空闲连接
        min-idle: 0 #最小空闲连接
        #连接等待时间
        max-wait: 100

mybatis-plus:
  type-aliases-package: com.study.pojo
  mapper-locations: classpath:mapper/*Mapper.xml

mybatis:
  type-aliases-package: com.study.pojo
  mapper-locations: classpath:mapper/*Mapper.xml

2.3 启动类

package com.study;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.study.mapper")
public class RedisCacheApplication {
    public static void main(String[] args) {
        SpringApplication.run(RedisCacheApplication.class, args);
    }
}

2.4 完成公共类

  • ResponseResult
package com.study.common;


import lombok.Data;

import java.io.Serializable;


@Data
public class ResponseResult<T> implements Serializable {
    private Boolean success;//是否成功
    private Integer code;//状态码
    private String message;//返回消息
    private T data;

    public ResponseResult() {
    }

    public static <T> ResponseResult<T> ok(){
        ResponseResult<T> responseResult = new ResponseResult<T>();
        responseResult.setSuccess(true);
        responseResult.setCode(ResultCode.SUCCESS);
        responseResult.setMessage("执行成功");
        return responseResult;
    }

    public static <T> ResponseResult<T> ok(T data){
        ResponseResult<T> responseResult = new ResponseResult<T>();
        responseResult.setSuccess(true);
        responseResult.setCode(ResultCode.SUCCESS);
        responseResult.setMessage("执行成功");
        responseResult.setData(data);
        return responseResult;
    }

    public static <T> ResponseResult<T> error(Integer code){
        ResponseResult<T> responseResult = new ResponseResult<T>();
        responseResult.setSuccess(false);
        responseResult.setCode(code);
        responseResult.setMessage("执行失败");
        return responseResult;
    }
    public static <T> ResponseResult<T> error(){
        ResponseResult<T> responseResult = new ResponseResult<T>();
        responseResult.setSuccess(false);
        responseResult.setCode(ResultCode.ERROR);
        responseResult.setMessage("执行失败");
        return responseResult;
    }

    public ResponseResult<T> success(Boolean success){
        this.setSuccess(success);
        return this;
    }

    public ResponseResult<T> code (Integer code){
        this.setCode(code);
        return this;
    }

    public ResponseResult<T> message (String message){
        this.setMessage(message);
        return this;
    }

    public static<T> ResponseResult<T> exist (String message){
        ResponseResult<T> responseResult = new ResponseResult<T>();
        responseResult.setSuccess(true);
        responseResult.setCode(ResultCode.SUCCESS);
        responseResult.setMessage(message);
        responseResult.setSuccess(true);
        return responseResult;
    }

    public static<T> ResponseResult<T> exist (){
        ResponseResult<T> responseResult = new ResponseResult<T>();
        responseResult.setSuccess(true);
        responseResult.setCode(ResultCode.SUCCESS);
        responseResult.setSuccess(true);
        return responseResult;
    }
}
  • ResultCode
package com.study.common;

public class ResultCode {
    public static final Integer SUCCESS = 200;
    public static final Integer ERROR = 500;
    public static final int NOT_LOGIN = 600;
    public static final int NOT_AUTH = 700;
}

2.5 完成常量类

package com.study.constants;

public class RedisConstants {
    public static final String LOGIN_CODE_KEY = "login:code:";
    public static final Long LOGIN_CODE_TTL = 10L;
    public static final String LOGIN_USER_KEY = "login:token:";
    public static final Long LOGIN_USER_TTL = 36000L;

    public static final Long CACHE_NULL_TTL = 2L;

    public static final Long CACHE_SHOP_TTL = 30L;
    public static final String CACHE_SHOP_KEY = "cache:shop:";

    public static final String LOCK_SHOP_KEY = "lock:shop:";
    public static final Long LOCK_SHOP_TTL = 10L;

    public static final String SECKILL_STOCK_KEY = "seckill:stock:";
    public static final String BLOG_LIKED_KEY = "blog:liked:";
    public static final String FEED_KEY = "feed:";
    public static final String SHOP_GEO_KEY = "shop:geo:";
    public static final String USER_SIGN_KEY = "sign:";

    public static final String CACHE_SHOPTYPE_KEY = "cache_shoptype_key";
    public static final Long CACHE_SHOPTYPE_TTL = 36000L;
}

2.6 完成代码生成工具

package com.study.utils;


import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.converts.MySqlTypeConvert;
import com.baomidou.mybatisplus.generator.config.querys.MySqlQuery;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;
import com.baomidou.mybatisplus.generator.fill.Column;
import com.baomidou.mybatisplus.generator.keywords.MySqlKeyWordsHandler;

public class MysqlCodeGenerator {

    private static final String URL = "jdbc:mysql://127.0.0.1:3306/java_pro?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&serverTimezone=UTC";
    private static final String username = "root";
    private static final String password = "Root-123";
    private static final String author = "linailong";
    public static void main(String[] args) {
        packMybatisPlus("sys_product");
    }

    static void packMybatisPlus(String table) {
        FastAutoGenerator.create(new DataSourceConfig.Builder(URL, username, password)
                .dbQuery(new MySqlQuery())
                .typeConvert(new MySqlTypeConvert())
                .keyWordsHandler(new MySqlKeyWordsHandler()))
                .globalConfig(builder -> {
                    // 设置作者
                    builder.author("".equals(author) ? System.getProperty("user.name") : author)
                            // 使用java8新的时间类型
                            .dateType(DateType.TIME_PACK)
                            // 指定日期格式化方式
                            .commentDate("yyyy-MM-dd hh:mm:ss")
                            .outputDir("E:\\a_linailong\\myProject\\redis\\Demo03_Redis_Cache\\src\\main\\java");
                })
                .packageConfig(builder -> {
                    // TODO 设置父包名
                    builder.parent("com.study")
                            // 设置父包模块名
//                            .moduleName("system")
                            .entity("pojo")
                            .service("service")
                            .serviceImpl("service.impl")
                            .mapper("mapper")
                            .xml("mapper.xml")
                            .controller("controller");
                })
                .strategyConfig(builder -> {

                    builder
                            // 设置需要生成的表名 不设置表名则生成全部表
                            .addInclude(table)
                            // 开启跳过视图
                            .enableSkipView();

                    // 设置实体类策略
                    builder.entityBuilder()
                            // 开启链式模型
                            .enableChainModel()
                            // 开启lombok
//                            .enableLombok()
                            // 移除boolean的is前缀
                            .enableRemoveIsPrefix()
                            // 从数据库中生成字段注解
                            .enableTableFieldAnnotation()
                            // 命名规则下划线转驼峰
                            .naming(NamingStrategy.underline_to_camel)
                            // 数据库表字段映射到实体的命名策略
                            .columnNaming(NamingStrategy.underline_to_camel)
                            // 设置表字段自动填充
                            .addTableFills(new Column("create_time", FieldFill.INSERT))
                            .addTableFills(new Column("update_time", FieldFill.INSERT_UPDATE));

                    // mapper 生成策略
                    builder.mapperBuilder()
                            // 开启@Mapper注解
                            .enableMapperAnnotation();

                    // service 生成策略
                    builder.serviceBuilder()
                            .formatServiceFileName("%sService")
                            .formatServiceImplFileName("%sServiceImpl");

                    // controller 生成策略
                    builder.controllerBuilder()
                            // 开启驼峰连字符
                            .enableHyphenStyle()
                            // 开始@RestController
                            .enableRestStyle();


                })
                // 使用Freemarker引擎模板，默认的是Velocity引擎模板
                .templateEngine(new FreemarkerTemplateEngine())
                .execute();
    }

}

2.7 完成实体类

package com.study.pojo;

import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.io.Serializable;

/**
 * <p>
 * 商品表
 * </p>
 *
 * @author linailong
 * @since 2023-02-07 01:59:33
 */
@TableName("sys_product")
@Data
public class SysProduct implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId("ID")
    private String id;

    @TableField("`NAME`")
    private String name;

    @TableField("INTRODUCE")
    private String introduce;

    @Override
    public String toString() {
        return "SysProduct{" +
            "id=" + id +
            ", name=" + name +
            ", introduce=" + introduce +
        "}";
    }
}

2.8 完成mapper

package com.study.mapper;

import com.study.pojo.SysProduct;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

/**
 * <p>
 * 商品表 Mapper 接口
 * </p>
 *
 * @author linailong
 * @since 2023-02-07 01:59:33
 */
@Mapper
public interface SysProductMapper extends BaseMapper<SysProduct> {

}

2.9 完成service以及实现

package com.study.service;

import com.study.common.ResponseResult;
import com.study.pojo.SysProduct;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 * 商品表 服务类
 * </p>
 *
 * @author linailong
 * @since 2023-02-07 01:59:33
 */
public interface SysProductService extends IService<SysProduct> {

    /**
     * 根据id查询商品
     * @param id
     * @return
     */
    ResponseResult getProById(String id);
}


package com.study.service.impl;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.study.common.ResponseResult;
import com.study.constants.RedisConstants;
import com.study.pojo.SysProduct;
import com.study.mapper.SysProductMapper;
import com.study.service.SysProductService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.management.Query;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * <p>
 * 商品表 服务实现类
 * </p>
 *
 * @author linailong
 * @since 2023-02-07 01:59:33
 */
@Slf4j
@Service
public class SysProductServiceImpl extends ServiceImpl<SysProductMapper, SysProduct> implements SysProductService {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Resource
    private SysProductMapper sysProductMapper;

   /**
     * 根据id查询商品
     * @param id
     * @return
     */
    @Override
    public ResponseResult getProById(String id) {
        //1.从Redis内查询商品缓存
        String shopJson = stringRedisTemplate.opsForValue().get(RedisConstants.CACHE_SHOP_KEY + id);
        if(StrUtil.isNotBlank(shopJson)){
            //手动反序列化
            SysProduct pro = JSONUtil.toBean(shopJson, SysProduct.class);
            return ResponseResult.ok(pro);
        }

        //2.不存在就根据id查询数据库
        SysProduct sysProduct = sysProductMapper.selectById(id);
        if(sysProduct==null){
            return ResponseResult.error().message("商品不存在！");
        }

        //3.数据库数据写入Redis
        //手动序列化
        String shopStr = JSONUtil.toJsonStr(sysProduct);
        stringRedisTemplate.opsForValue().set(RedisConstants.CACHE_SHOP_KEY + id,shopStr,RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);
        return ResponseResult.ok(shopStr);
    }
}

2.10 完成controller

package com.study.controller;


import com.study.common.ResponseResult;
import com.study.pojo.SysProduct;
import com.study.service.SysProductService;
import com.study.service.impl.SysProductServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

/**
 * <p>
 * 商品表 前端控制器
 * </p>
 *
 * @author linailong
 * @since 2023-02-07 01:59:33
 */
@RestController
@ResponseBody
@RequestMapping("/sysProduct")
public class SysProductController {

    @Resource
    public SysProductService sysProductService;

    /**
     * 根据id查询商品
     */
    @GetMapping("/getProById")
    private ResponseResult getProById(@RequestParam("id") String id){
        return sysProductService.getProById(id);
    }

}

2.11 测试

http://localhost:18083/sysProduct/getProById?id=1
在这里插入图片描述
在这里插入图片描述

3，添加批量查询商品缓存

3.1 完成service以及实现

/**
     * 查询所以商品
     * @return
     */
    ResponseResult getProList();

/**
     * 查询所以商品
     * @return
     */
    @Override
    public ResponseResult getProList() {
        //1.从Redis中查询
        String key = RedisConstants.CACHE_SHOPTYPE_KEY;

        List<String> list = stringRedisTemplate.opsForList().range(key, 0, -1);

        if(!list.isEmpty()){
            //手动反序列化
            List<SysProduct> productList = new ArrayList<>();
            for (String s : list) {
                SysProduct product = JSONUtil.toBean(s, SysProduct.class);
                productList.add(product);
            }
            return ResponseResult.ok(productList);
        }

        //2.从数据库内查询
        QueryWrapper<SysProduct> wrapper = new QueryWrapper<>();
        List<SysProduct> proList = sysProductMapper.selectList(wrapper);
        if(proList.isEmpty()){
            return ResponseResult.error().message("没有商品!");
        }

        //序列化
        for (SysProduct shopType : proList) {
            String s = JSONUtil.toJsonStr(shopType);
            list.add(s);
        }

        //3.存入缓存
        stringRedisTemplate.opsForList().rightPushAll(key,list);
        stringRedisTemplate.expire(key,RedisConstants.CACHE_SHOPTYPE_TTL, TimeUnit.MINUTES);
        return ResponseResult.ok(list);
    }

3.2 完成controller

/**
     * 查询所以商品
     * @return
     */
    @GetMapping("/getProList")
    private ResponseResult getProList(){
        return sysProductService.getProList();
    }

3.3 测试

在这里插入图片描述

在这里插入图片描述

李乃龙1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
fastapi_cache:简单缓存FastAPI
05-06
FastAPI缓存 将简单的轻量级缓存系统实现为FastAPI中的依赖项。 安装 pip install fastapi-cache 用法示例 from fastapi import Depends , FastAPI ... cache : RedisCacheBackend = Depends ( redis_cache
Nginx配置srcache_nginx模块搭配Redis建立缓存系统
09-10
在本文中，我们将探讨如何使用Nginx配置srcache_nginx模块与Redis来建立一个高效的缓存系统。首先，让我们了解这两个关键组件的作用。 Nginx是一款高性能的HTTP和反向代理服务器，它以其轻量级、稳定性和高并发处理...
python使用redis缓存_Python读写Redis缓存
weixin_31328561的博客
01-11 589
需要使用redis模块。代码中增加将图片存储到redis的操作。importredisimportpickleclassCache:#设置默认的redis服务ip和密码def__init__(self,host='redis服务ip地址',password='redis密码wanmait.com'):pool=redis.ConnectionPool(host=host,passwor...
python使用redis做缓存_python实现类redis缓存
weixin_40007668的博客
12-11 1518
越来越觉得的缓存是计算机科学里最NB的发明(没有之一), 现在项目用的是redis做的缓存, 它的两个特性用的蛮顺手的：键值查找功能缓存可设置过期时间突突然的，觉得用python也可以简单的模拟一下,做一个本地的轻量级缓存.(不过, 注意一点：redis的缓存可以用于分布式, python模拟的则不行, 但是如果把本地缓存的过期时间设的短一点,比如10s, 在大并发下还是有不错表现的)对于键值查找...
java redis缓存清除_Spring Cache手动清理Redis缓存
weixin_42347882的博客
02-16 937
这篇文章主要介绍了Spring Cache手动清理Redis缓存,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下注册cacheRedisTemplate将 cache 的 RedisTemplate 注册为Bean@Bean(name = "cacheRedisTemplate")public RedisTemplate cacheRedisTem...
Redis 缓存(Cache)
ikun66666的博客
02-19 1853
Redis 缓存(Cache)
Django使用Redis进行缓存详细最全流程
segegefe的博客
09-01 1146
直接输入redis-server命令使用的配置文件是安装目录下的redis.windows.conf文件。服务器数据非经常更新。默认情况下，访问Redis服务器是不需要密码的，为了让其他服务器使用同时增加安全性我们需要设置Redis服务器的访问密码。数据库的数量是可以配置的，不知道数据库就是数据库0，默认情况下是16个。通过以下命令从另一台linux服务器访问redis,password替换为你的密码，host替换为要访问的服务器。安装完成后，Redis服务器会自动启动，我们检查Redis服务器程序。...
Redis高频面试基本问题整理
热门推荐
张彦峰的博客
04-07 170万+
对Redis一些重点内容进行整理总结用于查缺补漏
Redis - evicted_keys 解读
牧码的博客
07-07 768
Redis - evicted_keys 解读
flask_cache redis做缓存的配置与使用
笨笨的博客
05-22 2797
1 安装三方库 pip install flask_cache 2 代码实现 # --*-- encoding:utf8 --*-- from flask import Flask, jsonify from flask_cache import Cache cache = Cache() class config(): # 缓存的存储类型 CACHE_TYPE =...
flask中使用redis做缓存
python_web全栈
10-31 4352
有很多种实例方式，这里介绍我最常用的一种CACHE_TYPE:设置缓存的类型# 下面五个参数是所有的类型共有的CACHE_NO_NULL_WARNING = "warning" # null类型时的警告消息CACHE_ARGS = [] # 在缓存类实例化过程中解包和传递的可选列表，用来配置相关后端的额外的参数CACHE_OPTIONS = {} # 可选字典,在缓存类实例化期间传递，也是用来配置相关后端的额外的键值对参数。
SpringBoot_redis使用实战(二)_缓存
Myron_007的博客
02-20 1327
介绍springboot中使用redis作为缓存的相关实战内容, 涉及各种缓存问题产生原因及解决方式. 如缓存雪崩/缓存击穿/缓存穿透等
Django如何使用redis作为缓存
12-17
已有Django项目，在其中设置以redis为缓存。 1、 安装django-redis： pip install django-redis 2、 在settings里面配置cache设置： CACHES = { "default":{ "BACKEND":"django_redis.cache.RedisCache", ...
cache_redis_node:在Redis，Mongo和Node.js中使用Cache的示例
05-01
将缓存与Redis和Node.js结合使用 概括 快取 快取类型 客户端缓存（浏览器） Web服务器上的缓存 应用内缓存 在每种情况下缓存的优缺点 使用缓存即服务 雷迪斯 比较Redis和Memcached 安装和使用Redis和Node.js进行...
cache:带有Redis后端的Golang缓存库
03-29
用于Golang的Redis缓存库 go-redis / cache库使用Redis作为键/值存储来实现缓存。 它使用送值。 最佳地，您可以使用或任何其他作为本地进程内缓存。安装go-redis / cache支持2个最新的Go版本，并且需要具有支持的Go...
Redis简介
最新发布
YJ_12340的博客
06-17 456
Redis（Remote Dictionary Server）是一个开源的高性能键值对存储系统，以其快速、灵活和可扩展性而著称。它是一个内存中的数据结构存储系统，支持多种数据类型，可以作为数据库、缓存、消息队列和发布/订阅系统使用。
基于redis的分布式锁
孟斌斌的博客
06-12 523
用脚本的方式执行redisTemplate.execute会出现异常java.lang.UnsupportedOperationException: io.lettuce.core.output.ValueOutput does not support set(long)，好像是返回值无法转换，由于redis版本不匹配，我这边redis版本是5.0.14.1；释放锁时需要确保只有持有锁的客户端才能释放锁，因此需要在释放锁时检查锁的值是否是当前客户端的标识。4.3通过value比对保证解的锁是自己持有的；
Redis 内存碎片是什么？如何清理？
辣香牛肉面的博客
06-17 1185
你可以将内存碎片简单地理解为那些不可用的空闲内存。举个例子：操作系统为你分配了 32 字节的连续内存空间，而你存储数据实际只需要使用 24 字节内存空间，那这多余出来的 8 字节内存空间如果后续没办法再被分配存储其他数据的话，就可以被称为内存碎片。内存碎片Redis 内存碎片虽然不会影响 Redis 性能，但是会增加内存消耗。
“深入了解Redis缓存：探索Redis 6的新数据类型“
光就是羁绊之力，它会再度被某人继承，散发出耀眼的光。
06-13 1325
在Redis 6中，有几种比较特殊且功能强大的数据结构：Bitmaps（位图）、HyperLogLog（超级对数日志）、Geospatial（地理空间）作用：Bitmaps 是 Redis 中的一种非常紧凑和高效的数据结构，用来处理位操作相关的需求。用途：主要用于记录某些状态或者事件是否发生过，例如用户是否点击过某个按钮、某天是否有用户访问网站等。因为它可以节省大量内存，特别适合于需要高效率地记录大量布尔型状态的场景。作用。
redis_cache.RedisCache 是什么缓存后端
07-14
`redis_cache.RedisCache`是Django Redis Cache提供的一个缓存后端。它是基于Redis的缓存后端实现，用于在Django中使用Redis作为缓存存储。它提供了与Django缓存框架兼容的接口，可以将缓存数据存储到Redis服务器，并从Redis中获取缓存数据。 使用`redis_cache.RedisCache`作为缓存后端，可以充分利用Redis的性能和功能，例如快速的读写速度、支持过期时间、支持缓存分区等。你可以在Django的设置文件中配置使用`redis_cache.RedisCache`作为默认的缓存后端，然后通过Django的缓存API进行缓存操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值