Spring全家桶—SpringBoot2集成Redis缓存

Spring Boot Redis Cache

在此章,我们将SpringBoot2.x集成Redis Cache,Redis是一个开源的,基于内存的数据结构存储,可以用作数据库、缓存和消息代理,在本章仅讲解缓存集成。

准备工作

当前项目工具及环境

  • 开发工具 IDEA 2018.3

  • 依赖管理 Gradle 5.0

  • JDK 1.8

  • Redis

现在去初始化一个Spring网站初始生成一个SpringBoot项目

Spring Boot Redis 项目生成

进入网站 https://start.spring.io/

我们现在使用 SPRING INITIALIZR工具生成一个初始化项目,在这里我们初始了4个依赖包

Spring全家桶—SpringBoot2集成Redis缓存

点击生成下载过来一个zip包,解压之后导入IDEA工具就可以了

项目导入开发环境

build.gradle文件和maven的pom.xml相似,可以构建项目的依赖配置文件

在IDEA初始界面点击OPEN -> 选择文件 -> 找到.gradle文件 -> 选择Open —> Open as Project

Spring全家桶—SpringBoot2集成Redis缓存

Spring全家桶—SpringBoot2集成Redis缓存

Spring全家桶—SpringBoot2集成Redis缓存

这里的gradle环境是本地的,很简单安装配置,gradle官网下载二进制包然后解压,环境变量配置一下就可以使用了

Spring Boot Redis Cache Gradle Dependencies

上面我们已经初始化了一个项目依赖文件build.gradle,我们也可以去手动修改然后添加或修改自己需要的依赖等

Spring全家桶—SpringBoot2集成Redis缓存

点击上图左上角停止下载,换成下面的国内源之后在加载gradle

build.gradle

  1. buildscript {

  2.    ext {

  3.        springBootVersion ='2.1.1.RELEASE'

  4.    }

  5.    repositories {

  6.        maven { url 'http://maven.aliyun.com/nexus/content/groups/public/'}

  7.        mavenCentral()

  8.    }

  9.    dependencies {

  10.        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")

  11.    }

  12. }

  13. apply plugin:'java'

  14. apply plugin:'idea'

  15. apply plugin:'org.springframework.boot'

  16. apply plugin:'io.spring.dependency-management'

  17. group='com.example'

  18. version ='0.0.1-SNAPSHOT'

  19. sourceCompatibility =1.8

  20. repositories {

  21.    maven { url 'http://maven.aliyun.com/nexus/content/groups/public/'}

  22.    mavenCentral()

  23. }

  24. dependencies {

  25.    implementation('org.springframework.boot:spring-boot-starter-data-jpa')

  26.    implementation('org.springframework.boot:spring-boot-starter-data-redis')

  27.    implementation('org.springframework.boot:spring-boot-starter-web')

  28.    runtimeOnly('com.h2database:h2')

  29.    testImplementation('org.springframework.boot:spring-boot-starter-test')

  30. }

Spring全家桶—SpringBoot2集成Redis缓存

定义一个实体对象

要将数据存到redis,我们需要定义一个实体来进行交互,并需要序列化实体对象

User.java

  1. package com.example.rediscache.model;

  2. import javax.persistence.*;

  3. import java.io.Serializable;

  4. @Entity

  5. publicclassUserimplementsSerializable{

  6.    privatestaticfinallong serialVersionUID =1L;

  7.    @Id

  8.    @SequenceGenerator(name ="SEQ_GEN", sequenceName ="SEQ_USER", allocationSize =1)

  9.    @GeneratedValue(strategy =GenerationType.SEQUENCE, generator ="SEQ_GEN")

  10.    privateLong id;

  11.    privateString name;

  12.    privatelong money;

  13.    publicUser(){

  14.    }

  15.    publicUser(String name,long money){

  16.        this.name = name;

  17.        this.money = money;

  18.    }

  19.    //省略Getter 和 Setter

  20.    @Override

  21.    publicString toString(){

  22.        returnString.format("User{id=%d, name='%s', money=%d}", id, name, money);

  23.    }

  24. }

配置 Redis Cache

使用springboot的依赖我们已经用gradle来完成,除此之外我们还要配置下:

application.yml

  1. # Redis Config

  2. spring:

  3.  cache:

  4.    type: redis

  5.  redis:

  6.    host: localhost

  7.    port:6379

  8.    password: pass1234

基于JPA的简洁数据操作

UserRepository.java

  1. package com.example.rediscache.repository;

  2. import com.example.rediscache.model.User;

  3. import org.springframework.data.jpa.repository.JpaRepository;

  4. import org.springframework.stereotype.Repository;

  5. @Repository

  6. publicinterfaceUserRepositoryextendsJpaRepository<User,Long>  {}

开启缓存并初始化数据

在启动类增加注解 @EnableCaching开启缓存

并实现CommandLineRunner接口来执行启动完成之后的任务

