目录
一、确认redis服务开启
首先要确认redis正常开启,命令行输入
redis-server.exe
一定要确认redis服务启动,如未启动,程序肯定会报错。
二、Jedis的配置及使用
1、添加依赖
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
2、连接Redis
import redis.clients.jedis.Jedis;
public class RedisUtil {
private static Jedis jedis;
public static Jedis connectRedis(String host) {
jedis = new Jedis(host);
return jedis;
}
public static void main(String[] args) {
Jedis jedis = RedisUtil.connectRedis("localhost");
System.out.println(jedis.ping()); // 输出:PONG
}
}
3、key的相关操作
方法名 | 功能 |
---|---|
flushDB() | 清除数据库所有数据 |
exists(String key) | 判断键key是否存在 |
expire(String key, int second) | 设置键key的过期时间 |
ttl(String key) | key的剩余生存时间,不存在或永久都返回-1 |
type(String key) | key所储存值的类型 |
4、string(字符串)类型:增删改查
import redis.clients.jedis.Jedis;
public class RedisStringTest {
public static void main(String[] args) {
Jedis jedis = RedisUtil.connectRedis("localhost");
// 增加String
jedis.set("one", "1");
jedis.set("two", "2");
// 查询键所对应的值
System.out.println("键为“two”的值:" + jedis.get("two"));
// 原来基础上修改
jedis.append("two", "-修改");
System.out.println("修改后,键为“two”的值:" + jedis.get("two"));
// 覆盖修改
jedis.set("two", "2-覆盖修改");
System.out.println("覆盖修改后,键为“two”的值:" + jedis.get("two"));
// 删除String
jedis.del("two");
System.out.println("删除后,键为“two”的值:" + jedis.get("two"));
}
}
运行结果:
5、hash(哈希)类型:增删改查
import redis.clients.jedis.Jedis;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class RedisHashTest {
public static void main(String[] args) {
Jedis jedis = RedisUtil.connectRedis("localhost");
Map<String, String> map = new HashMap<String, String>();
map.put("AAA", "1");
map.put("BBB", "2");
map.put("CCC", "3");
// 增加
jedis.hmset("map", map);
// 查询,注意返回值是List型,第二个参数可以跟多个map的key。
List<String> mapAAA = jedis.hmget("map", "AAA");
System.out.println("查询map键为“AAA”的值:" + mapAAA);
// 删除
jedis.hdel("map", "AAA");
System.out.println("删除后,查询map键为“AAA”的值:" + jedis.hmget("map", "AAA"));
// 其他查询
System.out.println("map中键值对的个数:" + jedis.hlen("map"));
System.out.println("map中所有的键:" + jedis.hkeys("map"));
System.out.println("map中所有的值:" + jedis.hvals("map"));
}
}
运行结果:
6、list(列表)类型:增删改查、排序
import redis.clients.jedis.Jedis;
import redis.clients.jedis.SortingParams;
public class RedisListTest {
public static void main(String[] args) {
Jedis jedis = RedisUtil.connectRedis("localhost");
// 清楚列表中所有数据
jedis.del("listTest");
// 增加
jedis.lpush("listTest", "1");
jedis.lpush("listTest", "java");
jedis.lpush("listTest", "2");
jedis.lpush("listTest", "java");
jedis.lpush("listTest", "3");
jedis.lpush("listTest", "4");
jedis.lpush("listTest", "java");
jedis.lpush("listTest", "redis");
// 查询,-1表示所有,注意查询出来的元素和插入顺序是相反的
System.out.println("查询所有元素:" + jedis.lrange("listTest", 0, -1));
// 获取指定坐标的值
System.out.println("获取指定坐标的值:" + jedis.lindex("listTest", 2));
// 出栈
jedis.lpop("listTest");
System.out.println("出栈后,查询所有元素:" + jedis.lrange("listTest", 0, -1));
// 删除
// 删除指定元素,第二个参数为删除个数(有重复元素),后添加的元素先被删除
jedis.lrem("listTest", 2, "java");
System.out.println("删除指定元素后,查询所有元素:" + jedis.lrange("listTest", 0, -1));
// 删除某一范围以外的数据
jedis.ltrim("listTest", 0, 3);
System.out.println("删除某一范围以外元素后,查询所有元素:" + jedis.lrange("listTest", 0, -1));
// 修改指定坐标数据
jedis.lset("listTest", 1, "jedis");
System.out.println("修改后,查询所有元素:" + jedis.lrange("listTest", 0, -1));
// 排序,存在字母必须使用SortingParams,若为纯数字可直接使用sort
SortingParams sortingParameters = new SortingParams();
// 按字母排序
sortingParameters.alpha();
// 对某一范围排序
sortingParameters.limit(0, 4);
System.out.println("排序后,查询所有元素:"+ jedis.sort("listTest",sortingParameters));
// 其他查询
System.out.println("指定list的长度:" + jedis.llen("listTest"));
}
}
运行结果:
7、set(集合)类型:增删改查
import redis.clients.jedis.Jedis;
public class RedisSetTest {
public static void main(String[] args) {
Jedis jedis = RedisUtil.connectRedis("localhost");
// 增加
jedis.sadd("setTest", "1");
jedis.sadd("setTest", "java");
jedis.sadd("setTest", "2");
// 重复元素不会出现两次
jedis.sadd("setTest", "java");
// 查询
System.out.println("查询所有元素:" + jedis.smembers("setTest"));
// 删除
jedis.srem("setTest", "1");
System.out.println("删除后,查询所有元素:" + jedis.smembers("setTest"));
// 交并差
jedis.sadd("setTest2", "2", "3");
System.out.println("查询第二个集合所有元素:" + jedis.smembers("setTest2"));
System.out.println("两集合的交集" + jedis.sinter("setTest", "setTest2"));
System.out.println("两集合的并集" + jedis.sunion("setTest", "setTest2"));
// setTest中有,setTest2中没有的元素
System.out.println("两集合的差集" + jedis.sdiff("setTest", "setTest2"));
}
}
运行结果:
8、sorted set(有序集合):增删改查
public class RedisSortedSetTest {
public static void main(String[] args) {
Jedis jedis = RedisUtil.connectRedis("localhost");
// 增加
jedis.zadd("sortedSetTest", 3.1, "key1");
jedis.zadd("sortedSetTest", 7.0, "key2");
jedis.zadd("sortedSetTest", 5.5, "key3");
jedis.zadd("sortedSetTest", 1.0, "key4");
// 按权重值进行排序
System.out.println("查询所有元素:" + jedis.zrange("sortedSetTest", 0, -1));
// 删除
jedis.zrem("sortedSetTest", "key1");
System.out.println("删除后,查询所有元素:" + jedis.zrange("sortedSetTest", 0, -1));
// 其他查询
System.out.println("查询集合中的元素中个数:" + jedis.zcard("sortedSetTest"));
System.out.println("查询集合中权重某个范围内(1.0——5.0),元素的个数:" + jedis.zcount("sortedSetTest", 1.0, 5.0));
System.out.println("查看集合中指定元素的权重:" + jedis.zscore("sortedSetTest", "key4"));
}
}
运行结果:
三、RedisTemplate的配置及使用
1、RedisTemplate和Jedis优缺点比较
Jedis的不足:
(1)connection管理缺乏自动化;
(2)数据操作需要关注“序列化”/“反序列化”,因为jedis只接收String和byte数据类型,对于json、xml、pojo等结构化数据类型需要额外的支持;
(3)事务操作纯粹硬编码;
(4)对于pub/sub功能,缺乏必要的设计模式支持。对于开发者而言,需要关注的太多。
RedisTemplate的优点:
(1)RedisTemplate高度封装,连接池自动管理;
(2)对jedis客户端中大量api进行了封装,将同一类型操作封装为operation接口(ValueOperations-简单K-V操作、HashOperations、ListOperations、SetOperations、ZSetOperations);
(3)提供了对key的bound便捷化操作API;
(4)将事务操作封装,由容器控制;
(5)针对数据的“序列化和反序列化”提供了多种可选择测量(JdkSerializationRedisSerializer、StringRedisSerializer、JacksonJsonRedisSerializer、OxmSerializer)。也可自定义类进行序列化和反序列化。
(6)基于设计模式和JMS开发思路,将pub/sub的API设计进行了封装,使开发更加便捷。
2、添加依赖
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.8.10.RELEASE</version>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>compile</scope>
</dependency>
3、redis属性配置
resources目录下创建redis.properties
#ip地址
redis.hostName=127.0.0.1
#端口号
redis.port=6379
#如果有密码
redis.password=
#客户端超时时间单位是毫秒 默认是2000
redis.timeout=2000
#最大空闲数
redis.maxIdle=10
#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal
redis.maxActive=10
#控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性
redis.maxTotal=10
#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
redis.maxWaitMillis=1000
#连接的最小空闲时间 默认1800000毫秒(30分钟)
redis.minEvictableIdleTimeMillis=300000
#每次释放连接的最大数目,默认3
redis.numTestsPerEvictionRun=1024
#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
redis.timeBetweenEvictionRunsMillis=30000
#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
redis.testOnBorrow=false
#在空闲时检查有效性, 默认false
redis.testWhileIdle=false
4、工具类
封装RedisTemplate,便于更方便使用。
本部分过长,为便于阅读,放于文末附录。
5、配置类
使用JavaConfig的方式来配置,主要是三个Bean,读取配置文件设置各种参数的RedisConnectionFactory以及预期的RedisTemplate和RedisUtil。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.jcache.config.JCacheConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
@Configuration
@PropertySource("classpath:redis.properties")
public class RedisConfig extends JCacheConfigurerSupport {
@Autowired
private Environment environment;
@Bean
public RedisConnectionFactory redisConnectionFactory() {
JedisConnectionFactory fac = new JedisConnectionFactory();
fac.setHostName(environment.getProperty("redis.hostName"));
fac.setPort(Integer.parseInt(environment.getProperty("redis.port")));
fac.setPassword(environment.getProperty("redis.password"));
fac.setTimeout(Integer.parseInt(environment.getProperty("redis.timeout")));
fac.getPoolConfig().setMaxIdle(Integer.parseInt(environment.getProperty("redis.maxIdle")));
fac.getPoolConfig().setMaxTotal(Integer.parseInt(environment.getProperty("redis.maxTotal")));
fac.getPoolConfig().setMaxWaitMillis(Integer.parseInt(environment.getProperty("redis.maxWaitMillis")));
fac.getPoolConfig().setMinEvictableIdleTimeMillis(
Integer.parseInt(environment.getProperty("redis.minEvictableIdleTimeMillis")));
fac.getPoolConfig()
.setNumTestsPerEvictionRun(Integer.parseInt(environment.getProperty("redis.numTestsPerEvictionRun")));
fac.getPoolConfig().setTimeBetweenEvictionRunsMillis(
Integer.parseInt(environment.getProperty("redis.timeBetweenEvictionRunsMillis")));
fac.getPoolConfig().setTestOnBorrow(Boolean.parseBoolean(environment.getProperty("redis.testOnBorrow")));
fac.getPoolConfig().setTestWhileIdle(Boolean.parseBoolean(environment.getProperty("redis.testWhileIdle")));
return fac;
}
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> redis = new RedisTemplate<String, Object>();
redis.setConnectionFactory(redisConnectionFactory);
redis.afterPropertiesSet();
return redis;
}
@Bean
public RedisUtil redisUtil() {
return new RedisUtil();
}
}
6、测试类
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.HashMap;
import java.util.Map;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {RedisConfig.class})
public class RedisTest {
@Autowired
private RedisUtil redisUtil;
@Test
public void test() {
Map<String, Object> hashMap = new HashMap<String, Object>();
hashMap.put("123", "hello");
hashMap.put("abc", "456");
redisUtil.hmset("hashTT", hashMap);
System.out.println(redisUtil.hmget("hashTT"));
redisUtil.set("a","123");
System.out.println(redisUtil.get("a"));
}
}
运行结果:
redis数据库中显示:
可以看到是有前缀的,这就意味着使用redis命令:get hashTT是获取不到内容的,如图
为解决存在前缀的问题,就要解决序列化问题。
7、序列化问题
追溯源码,hash在存入redis时使用putAll()方法,而putAll调用了rawKey()方法。
观察rawKey()方法的源码,可以看到并不是直接返回想要的key.getBytes(),而是调用了this.keySerializer().serialize(key),
而在RedisTemplate的afterPropertiesSet()源码中默认的序列化方式(defaultSerializer)是JdkSerializationRedisSerializer。
因此需要在配置类中进行设置,可以使用StringRedisSerializer类,但是该类的序列化方法只接收String类型,如果hashTT中存入了Integer的值(hashMap.put(“Integer”, 555);),会报错。
因此可以仿照StringRedisSerializer重写一个序列化类,
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.util.Assert;
import java.nio.charset.Charset;
public class RedisSerializerUtil implements RedisSerializer<Object> {
private final Charset charset;
public RedisSerializerUtil() {
this(Charset.forName("UTF8"));
}
public RedisSerializerUtil(Charset charset) {
Assert.notNull(charset, "Charset must not be null!");
this.charset = charset;
}
@Override
public byte[] serialize(Object object) throws SerializationException {
return object == null ? null : String.valueOf(object).getBytes(charset);
}
@Override
public Object deserialize(byte[] bytes) throws SerializationException {
return bytes == null ? null : new String(bytes, this.charset);
}
}
然后设置序列化方式,
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
RedisTemplate<String, Object> redis = new RedisTemplate<String, Object>();
redis.setConnectionFactory(redisConnectionFactory);
redis.afterPropertiesSet();
// 设置redis的String/Value的默认序列化方式
RedisSerializerUtil redisSerializerUtil = new RedisSerializerUtil();
redis.setKeySerializer(redisSerializerUtil);
redis.setHashKeySerializer(redisSerializerUtil);
redis.setValueSerializer(redisSerializerUtil);
redis.setHashValueSerializer(redisSerializerUtil);
return redis;
}
在测试类中加入
hashMap.put("Integer", 555);
运行结果:
命令行查询:
附录:RedisTemplate的工具类RedisUtil
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;
/**
* 基于spring和redis的redisTemplate工具类
* 针对所有的hash 都是以h开头的方法
* 针对所有的Set 都是以s开头的方法 不含通用方法
* 针对所有的List 都是以l开头的方法
* 引用自how2java网站
*/
@Component
public class RedisUtil {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
//=============================common============================
/**
* 指定缓存失效时间
* @param key 键
* @param time 时间(秒)
* @return
*/
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)
* @return
*/
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)
* @return
*/
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
* @return 值
*/
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 对应多个键值
* @return true 成功 false 失败
*/
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)
* @return
*/
public double hincr(String key, String item, double by){
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
* @return
*/
public double hdecr(String key, String item, double by){
return redisTemplate.opsForHash().increment(key, item,-by);
}
//============================set=============================
/**
* 根据key获取Set中的所有值
* @param key 键
* @return
*/
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 键
* @return
*/
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代表所有值
* @return
*/
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 键
* @return
*/
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倒数第二个元素,依次类推
* @return
*/
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 值
* @return
*/
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 时间(秒)
* @return
*/
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;
}
}
}