redis浅学

最新推荐文章于 2024-08-30 22:17:40 发布
最新推荐文章于 2024-08-30 22:17:40 发布
阅读量575 收藏
点赞数
分类专栏： Java初阶 文章标签： java redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bowl_IronMan/article/details/124578681
版权

总结

1>redis 概念 优缺点 定位 与mysql的区别(必须会)2>redis 常用数据类型命令

  • 强调加粗命令必须掌握

  • 当前阶段至少-->指定redis有哪些功能

3>redis 其他全局命令4>redis 事务操作(能讲出来)5>redis 持久化机制策略(能讲出来)6>redis key淘汰机制 redis过期key策略(能讲出来)7>java 操作redis

  • jedis

  • SpringBoot-redis

复习

mybatis-plusspringbootjs

vue 前后端分离

---------------------------------------------------------------------------------------------------------------------------------

拓展

小案例--文章阅读数统计

---------------------------------------------------------------------------------------------------------------------------------

一 入门

1>简介

  键值对形式的非关系型数据库

  • 是以key-value形式存储,和传统的关系型数据库不一样.不一定遵循传统数据库的一些基本要求.(非关系型的,分布式的,开源的,水平可拓展的)

  • redis定位是缓存, 提高数据读写速度, 减轻对数据库存储与访问压力(记住)

  • 项目中涉及到缓存-->优先考虑方案-->redis

   问题-->能不能将重要数据放到缓存(临时存储)

   回答-->不能,因为不能保证数据安全保存

优点

  • 对数据高并发读写(直接是内存中进行读写的)

  • 对海量数据的高效率存储和访问

  • 对数据的可拓展性和高可用性

  • 单线程操作,每个操作都是原子操作,没有并发相关问题(redis 6)

缺点

  • redis(ACID处理非常简单)

  • 无法做太复杂的关系数据库模型

2>数据库分类

  1. 关系型数据库

  2. NoSql数据库

  • 非关系型数据库特点

  • 与关系型数据区分

 

二 数据类型

命令格式类型命令 key 参数数据set name gutianle

1>String类型

Map<String,String>mapmap.put("name", Json.toJsonString(user));可以包含任何数据 比如图片序列化的对象,最大容量为512mb

必须掌握的指令

set key value -> 存入键值对

get key -> 根据键取出值

incr key --> 把值递增1       

decr key--> 把值递减1

 

del key -> 根据键删除键值对

 

setex key timeout value -> 存入键值对

timeout表示失效时间,单位s从你开始写setex开始计算时间

 ttl key->可以查询出当前的key还剩余多长时间过期

 setnx key value -> 如果key已经存在,

不做操作, 如果key不存在,直接添加 分布式锁的一种实现方案

 

应用场景

1)计数器许多运用都会使用redis作为计数的基础工具，他可以实现快速计数、查询缓存的功能,同时数据可以异步落地到其他的数据源

如：视频播放数系统就是使用redis作为视频播放数计数的基础组件

2)共享session

-->当应用进行分布式集群部署的时候，如何保证不同服务器上session信息能够共享呢??

-->出于负载均衡的考虑，分布式服务会将用户信息的访问均衡到不同服务器上,用户刷新一次访问可能会需要重新登录，为避免这个问题可以用redis将用户session集中管理，在这种模式下只要保证redis的高可用和扩展性的，每次获取用户更新或查询登录信息都直接从redis中集中获取

回顾知识-->Session的实现原理：

  1. 服务端首先查找对应的cookie的值（sessionid）。

  2. 根据sessionid，从服务器端session存储中获取对应id的session数据，进行返回。

  3. 如果找不到sessionid，服务器端就创建session，生成sessionid对应的cookie，写入到响应头中

基于session集中存储的实现方案：

  • 新增Filter，拦截请求，包装HttpServletRequest

  • 改写getSession方法，从session存储中获取session数据，返回自定义的HttpSession实现

  • 在生成新Session后，写入sessionid到cookie中

 

2>Hash类型(无序)

Hash类型是String类型的field和value的映射表.或者说是一个String集合.它特别适合存储对象,相比较而言,讲一个对象存储在Hash类型里要比存储在String类型里占用更少的内存空间,并方便存储整个对象

