标签：return value jedis param key redisTemplate
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;
}
}
}
标签：return,value,jedis,param,key,redisTemplate 来源： https://blog.csdn.net/TYM112/article/details/117234666
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。