SpringMVC使用 redis 实现缓存

最新推荐文章于 2024-05-13 21:02:42 发布
最新推荐文章于 2024-05-13 21:02:42 发布
阅读量529 收藏 1
点赞数
分类专栏： # springMvc 文章标签： redis 缓存 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pengjinlong521/article/details/129254942
版权

简介

SpringMVC 中也可以将缓存标签和 redis 结合起来使用，其实此时缓存没有起作用，只是通过缓存的那几个注解来操作 redis 而已；SpringMVC 中整合 redis 比较麻烦的是注意版本冲突的问题，如下是官网有关于版本的要求

https://docs.spring.io/spring-data/data-redis/docs/current/reference/html/#requirements

实现步骤

  1. 在 pom.xml 中添加如下依赖，尤其要注意各个依赖的版本，基本上都是 maven 官网上的最新版
<properties>
    <!-- java 版本 -->
    <java.version>1.8</java.version>
    <!-- spring 版本 -->
    <spring.version>5.1.2.RELEASE</spring.version>
    <!-- jstl 版本 -->
    <jstl.version>1.2</jstl.version>
    <!-- standard 版本 -->
    <standard.version>1.2.5</standard.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-servlets</artifactId>
        <version>9.1.0.M0</version>
    </dependency>
    <!-- begin SpringMVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-instrument</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jms</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-messaging</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-oxm</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-websocket</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc-portlet</artifactId>
        <version>4.3.20.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-instrument-tomcat</artifactId>
        <version>4.3.20.RELEASE</version>
    </dependency>
    <!-- end SpringMVC -->
    <!-- begin jstl -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>${jstl.version}</version>
    </dependency>
    <dependency>
        <groupId>org.apache.taglibs</groupId>
        <artifactId>taglibs-standard-impl</artifactId>
        <version>${standard.version}</version>
    </dependency>
    <!-- end jstl -->
    <!-- config redis data and client jar-->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>2.1.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <!-- 用于处理将对象转化为json格式的字符串 -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.7</version>
    </dependency>
</dependencies>
  1. 新建 CacheConfig.class，实现 Cache 接口，添加如下属性和方法
@Component
public class CacheConfig implements Cache {
    private StringRedisTemplate redisTemplate;
    private String name;

    public CacheConfig() {}

    public CacheConfig(StringRedisTemplate redisTemplate, String name) {
        this.redisTemplate = redisTemplate;
        this.name = name;
    }

    public StringRedisTemplate getStringRedisTemplate() {
        return redisTemplate;
    }

    public void setStringRedisTemplate(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void clear() {
        redisTemplate.execute(new RedisCallback < String > () {
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushDb();
                return "ok";
            }
        });
    }

