Redis實戰-詳細配置-優雅的使用Redis註解/RedisTemplate

張鐵牛發表於2021-08-13

Redis

1. 簡介

當我們對redis的基本知識有一定的瞭解後，我們再通過實戰的角度學習一下在SpringBoot環境下，如何優雅的使用redis。

我們通過使用SpringBoot內建的Redis註解（文章最後有解釋）來操作User相關的資訊，

再通過Redis工具類的方式操作Role相關資訊來全面的學習Redis的使用。

嫌篇幅太長的可以直接跳到2.6檢視具體邏輯即可。

2. 開擼

2.1 專案結構

結構說明：

├── src
│   └── main
│       ├── java
│       │   └── com
│       │       └── ldx
│       │           └── redis
│       │               ├── RedisApplication.java # 啟動類
│       │               ├── config
│       │               │   └── RedisConfig.java # redis 配置類
│       │               ├── constant
│       │               │   └── CacheConstant.java # 快取key常量類
│       │               ├── controller
│       │               │   ├── RoleController.java # 角色管理控制器
│       │               │   └── UserController.java # 使用者管理控制器
│       │               ├── entity
│       │               │   ├── SysRole.java # 角色entity
│       │               │   └── SysUser.java # 使用者entity
│       │               ├── mapper
│       │               │   ├── SysRoleMapper.java # 角色持久層
│       │               │   └── SysUserMapper.java # 使用者持久層
│       │               ├── service
│       │               │   ├── SysRoleService.java # 角色介面層
│       │               │   ├── SysUserService.java # 使用者介面層
│       │               │   └── impl
│       │               │       ├── SysRoleServiceImpl.java # 角色介面實現層
│       │               │       └── SysUserServiceImpl.java # 使用者介面實現層
│       │               └── util
│       │                   └── RedisUtil.java # redis 工具類
│       └── resources
│           └── application.yaml # 系統配置檔案
└── pom.xml # 依賴管理

2.2 匯入依賴

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>2.5.3</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>com.ldx</groupId>
   <artifactId>redis</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>redis</name>
   <description>Demo project for Spring Boot</description>
   <properties>
      <java.version>1.8</java.version>
   </properties>
   <dependencies>
      <!--spring-web-->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      <!-- redis -->
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-data-redis</artifactId>
      </dependency>
      <!-- lettuce pool -->
      <dependency>
         <groupId>org.apache.commons</groupId>
         <artifactId>commons-pool2</artifactId>
      </dependency>
      <!-- mybatis-plus -->
      <dependency>
         <groupId>com.baomidou</groupId>
         <artifactId>mybatis-plus-boot-starter</artifactId>
         <version>3.4.2</version>
      </dependency>
      <!-- mysql驅動 -->
      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
      </dependency>
      <!-- lombok 工具包 -->
      <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <optional>true</optional>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
               <excludes>
                  <exclude>
                     <groupId>org.projectlombok</groupId>
                     <artifactId>lombok</artifactId>
                  </exclude>
               </excludes>
            </configuration>
         </plugin>
      </plugins>
   </build>
</project>

2.3 專案基本配置

2.3.1 application.yaml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
    username: root
    password: 123456
    type: com.zaxxer.hikari.HikariDataSource
  # redis 配置
  redis:
    # 地址
    host: localhost
    # 埠，預設為6379
    port: 6379
    # 密碼
    password:
    # 連線超時時間
    timeout: 10s
    lettuce:
      pool:
        # 連線池中的最小空閒連線
        min-idle: 0
        # 連線池中的最大空閒連線
        max-idle: 8
        # 連線池的最大資料庫連線數
        max-active: 8
        # #連線池最大阻塞等待時間（使用負值表示沒有限制）
        max-wait: -1ms

mybatis-plus:
  # 設定Mapper介面所對應的XML檔案位置，如果你在Mapper介面中有自定義方法，需要進行該配置
  mapper-locations: classpath*:mapper/*.xml
  # 設定別名包掃描路徑，通過該屬性可以給包中的類註冊別名
  type-aliases-package: com.ldx.redis.entity
  configuration:
    # 控制檯sql列印
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

# 日誌配置
logging:
  level:
    com.ldx.redis.service.impl: debug
    org.springframework: warn

2.3.2 啟動類

@EnableCaching：啟用快取支援

@MapperScan: 掃描mapper介面層

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

/**
 * 啟動類
 * @author ludangxin
 * @date 2021/8/11
 */
