springboot 整合Redis实现分布式缓存

最新推荐文章于 2023-05-19 22:07:23 发布
最新推荐文章于 2023-05-19 22:07:23 发布
阅读量919 收藏 4
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovely960823/article/details/107541875
版权

为什么要使用分布式缓存，因为本地缓存容易丢失。
这里来简单实现以下分布式缓存，即把缓存放入redis中。首先环境什么的我就默认配置好了，下面上主要代码。
没有使用缓存之前我的查询是这样的
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
开始设计缓存。
第一步开启缓存，这里我们自定义一个类来实现他的方法（cache-ref在关联表中的xml使用，这样的话，缓存就会是同一个命名空间了，操作也会关联在一起，比如当关联表被修改，数据也会被清除）
在这里插入图片描述

package boot.cache.mycache;

import java.util.concurrent.locks.ReadWriteLock;

import org.apache.ibatis.cache.Cache;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import boot.cache.utils.AppGetBean;

public class RedisCache implements Cache {
	
	//使用StringRedisTemplate key value 都是string类型，结果集会不正确
	
	//缺少参数id：Base cache implementations must have a constructor that takes a String id as a parameter
	private  String id; // 后期得知这是namespace  eg:boot.cache.mapper.UserMapper
	
	public RedisCache(String id) {
		this.id=id;
	}
	
	/**
	 * 当有变动，例如添加修改删除的时候，缓存清空
	 */
	@Override
	public void clear() {
		RedisTemplate<String,Object> redisTemplate = getStringRedisTemplate();
		redisTemplate.delete(id.toString());
	}

	@Override
	public String getId() {
		// TODO Auto-generated method stub
		return id;
	}

	/**
	 * 取缓存值
	 */
	@Override
	public Object getObject(Object arg0) {
		RedisTemplate<String,Object> redisTemplate = getStringRedisTemplate();
		return redisTemplate.opsForHash().get(id.toString(), arg0.toString());
	}

	@Override
	public ReadWriteLock getReadWriteLock() {
		// TODO Auto-generated method stub
		return null;
	}

	/**
	 * The number of elements stored in the cache (not its capacity)
	 */
	@Override
	public int getSize() {
		RedisTemplate<String,Object> redisTemplate = getStringRedisTemplate();
		return redisTemplate.opsForHash().size(id.toString()).intValue();
	}

	/**
	 * 放入缓存中
	 */
	@Override
	public void putObject(Object arg0, Object arg1) {
		//arg0:namespace+mapper的id
		//arg1：结果集
		RedisTemplate<String,Object> redisTemplate = getStringRedisTemplate();
		redisTemplate.opsForHash().put(id.toString(), arg0.toString(), arg1);
		redisTemplate.expire(id.toString(),300, TimeUnit.SECONDS);//设置有效期五分钟
		
	}

	@Override
	public Object removeObject(Object arg0) {
		// TODO Auto-generated method stub
		return null;
	}

	
	//获取redisTemplate 模板 
	@SuppressWarnings("unchecked")
	private RedisTemplate<String,Object> getStringRedisTemplate(){
		return (RedisTemplate<String,Object>) AppGetBean.getBean("redisTemplate");
	}
}

获取模板类

package boot.cache.utils;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class AppGetBean implements ApplicationContextAware  {

	 private static ApplicationContext applicationContext;
	
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
		
	}

	public static Object getBean(String beanName){
		return applicationContext.getBean(beanName);
	}
}

看效果
首先看redis里面没有任何值
在这里插入图片描述
开始查询，我们发现第一次查询数据库了 第二次则么有
在这里插入图片描述
此时redis里面有一个key 并且类型为hash
在这里插入图片描述

再次查询数据库，我们发现完全没有打印SQL
在这里插入图片描述
到这一个简单的redis缓存做好了，主要说明都在代码上

为了阅读性更强，一般都重写序列化方式，附上配置类

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.StringRedisSerializer;

/**
 * @author ljw
 * @create 2021-01-22-11:46
 */
@Configuration
public class RedisConfig {

	@Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }
}

分享两个好用的工具类，从若依上面拷贝下来的。20210421
模板获取工厂类

import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import com.ruoyi.common.utils.StringUtils;

