SpringBoot+Redis作为二级缓存整合的基本Demo

最新推荐文章于 2024-06-27 18:31:08 发布
最新推荐文章于 2024-06-27 18:31:08 发布
阅读量297 收藏
点赞数
文章标签： 数据库 java python
原文链接：https://juejin.im/post/5c9e23e36fb9a05e58493c50
版权

一、Redis简介

1、概述

  Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类key/value存储的不足，在部 分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。

2、优点

（1）数据操作全在内存，读写性能强。
（2）数据结构丰富，支持string，hash，list，set及zset(sorted set)。
（3）支持主从复制，以及数据持久化等

二、Redis的搭建

1、安装

按顺序执行如下命令：

$ wget http://download.redis.io/releases/redis-5.0.4.tar.gz
$ tar xzf redis-5.0.4.tar.gz
$ cd redis-5.0.4
$ make
$ make install
复制代码

2、测试

开启服务

$ redis-server
复制代码

启动客户机交互测试

$ redis-cli -p 6379
127.0.0.1:6379> set k1 k2
OK
127.0.0.1:6379> get k1
"k2"
127.0.0.1:6379> 

复制代码

三、基本环境配置

这里使用MyBatis作为持久层框架，使用MySql数据库。

1、POM依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
复制代码

2、YML配置文件

server:
  port: 80
spring:
  http:
    encoding:
      charset: UTF-8
  cache:
    type: redis
  redis:
    #redis服务器地址
    host: 192.168.78.128
    #设置端口号，默认6379
    port: 6379
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: 123456
    url: jdbc:mysql://localhost:3306/test
#控制台查看SQL执行状况
logging:
  level:
   com.yurui.rediscache: debug
复制代码

3、测试连接

package com.yurui.rediscache;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RediscacheApplicationTests {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    
    @Test
    public void contextLoads() {
        stringRedisTemplate.opsForValue().set("k1","v1");
        System.out.println(stringRedisTemplate.opsForValue().get("k1"));
    }
}
复制代码

测试成功效果:

测试失败的可能原因：

1、Linux防火墙没设置好
2、启动服务器前配置文件内没有把bind 127.0.0.1注释掉
3、配置文件中没把protected-mode yes改为no

四、三个基本的缓存标签

1、@Cacheable

  @Cacheable可以标记在一个方法上，也可以标记在一个类上。当标记在一个方法上时表示该方法是支持缓存的，当标记在一个类上时则表示该类所有的方法都是支持缓存的。对于一个支持缓存的方法，Spring会在其被调用后将其返回值缓存起来，以保证下次利用同样的参数来执行该方法时可以直接从缓存中获取结果，而不需要再次执行该方法。

2、@CachePut

  @CachePut可以声明一个方法支持缓存功能。与@Cacheable不同的是使用@CachePut标注的方法在执行前不会去检查缓存中是否存在之前执行过的结果，而是每次都会执行该方法，并将执行结果以键值对的形式存入指定的缓存中。

3、@CacheEvict

  @CacheEvict是用来标注在需要清除缓存元素的方法或类上的。当标记在一个类上时表示其中所有的方法的执行都会触发缓存的清除操作。@CacheEvict可以指定的属性有value、key、condition、allEntries和beforeInvocation。

三者共有属性：

  • value(cacheName)
    @Cacheable、@CachePut标注时表示生成的缓存的名称，@CacheEvict标注时表示将要清空的缓存的名称。

  • key
    在同一名称（类别）下的缓存，需要唯一的key值来标识唯一的缓存，如未指定则会使用默认策略生成的key；

  • condition
    表示缓存操作发生的条件

@CacheEvict的allEntries和beforeInvocation属性

  • allEntries
      allEntries是boolean类型，表示是否需要清除同一名称的缓存中的所有元素。默认为false，表示不需要。当指定了allEntries为true时，Spring Cache将忽略指定的key，清除所有同一名称的缓存。
  • beforeInvocation
      清除操作默认是在对应方法成功执行之后触发的，即方法如果因为抛出异常而未能成功返回时也不会触发清除操作。使用beforeInvocation可以改变触发清除操作的时间，当我们指定该属性值为true时，Spring会在调用该方法之前清除缓存中的指定元素。

