1. 简介

当我们对redis的基本知识有一定的了解后，我们再通过实战的角度学习一下在SpringBoot环境下，如何优雅的使用redis。

我们通过使用SpringBoot内置的Redis注解（文章最后有解释）来操作User相关的信息，

再通过Redis工具类的方式操作Role相关信息来全面的学习Redis的使用。

嫌篇幅太长的 可以直接跳到2.6查看具体逻辑即可。

2. 开撸

2.1 项目结构

结构说明：

  1. ├── src
  2. │   └── main
  3. │       ├── java
  4. │       │   └── com
  5. │       │       └── ldx
  6. │       │           └── redis
  7. │       │               ├── RedisApplication.java # 启动类
  8. │       │               ├── config
  9. │       │               │   └── RedisConfig.java # redis 配置类
  10. │       │               ├── constant
  11. │       │               │   └── CacheConstant.java # 缓存key常量类
  12. │       │               ├── controller
  13. │       │               │   ├── RoleController.java # 角色管理控制器
  14. │       │               │   └── UserController.java # 用户管理控制器
  15. │       │               ├── entity
  16. │       │               │   ├── SysRole.java # 角色entity
  17. │       │               │   └── SysUser.java # 用户entity
  18. │       │               ├── mapper
  19. │       │               │   ├── SysRoleMapper.java # 角色持久层
  20. │       │               │   └── SysUserMapper.java # 用户持久层
  21. │       │               ├── service
  22. │       │               │   ├── SysRoleService.java # 角色接口层
  23. │       │               │   ├── SysUserService.java # 用户接口层
  24. │       │               │   └── impl
  25. │       │               │       ├── SysRoleServiceImpl.java # 角色接口实现层
  26. │       │               │       └── SysUserServiceImpl.java # 用户接口实现层
  27. │       │               └── util
  28. │       │                   └── RedisUtil.java # redis 工具类
  29. │       └── resources
  30. │           └── application.yaml # 系统配置文件
  31. └── pom.xml # 依赖管理

2.2 导入依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.    <modelVersion>4.0.0</modelVersion>
  5.    <parent>
  6.       <groupId>org.springframework.boot</groupId>
  7.       <artifactId>spring-boot-starter-parent</artifactId>
  8.       <version>2.5.3</version>
  9.       <relativePath/> <!-- lookup parent from repository -->
  10.    </parent>
  11.    <groupId>com.ldx</groupId>
  12.    <artifactId>redis</artifactId>
  13.    <version>0.0.1-SNAPSHOT</version>
  14.    <name>redis</name>
  15.    <description>Demo project for Spring Boot</description>
  16.    <properties>
  17.       <java.version>1.8</java.version>
  18.    </properties>
  19.    <dependencies>
  20.       <!--spring-web-->
  21.       <dependency>
  22.          <groupId>org.springframework.boot</groupId>
  23.          <artifactId>spring-boot-starter-web</artifactId>
  24.       </dependency>
  25.       <!-- redis -->
  26.       <dependency>
  27.          <groupId>org.springframework.boot</groupId>
  28.          <artifactId>spring-boot-starter-data-redis</artifactId>
  29.       </dependency>
  30.       <!-- lettuce pool -->
  31.       <dependency>
  32.          <groupId>org.apache.commons</groupId>
  33.          <artifactId>commons-pool2</artifactId>
  34.       </dependency>
  35.       <!-- mybatis-plus -->
  36.       <dependency>
  37.          <groupId>com.baomidou</groupId>
  38.          <artifactId>mybatis-plus-boot-starter</artifactId>
  39.          <version>3.4.2</version>
  40.       </dependency>
  41.       <!-- mysql驱动 -->
  42.       <dependency>
  43.          <groupId>mysql</groupId>
  44.          <artifactId>mysql-connector-java</artifactId>
  45.       </dependency>
  46.       <!-- lombok 工具包 -->
  47.       <dependency>
  48.          <groupId>org.projectlombok</groupId>
  49.          <artifactId>lombok</artifactId>
  50.          <optional>true</optional>
  51.       </dependency>
  52.    </dependencies>
  54.    <build>
  55.       <plugins>
  56.          <plugin>
  57.             <groupId>org.springframework.boot</groupId>
  58.             <artifactId>spring-boot-maven-plugin</artifactId>
  59.             <configuration>
  60.                <excludes>
  61.                   <exclude>
  62.                      <groupId>org.projectlombok</groupId>
  63.                      <artifactId>lombok</artifactId>
  64.                   </exclude>
  65.                </excludes>
  66.             </configuration>
  67.          </plugin>
  68.       </plugins>
  69.    </build>
  70. </project>

