千家信息网

redis使用实例分析

发表于:2024-11-28 作者:千家信息网编辑
千家信息网最后更新 2024年11月28日,这篇文章主要介绍"redis使用实例分析",在日常操作中,相信很多人在redis使用实例分析问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答"redis使用实例分析"的疑惑
千家信息网最后更新 2024年11月28日redis使用实例分析

这篇文章主要介绍"redis使用实例分析",在日常操作中,相信很多人在redis使用实例分析问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答"redis使用实例分析"的疑惑有所帮助!接下来,请跟着小编一起来学习吧!

首先我们为要先了解,我们在原先使用mysql的时候,用jdbc连接数据库。同理这里我们连接redis,就要使用jedis。

第一步:新建java项目,导包

新建java项目,导包

    redis.clients    jedis    3.3.0    com.alibaba    fastjson    1.2.73

第二步:打开redis服务,写方法

打开redis服务

新建一个测试类,写一个方法

public class Ping {   public static void main(String[] args) {            Jedis jedis = new Jedis("127.0.0.1",6379);           System.out.println("连接成功"); //查看服务是否运行            System.out.println("服务正在运行: "+jedis.ping());   }  }

证明连同了

第三步:简单操作

这里写一些简单的jedis对各种类型的操作

基本操作api

public class TestPassword { public static void main(String[] args) { Jedis jedis = new Jedis("127.0.0.1", 6379); //验证密码,如果没有设置密码这段代码省略 // jedis.auth("password"); jedis.connect(); //连接 jedis.disconnect(); //断开连接 jedis.flushAll(); //清空所有的key } }

对于key操作的命令

public class TestKey { public static void main(String[] args) { Jedis jedis = new Jedis("127.0.0.1", 6379); System.out.println("清空数据:"+jedis.flushDB());  System.out.println("判断某个键是否在:"+jedis.exists("username"));  System.out.println("新增<'username','kuangshen'>的键值对:"+jedis.set("username", "kuangshen"));  System.out.println("新增<'password','password'>的键值 对:"+jedis.set("password", "password"));  System.out.print("系统中所有的键如下:");  Set keys = jedis.keys("*");  System.out.println(keys);  System.out.println("删除键password:"+jedis.del("password"));   System.out.println("判断键password是否存在:"+jedis.exists("password"));  System.out.println("查看键username所存储的值的类 型:"+jedis.type("username"));  System.out.println("随机返回key空间的一个:"+jedis.randomKey());  System.out.println("重命名key:"+jedis.rename("username","name")); System.out.println("取出改后的name:"+jedis.get("name")); System.out.println("按索引查询:"+jedis.select(0));  System.out.println("删除当前选择数据库中的所key:"+jedis.flushDB());  System.out.println("返回当前数据库中key的数目:"+jedis.dbSize());  System.out.println("删除所有数据库中的所有key:"+jedis.flushAll());  } }

对String操作的命令

public class TestString { public static void main(String[] args) {         Jedis jedis = new Jedis("127.0.0.1", 6379);         jedis.flushDB();         System.out.println("===========增加数据===========");         System.out.println(jedis.set("key1","value1"));         System.out.println(jedis.set("key2","value2"));         System.out.println(jedis.set("key3", "value3"));        System.out.println("删除键key2:"+jedis.del("key2"));         System.out.println("获取键key2:"+jedis.get("key2"));         System.out.println("修改key1:"+jedis.set("key1", "value1Changed"));         System.out.println("获取key1的值:"+jedis.get("key1"));          System.out.println("在key3后面加入值:"+jedis.append("key3", "End"));          System.out.println("key3的值:"+jedis.get("key3"));          System.out.println("增加多个键值 对:"+jedis.mset("key01","value01","key02","value02","key03","value03"));          System.out.println("获取多个键值 对:"+jedis.mget("key01","key02","key03"));          System.out.println("获取多个键值 对:"+jedis.mget("key01","key02","key03","key04"));          System.out.println("删除多个键值对:"+jedis.del("key01","key02"));          System.out.println("获取多个键值 对:"+jedis.mget("key01","key02","key03"));         jedis.flushDB();          System.out.println("===========新增键值对防止覆盖原先值==============");           System.out.println(jedis.setnx("key1", "value1"));           System.out.println(jedis.setnx("key2", "value2"));           System.out.println(jedis.setnx("key2", "value2-new"));           System.out.println(jedis.get("key1"));           System.out.println(jedis.get("key2"));           System.out.println("===========新增键值对并设置有效时间=============");           System.out.println(jedis.setex("key3", 2, "value3"));           System.out.println(jedis.get("key3"));           try {              TimeUnit.SECONDS.sleep(3);           } catch (InterruptedException e) {                 e.printStackTrace();            }           System.out.println(jedis.get("key3"));            System.out.println("===========获取原值,更新为新值==========");            System.out.println(jedis.getSet("key2", "key2GetSet"));            System.out.println(jedis.get("key2"));           System.out.println("获得key2的值的字串:"+jedis.getrange("key2", 2, 4));   }  }

事务操作

public class TestMulti { public static void main(String[] args) {  //创建客户端连接服务端,redis服务端需要被开启   Jedis jedis = new Jedis("127.0.0.1", 6379);   jedis.flushDB();   JSONObject jsonObject = new JSONObject();   jsonObject.put("hello", "world");   jsonObject.put("name", "java");   //开启事务   Transaction multi = jedis.multi();   String result = jsonObject.toJSONString();   try{          //向redis存入一条数据           multi.set("json", result);           //再存入一条数据           multi.set("json2", result);           //这里引发了异常,用0作为被除数           int i = 100/0;           //如果没有引发异常,执行进入队列的命令          multi.exec();   }catch(Exception e){       e.printStackTrace();       //如果出现异常,回滚       multi.discard();   }finally{           System.out.println(jedis.get("json"));           System.out.println(jedis.get("json2"));           //最终关闭客户端            jedis.close();    }   }  }

在SpringBoot中一般使用RedisTemplate提供的方法来操作Redis。
源码分析

@Bean@ConditionalOnMissingBean(name = {"redisTemplate"}) // 我们可以自己定一个redisTemplate来替换这个默认的!public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {    // 默认的RedisTemplate没有过多的设置,redis对象都是需要序列化的    // 两个泛型都是Object,Object类型的,我们后续使用需要强制转换成    RedisTemplate template = new RedisTemplate();    template.setConnectionFactory(redisConnectionFactory);    return template;}@Bean@ConditionalOnMissingBeanpublic StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {    StringRedisTemplate template = new StringRedisTemplate();    template.setConnectionFactory(redisConnectionFactory);    return template;}

第一步:导入依赖

导入依赖