实例

    @Cacheable(cacheNames = "User", key = "#userId")
    @GetMapping("/testCacheable/{userId}")
    public User testCacheable(@PathVariable("userId") Integer userId) {
        //  方法体
    }
复制代码

访问/testCacheable/{userId}时会将返回的User进行缓存，其对应名称为"User"，所生成的key为传入进来的userId。

五、基本的Demo

项目结构

数据表结构

Entity类：

package com.yurui.rediscache.entity;

import org.springframework.stereotype.Component;
import java.io.Serializable;      //    返回实体缓存需要实现可序列化

@Component
public class User implements Serializable {
    private int userId;
    private String username;
    //  setters,getters,toString()方法已被省略
}
复制代码

由于业务逻辑简单，取消了Service层

Dao层：

package com.yurui.rediscache.dao;

import com.yurui.rediscache.entity.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserDao {
    @Insert("insert into user(userId,username) values(#{userId},#{username})")
    int userInsert(User user);

    @Select("select * from user where userId=#{userId}")
    User userQuery(int userId);
}
复制代码

Controller:

package com.yurui.rediscache.cotroller;

import com.yurui.rediscache.dao.UserDao;
import com.yurui.rediscache.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.*;

@RestController
public class UserController {

    @Autowired
    private UserDao userDao;

    @PostMapping("user")
    public String userAdd(User user) {
        return userDao.userInsert(user) != 0 ? "success" : "fail";
    }

    //  测试Cacheable注解
    @Cacheable(cacheNames = "User", key = "#userId")
    @GetMapping("/testCacheable/{userId}")
    public User testCacheable(@PathVariable("userId") Integer userId) {
        return userDao.userQuery(userId);
    }

    //  测试CachePut注解
    @CachePut(cacheNames = "User", key = "#userId") //缓存名字为"User","userId"作为key
    @GetMapping("/testCachePut/{userId}")
    public User testCachePut(@PathVariable("userId") Integer userId) {
        return userDao.userQuery(userId);
    }

    //  测试CacheEvict注解清空指定用户缓存
    @CacheEvict(cacheNames = "User", key = "#userId")
    @GetMapping("/testCacheEvict/{userId}")
    public String testCacheEvict(@PathVariable("userId") Integer userId) {
        return "cache for " + userId + " has been flushed";
    }

    //  测试CacheEvict注解的allEntries属性清空所有用户缓存
    @CacheEvict(cacheNames = "User", allEntries = true)
    @GetMapping("/testAllEntries")
    public String testAllEntries() {
        return "All caches have been flushed";
    }
}
复制代码

主类

package com.yurui.rediscache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching                          //    开启缓存注解
public class RediscacheApplication {

    public static void main(String[] args) {
        SpringApplication.run(RediscacheApplication.class, args);
    }

}
复制代码

主页（index.html)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>主页</title>
</head>
<body>
<h1>添加员工</h1>
<form method="post" action="/user">
    <table>
        <tr>
            <td>userId:</td>
            <td><input type="text" name="userId"></td>
        </tr>
        <tr>
            <td>username:</td>
            <td><input type="text" name="username"></td>
        </tr>
        <tr>
            <td></td>
            <td><input type="submit"></td>
        </tr>
    </table>
</form>
</body>
</html>
复制代码

六、Demo效果测试

准备工作

测试之前，先通过表格提交数据，向数据库插入两条记录：

清空redis的缓存 

127.0.0.1:6379> flushall
OK
复制代码

1、Cacheable

分别访问两次

localhost/testCacheable/1
localhost/testCacheable/2
复制代码

控制台打印情况：

由上图可得，两条语句均只打印一次，再查询redis： 

127.0.0.1:6379> keys *
1) "User::2"
2) "User::1"
127.0.0.1:6379> 
复制代码

可发现，已经使用作为二级缓存。