2.3 项目基本配置

2.3.1 application.yaml

  1. spring:
  2.   datasource:
  3.     driver-class-name: com.mysql.cj.jdbc.Driver
  4.     url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
  5.     username: root
  6.     password: 123456
  7.     type: com.zaxxer.hikari.HikariDataSource
  8.   # redis 配置
  9.   redis:
  10.     # 地址
  11.     host: localhost
  12.     # 端口，默认为6379
  13.     port: 6379
  14.     # 密码
  15.     password:
  16.     # 连接超时时间
  17.     timeout: 10s
  18.     lettuce:
  19.       pool:
  20.         # 连接池中的最小空闲连接
  21.         min-idle: 0
  22.         # 连接池中的最大空闲连接
  23.         max-idle: 8
  24.         # 连接池的最大数据库连接数
  25.         max-active: 8
  26.         # #连接池最大阻塞等待时间（使用负值表示没有限制）
  27.         max-wait: -1ms
  29. mybatis-plus:
  30.   # 设置Mapper接口所对应的XML文件位置，如果你在Mapper接口中有自定义方法，需要进行该配置
  31.   mapper-locations: classpath*:mapper/*.xml
  32.   # 设置别名包扫描路径，通过该属性可以给包中的类注册别名
  33.   type-aliases-package: com.ldx.redis.entity
  34.   configuration:
  35.     # 控制台sql打印
  36.     log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  38. # 日志配置
  39. logging:
  40.   level:
  41.     com.ldx.redis.service.impl: debug
  42.     org.springframework: warn

2.3.2 启动类

@EnableCaching：激活缓存支持

@MapperScan: 扫描mapper接口层

  1. import org.mybatis.spring.annotation.MapperScan;
  2. import org.springframework.boot.SpringApplication;
  3. import org.springframework.boot.autoconfigure.SpringBootApplication;
  4. import org.springframework.cache.annotation.EnableCaching;
  6. /**
  7.  * 启动类
  8.  * @author ludangxin
  9.  * @date 2021/8/11
  10.  */
  11. @EnableCaching
  12. @MapperScan(basePackages = "com.ldx.redis.mapper")
  13. @SpringBootApplication
  14. public class RedisApplication {
  15.   public static void main(String[] args) {
  16.     SpringApplication.run(RedisApplication.class, args);
  17.   }
  18. }

2.4 redis配置

2.4.1 RedisConfig

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

注解：

  1. 其默认的序列化方式为JdkSerializationRedisSerializer，这种方式跨语言和可读性都不太好，我们将其切换为Jackson2JsonRedisSerializer。

  2. 可以使用entryTtl()为对应的模块设置过期时长。

