Redis缓存

Love The Way You Lie 2022-02-14 00:35 292阅读 0赞

redis是Key-value形式的nosql数据库。先存到内存中，会根据一定的策略持久化到磁盘，即使断电也不会丢失数据。支持的数据类型比较多。  
主要用来做缓存数据库的数据和web集群中当转中央缓存存放session  
**缓存**：把经常需要查询很少修改的数据，放到读速很快的空间（内存），以便下次访问减少时间，减轻压力，减少访问时间。  
**计数器：**  
redis中的计数器是原子性的内存操作。  
可以解决库存溢出的问题，进销存系统库存溢出。  
session缓存服务器  
web集群时作为session缓存服务器。缓存队列等。  
**redis对象保存方式**  
JSON字符串：  
需要把对象转换为JSON字符串，当做字符串处理直接使用set get 设置或者获取。  
优势：操作简单，设置和获取比较简单  
缺点：没有提供专门的方法，需要把对象转换为json（jsonlib）  
字节：  
需要做序列号。就是把对象序列化为字节保存。  
如果担心JSON转对象会消耗资源的情况这个问题需要考量几个地方  
1、就是使用的JSON转换lib是否就会存在性能问题。  
2、就是数据的数据量级别，如果是存储百万级的大数据对象，建议采用存储序列化对象方式，如果是少量的数据级对象，或者是数据对象字段不多，还是建议才赢JSON转换完成String方式。毕竟Redis对存储字符类型这部分优化的非常好，具体采用方式与方法，还要看所使用的场景。  
**Redis的数据淘汰机制**  
在Redis中，允许用户设置最大使用内存大小server.maxmemory,在内存限定的情况下是很有用的。比如在一台8G机子上部署4个Redis服务点，每一个服务点分配1.5G的内存大小，减少内存紧张的情况，由此获取更为稳健的服务。

**由于内存大小有限，需要保存有效的数据。**  
Redis内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略，Redis提供了6种数据淘汰策略  
volatile-lru:从已设置过期时间的数据集（server.db\[i\].expires）中挑选最近最少使用的数据淘汰；  
volatile-ttl:从已设置过期时间的数据集（server.db\[i\].expires）中挑选将要过期的数据淘汰。  
volatile-random:从已设置过期时间的数据集（server.db\[i\].expires）中任意选择数据淘汰  
**allkeys-lru:从数据集（server.db\[i\].expires）中挑选最近最少使用的数据淘汰(使用最多)**  
alljeys-random:从数据集（server.db\[i\].expires）中任意选择淘汰数据  
no-enviction(驱逐):禁止驱逐数据  
**Java访问Redis和Redis集群**  
使用jedisJava客户端访问Redis服务器有点类似通过jdbc访问MySQL一样  
当然如果是spring进行集成时可以使用spring data来访问Redis，spring data只是对jedis的二次封装，jdbcTemplate jdbc关系一样  
Redis集群：当一台数据无法满足要求，可以使用Redis集群来处理类似于mysql的读写分离。

安装完毕打开redis安装目录  
需要修改密码择打开安装目录文件，查找requirepass foobared  
启动bat 使用Redis可视化工具打开 连接  
数据库名称。连接地址 端口6379 密码等填写完毕 点击OK  
基本数据的添加、获取、删除使用方式  
@org.junit.Test  
public void test() \{  
//连接Redis  
Jedis jedis = new Jedis(“127.0.0.1”,6379);  
jedis.auth(“admin”);  
System.out.println(“连接成功!!!”+jedis.ping());  
//获取单个值  
System.out.println(jedis.get(“name”));  
//获取集合数据  
List list = jedis.lrange(“list”, 0, -1);  
System.out.println(list);  
//选择db区间  
jedis.select(1);  
//添加缓存  
jedis.set(“rowname”, “你好”);  
//添加无序map缓存  
Map<String,String> m = new HashMap<String,String>();  
m.put(“key0”, “0”);  
m.put(“key1”, “1”);  
m.put(“key2”, “2”);  
jedis.hmset(“hei”,m);  
//添加无序集合  
jedis.sadd(“add”, “redis”,“mysql”);  
//获取无序缓存  
System.out.println(“获取集合：”+jedis.smembers(“add”));  
//添加有序集合  
jedis.zadd(“list2”, 1, “w”);  
jedis.zadd(“list2”, 2, “d”);  
jedis.zadd(“list2”, 3, “a”);  
System.out.println(jedis.get(“name”));  
m.clear();  
//获取map集合  
m = jedis.hgetAll(“hei”);  
System.out.println(m.get(“key0”));  
//获取有序集合  
System.out.println(jedis.zrange(“list2”, 0, -1));  
//删除该数据  
jedis.del(“rowname”);  
\}