必须掌握的命令

hset key hashkey hashvalue -> 存入一个hash对象

hget key hashkey -> 根据hash对象键取去值

hexists key hashkey -> 判断hash对象是含有某个键

 hdel key hashkey -> 根据hashkey删除hash对象键值对

 

 其他操作

 

应用场景

-->缓存用户信息

String和hash两种方案的选择

-->看需求的侧重点

 

3>list类型(有序)

类似java中的queue-->Map<String, List>

 

必须掌握的指令

rpush key value -> 往列表右边添加数据

lrange key start end -> 范围显示列表数据,全显示则设置0 -1

0代表开始     -1代表最后一个

lpush key value -> 往列表左边添加数据

 

lpop key -> 弹出列表最左边的数据

rpop key -> 弹出列表最右边的数据

llen key -> 获取列表长度

 

应用场景

用户收藏文章列表

用户:[文章id1,文章id2....]

4>set类型(无序唯一)

和list的区别

  • 有序无序

  • 是否可重复

必须掌握的指令

sadd key value -> 往set集合中添加元素

smembers key -> 列出set集合中的元素

 

srem key value -> 删除set集合中的元素

spop key count -> 随机弹出集合中的元素(删除)

补充指令

sdiff key1 key2 -> 返回key1中特有元素(差集)

(a b c d)-(a d e f)-->b c

(a d e f)-(a b c d)-->e f

(a b c d)-(a d e f b h)-->c

sinter key1 key2 -> 返回两个set集合的交集-->去重

(a b c d)-(a d e f b h)-->d a b

sunion key1 key2 -> 返回两个set集合的并集

(a b c d)-(a d e f b h)-->a b c d e f h

应用场景

1)去重

2)抽奖

1,准备一个抽奖池:sadd luckydraw 1 2 3 4 5 6 7 8 9 10 11 12 13

2,抽3个三等奖:spop luckydraw 3

3,抽2个二等奖:spop luckydraw 2

4,抽1个二等奖:spop luckydraw 1

5>sorted_set类型

必须掌握的指令

zadd key score column -> 存入分数和名称

zincrby key score column -> 偏移名称对应的分数

zrange key start end -> 按照分数升序输出名称

zrevrange key start end -> 按照分数降序输出名称

zrank key name -> 升序返回排名

zrevrank key name -> 降序返回排名

zcard key -> 返回元素个数

应用场景

排行榜

 

三 redis的选用

要不要用缓存-->优先考虑redis-->本质上是map集合-->分析k咋样 v咋样-->如何设计kv

value值的设计

1>第一种(必须掌握)

 

 

2>第二种

如果后续用java操作redis 里面所有的kv从redis获取出来的数据都是Object类型,操作起来就很麻烦,还得转换回来字符串有些公司为了减少转换过程,所以全部转换成字符串,拿出来以后是json格式的字符串,再用json的工具换成能用的对象

 

key值的设计

1>唯一性

-->怎么保证key值的唯一性-->一般数据表主键

2>可读性

-->加上可读性前缀-->项目名+ 业务模块 + 可识别的前缀 +唯一性标识

3>灵活性

-->项目二再说

4>时效性

-->需要考虑key是否为临时还是永久

 

四 redis的进阶

高级命令

-->可以模糊查询

1>exists

2>expire

和setex的区别???设置的时候 创建的时候

3>persist

4>flushdb

清空当前库

select 选择数据库 数据库为0到15(一共16个数据库) 默认进入的是0数据库

move key 讲当前数据中的key转移到其他数据库中

randomkey 随机返回数据库里的一个key

rename重命名key

echo 打印名

dbsize 查看数据库的key数量

info 获取数据库信息

config get 实时传储收到的请求(返回相关的配置信息)

config get * 返回所有配置

 

安全性设置

-->搜索关键词-->requirepass-->443行 去掉#修改密码admin-->登陆的时候(正常操作)

 

 

事务(高频面试题)