redisTemplate：参考redisTemplate()。

  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import com.ldx.redis.constant.CacheConstant;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  8. import org.springframework.data.redis.cache.RedisCacheManager;
  9. import org.springframework.data.redis.cache.RedisCacheWriter;
  10. import org.springframework.data.redis.connection.RedisConnectionFactory;
  11. import org.springframework.data.redis.core.RedisTemplate;
  12. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  13. import org.springframework.data.redis.serializer.RedisSerializationContext;
  14. import org.springframework.data.redis.serializer.StringRedisSerializer;
  15. import java.time.Duration;
  16. import java.util.HashMap;
  17. import java.util.Map;
  19. /**
  20.  * redis配置类
  21.  * @author ludangxin
  22.  * @date 2021/8/11
  23.  */
  24. @Configuration
  25. public class RedisConfig {
  27.     @Bean
  28.     public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
  29.         //设置不同cacheName的过期时间
  30.         Map<String, RedisCacheConfiguration> configurations = new HashMap<>(16);
  31.         // 序列化方式
  32.         Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = getJsonRedisSerializer();
  33.         RedisSerializationContext.SerializationPair<Object> serializationPair =
  34.            RedisSerializationContext.SerializationPair.fromSerializer(jsonRedisSerializer);
  35.         // 默认的缓存时间
  36.         Duration defaultTtl = Duration.ofSeconds(20L);
  37.         // 用户模块的缓存时间
  38.         Duration userTtl = Duration.ofSeconds(50L);
  39.         // 默认的缓存配置
  40.         RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
  41.            //.entryTtl(defaultTtl)
  42.            .serializeValuesWith(serializationPair);
  43.         // 自定义用户模块的缓存配置 自定义的配置可以覆盖默认配置（当前的模块）
  44.         configurations.put(CacheConstant.USER_CACHE_NAME, RedisCacheConfiguration.defaultCacheConfig()
  45.            //.entryTtl(userTtl)
  46.            .serializeValuesWith(serializationPair)
  47.         );
  49.         return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory))
  50.            .cacheDefaults(redisCacheConfiguration)
  51.            .withInitialCacheConfigurations(configurations)
  52.            // 事物支持
  53.            .transactionAware()
  54.            .build();
  55.     }
  57.     @Bean
  58.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory factory) {
  59.         RedisTemplate<Object, Object> template = new RedisTemplate<>();
  60.         template.setConnectionFactory(factory);
  61.         Jackson2JsonRedisSerializer<Object> jsonRedisSerializer = getJsonRedisSerializer();
  62.         StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  63.         // key采用String的序列化方式
  64.         template.setKeySerializer(stringRedisSerializer);
  65.         // hash的key也采用String的序列化方式
  66.         template.setHashKeySerializer(stringRedisSerializer);
  67.         // value序列化方式采用jackson
  68.         template.setValueSerializer(jsonRedisSerializer);
  69.         // hash的value序列化方式采用jackson
  70.         template.setHashValueSerializer(jsonRedisSerializer);
  71.         // 支持事物
  72.         //template.setEnableTransactionSupport(true);
  73.         template.afterPropertiesSet();
  74.         return template;
  75.     }
  77.     /**
  78.      * 设置jackson的序列化方式
  79.      */
  80.     private Jackson2JsonRedisSerializer<Object> getJsonRedisSerializer() {
  81.         Jackson2JsonRedisSerializer<Object> redisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
  82.         ObjectMapper om = new ObjectMapper();
  83.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  84.         redisSerializer.setObjectMapper(om);
  85.         return redisSerializer;
  86.     }
  87. }

2.4.1 CacheConstant

我们为了防止redis中key的重复，尽量会给不同的数据主体加上不同的前缀，这样我们在查看和统计的时候也方便操作。

  1. /**
  2.  * 缓存key 常量类
  3.  * @author ludangxin
  4.  * @date 2021/8/11
  5.  */
  6. public interface CacheConstant {
  7.    /**
  8.     * 用户cache name
  9.     */
  10.    String USER_CACHE_NAME = "user_cache";
  12.    /**
  13.     * 用户信息缓存key前缀
  14.     */
  15.    String USER_CACHE_KEY_PREFIX = "user_";
  17.    /**
  18.     * 角色cache name
  19.     */
  20.    String ROLE_CACHE_NAME = "role_cache";
  22.    /**
  23.     * 角色信息缓存key前缀
  24.     */
  25.    String ROLE_CACHE_KEY_PREFIX = "role_";
  27.    /**
  28.     * 获取角色cache key
  29.     * @param suffix 后缀
  30.     * @return key
  31.     */
  32.    static String getRoleCacheKey(String suffix) {
  33.       return ROLE_CACHE_NAME + "::" + ROLE_CACHE_KEY_PREFIX + suffix;
  34.    }
  35. }