RedisCacheApplication.java

  1. package com.example.rediscache;

  2. import com.example.rediscache.model.User;

  3. import com.example.rediscache.repository.UserRepository;

  4. import org.slf4j.Logger;

  5. import org.slf4j.LoggerFactory;

  6. import org.springframework.beans.factory.annotation.Autowired;

  7. import org.springframework.boot.CommandLineRunner;

  8. import org.springframework.boot.SpringApplication;

  9. import org.springframework.boot.autoconfigure.SpringBootApplication;

  10. import org.springframework.cache.annotation.EnableCaching;

  11. //springboot启动时执行任务CommandLineRunner

  12. @SpringBootApplication

  13. //开启缓存

  14. @EnableCaching

  15. publicclassRedisCacheApplicationimplementsCommandLineRunner{

  16.    privatefinalUserRepository userRepository;

  17.    privatefinalLogger logger =LoggerFactory.getLogger(getClass());

  18.    @Autowired

  19.    publicRedisCacheApplication(UserRepository userRepository){

  20.        this.userRepository = userRepository;

  21.    }

  22.    publicstaticvoid main(String[] args){

  23.        SpringApplication.run(RedisCacheApplication.class, args);

  24.    }

  25.    @Override

  26.    publicvoid run(String... args)throwsException{

  27.        logger.info("开始初始化user ->user count ->{}",userRepository.count());

  28.        User james =newUser("James",2000);

  29.        User potter =newUser("Potter",4000);

  30.        User dumbledore =newUser("Dumbledore",999999);

  31.        userRepository.save(james);

  32.        userRepository.save(potter);

  33.        userRepository.save(dumbledore);

  34.        logger.info("初始化完成 数据-> {}.", userRepository.findAll());

  35.    }

  36. }

控制层骨架

UserController.java

  1. package com.example.rediscache.controller;

  2. import com.example.rediscache.repository.UserRepository;

  3. import org.slf4j.Logger;

  4. import org.slf4j.LoggerFactory;

  5. import org.springframework.beans.factory.annotation.Autowired;

  6. import org.springframework.cache.annotation.Cacheable;

  7. import org.springframework.web.bind.annotation.*;

  8. @RestController

  9. publicclassUserController{

  10.    privatefinalLogger logger =LoggerFactory.getLogger(getClass());

  11.    privatefinalUserRepository userRepository;

  12.    @Autowired

  13.    publicUserController(UserRepository userRepository){

  14.        this.userRepository = userRepository;

  15.    }

  16.    //...dosomething

  17. }

现在测试缓存

当我们数据库查询出来的值要放到缓存里,用 @Cacheable注解

  1.    @Cacheable(value ="users", key ="#userId", unless ="#result.money < 10000")

  2.    @RequestMapping(value ="/{userId}", method =RequestMethod.GET)

  3.    publicObject getUser(@PathVariableLong userId){

  4.        logger.info("获取user信息根据ID-> {}.", userId);

  5.        return userRepository.findById(userId);

  6.    }

我们访问 localhost:8080/1 和 localhost:8080/3 分别两次

Spring全家桶—SpringBoot2集成Redis缓存

发现id为3的就走了一次方法 说明缓存成功

id为1的走了两次是因为 unless里条件成立就不会缓存到redis

更新缓存

每次当我们的数据库的值要更改,我们缓存的也要更改 ,我们可以使用 @CachePut 注解

  1.   @CachePut(value ="users", key ="#user.id")

  2.    @PutMapping("/update")

  3.    publicUser updatePersonByID(@RequestBodyUser user){

  4.        userRepository.save(user);

  5.        return user;

  6.    }

Spring全家桶—SpringBoot2集成Redis缓存

删除缓存

当我们的数据从数据库删除,我们也要从缓存进行删除,我们可以使用 @CacheEvict 注解

allEntries 是否清空所有缓存内容,缺省为 false,如果指定为 true,则方法调用后将立即清空所有缓存

  1.    @CacheEvict(value ="users", allEntries=true)

  2.    @DeleteMapping("/{id}")

  3.    publicvoid deleteUserByID(@PathVariableLong id){

  4.        logger.info("删除用户根据ID-> {}", id);

  5.        userRepository.deleteById(id);

  6.    }

Spring全家桶—SpringBoot2集成Redis缓存

Spring全家桶—SpringBoot2集成Redis缓存

在redis中查看已经没有了缓存

送上redis可视化工具 redis desktop manager for windows:

链接:https://pan.baidu.com/s/1tYwfM0sHLlDGDdQZc-26Sg 密码:4ivg

redis desktop manager for mac:

链接:https://pan.baidu.com/s/1g9gxtLoAtm1IA0fA5Zs0qQ 密码:aj0r

本站所有文章均来自互联网,如有侵权,请联系站长删除。极客文库 » Spring全家桶—SpringBoot2集成Redis缓存
分享到:
赞(0)

评论抢沙发

评论前必须登录!