/**
 * spring工具类 方便在非spring管理环境中获取bean
 * 
 * @author ruoyi
 */
@Component
public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware 
{
    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

    private static ApplicationContext applicationContext;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException 
    {
        SpringUtils.beanFactory = beanFactory;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException 
    {
        SpringUtils.applicationContext = applicationContext;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws org.springframework.beans.BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws org.springframework.beans.BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name)
    {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getAliases(name);
    }

    /**
     * 获取aop代理对象
     * 
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker)
    {
        return (T) AopContext.currentProxy();
    }

    /**
     * 获取当前的环境配置，无配置返回null
     *
     * @return 当前的环境配置
     */
    public static String[] getActiveProfiles()
    {
        return applicationContext.getEnvironment().getActiveProfiles();
    }

    /**
     * 获取当前的环境配置，当有多个环境配置时，只获取第一个
     *
     * @return 当前的环境配置
     */
    public static String getActiveProfile()
    {
        final String[] activeProfiles = getActiveProfiles();
        return StringUtils.isNotEmpty(activeProfiles) ? activeProfiles[0] : null;
    }
}

RedisCache类

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

/**
 * spring redis 工具类
 *
 * @author ruoyi
 **/
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{
    @Autowired
    public RedisTemplate redisTemplate;

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value)
    {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout)
    {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key Redis键
     * @param timeout 超时时间
     * @param unit 时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit)
    {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 获得缓存的基本对象。
     *
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key)
    {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 删除单个对象
     *
     * @param key
     */
    public boolean deleteObject(final String key)
    {
        return redisTemplate.delete(key);
    }

    /**
     * 删除集合对象
     *
     * @param collection 多个对象
     * @return
     */
    public long deleteObject(final Collection collection)
    {
        return redisTemplate.delete(collection);
    }

    /**
     * 缓存List数据
     *
     * @param key 缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList)
    {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key)
    {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key 缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> long setCacheSet(final String key, final Set<T> dataSet)
    {
        Long count = redisTemplate.opsForSet().add(key, dataSet);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的set
     *
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(final String key)
    {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key
     * @param dataMap
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
    {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(final String key)
    {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value)
    {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey)
    {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
    {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern)
    {
        return redisTemplate.keys(pattern);
    }
}
好诡异
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot整合redis、mybatis以及redis和mybatis的联合使用
09-17
springboot集成redis、mybatis...5、springboot实现初始化加载配置（实现缓存预热）的两种方式 6、二级缓存联合使用 方式一：redis原生方法工具类（RedisService）+redis+mybatis 方式二：CacheManager+redis+mybatis
SpringBoot整合Redis实现分布式缓存及锁的实战分享
Free雅轩的博客
02-17 349
分布式缓存：在分布式的集群架构中，将缓存存储在内存中会出现很多的问题，比如用户回话信息，因为这部分信息需要与其他机器共享，此时利用 Redis 可以很好的解决机器之间数据共享的问题，缓存也是 Redis 中使用最多的场景。其次，无论什么时候，只要有可能就利用key​超时的优势，尽可能避免数据永久存储，因为一旦所有的key​都永久存储，大量无效的key，会服务器资源非常严重不足，甚至不可用！
SpringBoot + Redis 实现分布式缓存
oyc的博客
05-12 2425
SpringBoot + Redis 实现缓存 一、在pom中添加依赖 <!--springboot redis依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </depen...
SpringBoot整合redis实现分布式数据缓存
SherlockerSun的博客
09-14 479
SpringBoot整合redis实现分布式数据缓存 1.配置redis属性 ##=============redis config start ========== redis1.ip=127.0.0.1 redis1.port=6379 redis2.ip=192.168.0.138 redis2.port=6380 #最大连接数 redis.max.total=20 #最大空闲数 redis.max.idle=10 #最小空闲数 redis.min.idle=2 #从jedis连接池获取连
SpringBoot整合Redis缓存
m0_67402774的博客
08-02 1394
Redis是一个高性能的Key-Value开源数据库，是一个非关系型的数据库，是为了解决高并发、高扩展，大数据存储等一系列的问题而产生的数据库解决方案。但它不能替代关系型数据库，只能作为特定环境下的扩充。...
SpringBoot+Redis完成数据缓存（内容丰富度一定超出你的想象）
IT小辉同学
05-19 3298
亲爱的朋友， 今天我想对你说：相信梦想，你一定会成功！无论你的梦想是什么，只要你坚定地追求它，不断努力，就一定能够实现。 在这个世界上，有很多人因为对自己的梦想缺乏信心而放弃了追求。但是，我相信你是一个勇敢的人，你会选择坚持自己的梦想，不放弃，不言败。因为你知道，只有这样才能让自己变得更加出色。 当你遇到困难和挫折时，请不要气馁，因为这些都是成长的过程。只要你保持积极的心态，相信自己，不断学习和进步，你就一定会走向成功的彼岸。 最后，我祝愿你在追求梦想的路上一路顺风，心想事成。相信自己，勇往直前！
Springboot整合Redis的组件源代码
最新发布
04-03
1. 项目是基于Springboot的Redis的starter组件。 2. 组件使用注解方式即可方便集成。 3. 组件提供常用的数据存取功能。 4. 组件提供基于缓存的分布式锁。
springboot 整合redis
11-07
spring boot正和redis,我的是linux虚拟机，运行的是centos8，开启缓存，简单来说就是redis分布式缓存，代码参照哔哩哔哩的up主编程不良人来写和学习的，视频很好就拿来记录一波
springboot整合shiro，redis缓存session
02-09
为实现Web应用的分布式集群部署，要解决登录session的统一。本文利用shiro做权限控制，redis做session存储，结合spring boot快速配置实现session共享。
SpringBoot项目SSM+Redis整合
12-13
项目采用SpringBoot框架，整合了SSM框架及Redis缓存，前端页面采用的是thymeleaf，运行时，必须先启动Redis缓存数据库。
扩展spring boot cache实现redis一二级分布式缓存
05-01
NULL 博文链接：https://sundoctor.iteye.com/blog/2409237
Springboot整合redis实现缓存
m0_47761892的博客
04-21 1505
Springboot整合redis实现缓存
SpringBoot整合Redis 分布式缓存 详解
码小呆的博客
05-01 441
在上一篇中我们使用了，Spring Cache 来做缓存，这一章我们使用Redis 分布式数据库来做缓存，达到中间件的作用。 不熟悉Redis的朋友，请看官方文档，或者看看教程，这里我列出一些。 Redis官方文档 菜鸟教程 接下来，我们使用SpringBoot 来整合Redis做缓存，先创建一个SpringBoot项目。 1.pom依赖： <dependency> <groupId>org.springframework.boot</groupId
第八篇：SpringBoot整合Redis实现分布式缓存
凯耐的博客
07-07 2338
(一)前言 实际开发中缓存处理是必须的，不可能我们每次客户端去请求一次服务器 ，服务器每次都要去数据库中进行查找，为什么要使用缓存？说到底是为了提高系统的运行速度。将用户频繁访问的内容存放在离用户最近访问速度最快的地方，提高应用的响应速度，提升用户的体验。 （二）项目环境及结构 环境：JDK1.8，Maven3.5.4，SpringBoot 1.5.21.RELEASE、Red...
springboot-整合redis：做缓存，做分布式共享session
2010yhh
11-16 8777
springboot-整合redis：做缓存，做分布式共享session 文章目录springboot-整合redis：做缓存，做分布式共享session1.redis应用场景2配置 完整代码下载链接： https://github.com/2010yhh/springBoot-demos.git 环境 idea2018，jdk1.8， springboot版本：springboot1.5.9....
Spring Boot整合Redis实现缓存(实战详细)
weixin_38568503的博客
08-02 5770
springboot整合redis实现缓存
SpringBoot 系列教程(三十二)：SpringBoot整合Redis缓存
Thinkingcao的专栏
02-20 1819
前言 这篇文章主要介绍springboot整合redis，如果你还不了解redis，可以看下这篇文章：Redis入门配置 关于RedisTemplate的使用可查阅文章：https://blog.csdn.net/Thinkingcao/article/details/103730510 StringRedisTemplate与RedisTemplate 两者区别 StringRedis...
springboot整合redis实现分布式锁
09-27
-- 引入整合Redis缓存的依赖启动器 --> <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis <!-- redisson分布式锁依赖 --> <groupId>org.redisson <artifactId>redisson-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值