以Redis作为缓存技术，使用SpringBoot、MyBatisPlus来演示@Cacheable、@CachePut、@CacheEvit注解

最新推荐文章于 2024-08-02 22:24:33 发布

hdn_kb

最新推荐文章于 2024-08-02 22:24:33 发布

阅读量2k

点赞数 1

分类专栏： Spring Boot

本文链接：https://blog.csdn.net/hdn_kb/article/details/103830898

版权

Spring Boot 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

一、知识点

1、redis是什么？

key-value的nosql数据库，先存到内存中，会根据一定的策略持久化到磁盘。

2、主要作用有哪些?

主要用来做缓存数据库和web集群时当做中央缓存存放session。

3、@Cacheable、@CachePut、@CacheEvit、@Caching注解

注解	解释
@Cacheable	在方法执行前Spring先查看缓存中是否有数据，如果有数据，则直接返回缓存数据；若没有数据，调用方法并将方法返回值放进缓存
@CachePut	无论怎样，都会将方法的缓存值放到缓存中，查询数据库的方法总会被调用
@CacheEvit	将一条或多条数据从缓存中删除
@Caching	可以通过@Caching注解组合多个注解策略在一个方法上

4、注解相关属性

cacheNames/value：指定缓存组件的名称

key：缓存数据使用的key，默认是使用方法参数的值

condition：指定符合条件的情况下缓存

unless：否定缓存，当unless指定的条件为true的时候不进行缓存

5、Spring Boot中配置缓存

spring.cache.type= //配置要使用的缓存

spring.cache.cache-name= //程序启动时创建缓存的名称

二、使用工具

1、mysql数据库

2、安装redis

3、安装redis客户端工具：RedisDesktopManager

三、准备工作

创建Spring Boot工程

在Spring中使用缓存技术的关键是配置CacheManager，而Spring Boot中自动配置了多个CacheManager的实现。

四、编写程序

1、引用依赖

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>

   <!-- SpringBoot启动器-->
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
   </dependency>

   <!-- SpringBoot test启动器-->
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
   </dependency>

   <!-- MySql jdbc驱动 -->
   <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
   </dependency>

   <!-- MyBatis-Plus启动器 -->
   <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>3.3.0</version>
   </dependency>

   <!-- lombok简化代码-->
   <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <optional>true</optional>
   </dependency>

   <!-- p6spy 组件,用于完美的输出打印 SQL 及执行时长-->
   <dependency>
      <groupId>p6spy</groupId>
      <artifactId>p6spy</artifactId>
      <version>3.8.2</version>
   </dependency>

   <!-- redis-->
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-redis</artifactId>
      <version>2.2.2.RELEASE</version>
   </dependency>

</dependencies>

2、配置application.yml文件

server:
  port: 9999
spring:
  # 配置数据库信息
  datasource:
    driver-class-name: com.p6spy.engine.spy.P6SpyDriver
    url: jdbc:p6spy:mysql://localhost:3306/mp?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC
    username: root
    password: 123456
  # 配置redis
  redis:
    database: 15
    host: 127.0.0.1
    port: 6379
  # 配置使用的缓存：redis
  cache:
    type: redis
mybatis-plus:
  configuration:
    # 这个配置会将执行的sql打印出来，在开发或测试的时候可以用
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3、编写dao层

package com.test.redis.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.test.redis.entity.User;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface UserMapper extends BaseMapper<User>{
    
}

4、编写service

package com.test.redis.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.test.redis.entity.User;

public interface UserService extends IService<User> {
     User updateUser(User user);

     User getUser(String userId);

     int deleteUser(String userId);
}

实现类：

package com.test.redis.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.test.redis.dao.UserMapper;
import com.test.redis.entity.User;
import com.test.redis.service.UserService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {
    @Override
    @CachePut(cacheNames = "user", key = "#user.id")
    public User updateUser(User user) {
        baseMapper.updateById(user);
        return baseMapper.selectById(user.getId());
    }

    @Override
    @Cacheable(cacheNames = "user", key = "#id",unless="#result == null")
    public User getUser(String id) {
        return baseMapper.selectById(id);
    }

    @Override
    @CacheEvict(cacheNames = "user",key = "#id")
    public int deleteUser(String id) {
        return  baseMapper.deleteById(id);
    }
}

5、编写controller

package com.test.redis.controller;

import com.test.redis.entity.User;
import com.test.redis.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    UserService userService;

    @PutMapping
    public User updateUser(@RequestBody User user) {
        return userService.updateUser(user);
    }

    @GetMapping(value = "/{id}")
    public User getUser(@PathVariable String id) {
        User user = userService.getUser(id);
        return user;
    }

    @DeleteMapping(value = "/{id}")
    public String deleteUser(@PathVariable String id) {
        int i = userService.deleteUser(id);
        if(i==1){
            return "删除成功";
        }
        return "删除失败";
    }
}

6、在启动类上使用@EnableCaching来开启缓存

package com.test.redis;

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

@SpringBootApplication
@EnableCaching
public class RedisApplication {

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

}