    org.springframework.boot    spring-boot-starter-data-redis

第二步:yml文件配置

yml文件配置

spring.redis.host=127.0.0.1spring.redis.port=6379

第三步:测试

测试

@SpringBootTestclass Redis02SpringbootApplicationTests {    @Autowired    private RedisTemplate redisTemplate;    @Test    void contextLoads() {        redisTemplate.opsForValue().set("mykey", "我是大帅哥");        System.out.println(redisTemplate.opsForValue().get("mykey"));    }}

第四步:自定义RedisTemplate

通过开头的源码可以看出,SpringBoot自动帮我们在容器中生成了一个RedisTemplate和一个StringRedisTemplate。但是,这个RedisTemplate的泛型是,写代码不方便,需要写好多类型转换的代码;我们需要一个泛型为形式RedisTemplate。并且,这个RedisTemplate没有设置数据存在Redis时,key及value的序列化方式。看到这个@ConditionalOnMissingBean注解后,就知道如果Spring容器中有了RedisTemplate对象了,这个自动配置的RedisTemplate不会实例化。因此我们可以直接自己写个配置类,配置RedisTemplate。
自定义RedisTemplate

@Configurationpublic class RedisConfig {    @Bean    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {        RedisTemplate template = new RedisTemplate();        template.setConnectionFactory(redisConnectionFactory);        // 序列化配置        Jackson2JsonRedisSerializer objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);        ObjectMapper om = new ObjectMapper();        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);        om.enableDefaultTyping();        objectJackson2JsonRedisSerializer.setObjectMapper(om);        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();        template.setKeySerializer(stringRedisSerializer);        template.setHashKeySerializer(stringRedisSerializer);        template.setValueSerializer(objectJackson2JsonRedisSerializer);        template.setHashValueSerializer(objectJackson2JsonRedisSerializer);        template.afterPropertiesSet();        return template;    }}

第五步:写一个工具类,便于操作

写一个Redis工具类(直接用RedisTemplate操作Redis,需要很多行代码,因此直接封装好一个RedisUtils,这样写代码更方便点。这个RedisUtils交给Spring容器实例化,使用时直接注解注入。)
这里是别人写的工具类,很全!!!

import org.springframework.data.redis.connection.DataType;import org.springframework.data.redis.core.Cursor;import org.springframework.data.redis.core.ScanOptions;import org.springframework.data.redis.core.StringRedisTemplate;import org.springframework.data.redis.core.ZSetOperations.TypedTuple;import java.util.Collection;import java.util.Date;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.Set;import java.util.concurrent.TimeUnit;/** * Redis工具类*/public class RedisUtil {    private StringRedisTemplate redisTemplate;    public void setRedisTemplate(StringRedisTemplate redisTemplate) {        this.redisTemplate = redisTemplate;    }    public StringRedisTemplate getRedisTemplate() {        return this.redisTemplate;    }    /** -------------------key相关操作--------------------- */    /**     * 删除key     *      * @param key     */    public void delete(String key) {        redisTemplate.delete(key);    }    /**     * 批量删除key     *      * @param keys     */    public void delete(Collection keys) {        redisTemplate.delete(keys);    }    /**     * 序列化key     *      * @param key     * @return     */    public byte[] dump(String key) {        return redisTemplate.dump(key);    }    /**     * 是否存在key     *      * @param key     * @return     */    public Boolean hasKey(String key) {        return redisTemplate.hasKey(key);    }    /**     * 设置过期时间     *      * @param key     * @param timeout     * @param unit     * @return     */    public Boolean expire(String key, long timeout, TimeUnit unit) {        return redisTemplate.expire(key, timeout, unit);    }    /**     * 设置过期时间     *      * @param key     * @param date     * @return     */    public Boolean expireAt(String key, Date date) {        return redisTemplate.expireAt(key, date);    }    /**     * 查找匹配的key     *      * @param pattern     * @return     */    public Set keys(String pattern) {        return redisTemplate.keys(pattern);    }    /**     * 将当前数据库的 key 移动到给定的数据库 db 当中     *      * @param key     * @param dbIndex     * @return     */    public Boolean move(String key, int dbIndex) {        return redisTemplate.move(key, dbIndex);    }    /**     * 移除 key 的过期时间,key 将持久保持     *      * @param key     * @return     */    public Boolean persist(String key) {        return redisTemplate.persist(key);    }    /**     * 返回 key 的剩余的过期时间     *      * @param key     * @param unit     * @return     */    public Long getExpire(String key, TimeUnit unit) {        return redisTemplate.getExpire(key, unit);    }    /**     * 返回 key 的剩余的过期时间     *      * @param key     * @return     */    public Long getExpire(String key) {        return redisTemplate.getExpire(key);    }    /**     * 从当前数据库中随机返回一个 key     *      * @return     */    public String randomKey() {        return redisTemplate.randomKey();    }    /**     * 修改 key 的名称     *      * @param oldKey     * @param newKey     */    public void rename(String oldKey, String newKey) {        redisTemplate.rename(oldKey, newKey);    }    /**     * 仅当 newkey 不存在时,将 oldKey 改名为 newkey     *      * @param oldKey     * @param newKey     * @return     */    public Boolean renameIfAbsent(String oldKey, String newKey) {        return redisTemplate.renameIfAbsent(oldKey, newKey);    }    /**     * 返回 key 所储存的值的类型     *      * @param key     * @return     */    public DataType type(String key) {        return redisTemplate.type(key);    }    /** -------------------string相关操作--------------------- */    /**     * 设置指定 key 的值     * @param key     * @param value     */    public void set(String key, String value) {        redisTemplate.opsForValue().set(key, value);    }    /**     * 获取指定 key 的值     * @param key     * @return     */    public String get(String key) {        return redisTemplate.opsForValue().get(key);    }    /**     * 返回 key 中字符串值的子字符     * @param key     * @param start     * @param end     * @return     */    public String getRange(String key, long start, long end) {        return redisTemplate.opsForValue().get(key, start, end);    }    /**     * 将给定 key 的值设为 value ,并返回 key 的旧值(old value)     *      * @param key     * @param value     * @return     */    public String getAndSet(String key, String value) {        return redisTemplate.opsForValue().getAndSet(key, value);    }    /**     * 对 key 所储存的字符串值,获取指定偏移量上的位(bit)     *      * @param key     * @param offset     * @return     */    public Boolean getBit(String key, long offset) {        return redisTemplate.opsForValue().getBit(key, offset);    }    /**     * 批量获取     *      * @param keys     * @return     */    public List multiGet(Collection keys) {        return redisTemplate.opsForValue().multiGet(keys);    }    /**     * 设置ASCII码, 字符串'a'的ASCII码是97, 转为二进制是'01100001', 此方法是将二进制第offset位值变为value     *      * @param key 位置     * @param value     *            值,true为1, false为0     * @return     */    public boolean setBit(String key, long offset, boolean value) {        return redisTemplate.opsForValue().setBit(key, offset, value);    }    /**     * 将值 value 关联到 key ,并将 key 的过期时间设为 timeout     *      * @param key     * @param value     * @param timeout     *            过期时间     * @param unit     *            时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES     *            秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS     */    public void setEx(String key, String value, long timeout, TimeUnit unit) {        redisTemplate.opsForValue().set(key, value, timeout, unit);    }    /**     * 只有在 key 不存在时设置 key 的值     *      * @param key     * @param value     * @return 之前已经存在返回false,不存在返回true     */    public boolean setIfAbsent(String key, String value) {        return redisTemplate.opsForValue().setIfAbsent(key, value);    }    /**     * 用 value 参数覆写给定 key 所储存的字符串值,从偏移量 offset 开始     *      * @param key     * @param value     * @param offset     *            从指定位置开始覆写     */    public void setRange(String key, String value, long offset) {        redisTemplate.opsForValue().set(key, value, offset);    }    /**     * 获取字符串的长度     *      * @param key     * @return     */    public Long size(String key) {        return redisTemplate.opsForValue().size(key);    }    /**     * 批量添加     *      * @param maps     */    public void multiSet(Map maps) {        redisTemplate.opsForValue().multiSet(maps);    }    /**     * 同时设置一个或多个 key-value 对,当且仅当所有给定 key 都不存在     *      * @param maps     * @return 之前已经存在返回false,不存在返回true     */    public boolean multiSetIfAbsent(Map maps) {        return redisTemplate.opsForValue().multiSetIfAbsent(maps);    }    /**     * 增加(自增长), 负数则为自减     *      * @param key     * @return     */    public Long incrBy(String key, long increment) {        return redisTemplate.opsForValue().increment(key, increment);    }    /**     *      * @param key     * @return     */    public Double incrByFloat(String key, double increment) {        return redisTemplate.opsForValue().increment(key, increment);    }    /**     * 追加到末尾     *      * @param key     * @param value     * @return     */    public Integer append(String key, String value) {        return redisTemplate.opsForValue().append(key, value);    }    /** -------------------hash相关操作------------------------- */    /**     * 获取存储在哈希表中指定字段的值     *      * @param key     * @param field     * @return     */    public Object hGet(String key, String field) {        return redisTemplate.opsForHash().get(key, field);    }    /**     * 获取所有给定字段的值     *      * @param key     * @return     */    public Map hGetAll(String key) {        return redisTemplate.opsForHash().entries(key);    }    /**     * 获取所有给定字段的值     *      * @param key     * @param fields     * @return     */    public List hMultiGet(String key, Collection fields) {        return redisTemplate.opsForHash().multiGet(key, fields);    }    public void hPut(String key, String hashKey, String value) {        redisTemplate.opsForHash().put(key, hashKey, value);    }    public void hPutAll(String key, Map maps) {        redisTemplate.opsForHash().putAll(key, maps);    }    /**     * 仅当hashKey不存在时才设置     *      * @param key     * @param hashKey     * @param value     * @return     */    public Boolean hPutIfAbsent(String key, String hashKey, String value) {        return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);    }    /**     * 删除一个或多个哈希表字段     *      * @param key     * @param fields     * @return     */    public Long hDelete(String key, Object... fields) {        return redisTemplate.opsForHash().delete(key, fields);    }    /**     * 查看哈希表 key 中,指定的字段是否存在     *      * @param key     * @param field     * @return     */    public boolean hExists(String key, String field) {        return redisTemplate.opsForHash().hasKey(key, field);    }    /**     * 为哈希表 key 中的指定字段的整数值加上增量 increment     *      * @param key     * @param field     * @param increment     * @return     */    public Long hIncrBy(String key, Object field, long increment) {        return redisTemplate.opsForHash().increment(key, field, increment);    }    /**     * 为哈希表 key 中的指定字段的整数值加上增量 increment     *      * @param key     * @param field     * @param delta     * @return     */    public Double hIncrByFloat(String key, Object field, double delta) {        return redisTemplate.opsForHash().increment(key, field, delta);    }    /**     * 获取所有哈希表中的字段     *      * @param key     * @return     */    public Set hKeys(String key) {        return redisTemplate.opsForHash().keys(key);    }    /**     * 获取哈希表中字段的数量     *      * @param key     * @return     */    public Long hSize(String key) {        return redisTemplate.opsForHash().size(key);    }    /**     * 获取哈希表中所有值     *      * @param key     * @return     */    public List hValues(String key) {        return redisTemplate.opsForHash().values(key);    }    /**     * 迭代哈希表中的键值对     *      * @param key     * @param options     * @return     */    public Cursor> hScan(String key, ScanOptions options) {        return redisTemplate.opsForHash().scan(key, options);    }    /** ------------------------list相关操作---------------------------- */    /**     * 通过索引获取列表中的元素     *      * @param key     * @param index     * @return     */    public String lIndex(String key, long index) {        return redisTemplate.opsForList().index(key, index);    }    /**     * 获取列表指定范围内的元素     *      * @param key     * @param start     *            开始位置, 0是开始位置     * @param end     *            结束位置, -1返回所有     * @return     */    public List lRange(String key, long start, long end) {        return redisTemplate.opsForList().range(key, start, end);    }    /**     * 存储在list头部     *      * @param key     * @param value     * @return     */    public Long lLeftPush(String key, String value) {        return redisTemplate.opsForList().leftPush(key, value);    }    /**     *      * @param key     * @param value     * @return     */    public Long lLeftPushAll(String key, String... value) {        return redisTemplate.opsForList().leftPushAll(key, value);    }    /**     *      * @param key     * @param value     * @return     */    public Long lLeftPushAll(String key, Collection value) {        return redisTemplate.opsForList().leftPushAll(key, value);    }    /**     * 当list存在的时候才加入     *      * @param key     * @param value     * @return     */    public Long lLeftPushIfPresent(String key, String value) {        return redisTemplate.opsForList().leftPushIfPresent(key, value);    }    /**     * 如果pivot存在,再pivot前面添加     *      * @param key     * @param pivot     * @param value     * @return     */    public Long lLeftPush(String key, String pivot, String value) {        return redisTemplate.opsForList().leftPush(key, pivot, value);    }    /**     *      * @param key     * @param value     * @return     */    public Long lRightPush(String key, String value) {        return redisTemplate.opsForList().rightPush(key, value);    }    /**     *      * @param key     * @param value     * @return     */    public Long lRightPushAll(String key, String... value) {        return redisTemplate.opsForList().rightPushAll(key, value);    }    /**     *      * @param key     * @param value     * @return     */    public Long lRightPushAll(String key, Collection value) {        return redisTemplate.opsForList().rightPushAll(key, value);    }    /**     * 为已存在的列表添加值     *      * @param key     * @param value     * @return     */    public Long lRightPushIfPresent(String key, String value) {        return redisTemplate.opsForList().rightPushIfPresent(key, value);    }    /**     * 在pivot元素的右边添加值     *      * @param key     * @param pivot     * @param value     * @return     */    public Long lRightPush(String key, String pivot, String value) {        return redisTemplate.opsForList().rightPush(key, pivot, value);    }    /**     * 通过索引设置列表元素的值     *      * @param key     * @param index     *            位置     * @param value     */    public void lSet(String key, long index, String value) {        redisTemplate.opsForList().set(key, index, value);    }    /**     * 移出并获取列表的第一个元素     *      * @param key     * @return 删除的元素     */    public String lLeftPop(String key) {        return redisTemplate.opsForList().leftPop(key);    }    /**     * 移出并获取列表的第一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止     *      * @param key     * @param timeout     *            等待时间     * @param unit     *            时间单位     * @return     */    public String lBLeftPop(String key, long timeout, TimeUnit unit) {        return redisTemplate.opsForList().leftPop(key, timeout, unit);    }    /**     * 移除并获取列表最后一个元素     *      * @param key     * @return 删除的元素     */    public String lRightPop(String key) {        return redisTemplate.opsForList().rightPop(key);    }    /**     * 移出并获取列表的最后一个元素, 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止     *      * @param key     * @param timeout     *            等待时间     * @param unit     *            时间单位     * @return     */    public String lBRightPop(String key, long timeout, TimeUnit unit) {        return redisTemplate.opsForList().rightPop(key, timeout, unit);    }    /**     * 移除列表的最后一个元素,并将该元素添加到另一个列表并返回     *      * @param sourceKey     * @param destinationKey     * @return     */    public String lRightPopAndLeftPush(String sourceKey, String destinationKey) {        return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,                destinationKey);    }    /**     * 从列表中弹出一个值,将弹出的元素插入到另外一个列表中并返回它; 如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止     *      * @param sourceKey     * @param destinationKey     * @param timeout     * @param unit     * @return     */    public String lBRightPopAndLeftPush(String sourceKey, String destinationKey,            long timeout, TimeUnit unit) {        return redisTemplate.opsForList().rightPopAndLeftPush(sourceKey,                destinationKey, timeout, unit);    }    /**     * 删除集合中值等于value得元素     *      * @param key     * @param index     *            index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素;     *            index<0, 从尾部开始删除第一个值等于value的元素;     * @param value     * @return     */    public Long lRemove(String key, long index, String value) {        return redisTemplate.opsForList().remove(key, index, value);    }    /**     * 裁剪list     *      * @param key     * @param start     * @param end     */    public void lTrim(String key, long start, long end) {        redisTemplate.opsForList().trim(key, start, end);    }    /**     * 获取列表长度     *      * @param key     * @return     */    public Long lLen(String key) {        return redisTemplate.opsForList().size(key);    }    /** --------------------set相关操作-------------------------- */    /**     * set添加元素     *      * @param key     * @param values     * @return     */    public Long sAdd(String key, String... values) {        return redisTemplate.opsForSet().add(key, values);    }    /**     * set移除元素     *      * @param key     * @param values     * @return     */    public Long sRemove(String key, Object... values) {        return redisTemplate.opsForSet().remove(key, values);    }    /**     * 移除并返回集合的一个随机元素     *      * @param key     * @return     */    public String sPop(String key) {        return redisTemplate.opsForSet().pop(key);    }    /**     * 将元素value从一个集合移到另一个集合     *      * @param key     * @param value     * @param destKey     * @return     */    public Boolean sMove(String key, String value, String destKey) {        return redisTemplate.opsForSet().move(key, value, destKey);    }    /**     * 获取集合的大小     *      * @param key     * @return     */    public Long sSize(String key) {        return redisTemplate.opsForSet().size(key);    }    /**     * 判断集合是否包含value     *      * @param key     * @param value     * @return     */    public Boolean sIsMember(String key, Object value) {        return redisTemplate.opsForSet().isMember(key, value);    }    /**     * 获取两个集合的交集     *      * @param key     * @param otherKey     * @return     */    public Set sIntersect(String key, String otherKey) {        return redisTemplate.opsForSet().intersect(key, otherKey);    }    /**     * 获取key集合与多个集合的交集     *      * @param key     * @param otherKeys     * @return     */    public Set sIntersect(String key, Collection otherKeys) {        return redisTemplate.opsForSet().intersect(key, otherKeys);    }    /**     * key集合与otherKey集合的交集存储到destKey集合中     *      * @param key     * @param otherKey     * @param destKey     * @return     */    public Long sIntersectAndStore(String key, String otherKey, String destKey) {        return redisTemplate.opsForSet().intersectAndStore(key, otherKey,                destKey);    }    /**     * key集合与多个集合的交集存储到destKey集合中     *      * @param key     * @param otherKeys     * @param destKey     * @return     */    public Long sIntersectAndStore(String key, Collection otherKeys,            String destKey) {        return redisTemplate.opsForSet().intersectAndStore(key, otherKeys,                destKey);    }    /**     * 获取两个集合的并集     *      * @param key     * @param otherKeys     * @return     */    public Set sUnion(String key, String otherKeys) {        return redisTemplate.opsForSet().union(key, otherKeys);    }    /**     * 获取key集合与多个集合的并集     *      * @param key     * @param otherKeys     * @return     */    public Set sUnion(String key, Collection otherKeys) {        return redisTemplate.opsForSet().union(key, otherKeys);    }    /**     * key集合与otherKey集合的并集存储到destKey中     *      * @param key     * @param otherKey     * @param destKey     * @return     */    public Long sUnionAndStore(String key, String otherKey, String destKey) {        return redisTemplate.opsForSet().unionAndStore(key, otherKey, destKey);    }    /**     * key集合与多个集合的并集存储到destKey中     *      * @param key     * @param otherKeys     * @param destKey     * @return     */    public Long sUnionAndStore(String key, Collection otherKeys,            String destKey) {        return redisTemplate.opsForSet().unionAndStore(key, otherKeys, destKey);    }    /**     * 获取两个集合的差集     *      * @param key     * @param otherKey     * @return     */    public Set sDifference(String key, String otherKey) {        return redisTemplate.opsForSet().difference(key, otherKey);    }    /**     * 获取key集合与多个集合的差集     *      * @param key     * @param otherKeys     * @return     */    public Set sDifference(String key, Collection otherKeys) {        return redisTemplate.opsForSet().difference(key, otherKeys);    }    /**     * key集合与otherKey集合的差集存储到destKey中     *      * @param key     * @param otherKey     * @param destKey     * @return     */    public Long sDifference(String key, String otherKey, String destKey) {        return redisTemplate.opsForSet().differenceAndStore(key, otherKey,                destKey);    }    /**     * key集合与多个集合的差集存储到destKey中     *      * @param key     * @param otherKeys     * @param destKey     * @return     */    public Long sDifference(String key, Collection otherKeys,            String destKey) {        return redisTemplate.opsForSet().differenceAndStore(key, otherKeys,                destKey);    }    /**     * 获取集合所有元素     *      * @param key     * @return     */    public Set setMembers(String key) {        return redisTemplate.opsForSet().members(key);    }    /**     * 随机获取集合中的一个元素     *      * @param key     * @return     */    public String sRandomMember(String key) {        return redisTemplate.opsForSet().randomMember(key);    }    /**     * 随机获取集合中count个元素     *      * @param key     * @param count     * @return     */    public List sRandomMembers(String key, long count) {        return redisTemplate.opsForSet().randomMembers(key, count);    }    /**     * 随机获取集合中count个元素并且去除重复的     *      * @param key     * @param count     * @return     */    public Set sDistinctRandomMembers(String key, long count) {        return redisTemplate.opsForSet().distinctRandomMembers(key, count);    }    /**     *      * @param key     * @param options     * @return     */    public Cursor sScan(String key, ScanOptions options) {        return redisTemplate.opsForSet().scan(key, options);    }    /**------------------zSet相关操作--------------------------------*/        /**     * 添加元素,有序集合是按照元素的score值由小到大排列     *      * @param key     * @param value     * @param score     * @return     */    public Boolean zAdd(String key, String value, double score) {        return redisTemplate.opsForZSet().add(key, value, score);    }    /**     *      * @param key     * @param values     * @return     */    public Long zAdd(String key, Set> values) {        return redisTemplate.opsForZSet().add(key, values);    }    /**     *      * @param key     * @param values     * @return     */    public Long zRemove(String key, Object... values) {        return redisTemplate.opsForZSet().remove(key, values);    }    /**     * 增加元素的score值,并返回增加后的值     *      * @param key     * @param value     * @param delta     * @return     */    public Double zIncrementScore(String key, String value, double delta) {        return redisTemplate.opsForZSet().incrementScore(key, value, delta);    }    /**     * 返回元素在集合的排名,有序集合是按照元素的score值由小到大排列     *      * @param key     * @param value     * @return 0表示第一位     */    public Long zRank(String key, Object value) {        return redisTemplate.opsForZSet().rank(key, value);    }    /**     * 返回元素在集合的排名,按元素的score值由大到小排列     *      * @param key     * @param value     * @return     */    public Long zReverseRank(String key, Object value) {        return redisTemplate.opsForZSet().reverseRank(key, value);    }    /**     * 获取集合的元素, 从小到大排序     *      * @param key     * @param start     *            开始位置     * @param end     *            结束位置, -1查询所有     * @return     */    public Set zRange(String key, long start, long end) {        return redisTemplate.opsForZSet().range(key, start, end);    }    /**     * 获取集合元素, 并且把score值也获取     *      * @param key     * @param start     * @param end     * @return     */    public Set> zRangeWithScores(String key, long start,            long end) {        return redisTemplate.opsForZSet().rangeWithScores(key, start, end);    }    /**     * 根据Score值查询集合元素     *      * @param key     * @param min     *            最小值     * @param max     *            最大值     * @return     */    public Set zRangeByScore(String key, double min, double max) {        return redisTemplate.opsForZSet().rangeByScore(key, min, max);    }    /**     * 根据Score值查询集合元素, 从小到大排序     *      * @param key     * @param min     *            最小值     * @param max     *            最大值     * @return     */    public Set> zRangeByScoreWithScores(String key,            double min, double max) {        return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max);    }    /**     *      * @param key     * @param min     * @param max     * @param start     * @param end     * @return     */    public Set> zRangeByScoreWithScores(String key,            double min, double max, long start, long end) {        return redisTemplate.opsForZSet().rangeByScoreWithScores(key, min, max,                start, end);    }    /**     * 获取集合的元素, 从大到小排序     *      * @param key     * @param start     * @param end     * @return     */    public Set zReverseRange(String key, long start, long end) {        return redisTemplate.opsForZSet().reverseRange(key, start, end);    }    /**     * 获取集合的元素, 从大到小排序, 并返回score值     *      * @param key     * @param start     * @param end     * @return     */    public Set> zReverseRangeWithScores(String key,            long start, long end) {        return redisTemplate.opsForZSet().reverseRangeWithScores(key, start,                end);    }    /**     * 根据Score值查询集合元素, 从大到小排序     *      * @param key     * @param min     * @param max     * @return     */    public Set zReverseRangeByScore(String key, double min,            double max) {        return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max);    }    /**     * 根据Score值查询集合元素, 从大到小排序     *      * @param key     * @param min     * @param max     * @return     */    public Set> zReverseRangeByScoreWithScores(            String key, double min, double max) {        return redisTemplate.opsForZSet().reverseRangeByScoreWithScores(key,                min, max);    }    /**     *      * @param key     * @param min     * @param max     * @param start     * @param end     * @return     */    public Set zReverseRangeByScore(String key, double min,            double max, long start, long end) {        return redisTemplate.opsForZSet().reverseRangeByScore(key, min, max,                start, end);    }    /**     * 根据score值获取集合元素数量     *      * @param key     * @param min     * @param max     * @return     */    public Long zCount(String key, double min, double max) {        return redisTemplate.opsForZSet().count(key, min, max);    }    /**     * 获取集合大小     *      * @param key     * @return     */    public Long zSize(String key) {        return redisTemplate.opsForZSet().size(key);    }    /**     * 获取集合大小     *      * @param key     * @return     */    public Long zZCard(String key) {        return redisTemplate.opsForZSet().zCard(key);    }    /**     * 获取集合中value元素的score值     *      * @param key     * @param value     * @return     */    public Double zScore(String key, Object value) {        return redisTemplate.opsForZSet().score(key, value);    }    /**     * 移除指定索引位置的成员     *      * @param key     * @param start     * @param end     * @return     */    public Long zRemoveRange(String key, long start, long end) {        return redisTemplate.opsForZSet().removeRange(key, start, end);    }    /**     * 根据指定的score值的范围来移除成员     *      * @param key     * @param min     * @param max     * @return     */    public Long zRemoveRangeByScore(String key, double min, double max) {        return redisTemplate.opsForZSet().removeRangeByScore(key, min, max);    }    /**     * 获取key和otherKey的并集并存储在destKey中     *      * @param key     * @param otherKey     * @param destKey     * @return     */    public Long zUnionAndStore(String key, String otherKey, String destKey) {        return redisTemplate.opsForZSet().unionAndStore(key, otherKey, destKey);    }    /**     *      * @param key     * @param otherKeys     * @param destKey     * @return     */    public Long zUnionAndStore(String key, Collection otherKeys,            String destKey) {        return redisTemplate.opsForZSet()                .unionAndStore(key, otherKeys, destKey);    }    /**     * 交集     *      * @param key     * @param otherKey     * @param destKey     * @return     */    public Long zIntersectAndStore(String key, String otherKey,            String destKey) {        return redisTemplate.opsForZSet().intersectAndStore(key, otherKey,                destKey);    }    /**     * 交集     *      * @param key     * @param otherKeys     * @param destKey     * @return     */    public Long zIntersectAndStore(String key, Collection otherKeys,            String destKey) {        return redisTemplate.opsForZSet().intersectAndStore(key, otherKeys,                destKey);    }    /**     *      * @param key     * @param options     * @return     */    public Cursor> zScan(String key, ScanOptions options) {        return redisTemplate.opsForZSet().scan(key, options);    }}

第六步:用工具类进行测试

测试

@SpringBootTestclass Redis02SpringbootApplicationTests {    @Autowired    private RedisTemplate redisTemplate;    @Test    void contextLoads() {        redisUtil.set("mykey", "我是大帅哥");        System.out.println(redisUtil.get("mykey"));    }}

第一步:导包

