Hyperloglog
什么是基数？一组数据中不重复的个数
A（1,3,5,7,8,7）B（1,3,5,7,8）
基数 = 5
312312
简介
redis2.8.9更新了hyperloglog数据结构！
redis Hyperloglog基数统计算法！
优点：占用的内存是固定的，2^64不同的元素的技术，只需要费12KB的内存！如果要从内存的角度来比较 Hyperloglog是首选
注意：0.81%的错误率！统计UV任务，可以忽略不计
如果允许，就一定可以使用HYperloglog
如果不允许，则使用set或自己的数据类型
测试使用
127.0.0.1：6379>PDadd mykey a b c d e f g h i j # 创建一组数据
127.0.0.1：6379>PDCOUNT mykey # 统计mykey元素的基数数量
127.0.0.1：6379>PDMEGE mykey mykey1 …… # 合并，获取并集
Bitmaps
位存储
状态：0 1 0 0 1 0 …… 根据状态判断（两个状态可以使用【统计用户活跃，登录，打卡都可以使用】）
Bitmaps用二进制来记录，只有0和1的状态
365天 = 365bit 1字节 = 8bit 46个字节左右
测试使用
127.0.0.1：6379> setbit sign 1 0 # 星期一没有打卡
127.0.0.1：6379> setbit sign 2 1 # 星期二打卡了
…………
127.0.0.1：6379> getbit sign 1 0 # 查看星期一是否打卡
（interger）0
127.0.0.1：6379> bitcount sign # 统计这周打卡情况
（interger）1
Redis事务
事务的本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程中，会按照顺序执行（一次性，顺序性，排他性）
注意：Redis单条命令式保存原子性，但是事务不保存原子性（要么同时执行，要么同时失败），且Reids没有隔离级别的概念，在事务中并没有执行，只有执行命令启动时才执行
步骤：1. 开启事务（multi） 2.命令入队（） 3. 执行命令（exec）
测试使用
127.0.0.1：6379> multi # 开启事务
OK
# 命令入队
127.0.0.1：6379> SET K1 V1
QUEUED
127.0.0.1：6379> SET K2 V2
QUEUED
127.0.0.1：6379> GET K1
QUEUED
127.0.0.1：6379> EXEC #执行事务
1）OK
2）OK
3）"v1"
# 执行完事务后，事务就结束了，必须重新开启事务
# 放弃事务
127.0.0.1：6379> DISCARD
# 编译型异常（代码有问题！命令有错！），事务中所有命令不会执行
127.0.0.1：6379> getset k3 # 错误命令
（error）ERR wrong number of arguments for 'getset' command
127.0.0.1：6379> exec # 执行事务错误
（error）EXECABORT Transaction discarded bacause of previous errors.
# 运行时异常（1/0），如果事务队列中存在语法问题，那么执行命令的时候，其他命令是可以正常执行的，错误命令抛出问题
127.0.0.1：6379> set k1 "y1"
127.0.0.1：6379> multi
127.0.0.1：6379> incr k1 # 字符串不能加一
127.0.0.1：6379> set k2 "y2"
127.0.0.1：6379> exec
1）（error）ERR value is not an Interger or out of range
2）OK
监控
悲观锁：
很悲观，认为什么时候都会出问题，无论做什么都会加锁
乐观锁：
很乐观，认为什么时候都不会出问题，所有不会上锁！更新数据的时候去判断一下在此期间是否有人修改过这个数据
获取version（数据库使用的），更新时比较version
代码测试
# 测试成功
127.0.0.1：6379> set money 100
OK
127.0.0.1：6379> set out 20
OK
127.0.0.1：6379> watch money # 监视money对象
OK
127.0.0.1：6379> multi # 开始事务
OK
127.0.0.1：6379> DECRBY money 20
QUEUED
127.0.0.1：6379> INCRBY out 20
QUEUED
127.0.0.1：6379> exec
1）（interger）80
2）（interger）20
# 如果打开了多个线程，在该线程未提交时进行了更新，则会导致事务执行失败
127.0.0.1：6379> exec
（nil） # 结束事务失败
127.0.0.1：6379> unwatch # 放弃监视（可以在放弃监视之后再打开监视进行）
jedis
jedis是Redis官方推荐的java连接工具！使用java操作Redis中间件！
代码测试
- 导入jar包
<dependencies>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.2.0</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.68</version>
</dependency>
</dependencies>
-
编码测试
-
连接数据库
//首页要打开redis服务 public static void main(String[] args) { Jedis jedis = new Jedis("127.0.0.1", 6379); //Jedis中有redis的所有命令 } -
操作命令
//测试是否ping通 PONG代表通了 System.out.println("jedis = " + jedis.ping()); //来选择对应的数据库 jedis.select(N) //清空数据 System.out.println(jedis.flushDB()); //判断某个键是否存在 返回boolean System.out.println(jedis.exists("name")); //新增键值对 System.out.println(jedis.set("name1","n1")); System.out.println(jedis.set("name2","n2")); //查询系统中所有的jian Set<String> keys = jedis.keys("*"); System.out.println("keys = " + keys); //删除键 System.out.println(jedis.del("name1")); //查看键存储的类型 System.out.println(jedis.type("name2")); //随机返回一个键 System.out.println(jedis.randomKey()); //重命名key System.out.println(jedis.rename("name2","n2")); //按索引查询 System.out.println(jedis.select(0)); //返回当前数据库中键的数量 System.out.println(jedis.dbSize()); //删除当前数据库中所有的键 System.out.println(jedis.flushAll()); //list //添加一个list System.out.println("--------------------- list -----------------------"); jedis.lpush("clist","MAP","LIST","ARRAYLIST","HASHMAP"); jedis.lpush("clist","LINKEDLIST"); //获取区间的list 0 -- -1是查询所有 System.out.println(jedis.lrange("clist",0,-1)); //删除列表中指定的值，第二个参数为删除的个数（有重复性），后新增的值先删除，类似于出栈 System.out.println(jedis.lrem("clist",2,"HASHMAP")); //删除指定区间外的值 System.out.println(jedis.ltrim("clist",0,3)); //获取集合最左端的值 System.out.println("lpop："+jedis.lpop("clist")); //获取集合最右端的值 System.out.println("rpop："+jedis.rpop("clist")); //修改指定下标的值 System.out.println(jedis.lset("clist",0,"大魔王")); //获取集合的长度 System.out.println(jedis.llen("clist")); //获取指定下标的元素 System.out.println(jedis.lindex("clist",0)); //将集合进行排序 //jedis.lpush("list","2000","20","10","1","3"); System.out.println("排序前："+jedis.lrange("list",0,-1)); System.out.println(jedis.sort("list")); System.out.println("排序后："+jedis.lrange("list",0,-1)); //------------ SET ------------ //创建一个set System.out.println(jedis.sadd("eset","e1","e2","e3")); //查询所有set元素 System.out.println(jedis.smembers("eset")); //删除一个元素 System.out.println(jedis.srem("eset","e1")); //随机移除一个元素 System.out.println(jedis.spop("eset")); //查询set中包含的个数 System.out.println(jedis.scard("eset")); //判断值是否在set中存在 System.out.println(jedis.sismember("eset","e2")); //将e3在eset中删除存入eset01 System.out.println(jedis.smove("eset","eset01","e3")); //计算交集 System.out.println(jedis.sinter("eset","eset01")); //计算并集 System.out.println(jedis.sunion("eset","eset01")); //计算差集 System.out.println(jedis.sdiff("eset","eset01")); //计算交集，并且把并集存入e2 System.out.println(jedis.sinterstore("e2","eset","eset01")); //---------- 事务 ---------------- //开启事务 Transaction multi = jedis.multi(); //命令入队 multi.set("u1","u1"); //执行事务
-
multi.exec();
```
-
断开连接
jedis.close();
SpringBoot集成Redis
springboot操作数据的：springdata，jpa，jdbc，mongodb，redis
说明：在springboot2.x之后，原来使用的jedis被替换成了lettuce？
jedis：采用直连，多个线程操作的话，是不安全的，如果想要避免不安全，使用jedis pool连接池！更像BIO模式
lettuce：采用netty，实例可以在多个线程中进行共享，不存在线程不安全的情况！，可以减少线程数据了，更像NIO模式
springboot项目中都会有一个自动配置类
步骤：
然后找到 autoconfig
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w3yhxBxP-1621867446407)(C:\Users\8888\AppData\Roaming\Typora\typora-user-images\image-20201103172735791.png)]
最后在spring.factories中查找
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5PqPI91t-1621867446410)(C:\Users\8888\AppData\Roaming\Typora\typora-user-images\image-20201103164556506.png[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6gacdmFw-1621867447222)(C:\Users\8888\AppData\Roaming\Typora\typora-user-images\image-20201103172726414.png)]]
例：org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
测试代码
//依赖jar包
<!-- 操作Redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<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>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
//application.properties
spring.redis.host: 127.0.0.1
spring.redis.port: 6379
//yml
spring:
redis:
host: 127.0.0.1
port: 6379
//Test
@Autowired
private RedisTemplate redisTemplate;
/**
* redisTemplate 操作不同的数据类型，api和指令是一样的
* opsForValue 操作字符串，类似string
* opsForList 操作List，类似List
* opsforset
* opsforhash
* opsforzset
* opsforgeo
* opsforgyperloglog
*
* 除了基本的操作，常用的方法都可以直接进行操作，比如事务等，基本的crud（增删改查）
*
* 获取连接对象
* redisTemplate.getConnectionFactory().getConnection()
* flushAll() flushDB() CLOSE()
*/
RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
ValueOperations valueOperations = redisTemplate.opsForValue();
//尽量不要写中文，虽然控制台会返回中文，但是redis数据库会进行转义
valueOperations.set("mykey","哈哈哈");
System.out.println(valueOperations.get("mykey"));
在RedisTemplate<K, V> 类中
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zy5GWtbk-1621867446421)(C:\Users\8888\AppData\Roaming\Typora\typora-user-images\image-20201103180437622.png)]
//设置序列化
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory)
throws UnknownHostException {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
//配置序列化方式
//设置json类型的序列化对象
Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
objectJackson2JsonRedisSerializer.setObjectMapper(om);
//设置string类型序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用string的序列化
template.setKeySerializer(stringRedisSerializer);
//hash的key采用string的序列化
template.setHashKeySerializer(stringRedisSerializer);
//value 序列化采用jackson
template.setKeySerializer(objectJackson2JsonRedisSerializer);
//hash的value采用string的序列化
template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
// redis工具类
package com.util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
@Component
public final class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
// =============================common============================
/**
* 指定缓存失效时间
* @param key 键
* @param time 时间(秒)
*/
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 delta 要增加几(大于0)
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
* @param key 键
* @param delta 要减少几(小于0)
*/
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
*/
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 对应多个键值
*/
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)
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
* @param key 键
*/
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 键
*/
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代表所有值
*/
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 键
*/
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倒数第二个元素，依次类推
*/
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 值
*/
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 时间(秒)
*/
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 值
* @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;
}
}
}
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;
}
}
}