单个redis命令的执行时原子性的,但redis没有在事务上增加任何维持原子性的机制,所以redis事务的执行并不是原子性支持事务-->事务可以理解为一个打包的批量执行脚本,但批量指令并非原子化操作,中间某条指令的失败不会导致前面已做指令的回滚,也不会造成后续的指令不做不支持事务-->对应mysql事务的概念就是不支持事务(一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节)

从开始到执行会经历三个阶段

  1. 开始事务(MULTI)

  2. 命令入队

  3. 执行事务

自己描述-->Redis事务可以理解为一个打包的批量执行脚本，然后一次性、按顺序地执行多个命令的机制.且批量指令并非原子化操作,中间某条指令的失败不会导致前面已做指令的回滚,也不会造成后续的指令不做.(这个也是和mysql事务原子性特性的区别)redis事务从开始到执行会经历三个阶段1>开始事务(MULTI) 2>命令入队 3>执行事务

事务持久化机制(高频面试题)

-->会将内存的数据按照某种逻辑写到硬盘中

1>RDB方式

snapshotting(快照)默认方式.将内存中以快照的方式写入到二进制文件中.默认为dump.rdb.可以配置设置自动做快照持久化方式.我们可以配置redis在n秒内如果超过m个key就修改自动做快照

缺点-->两次快照之间数据可能会丢失

2>AOF方式

append-only file (缩写aof)的方式,由于快照方式是在一定时间间隔做一次,所以可能发生reids意外down的情况就会丢失最后一次快照后的所有修改的数据.aof比快照方式有更好的持久化性,是由于在使用aof时,redis会将每一个收到的写命令都通过write函数追加到命令中,当redis重新启动时会重新执行文件中保存的写命令来在内存中重建这个数据库的内容.这个文件在bin目录下:appendonly.aof,aof不是立即写到硬盘中,可以通过配置文件修改强制写到硬盘中

设置-->appendonly yes //启动aof持久化方式有三种修改方式

你怎么考虑的,这两个redis的方式

1>数据的重要性 提高备份的时间/频率

2>数据的数量 快照不适合 用AOF

 

内存淘汰机制和过期key的处理(高频面试题)

分为四大类

1>LRU

最近最少使用,仅与时间有关

2>LFU

最不经常使用,与频次/时间有关

3>TTL

设置了过期时间的,还没到时间,会提前淘汰掉

4>随机淘汰

全凭天意-->通过maxmemroy-policy可以配置具体的淘汰机制

 完整的

 

五 实际运用

关注一下编程语言排行榜 tiobe

jedis中的基本运用

jedis中的方法就是redis的命令

1>导进springboot的依赖(也可以不用)

导进redis相关依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/>
    </parent>
    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
    </dependencies>

2>在测试包新建测试类  

 

3>写一个普通main方法

1)v1版本(默认连接池)

    public static void main(String[] args) {
            // 默认连接池
            // 1:创建Jedis连接池
            JedisPool pool = new JedisPool("localhost", 6379);
            // 2:从连接池中获取Jedis对象
            Jedis jedis = pool.getResource();
    /* 设置密码
	jedis.auth(密码); */
            // 3:TODO
            System.out.println(jedis);
            // 4:关闭资源
            jedis.close();
            pool.destroy();
    }

需求-->添加:name=gutianle age = 18

1>string类型

public class StringJedisTest {
    public static void main(String[] args) {
        // 默认连接池
        // 1:创建Jedis连接池
        JedisPool pool = new JedisPool("localhost", 6379);
        // 2:从连接池中获取Jedis对象
        Jedis jedis = pool.getResource();
        /* 设置密码
        jedis.auth(密码); */
        // 3:TODO
        // 需求-->添加 name = gutianle  age = 18
        // jedis中方法就是redis的命令
        // String类型
        jedis.set("name","gutianle"); // 设置名字
        jedis.set("age","18");  // 设置年龄 18
        jedis.incr("age"); // 增长年龄 19
        jedis.decr("age"); // 减少年龄 18
        jedis.del("age"); // 删除键值对 null
        jedis.setex("name",5,"pyy");
        // 获取value值
        System.out.println(jedis.get("name"));
        System.out.println(jedis.get("age"));
        // 可以查询出当前的key还剩余多长时间过期
        System.out.println(jedis.ttl("name"));
        // 4:关闭资源
        jedis.close();
        pool.destroy();
    }
}

