SpringBoot中Redis的基础使用

这篇具有很好参考价值的文章主要介绍了SpringBoot中Redis的基础使用。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

基础使用

首先引入依赖

 <!-- redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>

然后在application.yml的spring下增加redis配置:

SpringBoot中Redis的基础使用

代码如下

 redis:
    # Redis数据库索引(默认为0)
    database: 0
    # Redis服务器地址
    host: 127.0.0.1
    # Redis服务器连接端口
    port: 6379
    password: '123456'
    jedis:
      pool:
        # 连接池最大连接数(使用负值表示没有限制)
        max-active: 8
        # 连接池最大阻塞等待时间(使用负值表示没有限制)
        max-wait: 1
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池中的最小空闲连接
        min-idle: 0
    # 连接超时时间(毫秒)
    timeout: 5000

然后在根包下创建一个service的文件夹加,然后在里面增加redis文件夹,redis文件夹里编写redis的基础操作函数。

编写IRedisService接口,编写增删改查函数,代码如下:

import java.util.Map;
​
@Service
public interface IRedisService {
    /**
     * 加入元素
     * @param key
     * @param value
     */
    void  setValue(String key, Map<String, Object> value);
    /**
     * 加入元素
     * @param key
     * @param value
     */
    void  setValue(String key, String value);
    /**
     * 加入元素
     * @param key
     * @param value
     */
    void   setValue(String key, Object value);
    /**
     * 获取元素
     * @param key
     */
    Object getMapValue(String key);
    /**
     * 获取元素
     * @param key
     */
    Object getValue(String key);
​
}

编写RedisServiceImpl实现,实现Redis的增删改查。

package com.example.dynamicdb.service.redis;
​
import org.springframework.beans.factory.annotation.Autowired;
​
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
​
import java.util.Map;
import java.util.concurrent.TimeUnit;
​
@Service("RedisServiceImpl")
public class RedisServiceImpl implements IRedisService {
​
    public RedisServiceImpl(){}
​
    @Autowired
    private RedisTemplate redisTemplate;
​
​
    @Override
    public void setValue(String key, Map<String, Object> value) {
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        vo.set(key, value);
        redisTemplate.expire(key, 1, TimeUnit.HOURS);
    }
​
    @Override
    public Object getValue(String key) {
        ValueOperations<String, String> vo = redisTemplate.opsForValue();
        return vo.get(key);
    }
​
    @Override
    public void setValue(String key, String value) {
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        vo.set(key, value);
        redisTemplate.expire(key, 1, TimeUnit.HOURS);
    }
​
    @Override
    public void setValue(String key, Object value) {
        ValueOperations<String, Object> vo = redisTemplate.opsForValue();
        vo.set(key, value);
        redisTemplate.expire(key, 1, TimeUnit.HOURS);
    }
​
    @Override
    public Object getMapValue(String key) {
        ValueOperations<String, String> vo = redisTemplate.opsForValue();
        return vo.get(key);
    }
​
}

然后创建一个RedisController,编写一个测试接口,如下:

@RestController
public class RedisController {
    @Resource(name = "RedisServiceImpl")//使用resource实例化对象,name是指定实例化的类,用于一个接口多个类继承的情况
    private IRedisService iRedisService;
    @PostMapping(value = "/Redis/TestRedis")
    @ApiOperation(value = "redis测试接口", notes = "redis测试接口", httpMethod = "POST")
    public String TestRedis(){
        iRedisService.setValue("redis", "这是redis的测试数据");
        Object redis = iRedisService.getValue("redis");
        return redis.toString();
    }
}

redis缓存使用

首先创建一个config文件夹,然后创建一个RedisCacheConfig文件,代码如下:

​
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
​
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;
​
@EnableCaching
@Configuration
public class RedisCacheConfig {
​
​
    /**
     * 最新版,设置redis缓存过期时间
     */
​
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        return new RedisCacheManager(
                RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
                this.getRedisCacheConfigurationWithTtl( 60), // 默认策略,未配置的 key 会使用这个
                this.getRedisCacheConfigurationMap() // 指定 key 策略
        );
    }
​
    private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
        Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
        //SsoCache和BasicDataCache进行过期时间配置
        redisCacheConfigurationMap.put("messagCache", this.getRedisCacheConfigurationWithTtl(30 * 60));
​
        //自定义设置缓存时间
        redisCacheConfigurationMap.put("studentCache", this.getRedisCacheConfigurationWithTtl(60 ));
​
        return redisCacheConfigurationMap;
    }
​
    private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
        redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
                RedisSerializationContext
                        .SerializationPair
                        .fromSerializer(jackson2JsonRedisSerializer)
        ).entryTtl(Duration.ofSeconds(seconds));
​
        return redisCacheConfiguration;
    }
}

类名上有注解@Configuration,代表该类会在启动时加入进bean集合。

然后在RedisController下编写测试函数,如下:

 @Autowired
    private SqlSession sqlSession;
    @GetMapping(value = "/Redis/TestRedisCache")
    @ResponseBody
    @DS("db2")
    @Cacheable(cacheNames = "userCache", key = "#id")
    @ApiOperation(value="查询单条记录",notes = "查询")
    public List<user> TestRedisCache(Integer id) {
        //读取第二个数据库的值
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<user> users = mapper.test();
        return users;
    }