2.4.2 RedisUtil

  1. import lombok.RequiredArgsConstructor;
  2. import org.springframework.data.redis.core.*;
  3. import org.springframework.stereotype.Component;
  4. import java.util.*;
  5. import java.util.concurrent.TimeUnit;
  7. /**
  8.  * spring redis 工具类
  9.  * @author ludangxin
  10.  **/
  11. @Component
  12. @RequiredArgsConstructor
  13. @SuppressWarnings(value = { "unchecked", "rawtypes" })
  14. public class RedisUtil {
  15.     public final RedisTemplate redisTemplate;
  17.     /**
  18.      * 缓存基本的对象，Integer、String、实体类等
  19.      * @param key 缓存的键值
  20.      * @param value 缓存的值
  21.      * @return 缓存的对象
  22.      */
  23.     public <T> ValueOperations<String, T> setCacheObject(String key, T value) {
  24.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  25.         operation.set(key, value);
  26.         return operation;
  27.     }
  29.     /**
  30.      * 缓存基本的对象，Integer、String、实体类等
  31.      * @param key 缓存的键值
  32.      * @param value 缓存的值
  33.      * @param timeout 时间
  34.      * @param timeUnit 时间颗粒度
  35.      * @return 缓存的对象
  36.      */
  37.     public <T> ValueOperations<String, T> setCacheObject(String key, T value, Integer timeout, TimeUnit timeUnit) {
  38.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  39.         operation.set(key, value, timeout, timeUnit);
  40.         return operation;
  41.     }
  43.     /**
  44.      * 获得缓存的基本对象。
  45.      * @param key 缓存键值
  46.      * @return 缓存键值对应的数据
  47.      */
  48.     public <T> T getCacheObject(String key) {
  49.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  50.         return operation.get(key);
  51.     }
  53.     /**
  54.      * 删除单个对象
  55.      * @param key
  56.      */
  57.     public void deleteObject(String key) {
  58.         redisTemplate.delete(key);
  59.     }
  61.     /**
  62.      * 删除集合对象
  63.      * @param collection
  64.      */
  65.     public void deleteObject(Collection collection) {
  66.         redisTemplate.delete(collection);
  67.     }
  69.     /**
  70.      * 缓存List数据
  71.      * @param key 缓存的键值
  72.      * @param dataList 待缓存的List数据
  73.      * @return 缓存的对象
  74.      */
  75.     public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList) {
  76.         ListOperations listOperation = redisTemplate.opsForList();
  77.         if (null != dataList) {
  78.             int size = dataList.size();
  79.             for (int i = 0; i < size; i++) {
  80.                 listOperation.leftPush(key, dataList.get(i));
  81.             }
  82.         }
  83.         return listOperation;
  84.     }
  86.     /**
  87.      * 获得缓存的list对象
  88.      * @param key 缓存的键值
  89.      * @return 缓存键值对应的数据
  90.      */
  91.     public <T> List<T> getCacheList(String key) {
  92.         List<T> dataList = new ArrayList<T>();
  93.         ListOperations<String, T> listOperation = redisTemplate.opsForList();
  94.         Long size = listOperation.size(key);
  95.         for (int i = 0; i < size; i++) {
  96.             dataList.add(listOperation.index(key, i));
  97.         }
  98.         return dataList;
  99.     }
  101.     /**
  102.      * 缓存Set
  103.      * @param key 缓存键值
  104.      * @param dataSet 缓存的数据
  105.      * @return 缓存数据的对象
  106.      */
  107.     public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet) {
  108.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  109.         Iterator<T> it = dataSet.iterator();
  110.         while (it.hasNext()) {
  111.             setOperation.add(it.next());
  112.         }
  113.         return setOperation;
  114.     }
  116.     /**
  117.      * 获得缓存的set
  118.      * @param key
  119.      * @return
  120.      */
  121.     public <T> Set<T> getCacheSet(String key) {
  122.         Set<T> dataSet = new HashSet<T>();
  123.         BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);
  124.         dataSet = operation.members();
  125.         return dataSet;
  126.     }
  128.     /**
  129.      * 缓存Map
  130.      * @param key
  131.      * @param dataMap
  132.      * @return
  133.      */
  134.     public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap) {
  135.         HashOperations hashOperations = redisTemplate.opsForHash();
  136.         if (null != dataMap) {
  137.             for (Map.Entry<String, T> entry : dataMap.entrySet()) {
  138.                 hashOperations.put(key, entry.getKey(), entry.getValue());
  139.             }
  140.         }
  141.         return hashOperations;
  142.     }
  144.     /**
  145.      * 获得缓存的Map
  146.      * @param key
  147.      * @return
  148.      */
  149.     public <T> Map<String, T> getCacheMap(String key) {
  150.         Map<String, T> map = redisTemplate.opsForHash().entries(key);
  151.         return map;
  152.     }
  154.     /**
  155.      * 获得缓存的基本对象列表
  156.      * @param pattern 字符串前缀
  157.      * @return 对象列表
  158.      */
  159.     public Collection<String> keys(String pattern) {
  160.         return redisTemplate.keys(pattern);
  161.     }
  162. }