2、CachePut

清空缓存后分别访问两次

localhost/testCachePut/1
localhost/testCachePut/2
复制代码

再访问

localhost/testCacheable/1
复制代码

控制台打印：

上图共有四条SQL语句执行，可发现每次访问@CachePut注解标注的方法时都会直接从数据库查询,并且查询结果已经存入缓存。

3、CacheEvict

1、不开启allEntries

测试前先访问两次@Cacheable标注的路径完成缓存，然后分别访问

http://localhost/testCacheEvict/1
http://localhost/testCacheable/1
http://localhost/testCacheable/2
复制代码

控制台打印：

可发现，用户张三的缓存已被清除，李四不受影响，再次访问testCacheable/1会从数据库查询并重新缓存张三。

2、开启allEntries

测试前先访问两边@Cacheable标注的路径完成缓存，然后分别访问

http://localhost/testAllEntries
http://localhost/testCacheable/1
http://localhost/testCacheable/2
复制代码

控制台打印：

可发现，用户张三、李四的缓存均被清空，再次查询会调用数据库重新缓存。

六、CacheManager的定制

1、未定制前

当我们使用引入redis的starter时，容器中默认使用的是RedisCacheManager。它在操作redis时默认采用JDK的序列化机制，例如redis中查看张三的缓存：

我们可以通过定制CacheManager改变采取的序列化机制。

2、进行定制

配置类

package com.yurui.rediscache.config;

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.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;

@Configuration
public class Config {

    @Bean
    public RedisCacheManager JsonCacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                //     使用GenericJackson2JsonRedisSerializer序列化得到Value
                .serializeValuesWith(RedisSerializationContext.SerializationPair.
                        fromSerializer(new GenericJackson2JsonRedisSerializer()));
        return RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
    }
}


复制代码

缓存之后查看：

到此，已经完成Json的序列化。其他配置可根据RedisCacheConfiguration中的不同方法配置。

