Java如何使用redis：Jedis和RedisTemplate

最新推荐文章于 2024-03-22 09:25:27 发布

毅一s

最新推荐文章于 2024-03-22 09:25:27 发布

阅读量3.1k

点赞数 2

分类专栏：实例用法文章标签： java redis jedis

本文链接：https://blog.csdn.net/qq_34826261/article/details/105977430

版权

实例用法专栏收录该内容

17 篇文章 8 订阅

订阅专栏

一、确认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;
        }
    }
}

毅一s

关注

2
点赞
踩
19

收藏

觉得还不错? 一键收藏
2
评论
Java如何使用redis：Jedis和RedisTemplate

本文详细介绍了Java使用redis的两种方式：Jedis和RedisTemplate的详细配置和使用。其中Jedis提供了各个数据类型的操作方法；RedisTemplate介绍了如何配置redis，以配置类的方式进行结合，提供了一个封装类RedisUtil更好的使用RedisTemplate，并且详细介绍了RedisTemplate的序列化问题(解决RedisTemplate前缀问题)。
复制链接

扫一扫