@EnableCaching
@MapperScan(basePackages = "com.ldx.redis.mapper")
@SpringBootApplication
public class RedisApplication {
  public static void main(String[] args) {
    SpringApplication.run(RedisApplication.class, args);
  }
}

2.4 redis配置

2.4.1 RedisConfig

我們除了在application.yaml中加入redis的基本配置外，一般還需要配置redis key和value的序列化方式，如下：

註解：

其預設的序列化方式為JdkSerializationRedisSerializer，這種方式跨語言和可讀性都不太好，我們將其切換為Jackson2JsonRedisSerializer。
可以使用entryTtl()為對應的模組設定過期時長。

redisTemplate：參考redisTemplate()。

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ldx.redis.constant.CacheConstant;
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.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
import java.util.HashMap;
import java.util.Map;

/**
 * redis配置類
 * @author ludangxin
 * @date 2021/8/11
 */
@Configuration
public class RedisConfig {
    
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        //設定不同cacheName的過期時間
        Map<String, RedisCacheConfiguration> configurations = new HashMap<>(16);
        // 序列化方式
        Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = getJsonRedisSerializer();
        RedisSerializationContext.SerializationPair<Object> serializationPair =
           RedisSerializationContext.SerializationPair.fromSerializer(jsonRedisSerializer);
        // 預設的快取時間
        Duration defaultTtl = Duration.ofSeconds(20L);
        // 使用者模組的快取時間
        Duration userTtl = Duration.ofSeconds(50L);
        // 預設的快取配置
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
           //.entryTtl(defaultTtl)
           .serializeValuesWith(serializationPair);
        // 自定義使用者模組的快取配置 自定義的配置可以覆蓋預設配置（當前的模組）
        configurations.put(CacheConstant.USER_CACHE_NAME, RedisCacheConfiguration.defaultCacheConfig()
           //.entryTtl(userTtl)
           .serializeValuesWith(serializationPair)
        );

        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory))
           .cacheDefaults(redisCacheConfiguration)
           .withInitialCacheConfigurations(configurations)
           // 事物支援 
           .transactionAware()
           .build();
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = getJsonRedisSerializer();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key採用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也採用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式採用jackson
        template.setValueSerializer(jsonRedisSerializer);
        // hash的value序列化方式採用jackson
        template.setHashValueSerializer(jsonRedisSerializer);
        // 支援事物
        //template.setEnableTransactionSupport(true);
        template.afterPropertiesSet();
        return template;
    }

    /**
     * 設定jackson的序列化方式
     */
    private Jackson2JsonRedisSerializer<Object> getJsonRedisSerializer() {
        Jackson2JsonRedisSerializer<Object> redisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        redisSerializer.setObjectMapper(om);
        return redisSerializer;
    }
}

2.4.1 CacheConstant

我們為了防止redis中key的重複，儘量會給不同的資料主體加上不同的字首，這樣我們在檢視和統計的時候也方便操作。

/**
 * 快取key 常量類
 * @author ludangxin
 * @date 2021/8/11
 */
public interface CacheConstant {
   /**
    * 使用者cache name
    */
   String USER_CACHE_NAME = "user_cache";

   /**
    * 使用者資訊快取key字首
    */
   String USER_CACHE_KEY_PREFIX = "user_";

   /**
    * 角色cache name
    */
   String ROLE_CACHE_NAME = "role_cache";

   /**
    * 角色資訊快取key字首
    */
   String ROLE_CACHE_KEY_PREFIX = "role_";

   /**
    * 獲取角色cache key
    * @param suffix 字尾
    * @return key
    */
   static String getRoleCacheKey(String suffix) {
      return ROLE_CACHE_NAME + "::" + ROLE_CACHE_KEY_PREFIX + suffix;
   }
}

2.4.2 RedisUtil