2.5 controller

2.5.1 UserController

  1. import com.ldx.redis.entity.SysUser;
  2. import com.ldx.redis.service.SysUserService;
  3. import lombok.RequiredArgsConstructor;
  4. import org.springframework.web.bind.annotation.*;
  5. import java.util.List;
  7. /**
  8.  * 用户管理
  9.  * @author ludangxin
  10.  * @date 2021/8/11
  11.  */
  12. @RestController
  13. @RequestMapping("user")
  14. @RequiredArgsConstructor
  15. public class UserController {
  16.    private final SysUserService userService;
  18.    @GetMapping
  19.    public List<SysUser> queryAll() {
  20.       return userService.queryAll();
  21.    }
  23.    @GetMapping("{userId}")
  24.    public SysUser getUserInfo(@PathVariable Long userId) {
  25.       return userService.getUserInfo(userId);
  26.    }
  28.    @PostMapping
  29.    public String add(@RequestBody SysUser user) {
  30.       userService.add(user);
  31.       return "新增成功～";
  32.    }
  34.    @PutMapping("{userId}")
  35.    public String update(@PathVariable Long userId, @RequestBody SysUser user) {
  36.       userService.update(userId, user);
  37.       return "更新成功～";
  38.    }
  40.    @DeleteMapping("{userId}")
  41.    public String del(@PathVariable Long userId) {
  42.       userService.delete(userId);
  43.       return "删除成功～";
  44.    }
  45. }

2.5.2 RoleController

  1. import com.ldx.redis.entity.SysRole;
  2. import com.ldx.redis.service.SysRoleService;
  3. import lombok.RequiredArgsConstructor;
  4. import org.springframework.web.bind.annotation.*;
  5. import java.util.List;
  7. /**
  8.  * 角色管理
  9.  * @author ludangxin
  10.  * @date 2021/8/12
  11.  */
  12. @RestController
  13. @RequestMapping("role")
  14. @RequiredArgsConstructor
  15. public class RoleController {
  16.    private final SysRoleService roleService;
  18.    @GetMapping
  19.    public List<SysRole> queryAll() {
  20.       return roleService.queryAll();
  21.    }
  23.    @GetMapping("{roleId}")
  24.    public SysRole getUserInfo(@PathVariable Long roleId) {
  25.       return roleService.getRoleInfo(roleId);
  26.    }
  28.    @PostMapping
  29.    public String add(@RequestBody SysRole role) {
  30.       roleService.add(role);
  31.       return "新增成功～";
  32.    }
  34.    @PutMapping("{roleId}")
  35.    public String update(@PathVariable Long roleId, @RequestBody SysRole role) {
  36.       roleService.update(roleId, role);
  37.       return "更新成功～";
  38.    }
  40.    @DeleteMapping("{roleId}")
  41.    public String del(@PathVariable Long roleId) {
  42.       roleService.delete(roleId);
  43.       return "删除成功～";
  44.    }
  45. }

2.6 service.impl

2.6.1 UserServiceImpl

优雅的使用redis注解实现对数据的缓存

@Cacheable:unless：当unless成立时则不缓存。这里判断size主要是不想将空值存入redis。

