代码：

依赖

  1. <dependencies>
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-data-redis</artifactId>
  5.         </dependency>
  6.         <!-- mybatis 持久层-->
  7.         <dependency>
  8.             <groupId>org.mybatis.spring.boot</groupId>
  9.             <artifactId>mybatis-spring-boot-starter</artifactId>
  10.             <version>2.1.2</version>
  11.         </dependency>
  12.         <dependency>
  13.             <groupId>org.springframework.boot</groupId>
  14.             <artifactId>spring-boot-starter-web</artifactId>
  15.         </dependency>
  16.         <dependency>
  17.             <groupId>org.apache.commons</groupId>
  18.             <artifactId>commons-pool2</artifactId>
  19.             <version>2.8.0</version>
  20.         </dependency>
  22.         <dependency>
  23.             <groupId>mysql</groupId>
  24.             <artifactId>mysql-connector-java</artifactId>
  25.             <scope>runtime</scope>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.projectlombok</groupId>
  29.             <artifactId>lombok</artifactId>
  30.             <optional>true</optional>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>org.springframework.boot</groupId>
  34.             <artifactId>spring-boot-starter-test</artifactId>
  35.             <scope>test</scope>
  36.             <exclusions>
  37.                 <exclusion>
  38.                     <groupId>org.junit.vintage</groupId>
  39.                     <artifactId>junit-vintage-engine</artifactId>
  40.                 </exclusion>
  41.             </exclusions>
  42.         </dependency>
  43.     </dependencies>

application.properties

  1. server.port=8081
  3. # ============数据库============
  4. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  5. spring.datasource.url=jdbc:mysql://localhost:3308/test?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
  6. spring.datasource.username=root
  7. spring.datasource.password=root
  9. # ============mybatis============
  10. mybatis.mapper-locations=classpath:/mapper/*.xml
  11. mybatis.type-aliases-package=com.example.entity
  12. mybatis.configuration.map-underscore-to-camel-case=true
  13. mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
  15. # ============redis============
  16. # 默认是使用0号数据库，这里我们使用1号，笔者现在0号有其他数据- -
  17. spring.redis.database=1
  18. spring.redis.host=localhost
  19. spring.redis.port=6379
  20. # 默认密码为空
  21. spring.redis.password=
  22. # 连接池最大连接数
  23. spring.redis.lettuce.pool.max-active=8
  24. # 连接池最大阻塞等待时间
  25. spring.redis.lettuce.pool.max-wait=-1ms
  26. # 连接池中的最大空闲连接
  27. spring.redis.lettuce.pool.max-idle=8
  28. # 连接池中的最小空闲连接
  29. spring.redis.lettuce.pool.min-idle=0

RedisConfig.java

  1. package com.example.redispractice.config;
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.springframework.cache.CacheManager;
  7. import org.springframework.cache.annotation.EnableCaching;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.data.redis.cache.RedisCacheConfiguration;
  11. import org.springframework.data.redis.cache.RedisCacheManager;
  12. import org.springframework.data.redis.connection.RedisConnectionFactory;
  13. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  14. import org.springframework.data.redis.serializer.RedisSerializationContext;
  15. import org.springframework.data.redis.serializer.RedisSerializer;
  16. import org.springframework.data.redis.serializer.StringRedisSerializer;
  18. import java.time.Duration;
  20. /**
  21.  * @author seanwang
  22.  * @date 2021/7/2 0002 上午 10:09
  23.  */
  24. @Configuration
  25. @SuppressWarnings("all")
  26. @EnableCaching
  27. public class RedisConfig {
  29.     @Bean
  30.     public CacheManager cacheManager(RedisConnectionFactory factory) {
  31.         RedisSerializer<String> redisSerializer = new StringRedisSerializer();
  32.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  33.         //解决查询缓存转换异常的问题
  34.         ObjectMapper om = new ObjectMapper();
  35.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  36.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  37.         jackson2JsonRedisSerializer.setObjectMapper(om);
  39.         // 配置序列化（解决乱码的问题）
  40.         RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
  41.                 .entryTtl(Duration.ofDays(1))
  42.                 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
  43.                 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
  44.                 .disableCachingNullValues();
  46.         RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
  47.                 .cacheDefaults(config)
  48.                 .build();
  49.         return cacheManager;
  50.     }
  51. }

UserDao.java

  1. package com.example.redispractice.dao;
  3. import com.example.redispractice.entity.User;
  4. import org.apache.ibatis.annotations.Mapper;
  5. import org.springframework.stereotype.Repository;
  7. import java.util.List;
  9. @Repository
  10. @Mapper
  11. public interface UserDao {
  13.     int deleteByPrimaryKey(Integer id);
  15.     int insert(User record);
  17.     int insertSelective(User record);
  19.     User selectByPrimaryKey(Integer id);
  21.     int updateByPrimaryKeySelective(User record);
  23.     int updateByPrimaryKey(User record);
  25.     List<User> queryAllUser();
  26. }

UserService.java

  1. package com.example.redispractice.service;
  3. import com.example.redispractice.entity.User;
  4. import java.util.List;
  6. /**
  7.  * @author seanwang
  8.  * @date 2021/7/2 0002 上午 9:11
  9.  */
  10. public interface UserService {
  12.     int deleteByPrimaryKey(Integer id);
  14.     int insert(User record);
  16.     int insertSelective(User record);
  18.     User selectByPrimaryKey(Integer id);
  20.     int updateByPrimaryKeySelective(User record);
  22.     int updateByPrimaryKey(User record);
  24.     List<User> queryAllUser();
  26.     int get1();
  27.     int get2();
  28.     int put1();
  29.     int evict();
  30. }