import lombok.RequiredArgsConstructor;
import org.springframework.data.redis.core.*;
import org.springframework.stereotype.Component;
import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * spring redis 工具類
 * @author ludangxin
 **/
@Component
@RequiredArgsConstructor
@SuppressWarnings(value = { "unchecked", "rawtypes" })
public class RedisUtil {
    public final RedisTemplate redisTemplate;

    /**
     * 快取基本的物件，Integer、String、實體類等
     * @param key 快取的鍵值
     * @param value 快取的值
     * @return 快取的物件
     */
    public <T> ValueOperations<String, T> setCacheObject(String key, T value) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        operation.set(key, value);
        return operation;
    }

    /**
     * 快取基本的物件，Integer、String、實體類等
     * @param key 快取的鍵值
     * @param value 快取的值
     * @param timeout 時間
     * @param timeUnit 時間顆粒度
     * @return 快取的物件
     */
    public <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        operation.set(key, value, timeout, timeUnit);
        return operation;
    }

    /**
     * 獲得快取的基本物件。
     * @param key 快取鍵值
     * @return 快取鍵值對應的資料
     */
    public <T> T getCacheObject(String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }

    /**
     * 刪除單個物件
     * @param key
     */
    public void deleteObject(String key) {
        redisTemplate.delete(key);
    }

    /**
     * 刪除集合物件
     * @param collection
     */
    public void deleteObject(Collection collection) {
        redisTemplate.delete(collection);
    }

    /**
     * 快取List資料
     * @param key 快取的鍵值
     * @param dataList 待快取的List資料
     * @return 快取的物件
     */
    public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList) {
        ListOperations listOperation = redisTemplate.opsForList();
        if (null != dataList) {
            int size = dataList.size();
            for (int i = 0; i < size; i++) {
                listOperation.leftPush(key, dataList.get(i));
            }
        }
        return listOperation;
    }

    /**
     * 獲得快取的list物件
     * @param key 快取的鍵值
     * @return 快取鍵值對應的資料
     */
    public <T> List<T> getCacheList(String key) {
        List<T> dataList = new ArrayList<T>();
        ListOperations<String, T> listOperation = redisTemplate.opsForList();
        Long size = listOperation.size(key);
        for (int i = 0; i < size; i++) {
            dataList.add(listOperation.index(key, i));
        }
        return dataList;
    }

    /**
     * 快取Set
     * @param key 快取鍵值
     * @param dataSet 快取的資料
     * @return 快取資料的物件
     */
    public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 獲得快取的set
     * @param key
     * @return
     */
    public <T> Set<T> getCacheSet(String key) {
        Set<T> dataSet = new HashSet<T>();
        BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);
        dataSet = operation.members();
        return dataSet;
    }

    /**
     * 快取Map
     * @param key
     * @param dataMap
     * @return
     */
    public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        if (null != dataMap) {
            for (Map.Entry<String, T> entry : dataMap.entrySet()) {
                hashOperations.put(key, entry.getKey(), entry.getValue());
            }
        }
        return hashOperations;
    }

    /**
     * 獲得快取的Map
     * @param key
     * @return
     */
    public <T> Map<String, T> getCacheMap(String key) {
        Map<String, T> map = redisTemplate.opsForHash().entries(key);
        return map;
    }

    /**
     * 獲得快取的基本物件列表
     * @param pattern 字串字首
     * @return 物件列表
     */
    public Collection<String> keys(String pattern) {
        return redisTemplate.keys(pattern);
    }
}

2.5 controller

2.5.1 UserController

import com.ldx.redis.entity.SysUser;
import com.ldx.redis.service.SysUserService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;

/**
 * 使用者管理
 * @author ludangxin
 * @date 2021/8/11
 */
@RestController
@RequestMapping("user")
@RequiredArgsConstructor
public class UserController {
   private final SysUserService userService;

   @GetMapping
   public List<SysUser> queryAll() {
      return userService.queryAll();
   }

   @GetMapping("{userId}")
   public SysUser getUserInfo(@PathVariable Long userId) {
      return userService.getUserInfo(userId);
   }

   @PostMapping
   public String add(@RequestBody SysUser user) {
      userService.add(user);
      return "新增成功～";
   }

