基于Spring Boot2.x使用Redis(Lettuce)详细教程---Redis数据类型之String类型 (三)

最新推荐文章于 2023-05-02 21:37:28 发布
最新推荐文章于 2023-05-02 21:37:28 发布
阅读量328 收藏
点赞数
分类专栏： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jetty_welcome/article/details/104867253
版权

string是redis最基本的类型，一个key对应一个value。string类型是Redis最基本的数据类型，一个键最大能存储512MB。

3.1 应用场景

String通常用于保存单个字符串或JSON字符串数据,常用的场景有：统计网站访问数量、当前在线人数、微博数、粉丝数等，全局递增ID等 。

3.2 代码示例

代码：com.javablog.redis.demo.service.impl.KeyValueCacheServiceImpl

package com.javablog.redis.demo.service.impl;

import com.javablog.redis.demo.service.KeyValueCacheService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@Service("keyValueCacheService")
public class KeyValueCacheServiceImpl implements KeyValueCacheService {
    private final static Logger log = LoggerFactory.getLogger(KeyValueCacheServiceImpl.class);

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;


    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @param expireTime 超时时间(秒)
     * @return true成功 false失败
     */
    @Override
    public Boolean set(String key, Object value, int expireTime) {
        try {
            redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @param expireTime 超时时间(秒)
     * @return true成功 false失败
     */
    @Override
    public Boolean set(String key, String value, int expireTime) {
        try {
            stringRedisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    @Override
    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 值
     * @return true成功 false失败
     */
    @Override
    public Boolean set(String key, String value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    @Override
    public String get(String key) {
        return key == null ? null : (String) stringRedisTemplate.opsForValue().get(key);
    }

    /**
     * 在原有的值基础上新增字符串到末尾。
     * @param key 键
     * @param value 追加的值
     * @return true成功 false失败
     */
    @Override
    public void append(String key, String value) {
        stringRedisTemplate.opsForValue().append(key,value);
    }

    /**
     * 截取key键对应值得字符串，从开始下标位置开始到结束下标的位置(包含结束下标)的字符串。
     * @param key   键
     * @param start 开始位置
     * @param end   结束位置
     * @return
     */
    @Override
    public String get(String key, long start, long end) {
        return stringRedisTemplate.opsForValue().get(key,start,end);
    }

    /**
     * 获取原来key键对应的值并重新赋新值。
     * @param key 键
     * @param value 值
     * @return 原来旧值
     */
    @Override
    public Object getAndSet(String key, String value) {
        return stringRedisTemplate.opsForValue().getAndSet(key,value);
    }

    /**
     * 覆盖从指定位置开始的值。
     * @param key  键
     * @param value  值
     * @param offset  位置
     */
    @Override
    public void set(String key, String value, long offset) {
        redisTemplate.opsForValue().set(key,value,offset);
    }

    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    @Override
    public Object getObject(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取指定字符串的长度。
     * @param key
     * @return 长度
     */
    @Override
    public long size(String key) {
        return stringRedisTemplate.opsForValue().size(key);
    }

    /**
     * 如果键不存在则新增,存在则不改变已经有的值
     * @param key
     * @param value
     * @return true成功 false失败
     */
    @Override
    public boolean setIfAbsent(String key, String value){
        return stringRedisTemplate.opsForValue().setIfAbsent(key,value);
    }

    /**
     * 删除指定KEY的缓存
     * @param keys
     */
    @Override
    public void del(String... keys) {
        if (keys != null && keys.length > 0) {
            if (keys.length == 1) {
                redisTemplate.delete(keys[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(keys));
            }
        }
    }

    /**
     * 根据key设置过期时间
     * @param key 键
     * @param seconds 超时时间(秒)
     * @return true成功 false失败
     */
    @Override
    public boolean expire(String key, long seconds) {
        return redisTemplate.expire(key,seconds,TimeUnit.SECONDS);
    }

    /**
     * 根据key获取过期时间
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    @Override
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 递增
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return 返回增加后的值
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return stringRedisTemplate.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 stringRedisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * 设置map集合到redis。
     * @param map
     */
    @Override
    public void multiSet(Map map) {
        stringRedisTemplate.opsForValue().multiSet(map);
    }

    /**
     * 根据集合取出对应的value值。
     * @param list
     * @return
     */
    @Override
    public List multiGet(List list) {
        return stringRedisTemplate.opsForValue().multiGet(list);
    }
}

3.3 测试用例

代码：com.javablog.redis.demo.KeyValueCacheServiceImplTest

package com.javablog.redis.demo;

import com.javablog.redis.demo.service.KeyValueCacheService;
import junit.framework.TestCase;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = CacheServiceApplication.class)
@WebAppConfiguration
public class KeyValueCacheServiceImplTest {
    private final static Logger log = LoggerFactory.getLogger(KeyValueCacheServiceImplTest.class);

    @Autowired
    private KeyValueCacheService redisService;

    //普通缓存测试
    @Test
    public void testSetGetString(){
        redisService.set("key","value",1000);
        String str = redisService.get("key1");
        System.out.println("查询结果:" + str);

        //在原有的值基础上新增字符串到末尾。 redisTemplate读不出APPEND的值，stringRedisTemplate可以
        redisService.append("key","add string");
        str = redisService.get("key");
        System.out.println("通过append(K key, String value)方法修改后的字符串:" + str);

        //截取key键对应值得字符串，从开始下标位置开始到结束下标的位置(包含结束下标)的字符串。
        String cutString = redisService.get("key",0,4);
        System.out.println("通过get(K key, long start, long end)方法获取截取的字符串:"+cutString);

        // 获取原来key键对应的值并重新赋新值。
        String oldAndNewStringValue = (String)redisService.getAndSet("key","new value");
        System.out.print("通过getAndSet(K key, V value)方法获取原来的" + oldAndNewStringValue + ",");
        String newStringValue = redisService.get("key");
        System.out.println("修改过后的值:"+newStringValue);

        //获取指定字符串的长度。
        Long stringValueLength = redisService.size("key");
        System.out.println("通过size(K key)方法获取字符串的长度:"+stringValueLength);

        //如果键不存在则新增,存在则不改变已经有的值。
        boolean absentBoolean = redisService.setIfAbsent("absentKey","fff");
        System.out.println("通过setIfAbsent(K key, V value)方法判断变量值absentValue是否存在:" + absentBoolean);
        if(absentBoolean) {
            String absentValue = redisService.get("absentKey") + "";
            System.out.print(",不存在，则新增后的值是:" + absentValue);
            boolean existBoolean = redisService.setIfAbsent("absentKey", "eee");
            System.out.println(",再次调用setIfAbsent(K key, V value)判断absentValue是否存在并重新赋值:" + existBoolean);
            if (!existBoolean) {
                absentValue = redisService.get("absentKey") + "";
                System.out.println("如果存在,则重新赋值后的absentValue变量的值是:" + absentValue);
            }
        }

        redisService.del("key");
        System.out.println("删除后再查结果:" + redisService.get("key"));
    }

    //集合功能测试
    @Test
    public void testmulti() {
        Map valueMap = new HashMap();
        valueMap.put("valueMap1", "map1");
        valueMap.put("valueMap2", "map2");
        valueMap.put("valueMap3", "map3");
        redisService.multiSet(valueMap);

        //根据集合取出对应的value值。
        List paraList = new ArrayList();
        paraList.add("valueMap1");
        paraList.add("valueMap2");
        paraList.add("valueMap3");
        List<String> valueList = redisService.multiGet(paraList);
        for (String value : valueList) {
            System.out.println("通过multiGet(Collection<K> keys)方法获取map值:" + value);
        }
    }

    //针对复杂的对象类型测试
    @Test
    public void testSetGetObject(){
        User user =new User();
        user.setAge(22);
        user.setName("张三");
        user.setUserId("1234567");
        redisService.set("userid:1234567",user,1000);
        User userEntity = (User) redisService.getObject("userid:1234567");
        System.out.println("user info>>>>>>>>>>>>>>>>>:" + userEntity.toString());
        TestCase.assertNotSame(user,userEntity);
    }

    // 过期测试
    @Test
    public void testSetKeyExpire() throws InterruptedException {
        redisService.set("expirekey","值");
        redisService.expire("expirekey" ,30);
        System.out.println("超时前取值:" + redisService.get("expirekey"));
        System.out.println("获取过期时间:" + redisService.getExpire("expirekey")+"秒") ;
        Thread.sleep(5000);
        String str = redisService.get("expirekey");
        System.out.println("超时后取值:"  + redisService.get("expirekey"));
    }

    // 计数测试
    @Test
    public void testIncrDecr() throws InterruptedException {
        redisService.incr("count:pv",10000);
        System.out.println("统计PV的数值:" + redisService.getObject("count:pv"));
        redisService.decr("count:pv",5000);
        Integer count = (Integer)redisService.getObject("count:pv");
        System.out.println("统计decr后的PV的数值:"  + count);
    }
}

github源码地址

java播客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot2配置Lettuce连接池完整代码
03-27
springboot2配置Lettuce连接池完整代码，采用common2-pool连接池，Lettuce为redis高级客户端，由于阅读官网文档太简单，无法完成配置，所有本示例是通过阅读源码后编写的
基于Spring Boot2.x使用Redis(Lettuce)详细教程---Redis使用环境配置 (一)
jetty_welcome的博客
03-14 1733
1.1 maven配置 新建SpringBoot2.0.3的WEB工程，在MAVEN的pom.xml文件中加入如下依赖 pom文件： <dependencies> <!--默认是lettuce客户端--> <dependency> <groupId>org.springframework.boot&...
在springboot中使用lettuce来连接redis
程序员徐小白的博客
03-01 2986
一.搭建一个项目 选中spring initializr 设置好项目名和包名后next 设置要用的jar包，然后next，finish 二.配置lettuce 在pom.xml文件添加依赖 <!--默认使用的是lettuce--> <dependency> <groupId>org.springframe...
SpringBoot集成redis乱码问题以及工具类
qq_38786320的博客
10-10 515
版本 SoringBoot2.1.2 Redis集成SpringBoot中产生乱码问题，引入下方类可解决（注意扫描该配置） import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframew...
Lettuce在Spring boot中的使用方式
weixin_30709061的博客
06-06 220
Lettuce是一个可伸缩线程安全的Redis客户端。多个线程可以共享同一个RedisConnection.本文是基于Lettuce5,主要介绍的知识点如下: Lettuce在Spring Boot中的配置 Lettuce的同步,异步,响应式使用方式 事件的订阅 发布自定义事件 读写分离 读写分离策略实现源码 客户端分片实现 @Configuration p...
Redis-x64-5.0.10.zip、Redis-x64-5.0.10.msi
02-06
Redis-x64-5.0.10.msi
Redis-x64-3.2.100.zip和Redis-x64-3.2.100.msi
04-23
资源在github上下载下来，包含Redis-x64-3.2.100.zip和Redis-x64-3.2.100.msi两个文件
Redis稳定版 Redis-x64-5.0.14.1.zip
07-21
Redis稳定版 Redis-x64-5.0.14.1.zip
Redis-x64-3.0.504安装包
最新发布
10-11
Redis-x64-3.0.504安装包
Redis-x64-3.0.504&Redis;-x64-3.2.100&redis;-desktop-manager-0.9.3.817
01-28
windows系统redis安装文件，Redis-x64-3.0.504（稳定版）；Redis-x64-3.2.100（预发行版）；redis-desktop-manager-0.9.3.817（redis界面工具）。具体安装方法详见：...
SpringBoot集成Lettuce
我的博客
05-02 767
SpringBoot从2.0起默认使用lettuce客户端进行连接。
springboot整合redis
仲夏的博客
03-17 289
springboot整合redis，实现增删改查操作 首先创建一个Maven工程，导入相关依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-parent</artifactId> ...
boot spring 插入一条数据_SpringBoot整合Lettuce实现对5种数据类型的操作
weixin_35744067的博客
12-25 164
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达 作者|缘未到来源 | urlify.cn/aUb6Nr1.在SpringBoot2.x版本之后,以下依赖默认使用Lettuce实现对redis的操纵。org.springframework.bootspring-boot-starter-data-redis2.添加对象池依赖org.ap...
常用的redis客户端Jedis 、Lettuce 、Redisson 介绍以及对比
jetty_welcome的博客
02-16 6315
Jedis api 在线网址：http://tool.oschina.net/uploads/apidocs/redis/clients/jedis/Jedis.html redisson 官网地址：https://redisson.org/ redisson git项目地址：https://github.com/redisson/redisson lettuce 官网地址：https://l...
基于Spring Boot2.x使用Redis(Lettuce)详细教程---Redis分布式锁(九)
jetty_welcome的博客
03-14 2719
9.1 分布式锁 随着互联网的兴起，现代软件发生了翻天覆地的变化，以前单机的程序，已经支撑不了现代的业务。无论是在抗压，还是在高可用等方面都需要多台计算机协同工作来解决问题。现代的互联网系统都是分布式部署的，分布式部署确实能带来性能和效率上的提升，但为此，我们就需要多解决一个分布式环境下，数据一致性的问题。 当某个资源在多系统之间共享的时候，为了保证大家访问这个资源数据是一致的，那么就必须要求在同...
基于Spring Boot2.x使用Redis(Lettuce)详细教程---Redis 发布订阅 (八)
jetty_welcome的博客
03-14 1446
8.1 应用场景 一般来说，消息队列有两种场景，一种是发布者订阅者模式，一种是生产者消费者模式。利用redis这两种场景的消息队列都能够实现。 定义： 生产者消费者模式：生产者生产消息放到队列里，多个消费者同时监听队列，谁先抢到消息谁就会从队列中取走消息；即对于每个消息只能被最多一个消费者拥有。 ​ 发布者订阅者模式：发布者生产消息放到队列里，多个监听队列的消费者都会收到同一份消息...
基于Spring Boot2.x使用Redis(Lettuce)详细教程---Redis的开发规范 (十)
jetty_welcome的博客
03-14 1135
10.1、键值设计 1、key名设计 可读性和可管理性 以业务名(或数据库名)为前缀(防止key冲突)，用冒号分隔，比如业务名:表名:id ugc:video:1 简洁性 保证语义的前提下，控制key的长度，当key较多时，内存占用也不容忽视，例如： user:{uid}:friends:messages:{mid}简化为u:{uid}:fr:m:{mid}。 不要包含特殊字符 反例：包含空格...
基于Spring Boot2.x使用Redis(Lettuce)详细教程---Redis数据类型哈希(Hash) (四)
jetty_welcome的博客
03-14 863
Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象。 Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿），可以看成具有KEY和VALUE的MAP容器，该类型非常适合于存储值对象的信息， 如：uname,upass,age等。该类型的数据仅占用很少的磁盘空间（相比于JSON）。 4.1 应用场景 保存纪录中的详细信息。比...
编写一个spring-boot-starter-data-redis的测试demo
07-11
当然，我可以帮你编写一个Spring Boot Starter Data Redis的测试demo。首先，你需要在你的项目中添加以下依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值