使用@Cacheable注解缓存接口的返回值,cacheNames的值和key的值,组合起来成为是缓存中的键值对的key值,如下图。

SpringBoot中Redis的基础使用

----------------------------------------------------------------------------------------------------

到此,SpringBoot中Redis的基础使用就已经介绍完了。

代码已经传到Github上了,欢迎大家下载。

Github地址:https://github.com/kiba518/dynamicdb

----------------------------------------------------------------------------------------------------

注:此文章为原创,任何形式的转载都请联系作者获得授权并注明出处!
若您觉得这篇文章还不错,请点击下方的推荐】,非常感谢!

https://www.cnblogs.com/kiba/p/17480377.html

 SpringBoot中Redis的基础使用

 文章来源地址https://www.toymoban.com/news/detail-482166.html

到了这里,关于SpringBoot中Redis的基础使用的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Redis——关于它为什么快?使用场景?以及使用方式?为何引入多线程?

    目录 1.既然redis那么快,为什么不用它做主数据库,只用它做缓存? 2.Redis 一般在什么场合下使用?  3.redis为什么这么快? 4.Redis为什么要引入了多线程? redis设计者的初衷,就只是为了存储 小量级的共享数据 。 所以,他敢直接单线程直接干上去,因为数据量小,所以够快

    2024年01月25日
    浏览(49)
  • SpringBoot引入OpenFeign,不使用注册中心

    【前言】 最近接到一个需求,需要对接第三方平台的api,在设计方案通过之后,打算将对接服务拆分出来,因为现在的项目没有使用到注册中心,打算单独引入OpenFeign组件简化服务通信方式,也为了更好的支持项目后续向微服务的转变! 很多人以为OpenFeign必须依赖于注册中

    2024年02月06日
    浏览(30)
  • 【SpringBoot】从零开始封装自己的starter并且引入到其他项目中使用

    简介 本文将介绍如何从零开始封装自己的starter并且引入到其他项目中使用 为什么要自己封装starter? 这样可以对spring以及其他第三方提供的starter做二次封装或者封装一些自己需要的内容提供给其他项目使用,提高项目级的代码复用性。 一、创建一个新的spring-boot项目 首先我

    2024年02月16日
    浏览(55)
  • redis(12):springboot使用redis注解做缓存

    1 新建springboot项目   2 相关注解 @EnableCaching 在启动类上加上注解启动缓存 #作用在你要缓存的数据上 @Cacheable(key=\\\"#id\\\",cacheNames=\\\"com.sxt.service.impl.MenuServiceImpl\\\") @Cacheput 解决脏读 @CachEvict(解决脏读) @Cacheconfig(全局的配置缓存) 3 修改yml

    2024年02月15日
    浏览(44)
  • SpringBoot集成Redis及Redis使用方法

    目录 应用背景 Redis简介 更新问题 一:环境配置 1.1: 在pom.xml文件中添加依赖 1.2:配置SpringBoot核心配置文件application.properties 二:在Config文件夹中创建RedisConfig配置文件类 2.1:RedisTemplate中的几个角色: 2.2:为什么要自定义序列化: 2.2.1:Spring 中提供了以下几个序列化器: 四

    2024年02月13日
    浏览(34)
  • springboot使用redis

    默认有三种方式连接redis. 第一种:jedis—传统的项目–ssm 第二种:lettuce:----刚出现没有多久就被springboot整合进来。 第三种:springboot连接redis (1)引入jedis依赖 (2)编写相关的代码 每次使用jedis对象时 都需要自己创建,当使用完后,需要关闭该对象。===jedis中也存在连接池. s

    2024年02月03日
    浏览(24)
  • 【SpringBoot】第一篇:redis使用

    背景: 本文是教初学者如何正确使用和接入redis。     好了,到此处就已经介绍完毕了! 如果有什么问题可以问博主的,可以在底下进行留言,看到一定回复你们。

    2024年02月11日
    浏览(36)
  • springboot中redis的使用

    springboot中redis的使用 一、springboot整合redis 1.1 基本使用 1、导入依赖 2、添加redis配置 此时已经可以在代码中使用redisTemplate对象了。例如: 但是,查看redis中存储的数据发现,key和value前面都有一段看似乱码的数据,而且中文也进行编码。为了解决该问题,需要参考前面ssm中整

    2024年02月17日
    浏览(32)
  • SpringBoot集成Redis使用Lettuce

            Redis是最常用的KV数据库,Spring 通过模板方式(RedisTemplate)提供了对Redis的数据查询和操作功能。本文主要介绍基于RedisTemplate + lettuce方式对Redis进行查询和操作的案例。 一、Redis基础数据类型         首先对redis来说,所有的key(键)都是字符串。我们在谈基

    2024年02月05日
    浏览(53)
  • SpringBoot 如何使用 Redis 作为缓存?

    在今天的互联网应用中,缓存是一个非常重要的概念。缓存可以减轻数据库的负担,提高系统的性能。Redis 是一个非常流行的内存数据库,它可以用作缓存,提供快速的读写速度和高可用性。在本文中,我们将介绍如何在 SpringBoot 中使用 Redis 作为缓存。 Redis 是一个高性能的

    2024年02月11日
    浏览(35)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包