CacheConstant.USER_CACHE_KEY_PREFIX + "' + #userId"：其key = 指定前缀 + 当前方法实参(userId)。

  1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  2. import com.ldx.redis.constant.CacheConstant;
  3. import com.ldx.redis.entity.SysUser;
  4. import com.ldx.redis.mapper.SysUserMapper;
  5. import com.ldx.redis.service.SysUserService;
  6. import lombok.RequiredArgsConstructor;
  7. import lombok.extern.slf4j.Slf4j;
  8. import org.springframework.cache.annotation.CacheConfig;
  9. import org.springframework.cache.annotation.CacheEvict;
  10. import org.springframework.cache.annotation.Cacheable;
  11. import org.springframework.cache.annotation.Caching;
  12. import org.springframework.stereotype.Service;
  13. import java.util.List;
  15. /**
  16.  * 用户管理实现
  17.  * @author ludangxin
  18.  * @date 2021/8/11
  19.  */
  20. @Slf4j
  21. @Service
  22. @RequiredArgsConstructor
  23. @CacheConfig(cacheNames = CacheConstant.USER_CACHE_NAME)
  24. public class SysUserServiceImpl implements SysUserService {
  25.    private final SysUserMapper userMapper;
  27.    @Override
  28.    @Cacheable(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "all'", unless = "#result.size() == 0")
  29.    public List<SysUser> queryAll() {
  30.       log.debug("查询全部用户信息～");
  31.       LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
  32.       return userMapper.selectList(queryWrapper);
  33.    }
  35.    @Override
  36.    @Cacheable(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "' + #userId", unless = "#result == null")
  37.    public SysUser getUserInfo(Long userId) {
  38.       log.debug("查询用户：{} 详情", userId);
  39.       return userMapper.selectById(userId);
  40.    }
  42.    @Override
  43.    @CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "all'")
  44.    public void add(SysUser user) {
  45.       log.debug("新增用户：{}", user.getNickName());
  46.       userMapper.insert(user);
  47.    }
  49.    @Override
  50.    @Caching(evict = {@CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "all'"),
  51.                      @CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "' + #userId")
  52.    })
  53.    public void update(Long userId, SysUser user) {
  54.       log.debug("更新用户：{}", user.getNickName());
  55.       user.setId(userId);
  56.       userMapper.updateById(user);
  57.    }
  59.    @Override
  60.    @Caching(evict = {@CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "all'"),
  61.                      @CacheEvict(key = "'" + CacheConstant.USER_CACHE_KEY_PREFIX + "' + #userId")
  62.    })
  63.    public void delete(Long userId) {
  64.       log.debug("删除用户：{}", userId);
  65.       userMapper.deleteById(userId);
  66.    }
  67. }

2.6.2 SysRoleServiceImpl

