缓存-Redis

2023-12-23 18:24:55

Springboot使用Redis

引入pom依赖：

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

在application.yml、application-dev.yml中配置Redis的访问信息

spring:
    redis:
      host: ${sky.redis.host}
      port: ${sky.redis.port}
      password: ${sky.redis.password}
      database: ${sky.redis.database}

sky:
  redis:
    host: localhost
    port: 6379
    password: foobared
    database: 0

其中，本机redis的password可以从/usr/local/etc/redis.conf获取（如果使用Homebrew安装的话），这个配置文件中有一行代码为

requirepass foobared

则password就是foobared

增加Redis配置类，实际上是封装RedisTemplate初始化的过程

@Configuration
@Slf4j
public class RedisConfiguration {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("RedisTemplate初始化");
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

Redis缓存的使用一般伴随着查询数据库的操作，即在Redis中缓存一些热点数据，减少查数据库的流量。下面是进行Redis缓存的过程，核心就是调用了redisTemplate.opsForValue().get/set方法。

@RestController("userDishController")
@RequestMapping("/user/dish")
@Slf4j
public class DishController {
    @Autowired
    private DishService dishService;
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    @GetMapping("/list")
    @SuppressWarnings("unchecked")
    public Result<List<DishVO>> list(Long categoryId){
        // 在redis中查询
        String cacheKey = "dish_" + categoryId;
        List<DishVO> list = (List<DishVO>) redisTemplate.opsForValue().get(cacheKey);
        if(list != null && !list.isEmpty()){
            return Result.success(list);
        }
        // 从数据库中查询
        Dish dish = new Dish();
        dish.setCategoryId(categoryId);
        dish.setStatus(StatusConstant.ENABLE);
        list = dishService.listWithFlavor(dish);
        // 放入redis缓存
        redisTemplate.opsForValue().set(cacheKey, list);
        return Result.success(list);
    }
}

缓存的目标是要和数据库保持一致，因此当数据库发生变更时，要及时清理缓存，也就是调用redisTemplate.delete的方法；在调用这个方法时，可以先从Redis中查询所有符合条件的key，查询key是可以通过通配符*进行匹配的。如下面代码就是删除所有dish_开头的缓存项。

/**
  * 删除菜品
  *
  * @param ids
  * @return
  */
 @DeleteMapping("/delete")
 public Result<String> delete(@RequestParam List<Long> ids) {
     log.info("删除菜品：{}", ids);
     dishService.deleteBatch(ids);
     clearRedis("dish_*");
     return Result.success();
 }

 /**
 * @param keys: dish_*
 * @return void
 * @author jiayueyuanfang
 * @description 只在这个类使用，使用private私有方法
 * @date 2023/12/23 11:53
 */

private void clearRedis(String pattern) {
    Set<String> cacheKeys = redisTemplate.keys(pattern);
    redisTemplate.delete(cacheKeys);
}

Redis适用场景:适合热点数据存储：数据量小，对延迟敏感的情况

SpringCache操作缓存

Spring Cache是Spring框架提供的一个抽象模块，它提供了一种通用的缓存抽象，可以让你在不改变应用代码的前提下，添加和切换不同的缓存实现。

Spring Cache主要提供了以下几个注解来支持缓存操作：

@Cacheable：应用在读取数据的方法上，用于将结果放入缓存。第一次调用时会执行方法并将结果放入缓存，之后的调用会直接从缓存中获取数据，不再执行方法。
@CachePut：应用在写数据的方法上，无论什么情况，都会执行方法，并将结果放入缓存。
@CacheEvict：应用在移除数据的方法上，用于从缓存中移除相应的数据。
@Caching：组合注解，可以同时应用多个其他的缓存注解。
@CacheConfig：类级别的注解，用于共享缓存的设置，比如缓存的名字。

Spring Cache并不直接实现缓存，而是提供了一套缓存抽象，你可以根据需要选择合适的缓存实现，比如EhCache、Guava Cache、Caffeine、Redis等。代码运行时，Spring Cache会生成代理来操作对应的缓存实现。下面介绍下操作Redis的情况。

如果操作Redis，需要引入pom依赖

// 引入Spring Cache
<dependency>
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>
// 引入redis依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

启动类上增加注解：@EnableCaching // 开启SpringCache

@Slf4j
@SpringBootApplication
@EnableCaching // 开启SpringCache
public class CacheDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(CacheDemoApplication.class,args);
        log.info("项目启动成功...");
    }
}

在controller查询方法上分别使用上述注解

package com.itheima.controller;

import com.itheima.entity.User;
import com.itheima.mapper.UserMapper;
import lombok.extern.slf4j.Slf4j;
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
@RequestMapping("/user")
@Slf4j
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @PostMapping
//    @CachePut(cacheNames = "userCache", key="#user.id")
    @CachePut(cacheNames = "userCache", key="#result.id")
    public User save(@RequestBody User user){
        userMapper.insert(user);
        return user;
    }

    @DeleteMapping
    @CacheEvict(cacheNames = "userCache", key = "#id")
    public void deleteById(Long id){
        userMapper.deleteById(id);
    }

	@DeleteMapping("/delAll")
    public void deleteAll(){
        userMapper.deleteAll();
    }

    @GetMapping
    @Cacheable(cacheNames = "userCache", key = "#id")
    public User getById(Long id){
        User user = userMapper.getById(id);
        return user;
    }

}

使用SpringCache最方便的地方在于，可以自由切换缓存类型，比如想切换成本地缓存CaffeineCache（GuavaCache的替代品，Spring5.1以后不再支持GuavaCache），仅需要在pom依赖里面把对Redis的依赖更改为CaffeineCache，同时增加CaffeineCache的配置类即可

 <dependency>
     <groupId>com.github.ben-manes.caffeine</groupId>
     <artifactId>caffeine</artifactId>
     <version>2.8.8</version>
 </dependency>

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder().expireAfterWrite(10, TimeUnit.MINUTES));
        return cacheManager;
    }
}

其他代码不需要变更

注意：如果pom中引入了多个缓存的依赖，则SpringCache无法辨别使用哪个缓存，则注解不生效

Git代码地址：Git
接口文档：http://localhost:8080/doc.html#/default/user-controller/saveUsingPOST

文章来源:https://blog.csdn.net/weixin_40650422/article/details/135170210
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！