   @PutMapping("{userId}")
   public String update(@PathVariable Long userId, @RequestBody SysUser user) {
      userService.update(userId, user);
      return "更新成功～";
   }

   @DeleteMapping("{userId}")
   public String del(@PathVariable Long userId) {
      userService.delete(userId);
      return "刪除成功～";
   }
}

2.5.2 RoleController

import com.ldx.redis.entity.SysRole;
import com.ldx.redis.service.SysRoleService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.*;
import java.util.List;

/**
 * 角色管理
 * @author ludangxin
 * @date 2021/8/12
 */
@RestController
@RequestMapping("role")
@RequiredArgsConstructor
public class RoleController {
   private final SysRoleService roleService;

   @GetMapping
   public List<SysRole> queryAll() {
      return roleService.queryAll();
   }

   @GetMapping("{roleId}")
   public SysRole getUserInfo(@PathVariable Long roleId) {
      return roleService.getRoleInfo(roleId);
   }

   @PostMapping
   public String add(@RequestBody SysRole role) {
      roleService.add(role);
      return "新增成功～";
   }

   @PutMapping("{roleId}")
   public String update(@PathVariable Long roleId, @RequestBody SysRole role) {
      roleService.update(roleId, role);
      return "更新成功～";
   }

   @DeleteMapping("{roleId}")
   public String del(@PathVariable Long roleId) {
      roleService.delete(roleId);
      return "刪除成功～";
   }
}

2.6 service.impl

2.6.1 UserServiceImpl

優雅的使用redis註解實現對資料的快取

@Cacheable:unless：當unless成立時則不快取。這裡判斷size主要是不想將空值存入redis。

CacheConstant.USER_CACHE_KEY_PREFIX + "' + #userId"：其key = 指定字首 + 當前方法實參(userId)。

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ldx.redis.constant.CacheConstant;
import com.ldx.redis.entity.SysUser;
import com.ldx.redis.mapper.SysUserMapper;
import com.ldx.redis.service.SysUserService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.stereotype.Service;
import java.util.List;

/**
 * 使用者管理實現
 * @author ludangxin
 * @date 2021/8/11
 */
@Slf4j
@Service
@RequiredArgsConstructor
@CacheConfig(cacheNames = CacheConstant.USER_CACHE_NAME)
public class SysUserServiceImpl implements SysUserService {
   private final SysUserMapper userMapper;

   @Override
   @Cacheable(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "all'", unless = "#result.size() == 0")
   public List<SysUser> queryAll() {
      log.debug("查詢全部使用者資訊～");
      LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
      return userMapper.selectList(queryWrapper);
   }

   
   @Override
   @Cacheable(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "' + #userId", unless = "#result == null")
   public SysUser getUserInfo(Long userId) {
      log.debug("查詢使用者：{} 詳情", userId);
      return userMapper.selectById(userId);
   }

   @Override
   @CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "all'")
   public void add(SysUser user) {
      log.debug("新增使用者：{}", user.getNickName());
      userMapper.insert(user);
   }

   @Override
   @Caching(evict = {@CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "all'"),
                     @CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "' + #userId")
   })
   public void update(Long userId, SysUser user) {
      log.debug("更新使用者：{}", user.getNickName());
      user.setId(userId);
      userMapper.updateById(user);
   }

   @Override
   @Caching(evict = {@CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "all'"),
                     @CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "' + #userId")
   })
   public void delete(Long userId) {
      log.debug("刪除使用者：{}", userId);
      userMapper.deleteById(userId);
   }
}

2.6.2 SysRoleServiceImpl

使用redis工具類實現對資料的快取。

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ldx.redis.constant.CacheConstant;
import com.ldx.redis.entity.SysRole;
import com.ldx.redis.mapper.SysRoleMapper;
import com.ldx.redis.service.SysRoleService;
import com.ldx.redis.util.RedisUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