     org.springframework.boot      spring-boot-starter-data-redis

第二步:yml配置文件改变

在原来的mysql配置基础上,再加上redis的配置

spring:  datasource:    driver-class-name: com.mysql.jdbc.Driver    url: jdbc:mysql://localhost:3306/book?useSSL=false    username: root    password: root    type: com.alibaba.druid.pool.DruidDataSource  redis:    # Redis数据库索引(默认为0)    database: 0    # host主机,默认为localhost    host: 127.0.0.1    # 端口号,默认为6379    port: 6379    # 密码,默认为空    password:    # 连接池    jedis:      pool:        # 连接池最大连接数(使用负值表示没有限制)        max-active: 8        # 连接池中的最小空闲连接        min-idle: 0        # 连接池中的最大空闲连接        max-idle: 8        # 连接池最大阻塞等待时间(使用负值表示没有限制)        max-wait: -1    # 连接超时时间(毫秒)    timeout: 5000

第三步:序列化要传输的数据

第四步:编写redisconfig配置文件

RedisConfiguration(序列化,必须配置,不然会json格式在redis中缓存会乱码; Springboot1.x和2.x版本的序列化配置也不同,需要特别注意)

package com.hzf.config;import org.springframework.cache.CacheManager;import org.springframework.cache.annotation.CachingConfigurerSupport;import org.springframework.cache.annotation.EnableCaching;import org.springframework.cache.interceptor.KeyGenerator;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.data.redis.cache.RedisCacheManager;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.JdkSerializationRedisSerializer;import org.springframework.data.redis.serializer.StringRedisSerializer;import java.lang.reflect.Method;@Configuration@EnableCachingpublic class RedisConfiguration extends CachingConfigurerSupport {    /**     * 缓存对象集合中,缓存是以 key-value 形式保存的。当不指定缓存的 key 时,SpringBoot 会使用 SimpleKeyGenerator 生成 key。     * @return     */    @Bean    public KeyGenerator keyGenerator() {        return new KeyGenerator() {            @Override            public Object generate(Object target, Method method, Object... params) {                StringBuilder sb = new StringBuilder();                sb.append(target.getClass().getName());                sb.append(method.getName());                for (Object obj : params) {                    sb.append(obj.toString());                }                return sb.toString();            }        };    }    @Bean    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {        RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory).build();        return redisCacheManager;    }    /**     * @return 返回类型     * @Description: 防止redis入库序列化乱码的问题     */    @Bean    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {        RedisTemplate redisTemplate = new RedisTemplate();        redisTemplate.setConnectionFactory(redisConnectionFactory);        redisTemplate.setKeySerializer(new StringRedisSerializer());//key序列化        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Object.class));  //value序列化        redisTemplate.setHashKeySerializer(new StringRedisSerializer());        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());        redisTemplate.afterPropertiesSet();        return redisTemplate;    }}

第五步:在我原有的项目controller中要使用缓存

注解作用
@Cacheable在方法执行前Spring先查看缓存中是否有数据,如果有数据,则直接返回缓存数据;没有则调用方法并将方法返回值放进缓存。
@CachePut将方法的返回值放到缓存中。
@CacheEvict删除缓存中的数据。

我这里将我的controller层某个方法返回的数据,上加上@Cacheable注解,也就是我们在第一次查询后的数据将放入redis中,不会继续再走mysql查询了

关于@Cacheable注解的详解,看别的博主所写
https://blog.csdn.net/qq_31404603/article/details/88081039

//主页推荐书籍    @Cacheable(value = "recommendbooks")    @RequestMapping(value = "/recommendBook", method = {RequestMethod.GET})    public ServerResponse recommendBook(){       System.out.println("第一次查询,会显示这个信息");        bookService.updaterecommend();        List books = bookService.recommendBook();        if(books != null){            return ServerResponse.success("操作成功").data("recommendbooks",books);        }        return ServerResponse.error("操作失败");    }

第五步:启动类上开启使用缓存

@EnableCaching 注解配置启用缓存

第六步:测试

启动项目,访问controller层的这个使用缓存的方法
网页显示的数据如下:

后端控制台显示

之后不管怎么刷新请求,控制台不在输出那句话,且只查询了一次
想要看到redis里面是否已经存入,我们可以直接通过命令行的方式

keys * 找到所有keyget key 查找某个数据

也可以通过可视化工具进行查看
看第四part

项目中用到了redis,想查询redis中的数据,一直想找一个可视化工具,今天发现了Redis Desktop Manager,试用了一下,很好用。

第一步:下载

Redis Desktop Manager是开源的,可以在github下载到源码。但是想在windows上用的话需要安装包。
官网下载:https://redisdesktop.com/download
github地址:https://github.com/uglide/RedisDesktopManager/releases
官网地址下载需要订阅,花钱的,还是算了吧。
晚上找到了一个免费下载的云盘:
百度网盘:http://pan.baidu.com/s/1kU8sY3P

第二步:安装

exe文件,一路next就行了

第三步:使用

连接redis服务器:


这里连接的前提是你要连的redis服务已启动

第四步:看实例

基于第三part实际项目的数据
可以看到存入redis中的数据,如果要是删除后,下次请求,还是先会找redis中是否有数据,有就直接返回,没有的话重新从mysql查数据,再放去redis中。

到此,关于"redis使用实例分析"的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!若想继续学习更多相关知识,请继续关注网站,小编会继续努力为大家带来更多实用的文章!

元素 数据 时间 多个 缓存 配置 查询 序列 方法 存储 位置 字段 哈希 数据库 服务 实例 工具 交集 字符 注解 数据库的安全要保护哪些东西 数据库安全各自的含义是什么 生产安全数据库录入 数据库的安全性及管理 数据库安全策略包含哪些 海淀数据库安全审计系统 建立农村房屋安全信息数据库 易用的数据库客户端支持安全管理 连接数据库失败ssl安全错误 数据库的锁怎样保障安全 打不开网页显示服务器停止响应 大华股份软件开发上下班时间 数据库一般在什么系统上运行 近期网络安全手抄报图片 无代码软件开发串口助手 网络安全专项 网络安全扫描检测技术 宁波交易软件开发 数据库删除账号怎么办 自己搭建h5服务器 杭州交友软件开发机构 数据库ifnull 如何预防黑客攻击 保护网络安全 数据库统计人数的代码 数据库安全性控制技术规范 梦幻西游杨洋在哪个服务器 wind数据库查上市公司数据 色弱能进软件开发行业么 腾讯云服务器关机有影响吗 小规模软件开发账务处理 软件开发过程中的架构 数据库保存不了中文乱码 河北交管12123服务器云主机 云计算服务器什么意思 软件开发流程及各类相关文档 软件开发需要的合作企业 三级数据库技术包括哪些 小米电视登陆服务器异常 腾讯云服务器关机有影响吗 数据库连接数一直很高
0