    public void evict(Object object) {
        final String key = (String) object;
        redisTemplate.execute(new RedisCallback < Long > () {
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                return connection.del(key.getBytes());
            }
        });
    }

    public ValueWrapper get(Object obj) {
        final String key = (String) obj;
        Object object = null;
        object = redisTemplate.execute(new RedisCallback < Object > () {
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] keys = key.getBytes();
                byte[] value = connection.get(keys);
                if (value == null) {
                    return null;
                }
                return toObject(value);
            }
        });
        return (object != null ? new SimpleValueWrapper(object) : null);
    }

    public Object getNativeCache() {
        return this.redisTemplate;
    }

    public void put(Object key, Object value) {
        final String keyf = (String) key;
        final Object valuef = value;
        final long liveTime = 86400;

        redisTemplate.execute(new RedisCallback < Long > () {
            public Long doInRedis(RedisConnection connection) throws DataAccessException {
                byte[] keyb = keyf.getBytes();
                byte[] valueb = toByteArray(valuef);
                connection.set(keyb, valueb);
                if (liveTime > 0) {
                    connection.expire(keyb, liveTime);
                }
                return 1 L;
            }
        });
    }

    public ValueWrapper putIfAbsent(Object key, Object value) {
        return null;
    }

    public < T > T get(Object object, Class < T > clz) {
        return null;
    }

    public < T > T get(Object object, Callable < T > callable) {
        return null;
    }

    private Object toObject(byte[] bytes) {
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        Object obj = null;
        try {
            bis = new ByteArrayInputStream(bytes);
            ois = new ObjectInputStream(bis);
            obj = ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            closeIO(ois, bis);
        }
        return obj;
    }

    private byte[] toByteArray(Object obj) {
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        byte[] bytes = null;
        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(obj);
            oos.flush();
            bytes = bos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            closeIO(oos, bos);
        }
        return bytes;
    }

    public void closeIO(Closeable...ios) {
        try {
            for (Closeable io: ios) {
                if (null != io) {
                    io.close();
                }@Configuration
@EnableWebMvc
@EnableCaching
@ComponentScan(basePackages = "com.ibm.redis")
public class SpringConfig extends WebMvcConfigurationSupport {@
    Resource
    private AppSetting appSetting;

    @Bean
    public CacheManager cacheManager(StringRedisTemplate redisTemplate) {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager
        // 注意此处设置的 cache name 后面将会用到
            .setCaches(Arrays.asList(new ConcurrentMapCache("myCache"), new CacheConfig(redisTemplate, "redis")));
        return cacheManager;
    }

    @Bean
    public KeyGenerator keyGenerator() {
        return new MyKeyGenerator();
    }
    // Jedis 连接池配置(对于缓存+redis配置来说, 该 bean 不是必需的, 只有单独使用 jedis 才用到)
    @Bean
    public GenericObjectPoolConfig poolConfig() {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        poolConfig.setMaxWaitMillis(appSetting.getMaxWaitMillis());
        poolConfig.setMaxTotal(appSetting.getMaxActive());
        poolConfig.setMaxIdle(appSetting.getMaxIdle());
        poolConfig.setMinIdle(appSetting.getMinIdle());
        return poolConfig;
    }

    // 创建 Jedis 连接池(对于缓存+redis配置来说, 该 bean 不是必需的, 只有单独使用 jedis 才用到)
    @Bean
    public JedisPool jedisPool(GenericObjectPoolConfig poolConfig) {
        JedisPool jedisPool = new JedisPool(poolConfig, appSetting.getHost(), appSetting.getPort(), 60, appSetting.getPass());
        return jedisPool;
    }

    // 创建 JedisConnectionFactory
    @Bean
    public JedisConnectionFactory redisConnectionFactory() {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName(appSetting.getHost());
        redisStandaloneConfiguration.setPassword(RedisPassword.of(appSetting.getPass()));
        redisStandaloneConfiguration.setPort(appSetting.getPort());
        return new JedisConnectionFactory(redisStandaloneConfiguration);
    }

    // 创建 StringRedisTemplate
    @Bean
    public StringRedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate redisTemplate = new StringRedisTemplate(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
        return redisTemplate;
    }
}
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  1. 新建 SpringConfig.class 为 spring 的配置类，添加如下配置
在这里插入代码片

注意：上面的主键生成器 Bean 的实现如下

// 缓存键的生成策略
public class MyKeyGenerator implements KeyGenerator {
    public Object generate(Object target, Method method, Object ... params) {
        return target.getClass().getName() + method.getName();
    }
}
  1. Appsetting.class 类主要用于从 redis.properties 中绑定数据

Appsetting.class

@PropertySource(value="classpath:redis.properties")
@Component
public class AppSetting {
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.password}")
    private String pass;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${spring.redis.pool.max-active}")
    private int maxActive;
    @Value("${spring.redis.pool.max-idle}")
    private int maxIdle;
    @Value("${spring.redis.pool.min-idle}")
    private int minIdle;
    @Value("${spring.redis.pool.max-wait}")
    private long maxWaitMillis;
    ... ... 省略 getter 和 setter 方法
}

redis.properties

# REDIS
#redis jedis配置
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址 （默认为127.0.0.1）
spring.redis.host=127.0.0.1
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=dufu9137
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=200
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0
#spring-session 使用
spring.session.store-type=none
  1. 在 RedisService.class 中使用
@Service
// 此处的 cache name 和第 3 步中声明 CacheManager 时添加的 name 要对应上
@CacheConfig(cacheNames = "redis", keyGenerator = "keyGenerator")
public class RedisService {
    @Resource
    private CacheManager cacheManager;

    @Cacheable
    public String get1() {
        System.out.println(new Date() + "--> No value from cache");
        return "Ramos";
    }

    @Cacheable
    public User get2() {
        System.out.println(new Date() + "--> No value from cache");
        return new User(1, "dufu");
    }
}

运行效果

  1. 操作字符串
    在这里插入图片描述

查看 redis 客户端，发现已经有数据存入到库中
在这里插入图片描述
2. 操作对象
在这里插入图片描述
查看 redis 客户端，发现已经有数据存入到库中
在这里插入图片描述
此时，如果我们反复刷新页面，RedisService.class 中的 get1() 和 get2() 方法也只会打印出一次：No value from cache，说明缓存（redis）已经生效

爱JAVA的少年闰土
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot干货——（十三【二】）整合redis（可配置redis多数据源）
东天里的冬天
11-27 1747
上篇博客(springboot整合redis)讲了最简单的整合redis方式，本篇博客讲讲通过RedisTemplate使用redis，与上篇博客的主要区别是本篇博客可以使用redis多数据源   一.项目结构   二.pom.xml 和上篇博客一致，此处不再赘述   三.RedisConfig.java 多数据源的配置就在此处，从demo上看，我这边只配置了redisTemp...
SpringMvc集成Redis项目完整示例
07-04
SpringMvc集成Redis项目完整示例,包含web示例和java示例（不用启动web服务器）即可测试，亲测没问题，本人项目中已经使用，欢迎有问题一起探讨！
Spring集成Redis进行数据缓存
02-22
SpringMVC集成Redis进行缓存管理，SpringMVC基于接口编程的实例，从代码中学习Spring是怎么集成缓存。
SpringMVC项目配置redis
csq19970528的博客
08-28 2318
SpringMVC项目配置redis 1,在resources文件夹在配置“redis.properties”文件 redis.hostName=127.0.0.1 #redis连接ip redis.port=6379 #redis端口 默认是6379 redis.password=123456 #redis密码 redis.timeout=100000 redis.maxIdle=400 r...
redis缓存的安装和使用
热门推荐
小单的博客专栏
05-09 4万+
Redis介绍     Redis本质上一个Key/Value数据库，与Memcached类似的NoSQL型数据库，但是他的数据可以持久化的保存在磁盘上，解决了服务重启后数据不丢失的问题，他的值可以是string（字符串）、list（列表）、sets（集合）或者是ordered  sets（被排序的集合），所有的数据类型都具有push/pop、add/remove、执行服务端的并集、交集、两个s
SpringMVC中使用Redis
程序员小挽的博客
10-28 1762
SpringMVC中使用Redis。
spring-data-redis 使用过程中需要注意的地方
04-24 185
1.序列化问题 <!-- SDR默认采用的序列化策略有两种，一种是String的序列化策略，一种是JDK的序列化策略。 StringRedisTemplate默认采用的是String的序列化策略，保存的key和value都是采用此策略序列化保存的。 RedisTemplate默认采用的是JDK的序列化策略，保存的key和valu...
springmvc配置使用redis
ITarmi的分享
08-21 2516
本篇文章不记录redis安装，redis在windows下安装也很简单。 首先下载安装redis,Windows下好像就是下载一个压缩包解压即可，内容如下 pom.xml文件引入redis依赖（注意redis和spring存在版本冲突，所以在你正确配置后仍然有问题就要考虑是不是版本冲突了） <dependency> <groupId>org.springframework.data</groupId> <arti
SpringMVC使用缓存
少年闰土
02-27 813
注意：@Cacheable 标签中的 cacheNames 属性的值 myCache 就是我们在 SpringConfig.class 中添加的缓存实例的属性值，一定要对应上，否则会报错。cacheManager 方法中可以添加多个缓存实例，缓存实例将会在后面用到。MyKeyGenerator 类的实现。
SpringMVC+Redis+MyBatis项目
11-24
SpringMVC+Redis+MyBatis项目，主要实现Redis注释缓存
Maven+Springmvc+Redis示例
08-30
Maven搭建springmvc加redis实现缓存示例 javaweb项目示例，java示例
springmvc+redis+mysql（数据库连接简单实现）数据缓存
08-09
实现redis与springmvc配置，数据库连接简单实现，待完善实现连接池
使用maven简单搭建Spring mvc + redis缓存
05-31
使用maven简单搭建Spring mvc + redis缓存 个人实验成功
Spring MVC集成Redis
weixin_57158463的博客
09-26 1590
SpringMVC集成Redis 相关jar包与配置
springmvc整合redis架构搭建实例
weixin_39403708的博客
08-26 154
1 原文 http://www.cnblogs.com/dennisit/p/3614521.html 2 3 新换环境,又有新东西可以学习了,哈皮! 抽空学习之余看了一下redis,个人对Springmvc的爱是忠贞不渝,所以整理了一下Springmvc整合redis的环境搭建.分享学习. 4 5 第一步 :...
SpringMVC简单使用Redis
卑微的码农
06-05 1077
一、添加 pom.xml 依赖 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <vers...
Redis在SpringMVC（或xml配置）项目中使用(注意版本兼容问题)
zgphacker2010的专栏
02-26 3273
原有的SpringMVC配置不动，添加下面这个配置 redis.xml: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
SpringMVC集成redis教程
u012775558的博客
03-31 6186
SpringMVC集成redis教程
redis试题按知识点归类(三)
最新发布
u012728971的博客
05-13 144
十一、发布/订阅 1.Redis 的发布/订阅模型是如何工作的？ 2.如何使用 Redis 作为消息队列？ 3.发布/订阅在实际应用中有哪些用例？ 十二、缓存策略 1.如何确定 Redis 的缓存策略？ 2.Redis 的缓存替换策略有哪些？ 3.如何使用 Redis 作为缓存层？ 十三、客户端与生态系统 1.Redis 支持哪些编程语言的客户端？ 2.Redisson 和 Jedis 有什么不同？ 3.如何使用 Redis 模块？ 十四、运维与管理 1.如何监控和管理 Redis
springmvc的一二三级缓存
05-30
2. 第二级缓存：分布式缓存，可以使用 Redis、Memcached 等实现。缓存的内容可以在多个 JVM 实例之间共享，可以有效减少服务端的压力。 3. 第三级缓存：客户端缓存，可以使用浏览器缓存等实现。缓存的内容可以在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值