weixin_34096182
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring Boot2.0+Redis+Ehcache实现二级缓存
art_code的博客
11-01 1074
Spring Boot2.0+Redis+Ehcache实现二级缓存 EHCache 本地缓存 Redis 分布式缓存（可以共享） 一级 Redis 二级Ehcache 当redis挂了 有备胎 反之： 先走本地，本地没有再走网络 尽量少走Redis 效率会高一些 Redis与数据库的区别： 相同点 都是需要进行网络连接 不同点 是存放的介质...
spring boot + mysql +mybatis +redis（二级缓存）实例
12-14
spring boot + mysql +mybatis +redis（二级缓存）实例------------------------------------------------------------
springboot+jpa(hibernate配置redis为二级缓存) springboot2.1.4
04-23
基于springboot最新版本2.1.4.RELEASE，采用jpa为dao层框架，配置redis（redisson）为hibernate的二级缓存。
springboot 缓存框架Cache整合redis组成二级缓存
最新发布
weixin_51114236的博客
06-27 805
项目性能优化的解决方案除开硬件外的方案无非就是优化sql，减少sql 的执行时间，合理运用缓存让同样的请求和数据库之间的连接尽量减少，内存的处理速度肯定比直接查询数据库来的要快一些。经测试，请求详情后的10秒内（设置的有效时间是10秒）不论请求几次都仅和数据库连接一次，过期后重复第一次的结果，过期时间可以自定义。首先定义注解：缓存注解和删除注解。缓存公共接口，和多级缓存接口。如有不合理的地方还请指教！redis缓存实现类。
【SpringBoot应用篇】SpringBoot集成j2cache二级缓存框架
输入技术、输出想法
01-01 2151
j2cache是OSChina(开源中国)目前正在使用的两级缓存框架。L1： 进程内缓存 caffeine/ehcacheL2： 集中式缓存 Redis/Memcachedj2cache其实并不是在重复造轮子，而是作资源整合，即将Ehcache、Caffeine、redis、Spring Cache等进行整合。J2Cache 的使用场景: 由于大量的缓存读取会导致L2的网络成为整个系统的瓶颈，因此L1的目标是降低对L2的读取次数。该缓存框架主要用于集群环境中。
SpringBoot 实现两级缓存
八戒的博客
06-11 1402
创建一个配置类来设置 Redis 缓存管理器：• 配置：定义一个。
springboot+mybatis+redis 二级缓存问题实例详解
08-28
Mybatis默认没有开启二级缓存，需要在全局配置(mybatis-config.xml)中开启二级缓存。本文讲述的是使用Redis作为缓存，与springboot、mybatis进行集成的方法。需要的朋友参考下吧
SpringBoot+redis+RabbitMq整合实例
07-13
总的来说，Spring Boot+Redis+RabbitMq的整合提供了高效的数据缓存和消息传递机制，对于构建可扩展、高可用的分布式系统具有极大的价值。通过理解和掌握这些技术，开发者可以更好地应对复杂的企业级项目挑战。
vue+springboot+redis+kaptcha实现登录验证码
04-10
本教程将介绍如何结合Vue.js前端框架、Spring Boot后端框架、Redis缓存服务以及Kaptcha验证码技术，实现一个前后端分离的登录页面验证码功能。这个组合可以提供高效、安全且用户友好的验证机制。 首先，Vue.js是一...
最最最简单的SpringBoot+Redis
03-04
标题 "最最最简单的SpringBoot+Redis" 描述了如何在SpringBoot项目中集成和使用Redis，这是一个流行的Java开发框架和一个...通过这些步骤，开发者可以轻松地在SpringBoot应用中集成Redis，实现高效的数据缓存和持久化。
SpringBoot+Mybatis项目使用Redis做Mybatis的二级缓存的方法
08-28
SpringBoot+Mybatis项目使用Redis做Mybatis的二级缓存的方法 本文主要讲解了在SpringBoot+Mybatis项目中使用Redis实现Mybatis的二级缓存的方法。该方法可以提高查询速度，进而改善用户体验。 首先，在pom.xml文件...
springboot2.x整合redis做mybatis的二级缓存
07-18
springboot整合redis做mybatis的二级缓存，含有自定义key，自定义过期时间，自定义序列化方式
spring-boot-starter-data-jpa 的二级缓存
12-25
spring-boot-starter-data-jpa整合 ehcahe 开启二级缓存
扩展spring boot cache实现redis一二级分布式缓存
05-01
NULL 博文链接：https://sundoctor.iteye.com/blog/2409237
SpringBoot集成Redis
02-26
此 demo 演示 SpringBoot 集成 Redis 操作数据库以及 Redis 做登录缓存
为Spring集成的Hibernate配置二级缓存
10-23
为Spring集成的Hibernate配置二级缓存
SpringBoot+Redis作为二级缓存整合
今晚摸鱼
04-11 3918
SpringBoot+Redis作为二级缓存整合
二级缓存（Spring Boot）
qq_41296669的博客
12-22 2869
开启缓存：@EnableCaching
Springboot简单设计两级缓存
Spirit_NKlaus的专栏
01-31 1226
如果是分布式环境下，一级缓存之间也会存在一致性问题，当一个节点下的本地缓存修改后，需要通知其他节点也刷新本地缓存中的数据，否则会出现读取到过期数据的情况，这一问题可以通过类似于Redis中的发布/订阅功能解决。定义一个注解，用于添加在需要操作缓存的方法上，使用cacheName + key作为缓存的真正key，timeOut为可以设置的二级缓存Redis的过期时间，type是一个枚举类型的变量，表示操作缓存的类型。但是在设计中，还是要考虑一些问题的，例如数据一致性问题。在yml中配置redis的相关信息。
spring boot+spring cache实现两级缓存(redis+caffeine)
竹林幽深
09-26 712
更新时间：2018年02月27日 13:43:41 作者：J猿这篇文章主要介绍了spring boot+spring cache实现两级缓存(redis+caffeine)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧spring boot中集成了spring cache，并有多种缓存方式的实现，如：Redis、Caffeine、JCache、EhCache等等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值