操作String  
Jedis jedis = jedisPool.getResource();  
//操作String  
//添加一条数据  
jedis.set(“name”,“king james”);  
//根据key找到对应的value的值  
jedis.get(“name”);  
//再次设置:对一个key多次赋值的话，key对应的值是最后一次赋值的值，之前的被覆盖。  
jedis.set(“name”,“kobe bryant”);  
//字符串拼接  
jedis.append(“name”," is my love");  
//删除某个键  
jedis.del(“name”);  
//同时设置多个键值对:获取值的方式同上  
jedis.mset(“name”,“king james”,“age”,“33”,“country”,“American”);  
//假如值里面有数字(字符串形式)，可以进行+1的操作  
jedis.incr(“age”);//age的值变成34  
//进行-1的操作  
jedis.decr(“age”);  
//某个值增加多少：这里是+20  
jedis.incrBy(“age”,20);  
//某个值减少多少：这里是-20  
jedis.decrBy(“age”,20);  
//判断是否存在某个key  
jedis.exists(“name”);  
//设置值的时间:存在5s  
jedis.setex(“name”,5,“king james”);  
//查询值的存活时间:当 key不存在时,返回 -2,当key存在但没有设置剩余生存时间时,返回-1,否则,以秒为单位,返回key的剩余生存时间。  
Long ttl = jedis.ttl(“name”);  
//去掉key的时间设置：不再有失效时间  
jedis.persist(“name”);  
操作List  
//操作List集合  
//保存数据:lpush–>left push  
jedis.lpush(“users”,“king james”);  
jedis.lpush(“users”,“kobe bryant”);  
jedis.lpush(“users”,“stephen curry”);  
jedis.lpush(“users”,“Kevin Durant”);  
//查询：第一个值是key，第二个值表示从0开始，第三个值表示结束(-1表示取全部)  
//userListA当中的值排列情况：\[“Kevin Durant”,“stephen curry”,“kobe bryant”,“king james”\]  
List userListA = jedis.lrange(“users”, 0, -1);  
//保存数据:rpush–>right push  
jedis.rpush(“users”,“Wilt Chamberlain”);  
jedis.rpush(“users”,“John Smith”);  
jedis.rpush(“users”,“Karl Malone”);  
//查询：第一个值是key，第二个值表示从0开始，第三个值表示结束(-1表示取全部)  
//userListB当中值排列情况：\[“Kevin Durant”,“stephen curry”,“kobe bryant”,“king james”,“Wilt Chamberlain”,“John Smith”,“Karl Malone”\]  
List userListB = jedis.lrange(“users”, 0, -1);  
//移除并返回列表key的头元素：lpop–>left pop  
String nameA = jedis.lpop(“users”);//Kevin Durant  
//移除并返回列表key的尾元素：rpop–>right pop  
String nameB = jedis.rpop(“users”);//Karl Malone  
//删除key  
jedis.del(“users”);  
//给特定位置赋值  
jedis.lset(“users”, 1, “Yao Ming”);  
//查询特定位置的值：idnex从0开始  
jedis.lindex(“users”,1);  
//对list进行裁剪：只保留下标1-3的值，其他的全部删除，下标从0开始  
jedis.ltrim(“users”, 1, 3);  
//返回list的长度  
jedis.llen(“users”);  
//根据参数count的值,移除列表中与参数value相等的元素。  
//count > 0 : 从表头开始向表尾搜索，移除与 value 相等的元素，数量为 count 。  
//count < 0 : 从表尾开始向表头搜索，移除与 value 相等的元素，数量为 count 的绝对值。  
//count = 0 : 移除表中所有与 value 相等的值。  
jedis.lrem(“users”,2,“king james”);  
/\*\*