使用redis工具类实现对数据的缓存。

  1. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  2. import com.ldx.redis.constant.CacheConstant;
  3. import com.ldx.redis.entity.SysRole;
  4. import com.ldx.redis.mapper.SysRoleMapper;
  5. import com.ldx.redis.service.SysRoleService;
  6. import com.ldx.redis.util.RedisUtil;
  7. import lombok.RequiredArgsConstructor;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.springframework.stereotype.Service;
  10. import org.springframework.util.CollectionUtils;
  11. import java.util.Collections;
  12. import java.util.List;
  13. import java.util.Objects;
  15. /**
  16.  * 角色管理
  17.  * @author ludangxin
  18.  * @date 2021/8/11
  19.  */
  20. @Slf4j
  21. @Service
  22. @RequiredArgsConstructor
  23. public class SysRoleServiceImpl implements SysRoleService {
  24.    private final SysRoleMapper roleMapper;
  26.    private final RedisUtil redisUtil;
  28.    String allKey = CacheConstant.getRoleCacheKey("all");
  30.    @Override
  31.    public List<SysRole> queryAll() {
  32.       List<SysRole> roles = redisUtil.getCacheList(allKey);
  33.       if(!CollectionUtils.isEmpty(roles)) {
  34.          return roles;
  35.       }
  36.       log.debug("查询全部角色信息～");
  37.       LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();
  38.       List<SysRole> sysRoles = roleMapper.selectList(queryWrapper);
  39.       if(CollectionUtils.isEmpty(sysRoles)) {
  40.          return Collections.emptyList();
  41.       }
  42.       redisUtil.setCacheList(allKey, sysRoles);
  43.       return sysRoles;
  44.    }
  46.    @Override
  47.    public SysRole getRoleInfo(Long roleId) {
  48.       String roleCacheKey = CacheConstant.getRoleCacheKey(String.valueOf(roleId));
  49.       SysRole role = redisUtil.getCacheObject(roleCacheKey);
  51.       if(Objects.nonNull(role)) {
  52.          return role;
  53.       }
  54.       log.debug("查询角色：{} 详情", roleId);
  55.       SysRole sysRole = roleMapper.selectById(roleId);
  57.       if(Objects.isNull(sysRole)) {
  58.          return null;
  59.       }
  60.       redisUtil.setCacheObject(roleCacheKey, sysRole);
  61.       return sysRole;
  62.    }
  64.    @Override
  65.    public void add(SysRole role) {
  66.       log.debug("新增角色：{}", role.getName());
  67.       roleMapper.insert(role);
  68.       redisUtil.deleteObject(allKey);
  69.    }
  71.    @Override
  72.    public void update(Long roleId, SysRole role) {
  73.       log.debug("更新角色：{}", role.getName());
  74.       String roleCacheKey = CacheConstant.getRoleCacheKey(String.valueOf(roleId));
  75.       role.setId(roleId);
  76.       roleMapper.updateById(role);
  77.       // 更新缓存
  78.       redisUtil.setCacheObject(roleCacheKey,role);
  79.       // 清除缓存
  80.       redisUtil.deleteObject(allKey);
  81.    }
  83.    @Override
  84.    public void delete(Long roleId) {
  85.       log.debug("删除角色：{}", roleId);
  86.       roleMapper.deleteById(roleId);
  87.       // 清除缓存
  88.       redisUtil.deleteObject(CacheConstant.getRoleCacheKey(String.valueOf(roleId)));
  89.       redisUtil.deleteObject(allKey);
  91.    }
  92. }

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 的作用 主要针对方法配置，能够根据一定的条件对缓存进行清空。

  1. // 清空当前cache name下的所有key
  2. @CachEvict(allEntries = true)

3.5 @Caching

@Caching可以使注解组合使用,比如根据id查询用户信息,查询完的结果为{key = id,value = userInfo},但我们现在为了方遍,想用用户的手机号,邮箱等缓存对应用户的信息,这时候我们就要使用@Caching。例:

  1. @Caching(put = {
  2. @CachePut(value = "user", key = "#user.id"),
  3. @CachePut(value = "user", key = "#user.username"),
  4. @CachePut(value = "user", key = "#user.email")
  5. })
  6. public User getUserInfo(User user){
  7.     ...
  8. return user;
  9. }