2>Hash类型

public class HashJedisTest {
    public static void main(String[] args) {
        // 默认连接池
        // 1:创建Jedis连接池
        JedisPool pool = new JedisPool("localhost", 6379);
        // 2:从连接池中获取Jedis对象
        Jedis jedis = pool.getResource();
        /* 设置密码
        jedis.auth(密码); */
        // 3:TODO
        // 需求-->添加 name = gutianle  age = 18
        // jedis中方法就是redis的命令
        // hash类型
        jedis.hset("user2","name","pyy"); // 设置名字
        jedis.hset("user2","age","26"); // 设置年龄
        // 是否存在
        System.out.println(jedis.hexists("user2", "name")); // true
        // 获取value值
        System.out.println(jedis.hvals("user2")); // [26,pyy]
        // 获取集合内所有对象
        System.out.println(jedis.hgetAll("user2")); // {age=26, name=pyy}
        // 获取集合的长度/个数
        System.out.println(jedis.hlen("user2")); // 长度:2
        // 获取key值对应的value值
        System.out.println(jedis.hget("user2", "name")); // pyy
        System.out.println(jedis.hget("user2", "age")); // 26

        // 4:关闭资源
        jedis.close();
        pool.destroy();
    }
}

3>List类型

public class ListJedisTest {
    public static void main(String[] args) {
        // 默认连接池
        // 1:创建Jedis连接池
        JedisPool pool = new JedisPool("localhost", 6379);
        // 2:从连接池中获取Jedis对象
        Jedis jedis = pool.getResource();
        /* 设置密码
        jedis.auth(密码); */
        // 3:TODO
        // 需求-->随意
        // jedis中方法就是redis的命令
        // List类型
        // key值要加list或者写别的名字
        //不然会报堆栈异常 因为缓存里面可能还创过之前的user的String类型
        jedis.rpush("user-list","java");
        jedis.rpush("user-list","C++");
        jedis.rpush("user-list","C#");
        List<String> list = jedis.lrange("user-list", 0, -1);

        // 列出list集合中的元素
        for (String string : list) {
            System.out.println(string);  // 获取存储的value
        }

        // 测试keys *  全局遍历key值
        Set<String> keys = jedis.keys("*");
        Iterator<String> it=keys.iterator() ;
        while(it.hasNext()){
            String key = it.next();
            System.out.println(key);
        }

        // 4:关闭资源
        jedis.close();
        pool.destroy();
    }
}

4>Set类型

public class SetJedisTest {
    public static void main(String[] args) {
        // 默认连接池
        // 1:创建Jedis连接池
        JedisPool pool = new JedisPool("localhost", 6379);
        // 2:从连接池中获取Jedis对象
        Jedis jedis = pool.getResource();
        /* 设置密码
        jedis.auth(密码); */
        // 3:TODO
        // 需求-->随意
        // jedis中方法就是redis的命令
        // List类型
        // key值要加list或者写别的名字
        //不然会报堆栈异常 因为缓存里面可能还创过之前的user的String类型
        jedis.sadd("user-set","man");
        jedis.sadd("user-set","girl");
        jedis.sadd("user-set","null");
        Set<String> smembers = jedis.smembers("user-set");
        // 列出set集合中的元素
        for (String string : smembers) {
            System.out.println("获取的value:" + string);  // 获取存储的value
        }
        System.out.println("-------------");
        // 删除set集合中的元素
        jedis.srem("user-set","null");

        // 列出删除后set集合中的元素
        Set<String> smembers2 = jedis.smembers("user-set");
        for (String string : smembers2) {
            System.out.println("获取的value:" + string);  // 获取存储的value
        }

        System.out.println("----------");
        // 随机弹出集合中的元素
        jedis.spop("user-set",1);

        // 列出随机弹出后set集合中的元素
        Set<String> smembers3 = jedis.smembers("user-set");
        for (String string : smembers3) {
            System.out.println("获取的value:" + string);  // 获取存储的value
        }

        // 返回set集合中的元素个数
        System.out.println(jedis.scard("user-set"));  // 1

        // 4:关闭资源
        jedis.close();
        pool.destroy();
    }
}