*  (“key”,“LIST\_POSITION”,“pivot”,“value”)
 *  LINSERT key BEFORE|AFTER pivot value
 *  将值 value 插入到列表 key 当中，位于值 pivot 之前或之后。
 *  当 pivot 不存在于列表 key 时，不执行任何操作。
 *  当 key 不存在时， key 被视为空列表，不执行任何操作。
 *  如果 key 不是列表类型，返回一个错误。  
    */  
    jedis.linsert(“users”, BinaryClient.LIST\_POSITION.AFTER,“Yao Ming”,“AAAA”);  
    //从users的右边弹出一个元素，把该元素左插入到players列表当中  
    jedis.rpoplpush(“users”,“players”);  
    操作Set集合：和List不同，元素是无序的，因此也不能够重复  
    //操作Set集合:和列表不同，集合中的元素是无序的，因此元素也不能重复。  
    jedis.sadd(“users”,“king james”);  
    jedis.sadd(“users”,“kobe bryant”);  
    jedis.sadd(“users”,“stephen curry”);  
    jedis.sadd(“users”,“Kevin Durant”);  
    //查询users里面的所有数据  
    Set users = jedis.smembers(“users”);  
    //移除users当中的某个元素  
    jedis.srem(“users”, “Kevin Durant”);  
    //获取users当中的元素个数  
    Long size = jedis.scard(“users”);  
    //随机移除users当中的一个元素  
    jedis.spop(“users”);  
    //返回users里面的一个随机元素  
    jedis.srandmember(“users”);  
    /*\*
 *  从users当中返回一个长度为3的随机数组。
 *  当数字大于0时，list里面元素都不相同，小于0时，元素可能相同，长度为count的绝对值  
    */  
    List list = jedis.srandmember(“users”,3);  
    //判断users里面是否含有某个元素  
    Boolean isMember = jedis.sismember(“users”, “king james”);  
    //批量插入数据  
    jedis.sadd(“players”, “Yao Ming”, “Wilt Chamberlain”,“Karl Malone”);  
    //交集  
    Set sinter = jedis.sinter(“users”,“players”);  
    //差集  
    Set sdiff = jedis.sdiff(“users”,“players”);  
    //并集  
    Set sunion = jedis.sunion(“users”, “players”);  
    //把users当中的king james 移动到players当中  
    jedis.smove(“users”,“players”,“king james”);  
    操作Sorted Set:有序的Set集合  
    //操作有序Set  
    //新增：根据“第二个参数（score）”进行排序。  
    jedis.zadd(“users”,10,“king james”);  
    //元素相同时，更新为当前的排序数  
    jedis.zadd(“users”,20,“king james”);  
    //查询users里面的所有元素  
    Set usersA = jedis.zrange(“users”, 0, -1);  
    //查询当前set集合的元素个数  
    jedis.zcard(“users”);  
    //返回users集合里面，score 值在min和max之间（包括）元素个数  
    jedis.zcount(“users”,10,20);  
    //移除users中的一个或多个成员，不存在的成员将被忽略。  
    jedis.zrem(“users”,“king james”);  
    //移除users当中第0到第1之间的元素（包含），也可以是负数：以 -1 表示最后一个成员， -2 表示倒数第二个成员  
    jedis.zremrangeByRank(“users”,0,3);  
    //移除users当中score值在min和max之间（包括）元素  
    jedis.zremrangeByScore(“users”,10,20);  
    //返回某个元素的score值  
    jedis.zscore(“users”, “king james”);  
    //返回有序集users中，所有score值介于min和max之间(包括)的元素  
    jedis.zrangeByScore(“users”,10,20);  
    //返回元素king james在users当中的序号，排第一位0  
    long rank = jedis.zrank(“users”,“king james”);  
    操作HashMap  
    //操作HashMap  
    Map<String,String> map = Maps.newHashMap();  
    map.put(“Cleveland Cavaliers”,“King James”);  
    map.put(“Los Angeles”,“Kobe Bryant”);  
    map.put(“Memphis Grizzlies”,“Mike Conley”);  
    map.put(“Miami Heat”,“Goran Dragic”);  
    map.put(“Golden State Warriors”,“Stephen Curry”);  
    //设置值  
    jedis.hmset(“NBA”,map);  
    //根据map当中的key，去查询key对应的value  
    List MVP = jedis.hmget(“NBA”, “Los Angeles”, “Cleveland Cavaliers”);  
    //删除某个key对应的value  
    jedis.hdel(“NBA”,“Miami Heat”);  
    //返回NBA当中map的键值对的数量  
    jedis.hlen(“NBA”);  
    //是否存在NBA这个key  
    jedis.exists(“NBA”);  
    //返回NBA当中map的所有的key  
    Set teams = jedis.hkeys(“NBA”);  
    //返回NBA当中所有的key对应value的值  
    List players = jedis.hvals(“NBA”);  
    //返回NBA当中对应的map的值  
    Map<String, String> map1 = jedis.hgetAll(“NBA”);  
    其他的一些通用操作  
    //通用操作  
    //删除  
    jedis.del(“NBA”);  
    //存在检测  
    jedis.exists(“NBA”);  
    //设置key的过期时间，单位为秒  
    jedis.expire(“NBA”,600);  
    //设置key在那个时间点过期  
    jedis.expireAt(“NBA”,System.currentTimeMillis()+30*1000);  
    //获取redis当中的所有的key值  
    Set keys = jedis.keys("\*");  
    //当前数据库的key移动到给定的数据库db当中。  
    jedis.move(“NBA”, 1);  
    //移除给定key的生存时间  
    jedis.persist(“NBA”);  
    //以毫秒为单位返回 key 的剩余生存时间  
    jedis.pttl(“NBA”);  
    //以秒为单位返回 key 的剩余生存时间  
    jedis.ttl(“NBA”);  
    //从当前数据库中随机返回(不删除)一个 key  
    jedis.randomKey();  
    //将 key 改名为 newkey  
    jedis.rename(“NBA”, “CBA”);  
    //当且仅当 newkey 不存在时，将 key 改名为 newkey  
    jedis.renamenx(“NBA”, “CBA”);  
    //返回 key 所储存的值的类型  
    jedis.type(“NBA”);  
    连接操作相关的命令  
    quit：关闭连接（connection）  
    auth：简单密码认证  
    持久化  
    save：将数据同步保存到磁盘  
    bgsave：将数据异步保存到磁盘  
    lastsave：返回上次成功将数据保存到磁盘的Unix时戳  
    shundown：将数据同步保存到磁盘，然后关闭服务  
    远程服务控制  
    info：提供服务器的信息和统计  
    monitor：实时转储收到的请求  
    slaveof：改变复制策略设置  
    config：在运行时配置Redis服务器