Redis实战-详细配置-优雅的使用Redis注解/RedisTemplate的更多相关文章

  1. Redis实战总结-配置、持久化、复制

    Redis的配置主要放置在redis.conf,可以通过修改配置文件实现Redis许多特性,比如复制,持久化,集群等. redis.conf部分配置详解 # 启动redis,显示加载配置redis.c ...

  2. 小D课堂 - 零基础入门SpringBoot2.X到实战_第9节 SpringBoot2.x整合Redis实战_39、SpringBoot2.x整合redis实战讲解

    笔记 3.SpringBoot2.x整合redis实战讲解 简介:使用springboot-starter整合reids实战 1.官网:https://docs.spring.io/spring-bo ...

  3. Redis实战篇（一）搭建Redis实例

    今天是Redis实战系列的第一讲,先从如何搭建一个Redis实例开始. 下面介绍如何在Docker.Windows.Linux下安装. Docker下安装 1.查看可用的 Redis 版本 访问 Re ...

  4. Redis实战阅读笔记——第二章（redis重构web）

    在性能的要求下,如何用redis重构已有的已有的部分,其实整个例子背后的思路挺好的.在应用缓存的过程中,还有一指标个需要考虑,读写比.

  5. Redis实战总结-Redis的高可用性

    在之前的博客<Redis实战总结-配置.持久化.复制>给出了一种Redis主从复制机制,简单地实现了Redis高可用.然后,如果Master服务器宕机,会导致整个Redis瘫痪,这种方式的 ...

  6. redis的主从复制配置

    redis的主从复制配置 一.     原理 Redis的主从复制功能非常强大,一个master可以拥有多个slave,而一个slave又可以拥有多个slave,如此下去,形成了强大的多级服务器集群架 ...

  7. 【转载】Redis Sentinel服务配置

    转载地址:http://blog.csdn.net/vtopqx/article/details/49247285 redis官网文档:http://www.redis.cn/topics/senti ...

  8. Spring集成Redis集群（含spring集成redis代码）

    代码地址如下:http://www.demodashi.com/demo/11458.html 一.准备工作 安装 Redis 集群 安装参考: http://blog.csdn.net/zk6738 ...

  9. 在centos7中安装redis，并通过node.js操作redis

    引言 最近在学习node.js 连接redis的模块,所以尝试了一下在虚拟机中安装cent OS7,并安装redis,并使用node.js 操作redis.所以顺便做个笔记. 如有不对的地方,欢迎大家 ...

随机推荐

  1. 100、nginx_https安全链接配置

    100.1. tcp的三次握手和四次挥手的过程: 1.三次握手(建立连接): 第一次:建立连接时,客户端发送SYN包(syn=j)到服务器,并进入SYN_SEND状态,等待服务器确认: 第二次:服务器 ...

  2. IDEA中Springboot启动热部署

    在IDEA中开发springboot项目时,每次修改代码后都需要手动重启项目比较麻烦,可以通过添加一定的配置使每次修改代码后项目进行自动重启 在IDEA中开发springboot项目时,每次修改代码后 ...

  3. MySql：使用Navicat定时备份数据库

    Navicat自带就有备份  还可以直接计划任务,很方便. 1. 新建计划 打开navicat客户端,连上mysql后,双击左边你想要备份的数据库.点击"计划",再点击" ...

  4. Windows软件包管理工具：Scoop

    前言 删库跑路后,Windows系统如何快速安装应用程序,部署环境呢? 以前想过这个问题,最近在安装Hugo时发现使用软件包管理工具可以解决这个问题. 阅读建议 首先需要测试下载速度,尝试从官网下载, ...

  5. ROS2学习之旅（12）——创建工作空间

    workspace(工作空间)是包含ROS2 packages(包)的文件夹.在使用ROS 2之前,有必要在终端中source一下ROS 2的安装工作区,这样就可以在该终端中使用ROS 2的软件包. ...

  6. 如何修改Windows 11 任务栏大小

    1.首先Win+R输入regedit打开注册表编辑器         2.进入注册表编辑器后,在地址栏中输入: HKEY_CURRENT_USER\Software\Microsoft\ Window ...

  7. Java基础00-分支语句6

    1. 流程控制 1.1 流程控制语句概述 1.2 流程控制语句分类 1.3 顺序结构 2. if语句 2.1 if语句格式1 适合一种情况的判断 执行流程图: 2.2 if语句格式2 适合两种情况的判 ...

  8. [010] - JavaSE面试题（十）：集合之Map

    第一期:Java面试 - 100题,梳理各大网站优秀面试题.大家可以跟着我一起来刷刷Java理论知识 [010] - JavaSE面试题(十):集合之Map 第1问:HashMap和HashTable ...

  9. .netcore第三方登录授权：10分钟急速接入

    前言 很多对外应用的开发都考虑接入第三方登录来提高用户的体验感,避免用户进行繁琐的注册登录(登录后的完善资料必不可免). 而QQ.微信.支付宝.淘宝.微博等应用就是首选目标(无他,用户群体大,支持发开 ...

  10. TypeScript——原始数据类型

    TypeScript原始数据类型 原始数据类型包括:布尔值.数值.字符串.null.undefined. Symbol.BigInt. 布尔值: let isDone: boolean = false ...