5>SortedSet类型

public class SortedSetJedisTest {
    public static void main(String[] args) {
        // 默认连接池
        // 1:创建Jedis连接池
        JedisPool pool = new JedisPool("localhost", 6379);
        // 2:从连接池中获取Jedis对象
        Jedis jedis = pool.getResource();
        /* 设置密码
        jedis.auth(密码); */
        // 3:TODO
        // 需求-->随意
        // jedis中方法就是redis的命令
        // Sorted类型 有序 唯一
        //不然会报堆栈异常 因为缓存里面可能还创过之前的user的String类型
        // String key, double score, String member
        jedis.zadd("user-sorted",2000,"A");
        jedis.zadd("user-sorted",1500,"B");
        jedis.zadd("user-sorted",3000,"C");
        System.out.println(jedis.zrangeByScore("user-sorted", 1, 100000));

        // 升序排列打印出对应的member值
        System.out.println(jedis.zrange("user-sorted", 0, -1)); // [B, A, C]

        // 降序排列打印出来对应的member值
        System.out.println(jedis.zrevrange("user-sorted", 0, -1)); // [C, A, B]
        
        // 4:关闭资源
        jedis.close();
        pool.destroy();
    }
}

2)v2版本(定制连接池)

public static void main2(String[] args) {
        // 定制连接池
        GenericObjectPoolConfig config = new GenericObjectPoolConfig();
        最大连接数, 默认8个
        config.setMaxTotal(100);
        最大空闲连接数, 默认8个
        config.setMaxIdle(20);
        //获取连接时的最大等待毫秒数(如果设置为阻塞时BlockWhenExhausted),如果超时就抛异常, 小于零:阻塞不确定的时间,  默认-1
        config.setMaxWaitMillis(-1);
        //在获取连接的时候检查有效性, 默认false
        config.setTestOnBorrow(true);
        JedisPool pool = new JedisPool(config,"192.168.122.128",6379,5000,"wolfcode");
        Jedis j = pool.getResource();
        String name = j.get("name");
        System.out.println(name);
        j.close();
        pool.close();
        pool.destroy();
    }

集成SpringBoot

1>导入依赖

2>配置application.properties

3>设置启动类 App新建测试类

RedisTest(记得贴SpringBootTest注解)

springboot-redis的方法就是redis的命令全称

1>Stirng类型

@SpringBootTest
public class StringRedisTest {
    @Autowired
    // kv都是String类型
    // redis存数据是list集合  指定list集合中的元素
    private StringRedisTemplate template;
    @Test
    public void testRedis(){
        // springboot-redis方法就是redis命令的全称
        // 需求-->随意
        // opsForValue 工具类
        template.opsForValue().set("nameString","gutianle");
        template.opsForValue().set("ageString","18");
        System.out.println(template.opsForValue().get("nameString"));

        // 递增  递减改为-值
        System.out.println(template.opsForValue().increment("ageString", 1)); // 19

        // 将 key 的值设为 value ，当且仅当 key 不存在  t不存在  f 存在
        System.out.println(template.opsForValue().setIfAbsent("nameString2", "pyy")); // true

        // key存在设置新值，并返回旧值
        System.out.println(template.opsForValue().getAndSet("ageString", "26"));  // 19

        // 获取修改以后的ageString的value
        System.out.println(template.opsForValue().get("ageString")); // 26
    }
}

2>Hash类型

