目录
1. 相关链接
官网：https://redis.io/
中文网：http://www.redis.cn/
2. 安装
2.1 在Linux下安装
1、去官网下载安装包
2、下载完安装包后通过Xftp传输到Linux，我是传输到了虚拟机的/opt文件夹
3、通过 tar -zxvf 指令解压压缩包
4、进入解压后的文件，可以看到redis的配置文件
5、基本的环境安装
- gcc环境安装
yum install gcc-c++ - make命令
make - 确认安装好的内容
make install
6、redis（上述安装的）默认的安装路径为 /usr/local/bin 下
7、在当前文件夹下创建 myconfig文件夹，将redis的配置文件复制到这个文件夹下
8、默认不是后台启动的，通过vim redis.conf 修改配置文件
9、启动redis服务
在/user/local/bin目录下启动服务端和客户端
10、使用cli进行连接测试（基本操作）：
11、在另一个窗口查看redis的进程是否开启
ps -ef | grep redis
12、关闭redis服务
再次查看进程，发现已关闭。
3. redis-benchmark性能测试
redis-benchmark + 命令参数
简单测试一下：
# 测试：100个并发连接 100000请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000
部分分析：
4. Redis基础知识
Redis默认有16个数据库，默认使用第0个。
命令总结：
redis默认没有密码
config get requirepass # 查看密码
config set requirepass 123456 # 设置密码
config set requirepass "" # 取消密码
auth 123456 # 如果有密码，先执行该命令，然后进行操作
select 3 # 切换到3号数据库
dbsize # 查看数据库大小
keys * # 查看当前数据库所有的key
flushdb # 清空当前数据库
flushall # 清空所有数据库
exists name # 判断name字段是否存在
move name 1 # 移除name字段，一般不用，最后的 1 代指当前数据库
get name # 得到name字段
expire name 10 # 给name字段设置过期时间10秒，10秒后自动消失
ttl name # 查看name字段过期的剩余时间
type name # 查看name字段类型
# 关于字符串类型
append name hello # 给字符串类型字段name追加“hello”值,如果name字段本身不存在，相当于set命令,追加的值带不带双引号都可以
strlen name # 查看name字段字符串的长度
incr age # age值自加1
incrby age 4 # age值自加4
decr age # age值自减1
decrby age 4 # age值自减4
getrange name 0 3 # 取出指定范围字符串，前后闭区间[]
setrange name 1 xx # 从下标为1的字符开始，替换成xx
setex key3 30 "hello" # 设置key3为hello，30秒后过期，为nil
setnx key4 "redis" # 如果key4不存在则设置值为redis，若已存在则不生效
mset k1 v1 k2 v2 k3 v3 # 批量设置多个值
mget k1 k2 k3 # 批量获取多个值
msetnx k4 v4 k5 v5 # 批量操作如果不存在则设置值。该操作是原子操作，一个已存在的话便都失败
set user:1 {name:zhangsan,age:21} # 使用json字符串的形式存储对象
get user:1 # 获取对象
mset user:1:name zhangsan user:1:age 20 #批量设置
getset name "zhangsan" # 先get再set，如果不存在值，则返回nil,然后赋值为后面的值；如果存在值，则返回原来存在的值,然后赋值为后面的值
# 关于List类型
lpush mylist hello # 在列表左侧加入hello节点
rpush mylist hello # 在列表右侧加入hello节点
lrange mylist 0 1 # 通过区间获得列表中的值
lpop mylist # 移除列表最左边元素
rpop mylist # 移除列表最右边元素
lindex mylist 0 # 获取指定下标元素的值
llen mylist # 获取list的长度
lrem mylist 1 hello # 移除指定个数的节点
lrem mylist 2 hello # 移除两个hello
ltrim mylist 1 2 # 通过下标截取指定区间
rpoplpush mylist otherlist # 把mylist最后一个元素弹出，放入otherlist中
lset mylist 0 hello # 将列表中指定下标的值替换为另外一个值，更新操作（如果列表不存在，或者下标不存在都会报错）
linsert mylist before "hello" "world" # 在元素hello前插入world
linsert mylist after "hello" "news" # 在元素hello后插入news
#关于Set类型
sadd myset value # 添加进set
smembers myset # 查看set中所有值
sismember myset value # 查看set中是否存在value
scard myset # 获取set中元素的个数
srem myset hello # 移除set集合中指定的元素hello
srandmember myset # 获取set中的一个随机值
srandmember myset 2 # 获取set中的任意两个值
spop myset # 随机弹出set中的一个元素
smove myset myset2 “hello” # 将myset中的hello移动到myset2中
sdiff myset1 myset2 # 取两集合差集
sinter myset1 myset2 # 取两集合交集
sunion myset1 myset2 # 取两集合并集
# 关于Hash类型
hset myhash field1 zhangsan # set一个具体的key-value
hget myhash field1 # 根据key获得value值
hmset myhash field1 hello field2 world # 批量赋值
hmget myhash field1 field2 # 获得多个值
hgetall myhash # 得到所有的值
hdel myhash field1 # 删除hash指定的key，对应的value也消失了
hlen myhash # 获取myhash的长度
hexists myhash field1 # 判断myhash指定key是否存在
hkeys myhash # 获取所有的key
hvals myhash # 获取所有的value
hincr、hdecr、hincrby、hdecrby # 与string中自增自减用法一样
hsetnx # 与string中setnx用法差不多
# 关于Zset类型
zadd myset 1 one # 添加一个值，这个1是为了以后排序增加的标志
zadd myset 3 three 4 four # 添加多个值
zrange myset 0 -1 # 获取一定区间的元素
zrangebyscore myset -inf +inf # zrangebyscore key min max [withscores] 从小到大排序[并附带值]
zrevrange myset 0 -1 # 从大到小排序
zrem myset xiaohong # 移除指定用户
zcard myset # 获取集合元素个数
zcount myset 1 3 # 获取指定区间的成员数量
5. 三种特殊数据类型
5.1 geospatial（地理位置）
相关命令：
- 1.GEOADD
- 2.GEOPOS
- 3.GEODIST
- 4.GEORADIUS
- 5.GEORADIUSBYMEMBER
- 6.GEOHASH
5.1.1 GEOADD添加地理位置
- 有效的经度从-180度到180度。
- 有效的纬度从-85.05112878度到85.05112878度。
- 一般会先下载城市数据，然后直接用java程序一次性导入
- 参数 key 值（经度、纬度、名称）
# 添加位置信息
127.0.0.1:6379> geoadd china:city 116.40 39.90 beijing
(integer) 1
127.0.0.1:6379> geoadd china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> geoadd china:city 106.50 29.53 chongqing
(integer) 1
127.0.0.1:6379> geoadd china:city 114.05 22.52 shenzhen
(integer) 1
127.0.0.1:6379> geoadd china:city 120.16 30.24 hangzhou
(integer) 1
127.0.0.1:6379> geoadd china:city 108.96 34.26 xian
(integer) 1
5.1.2 GEOPOS获取经纬度
# 获得当前定位：一定是一个坐标值
127.0.0.1:6379> geopos china:city beijing
1) 1) "116.39999896287918091"
2) "39.90000009167092543"
127.0.0.1:6379> geopos china:city beijing chongqing
1) 1) "116.39999896287918091"
2) "39.90000009167092543"
2) 1) "106.49999767541885376"
2) "29.52999957900659211"
5.1.3 GEODIST返回两个给定位置之间的距离
指定单位的参数 unit 必须是以下单位的其中一个：
- m 表示单位为米。
- km 表示单位为千米。
- mi 表示单位为英里。
- ft 表示单位为英尺。
# 返回北京到上海的距离，默认单位为m
127.0.0.1:6379> geodist china:city beijing shanghai
"1067378.7564"
127.0.0.1:6379> geodist china:city beijing shanghai km # 指定单位
"1067.3788"
5.1.4 GEORADIUS返回一定半径内的元素
以给定的经纬度为中心， 返回键包含的位置元素当中， 与中心的距离不超过给定最大距离的所有位置元素。
- WITHDIST: 在返回位置元素的同时， 将位置元素与中心之间的距离也一并返回。 距离的单位和用户给定的范围单位保持一致。
- WITHCOORD: 将位置元素的经度和维度也一并返回。
- WITHHASH: 以 52 位有符号整数的形式， 返回位置元素经过原始 geohash 编码的有序集合分值。 这个选项主要用于底层应用或者调试， 实际中的作用并不大。
127.0.0.1:6379> georadius china:city 110 30 1000 km # 查询以(110,30)为中心，半径为1000内的城市
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
# 查询一定半径内的城市，并带上距离与经纬度，且指定个数为1
127.0.0.1:6379> georadius china:city 110 30 500 km withdist withcoord count 1
1) 1) "chongqing"
2) "341.9374"
3) 1) "106.49999767541885376"
2) "29.52999957900659211"
5.1.5 GEORADIUSBYMEMBER返回一定半径内的元素
这个命令和 GEORADIUS 命令一样， 都可以找出位于指定范围内的元素， 但是 GEORADIUSBYMEMBER 的中心点是由给定的位置元素决定的， 而不是像 GEORADIUS 那样， 使用输入的经度和纬度来决定中心点。
127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km
1) "beijing"
2) "xian"
5.1.6 GEOHASH（用的不多）
命令将返回11个字符的Geohash字符串（将二维的经纬度，转成一维的字符串）
# 距离越近的位置，字符串越相近
127.0.0.1:6379> geohash china:city beijing chongqing
1) "wx4fbxxfke0"
2) "wm5xzrybty0"
5.1.7 GEO的底层是Zset
所以Zset所有命令都可以使用，也可以删除位置信息等操作。
127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
6) "beijing"
127.0.0.1:6379> zrem china:city beijing
(integer) 1
127.0.0.1:6379> zrange china:city 0 -1
1) "chongqing"
2) "xian"
3) "shenzhen"
4) "hangzhou"
5) "shanghai"
5.2 hyperloglogs数据结构（用于计数）
什么是基数？
A{1,3,5,7,8,7}
B{1,3,5,7,8}
基数（两个集合合并之后不重复的元素）= 5
Redis Hyperloglogs是一种基数统计的算法！
优点：占用的内存是固定的，2^64不同的元素的技术，只需要废12KB的内存！如果从内存的角度，Hyperloglogs首选！
127.0.0.1:6379> PFadd mykey a b c d e f g h i j
(integer) 1
127.0.0.1:6379> PFcount mykey
(integer) 10
127.0.0.1:6379> PFadd mykey2 i j z x c v b n m
(integer) 1
127.0.0.1:6379> PFcount mykey2
(integer) 9
127.0.0.1:6379> pfmerge mykey3 mykey mykey2 # 合并mykey和mykey2到mykey3中
OK
127.0.0.1:6379> pfcount mykey3
(integer) 15
5.3 bitmaps
Bitmaps位图，数据结构！都是操作二进制位来进行记录，就只有0和1两个状态！
例如使用bitmap来记录周一到周日的打卡。
查看某一天是否打卡(周三)：
127.0.0.1:6379> getbit sign 3
(integer) 1
统计这周打卡次数：
127.0.0.1:6379> bitcount sign
(integer) 4
6. 事务
Redis事务本质：一组命令的集合！一个事务中的所有命令都会被序列化，在事务执行过程的中,会按照顺序执行！
一次性、顺序性、排他性！执行一些列的命令！
Redis事务没有隔离级别的概念！
所有的命令在事务中,并没有直接被执行！只有发起执行命令（exec）的时候才会执行！
Redis单条命令保证原子性，但是事务不保证原子性！
6.1 Redis的事务
- 开启事务（multi）
- 命令入队（…）
- 执行事务（exec）
- 放弃事务：discard
6.2 出现异常
编译型异常（代码有问题，命令有错），事务中所有命令都不会执行。
运行时异常，如果事务队列中存在语法性错误，那么执行命令的时候，其他命令是可以正常执行的，错误命令会抛异常！
6.3 乐观锁
悲观锁：很悲观，认为什么时候都会出问题，无论做什么都会加锁！（影响性能）
乐观锁：很乐观，认为什么时候都不会出问题，所以不会上锁！更新数据的时候去判断一下，在此期间是否有人修改过这个数据，通过加一个version字段来判断（mybatis-plus中使用过）。
Redis的监视测试（watch money：监视money对象）
测试多线程修改值，使用watch可以当作redis的乐观锁操作。（执行watch money命令之后，用另外一个进程对money进行修改，则本进程的事务会执行失败）
第一个线程执行到如下还未exec时：
另一个线程修改了money的值：
然后第一个线程exec时，会修改失败（相当于version已经发生变化，比较时判断出错）：
如果修改失败，则获取最新的值就好。（先unwatch）
7. Jedis
Jedis是Redis官方推荐的java连接开发工具!是使用Java操作Redis的中间件！
7.1 导入对应的依赖
<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.73</version>
</dependency>
</dependencies>
7.2 编码测试
- 连接数据库
- 操作命令
- 断开连接
public class TestPing {
public static void main(String[] args) {
// 1. new Jedis 对象即可，连接到虚拟机ip地址
Jedis jedis = new Jedis("192.168.200.130", 6379);
// Jedis所有的命令就是我们之前学习的所有指令！
String ping = jedis.ping();
System.out.println(ping);
jedis.close();
}
}
常用的API
- String
- List
- Set
- Hash
- Zset
所有命令跟上面的命令是一样的。
部分命令演示如下：
8. SpringBoot整合
说明：在SpringBoot2.x之后，原来使用的jedis被替换为了lettuce。
jedis ：采用的连接方式是直连，多个线程操作的话，是不安全的，如果想要避免不安全的，使用jedis pool连接池！更像BIO模式。
lettuce ：采用netty ,实例可以再多个线程中进行共享,不存在线程不安全的情况!可以减少线程数据了，更像NIO模式。
8.1 导入依赖
也可以在创建springboot项目时勾选上NoSQL中的redis即可！
<!-- 操作redis -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
8.2 配置信息
# 配置redis
spring.redis.host=192.168.200.130
spring.redis.port=6379
8.3 测试
@SpringBootTest
class RedisSpringbootApplicationTests {
@Autowired
private RedisTemplate redisTemplate;
@Test
void contextLoads() {
// redisTemplate 操作不同的数据类型
// opsForValue 操作字符串 类似 String
// opsForList 操作字符串 类似 List
// opsForSet 操作字符串 类似 Set
// opsForHash 操作字符串 类似 Hash
// opsForZSet 操作字符串 类似 Zset
// opsForGeo 操作字符串 类似 Geospatial
// opsForHyperLogLog 操作字符串 类似 Hyperloglogs
redisTemplate.opsForValue().set("mykey","liumeng");
System.out.println(redisTemplate.opsForValue().get("mykey"));
// 除了基本的操作，我们常用的方法都可以直接redisTemplate来操作，比如事务和基本的 CRUD
// redisTemplate.multi();
// redisTemplate.exec();
// redisTemplate.discard();
// 关于数据库的操作，获取数据库连接
// RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
// connection.flushDb();
// connection.flushAll();
}
}
8.4 自定义RedisTemplate
Redis存储的对象必须序列化！
新建一个User对象
测试：
可按照如下方式自定义RedisTemplate，键前面的序列化字符串会消失（为正常的user）
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.net.UnknownHostException;
@Configuration
public class RedisConfig {
// 这是一个固定的模板，可以直接使用
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) throws UnknownHostException {
// 为了方便开发，一般直接使用<String,Object>
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(factory);
// Json序列化配置
Jackson2JsonRedisSerializer<Object> Jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
Jackson2JsonRedisSerializer.setObjectMapper(om);
// String 的序列化
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
// 配置具体的序列化方式
// key采用String的序列化方式
template.setKeySerializer(stringRedisSerializer);
// hash的key也采用String的序列化方式
template.setHashKeySerializer(stringRedisSerializer);
template.setValueSerializer(stringRedisSerializer);
template.afterPropertiesSet();
return template;
}
}
然后在测试类中，引入这个自定义配置类
此时再次执行测试方法后：
工作中常常自定义Redis配置类RedisUtils
package com.liu.utils;
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 RedisUtils {
@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;
}
}
}
8.5 Redis.conf 配置
配置文件中：
bind 127.0.0.1 # 绑定的ip，也是允许访问redis的ip，一般注释掉，表示全部允许访问
protected-mode yes # 保护模式，在jedis使用时，修改为no
port 6379 # 端口设置
568
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