/**
 * 角色管理
 * @author ludangxin
 * @date 2021/8/11
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class SysRoleServiceImpl implements SysRoleService {
   private final SysRoleMapper roleMapper;

   private final RedisUtil redisUtil;

   String allKey = CacheConstant.getRoleCacheKey("all");

   @Override
   public List<SysRole> queryAll() {
      List<SysRole> roles = redisUtil.getCacheList(allKey);
      if(!CollectionUtils.isEmpty(roles)) {
         return roles;
      }
      log.debug("查詢全部角色資訊～");
      LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();
      List<SysRole> sysRoles = roleMapper.selectList(queryWrapper);
      if(CollectionUtils.isEmpty(sysRoles)) {
         return Collections.emptyList();
      }
      redisUtil.setCacheList(allKey, sysRoles);
      return sysRoles;
   }

   @Override
   public SysRole getRoleInfo(Long roleId) {
      String roleCacheKey = CacheConstant.getRoleCacheKey(String.valueOf(roleId));
      SysRole role = redisUtil.getCacheObject(roleCacheKey);

      if(Objects.nonNull(role)) {
         return role;
      }
      log.debug("查詢角色：{} 詳情", roleId);
      SysRole sysRole = roleMapper.selectById(roleId);

      if(Objects.isNull(sysRole)) {
         return null;
      }
      redisUtil.setCacheObject(roleCacheKey, sysRole);
      return sysRole;
   }

   @Override
   public void add(SysRole role) {
      log.debug("新增角色：{}", role.getName());
      roleMapper.insert(role);
      redisUtil.deleteObject(allKey);
   }

   @Override
   public void update(Long roleId, SysRole role) {
      log.debug("更新角色：{}", role.getName());
      String roleCacheKey = CacheConstant.getRoleCacheKey(String.valueOf(roleId));
      role.setId(roleId);
      roleMapper.updateById(role);
      // 更新快取
      redisUtil.setCacheObject(roleCacheKey,role);
      // 清除快取
      redisUtil.deleteObject(allKey);
   }

   @Override
   public void delete(Long roleId) {
      log.debug("刪除角色：{}", roleId);
      roleMapper.deleteById(roleId);
      // 清除快取
      redisUtil.deleteObject(CacheConstant.getRoleCacheKey(String.valueOf(roleId)));
      redisUtil.deleteObject(allKey);

   }
}

2.7 啟動測試

這裡只測試了user模組（都測試並且貼圖會顯得篇幅太長且繁瑣），role模組本人測試後結果正確。

查詢列表：

呼叫介面返回全部資料並快取完成，再次呼叫無查詢日誌輸出，符合預期。

介面呼叫：

檢視快取：

檢視使用者詳情：

介面呼叫返回使用者詳情資訊並快取完成，再次呼叫無查詢日誌輸出，符合預期。

介面呼叫：

檢視快取：

更新資料：

介面呼叫返回更新成功，並且檢視全部的快取被清除。符合預期。

介面呼叫：

檢視快取：

3. 內建快取註解

3.1 @CacheConfig

@Cacheable()裡面都有一個value＝“xxx”的屬性，這顯然如果方法多了，寫起來也是挺累的，如果可以一次性宣告完那就省事了，所以，有了@CacheConfig這個配置，@CacheConfig is a class-level annotation that allows to share the cache names，如果你在你的方法寫別的名字，那麼依然以方法的名字為準。

3.2 @Cacheable

@Cacheable(value="myCache")，這個註釋的意思是，當呼叫這個方法的時候，會從一個名叫myCache 的快取中查詢，如果沒有，則執行實際的方法（即查詢資料庫），並將執行的結果存入快取中，否則返回快取中的物件。

3.3 @CachePut

@CachePut 的作用主要針對方法配置，能夠根據方法的請求引數對其結果進行快取，和 @Cacheable 不同的是，它每次都會觸發真實方法的呼叫。

3.4 @CacheEvict

@CachEvict 的作用主要針對方法配置，能夠根據一定的條件對快取進行清空。

// 清空當前cache name下的所有key
@CachEvict(allEntries = true)

3.5 @Caching

@Caching可以使註解組合使用,比如根據id查詢使用者資訊,查詢完的結果為{key = id,value = userInfo},但我們現在為了方遍,想用使用者的手機號,郵箱等快取對應使用者的資訊,這時候我們就要使用@Caching。例:

@Caching(put = {
@CachePut(value = "user", key = "#user.id"),
@CachePut(value = "user", key = "#user.username"),
@CachePut(value = "user", key = "#user.email")
})
public User getUserInfo(User user){
    ...
return user;
}

Redis詳解 - SpringBoot整合Redis，RedisTemplate和註解兩種方式的使用
2018-11-16
RedisSpring Boot
【Redis 系列】redis 學習十一，redis 的哨兵模式詳解和實戰
2022-04-10
Redis模式
使用Jenkins優雅部署Java專案【超級詳細的實戰教程】
2022-11-24
JenkinsJava
springboot使用redis(從配置到實戰)
2021-08-28
Spring BootRedis
還在用 RedisTemplate？試試 Redis 官方 ORM 框架吧，用起來夠優雅！
2022-03-17
RedisORM框架
【進階篇】Redis實戰之Jedis使用技巧詳解
2022-12-29
Redis
Redis優雅實現分散式鎖
2019-10-09
Redis分散式
spring配置redis註解快取
2018-03-15
SpringRedis快取
Java 如何優雅的使用註解
2019-04-08
Java
redis 配置檔案詳解
2019-08-14
Redis
redis配置檔案詳解
2018-07-16
Redis
Redis刪除特定字首key的優雅實現
2019-06-17
Redis
.Net使用Redis詳解之ServiceStack.Redis
2018-04-25
Redis
Go實戰-redis的基本使用
2020-10-18
GoRedis
【Redis 系列】redis 學習七，那些你不知道的 redis 配置檔案詳解
2022-03-06
Redis
自定義RedisTemplate，解決Redis亂碼問題
2024-05-26
Redis
Redis 持久化之 AOF 配置詳解
2018-07-20
Redis持久化
Redis 主從複製詳細解讀
2019-11-13
Redis
如何使用RedisTemplate訪問Redis資料結構
2018-08-27
Redis資料結構
如何優雅地使用Redis之點陣圖操作
2018-08-23
Redis
redis自學（34）redisTemplate的哨兵模式
2024-04-15
Redis模式
優雅的快取解決方案--SpringCache和Redis整合(SpringBoot)
2019-03-26
快取GCRedisSpring Boot
優雅實現延時任務之Redis篇
2018-09-13
Redis
springboot註解方式使用redis快取
2018-07-14
Spring BootRedis快取
搭建Redis哨兵叢集並使用RedisTemplate實現讀寫分離
2024-10-10
Redis
Redis詳解
2018-05-25
Redis
springboot整合redis,redisTemplate 空指標
2024-10-30
Spring BootRedis指標
Redis API & Java RedisTemplate深入分析
2018-10-25
RedisAPIJava
Redis優化配置解析
2020-12-18
Redis優化
Redis實戰解讀-初識Redis&Redis基本資料型別
2023-05-15
Redis資料型別
Redis實戰
2024-08-14
Redis
NoSQL之Redis的配置優化
2020-12-17
SQLRedis優化
《Redis實戰》筆記-Redis的有序集合
2018-03-20
Redis筆記
學會優雅地使用@Valid系列註解
2024-07-26
redis的GEO實戰
2018-09-08
Redis
Java註解詳解「註解專案實戰」
2018-12-09
Java
Mac安裝Redis，詳細redis安裝步驟
2020-12-24
MacRedis
小程式抓包實戰：Fiddler配置與使用詳細
2024-06-02

Redis實戰-詳細配置-優雅的使用Redis註解/RedisTemplate

1. 簡介

2. 開擼

2.1 專案結構

2.2 匯入依賴

2.3 專案基本配置

2.3.1 application.yaml

2.3.2 啟動類

2.4 redis配置

2.4.1 RedisConfig

2.4.1 CacheConstant

2.4.2 RedisUtil

2.5 controller

2.5.1 UserController

2.5.2 RoleController

2.6 service.impl

2.6.1 UserServiceImpl

2.6.2 SysRoleServiceImpl

2.7 啟動測試

3. 內建快取註解

3.1 @CacheConfig

3.2 @Cacheable

3.3 @CachePut

3.4 @CacheEvict

3.5 @Caching

相關文章