@SpringBootTest
public class HashRedisTest {
    @Autowired
    // kv都是String类型
    // redis存数据是list集合  指定list集合中的元素
    // private RedisTemplate<key,value>template;
    private StringRedisTemplate template;
    @Test
    public void hashTestRedis(){
        // 需求-->存name='gutianle'
        // opsForValue 工具类
        // 往hash集合存入k-v
        // springboot-redis方法就是redis命令的全称
        template.opsForHash().put("user-hash","name","zzl");
        template.opsForHash().put("user-hash","age","26");

        // 往hash集合获取value值
        System.out.println(template.opsForHash().get("user-hash", "name"));

        // 获取hash集合对应的所有k-v值
        System.out.println(template.opsForHash().entries("user-hash")); // {name=zzl, age=26}

        // 判断是否存在key值
        System.out.println(template.opsForHash().hasKey("user-hash", "name")); // true

        // hash递增 如果不存在,就会创建一个 并把新增后的值返回
        // 递减 将最后的delta值改为负数
        System.out.println(template.opsForHash().increment("user-hash", "age", 1)); // 27
    }
}

3>List类型

@SpringBootTest
public class ListRedisTest {
    @Autowired
    // kv都是String类型
    // redis存数据是list集合  指定list集合中的元素
    private StringRedisTemplate template;
    @Test
    public void testRedis(){
        // springboot-redis方法就是redis命令的全称
        // 需求-->随意
        // opsForXxxx 工具类
        // 队列右存入数据  有序不唯一
//        template.opsForList().rightPush("myList", "money"); //操作list
//        template.opsForList().rightPush("myList", "phone");
//        template.opsForList().rightPush("myList", "computer");

        // 获取内容
        System.out.println(template.opsForList().range("myList", 0, -1)); //[money, phone, computer]

        // 获取长度
        System.out.println(template.opsForList().size("myList"));

        // 根据索引获取对应的value值
        System.out.println(template.opsForList().index("myList", 2)); //computer

        // 根据索引修改某条数据
        template.opsForList().set("myList", 3, "telephone");

        // 获取修改以后的内容
        System.out.println(template.opsForList().range("myList", 0, -1));
        // [money, phone, computer, telephone, phone, computer]
    }
}

4>Set类型

@SpringBootTest
public class SetRedisTest {
    @Autowired
    // kv都是String类型
    // redis存数据是list集合  指定list集合中的元素
    private StringRedisTemplate template;
    @Test
    public void testRedis(){
        // set集合 无序唯一
        // 需求-->随意
        // opsForXxxx 工具类
        // 存入kv
        template.opsForSet().add("setList","pyy","gtl","gaga","ldy");  //操作set
        template.opsForSet().add("setList2","pyy","gtl2","gaga2","ldy");  //操作set
        template.opsForSet().remove("setList2", "pyy2","ldy2");  // 移除value
        // 根据value从一个set中查询,是否存在
        System.out.println(template.opsForSet().isMember("setList", "ldy")); // T

        // 根据key获取Set中的所有值
        System.out.println(template.opsForSet().members("setList")); // [pyy, ldy, gtl, gaga]
        System.out.println(template.opsForSet().members("setList2")); // [ldy, pyy, gaga2, gtl2]
        System.out.println("------------");

        //  返回key1中特有元素(差集)
        System.out.println(template.opsForSet().difference("setList", "setList2")); //[gaga, gtl]
        System.out.println(template.opsForSet().difference("setList2", "setList")); //[gaga2, gtl2]

        //  返回两个set集合的交集-->去重
        System.out.println(template.opsForSet().intersect("setList", "setList2")); //[pyy, ldy]

        // 返回两个set集合的并集
        System.out.println(template.opsForSet().union("setList", "setList2"));
        // [pyy, ldy, gaga2, gtl2, gtl, gaga]
    }
}