UserServiceImpl.java

  1. package com.example.redispractice.service.impl;
  3. import com.example.redispractice.dao.UserDao;
  4. import com.example.redispractice.entity.User;
  5. import com.example.redispractice.service.UserService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.cache.annotation.CacheConfig;
  8. import org.springframework.cache.annotation.CacheEvict;
  9. import org.springframework.cache.annotation.CachePut;
  10. import org.springframework.cache.annotation.Cacheable;
  11. import org.springframework.stereotype.Service;
  13. import javax.annotation.Resource;
  14. import java.util.List;
  16. /**
  17.  * @author seanwang
  18.  * @date 2021/7/2 0002 上午 9:12
  19.  */
  20. @Service
  21. @CacheConfig(cacheNames = "userCache")
  22. public class UserServiceImpl implements UserService {
  24.     @Resource
  25.     UserDao userDao;
  27.     static int i = 0;
  30.     @Override
  31.     public int deleteByPrimaryKey(Integer id) {
  32.         return userDao.deleteByPrimaryKey(id);
  33.     }
  35.     @Override
  36.     public int insert(User record) {
  37.         return userDao.insert(record);
  38.     }
  40.     @Override
  41.     public int insertSelective(User record) {
  42.         return userDao.insertSelective(record);
  43.     }
  45.     @Override
  46.     @Cacheable
  47.     public User selectByPrimaryKey(Integer id) {
  48.         return userDao.selectByPrimaryKey(id);
  49.     }
  51.     @Override
  52.     public int updateByPrimaryKeySelective(User record) {
  53.         return userDao.updateByPrimaryKeySelective(record);
  54.     }
  56.     @Override
  57.     public int updateByPrimaryKey(User record) {
  58.         return userDao.updateByPrimaryKey(record);
  59.     }
  61.     @Override
  62.     @Cacheable(value = "allUser")
  63.     public List<User> queryAllUser() {
  64.         return userDao.queryAllUser();
  65.     }
  67.     @Override
  68.     @Cacheable(value="cache1")
  69.     public int get1() {
  70.         return ++i;
  71.     }
  73.     /**
  74.      * Cacheable注解会根据设置的value先读缓存，读取到value值下的缓存就不走方法，没有对应的才会执行方法，（没有缓存才执行）
  75.      * @return 更新后的i值
  76.      */
  77.     @Override
  78.     @Cacheable(value="cache2")
  79.     public int get2() {
  80.         return ++i;
  81.     }
  83.     /**
  84.      * CachePut注解会执行方法，判断设置的value是否有对应缓存来进行新增/更新缓存
  85.      * @return 返回操作后的i值
  86.      */
  87.     @Override
  88.     @CachePut(value={"cache1"})
  89.     public int put1() {
  90.         return ++i;
  91.     }
  93.     /**
  94.      * 清空CacheEvict指定value的缓存，并执行方法。
  95.      * @return 返回操作后的i值
  96.      */
  97.     @Override
  98.     @CacheEvict(value={"cache1","cache2"})
  99.     public int evict() {
  100.         System.out.println("some thing");
  101.         return --i;
  102.     }
  103. }

UserController.java

  1. package com.example.redispractice.controller;
  3. import com.example.redispractice.entity.User;
  4. import com.example.redispractice.service.UserService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.PathVariable;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  11. import javax.annotation.Resource;
  12. import javax.servlet.http.HttpServletRequest;
  13. import java.util.List;
  15. /**
  16.  * @author seanwang
  17.  * @date 2021/7/2 0002 下午 1:57
  18.  */
  19. @RestController
  20. public class UserController {
  22.     @Resource
  23.     private UserService userService;
  25.     @GetMapping("/list")
  26.     public List<User> getAllUsers() {
  27.         return userService.queryAllUser();
  28.     }
  30.     @GetMapping("/{id}")
  31.     public User getUserById(@PathVariable("id") int id) {
  32.         return userService.selectByPrimaryKey(id);
  33.     }
  35.     @RequestMapping("/login")
  36.     public String login(HttpServletRequest request){
  37.         System.out.println(userService.get1());
  38.         System.out.println(userService.get2());
  39.         return "fail";
  40.     }
  41.     @RequestMapping("/put")
  42.     public String put(HttpServletRequest request){
  43.         userService.put1();
  44.         return "fail";
  45.     }
  46.     @RequestMapping("/evict")
  47.     public int evict(HttpServletRequest request){
  48.         return userService.evict();
  49.     }
  50. }

测试：

访问localhost:8081/list：
image.png
此时Service中的查询方法上的注解@Cacheable(value = “allUser”)生效，会保存到缓存：
image.png

再次访问localhost:8081/list：
直接走缓存里的数据，并没有走方法执行sql：
image.png

注解介绍：

@CacheConfig

image.pngimage.png

@Cacheable

优先读取缓存，缓存读到了就不走方法了。缓存如果没有则执行方法，并缓存到redis。

@CachePut

CachePut注解会执行方法，判断设置的value是否有对应缓存来进行新增/更新缓存
image.png

@CacheEvict

清空CacheEvict指定value的缓存，并执行方法。
image.png