小趴菜的进阶之路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis 6.0 windows 版本
02-15
Redis是一款高性能的键值存储系统，常用于数据库、缓存和消息代理等场景。它支持丰富的数据类型，如字符串、哈希、列表、集合和有序集合。在Windows平台上使用Redis，通常需要通过编译源码或者寻找预编译的二进制...
Redis入门-开启了解使用redis的大门
kentlhxy的博客
05-27 234
Redis入门   1.了解数据库分类 2.Redis简介   2.1 什么是redis?   2.2 Redis优缺点   2.3 redis-memcache与redis有什么区别? 3.Redis数量类型指令   3.1 String类型   3.2 hash类型   3.2 list类型   3.3 set类型   3.4 zset类型 4.redis进阶-高级命令 5.redis持久化机制 6.redis内存淘汰机制以及过去key处理 7.Java redis应用   7.1jedis
redis简单入门
wu上岗码农
04-24 838
文章目录Redis：redis 简介：什么是redis：redis的优势：相关网站：下载安装：常用的数据类型：String类型 ：应用的场景：相关常用命令：其他：Hash类型：应用的场景：相关常用命令：其他：List类型：应用场景：相关常用命令：其他：set类型：应用场景：相关常用命令：其他：sorted_set 类型：应用场景：相关常用命令：其他：数据类型使用总结：redis进阶：redis高级命令：redis安全性：redis事务：redis持久化机制：reids内存淘汰机制以及过期key的处理： Re
Redis-5.0.12
07-02
Redis-5.0.12
redis7.2.3-windows
11-15
Redis是一款开源、高性能的键值对存储系统，常被用作数据库、缓存和消息中间件。在Windows环境下安装和使用Redis可能与在Linux等操作系统上有所不同，但其核心概念和功能保持一致。这里我们将详细探讨Redis 7.2.3在...
Redis5.0 Windows64
08-26
Redis 5.0是Redis数据库的一个重要版本，它在Windows 64位平台上提供了全面的支持。Redis是一款开源的、基于键值对的数据存储系统，常用于缓存、数据库和消息中间件等场景。以下是关于Redis 5.0在Windows 64位环境中...
linux离线安装redis
01-20
在Linux环境中离线安装Redis是常见的需求，尤其是在内网服务器上，由于无法直接访问公网，我们需要提前下载Redis的源码包并手动安装。下面将详细解释如何进行这一过程。 首先，你需要从Redis官方网站获取Redis的...
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 466
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 5411
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 5614
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
操作系统原子操作
zzt_is_me的博客
08-28 3567
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 2241
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 2947
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 459
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
死锁及其产生条件
秋夫人
08-26 1619
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
JVM 内存参数
iOS逆向与安全
08-29 823
它屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在各种平台上不加修改的运行。‌例如，‌可以将最小堆内存设置为2GB（‌-Xms2048m）‌，‌最大堆内存设置为4GB（‌-Xmx4096m）‌。如果初始化的高水位线设置过低，会频繁的触发Full GC，高水位线会被多次调整。一般来说，垃圾回收器都会有默认的对象晋升到老年代的年龄参数阈值，CMS默认是6，G1默认是15，不过这参数值也不是一成不变的，它会根据动态年龄判断规则来重新被赋值。
SpringBoot SSM vue在线作业考试系统
最新发布
yinjl123456的博客
08-30 159
使用技术: SpringBoot或SSM + Mybaits + Mysql + vue(前端)后台管理 登录注册 个人中心 教师信息管理 学生信息管理 学院信息管理 专业信息管理。班级信息管理 作业信息管理 作业提交管理 通知公告管理 试卷管理 试题管理。系统管理 管理员管理 考试管理。
Java并发编程 进程与线程
m0_56369671的博客
08-28 818
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的。但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms 注：需要在多核 cpu 才能提高效率，单核仍然时是轮流执行。
Java面试宝典-java基础02
杜盟恩的博客
08-27 1371
机器语言是一种指令集的体系，是最早出现的计算机语言。机器语言从属于硬件设备。不同的计算机设备有不同的机器语言．所以机器语言是一种面向机器的语言。计算机指令系统中的指令是由“0”和“1”两种符号组成的代码，并且能被机器直接理解执行，它们被称为机器指令。一个计算机的机器指令的集，就构成了该计算机的机器语言，即计算机可以直接接受、理解的语言。机器语言能利用机器指令精准地描述算法、且编程质量高、所占存储空间小，执行速度快。但是这种程序直观性很差，容易出错，阅读检查和修改调试非常困难。
Redis 6.2.4 安装教程
3. **配置文件备份与修改**：Redis的默认配置文件是`redis.conf`，可以使用`cp`命令备份原有配置，如`cp /usr/local/redis/redis-6.2.4/redis.conf /usr/local/redis/redis-6.2.4/redis.bak.conf`。接着，编辑配置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值