Springboot:整合redis对接口数据进行缓存

源码地址:https://gitee.com/huanglei1111/springboot-demo/tree/master/springboot-ehcache

Springboot:整合redis对接口数据进行缓存

一、注解及其属性介绍

@Cacheable

  • cacheNames:指定缓存的名称

@Cacheable({"menu", "menuById"})关联多个缓存名,当执行方法之前,这些关联的每一个缓存都会被检查,而且只要至少其中一个缓存命中了,那么这个缓存中的值就会被返回

  • key:定义组成的key值,如果不定义,则使用全部的参数计算一个key值。可以使用spring El表达式

  • keyGenerator:定义key生成的类,和key的不能同时存在

  • sync:如果设置sync=true:a. 如果缓存中没有数据,多个线程同时访问这个方法,则只有一个方法会执行到方法,其它方法需要等待; b. 如果缓存中已经有数据,则多个线程可以同时从缓存中获取数据

  • condition和unless 只满足特定条件才进行缓存:

    1.condition: 在执行方法前,condition的值为true,则缓存数据

    2.unless :在执行方法后,判断unless ,如果值为true,则不缓存数据

    3.conditon和unless可以同时使用,则此时只缓存同时满足两者的记录

@Cacheable(value=”testcache”,condition=”#userName.length()>2”)

@CacheEvict

删除缓存

  • allEntries = true: 清空缓存book1里的所有值
  • allEntries = false: 默认值,此时只删除key对应的值

@CachePut

每次执行都会执行方法,无论缓存里是否有值,同时使用新的返回值的替换缓存中的值。这里不同@Cacheable:@Cacheable如果缓存没有值,从则执行方法并缓存数据,如果缓存有值,则从缓存中获取值

@CacheConfig

@CacheConfig: 类级别的注解:如果我们在此注解中定义cacheNames,则此类中的所有方法上 @Cacheable的cacheNames默认都是此值。当然@Cacheable也可以重定义cacheNames的值

二、代码实现

1.创建数据库

-- 判断数据表是否存在,存在则删除
DROP TABLE IF EXISTS tb_user;
 
-- 创建“用户信息”数据表
CREATE TABLE `tb_user` (
  `user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户编号',
  `user_name` varchar(50) NOT NULL COMMENT '用户名称',
  `blog_url` varchar(50) NOT NULL COMMENT '博客地址',
  `blog_remark` varchar(50) DEFAULT NULL COMMENT '博客备注',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='用户信息表';
 
-- 添加数据
INSERT INTO tb_user(user_name,blog_url,blog_remark) VALUES('拒绝熬夜啊的博客','https://blog.csdn.net/weixin_43296313/','您好,欢迎访问 拒绝熬夜啊的博客');

2.application.yaml配置问加你

#Spring配置
spring:
  #缓存管理器
  cache:
    type: redis
  #Redis配置
  redis:
    database: 0 #Redis数据库索引(默认为0)
    host: 127.0.0.1 #Redis服务器地址
    port: 6379 #Redis服务器连接端口
    password:  #Redis服务器连接密码(默认为空)
    jedis:
      pool:
        max-active: 8 #连接池最大连接数(使用负值表示没有限制)
        max-wait: -1s #连接池最大阻塞等待时间(使用负值表示没有限制)
        max-idle: 8  #连接池中的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接
    lettuce:
      shutdown-timeout: 100ms #关闭超时时间,默认值100ms
  #使用Thymeleaf模板引擎
  thymeleaf:
    mode: HTML5
    encoding: UTF-8
    cache: false  #使用Thymeleaf模板引擎,关闭缓存
    servlet:
      content-type: text/html
  #DataSource数据源
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis_test?useSSL=false&amp
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

#MyBatis配置
mybatis:
  type-aliases-package: com.hl.springbootehcache.pojo #别名定义
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #指定 MyBatis 所用日志的具体实现,未指定时将自动查找
    map-underscore-to-camel-case: true #开启自动驼峰命名规则(camel case)映射
    lazy-loading-enabled: true #开启延时加载开关
    aggressive-lazy-loading: false #将积极加载改为消极加载(即按需加载),默认值就是false
    #lazy-load-trigger-methods: "" #阻挡不相干的操作触发,实现懒加载
    cache-enabled: true #打开全局缓存开关(二级环境),默认值就是true

3.redisConfig.java配置类

package com.hl.springbootehcache.config;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
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.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.jedis.JedisClientConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import redis.clients.jedis.JedisPoolConfig;

import java.lang.reflect.Method;
import java.time.Duration;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    //配置redis的过期时间
    private static final Duration TIME_TO_LIVE = Duration.ZERO;

    @Bean(name = "jedisPoolConfig")
    public JedisPoolConfig jedisPoolConfig() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        //控制一个pool可分配多少个jedis实例
        jedisPoolConfig.setMaxTotal(500);
        //最大空闲数
        jedisPoolConfig.setMaxIdle(200);
        //每次释放连接的最大数目,默认是3
        jedisPoolConfig.setNumTestsPerEvictionRun(1024);
        //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
        jedisPoolConfig.setTimeBetweenEvictionRunsMillis(30000);
        //连接的最小空闲时间 默认1800000毫秒(30分钟)
        jedisPoolConfig.setMinEvictableIdleTimeMillis(-1);
        jedisPoolConfig.setSoftMinEvictableIdleTimeMillis(10000);
        //最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
        jedisPoolConfig.setMaxWaitMillis(1500);
        jedisPoolConfig.setTestOnBorrow(true);
        jedisPoolConfig.setTestWhileIdle(true);
        jedisPoolConfig.setTestOnReturn(false);
        jedisPoolConfig.setJmxEnabled(true);
        jedisPoolConfig.setBlockWhenExhausted(false);
        return jedisPoolConfig;
    }

    @Bean("connectionFactory")
    public JedisConnectionFactory connectionFactory() {
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setHostName("127.0.0.1");
        redisStandaloneConfiguration.setDatabase(0);
//        redisStandaloneConfiguration.setPassword(RedisPassword.of("123456"));
        redisStandaloneConfiguration.setPort(6379);
        //获得默认的连接池构造器
        JedisClientConfiguration.JedisPoolingClientConfigurationBuilder jpcb =
                (JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
        //指定jedisPoolConifig来修改默认的连接池构造器(真麻烦,滥用设计模式!)
        jpcb.poolConfig(jedisPoolConfig());
        //通过构造器来构造jedis客户端配置
        JedisClientConfiguration jedisClientConfiguration = jpcb.build();
        //单机配置 + 客户端配置 = jedis连接工厂
        return new JedisConnectionFactory(redisStandaloneConfiguration, jedisClientConfiguration);
    }

    @Bean
    public RedisTemplate<Object, Object> redisTemplate(JedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);

        GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        //初始化参数和初始化工作
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }

    /**
     * 缓存对象集合中,缓存是以key-value形式保存的,
     * 当不指定缓存的key时,SpringBoot会使用keyGenerator生成Key。
     */
    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                //类名+方法名
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    /**
     * 缓存管理器
     * @param connectionFactory 连接工厂
     * @return  cacheManager
     */
    @Bean
    public CacheManager cacheManager(JedisConnectionFactory connectionFactory) {
        //新建一个Jackson2JsonRedis的redis存储的序列化方式
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //解决查询缓存转换异常的问题
        // 配置序列化(解决乱码的问题)
        //entryTtl设置过期时间
        //serializeValuesWith设置redis存储的序列化方式
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(TIME_TO_LIVE)
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
                .disableCachingNullValues();
        //定义要返回的redis缓存管理对象
        return RedisCacheManager.builder(connectionFactory).cacheDefaults(config).build();
    }
}

4.UserInfo实体类

@Data
public class UserInfo implements Serializable {
    private int userId; //用户编号
    private String userName; //用户姓名
    private String blogUrl; //博客地址
    private String blogRemark; //博客信息
}

5.UserMapper.java

@Mapper
@Repository
public interface UserMapper {
    /**
     * 根据用户ID,获取用户信息
     */
    @Select("SELECT * FROM tb_user WHERE user_id = #{userId}")
    public UserInfo getUserById(int userId);
 
    /**
     * 新增用户,并获取自增主键
     */
    @Insert("INSERT INTO tb_user(user_name,blog_url,blog_remark) VALUES(#{userName},#{blogUrl},#{blogRemark});")
    @Options(useGeneratedKeys = true, keyColumn = "user_id", keyProperty = "userId")
    public int insertUser(UserInfo userInfo);
 
    /**
     * 修改用户
     */
    @Update("UPDATE tb_user SET user_name = #{userName},blog_url = #{blogUrl} ,blog_remark = #{blogRemark} WHERE user_id = #{userId}")
    public int updateUser(UserInfo userInfo);
 
    /**
     * 删除用户
     */
    @Delete("DELETE FROM tb_user WHERE user_id = #{userId}")
    public int deleteUser(int userId);
}

6.Uservice及实现类

public interface UserService {
    UserInfo getUserById(int userId);

    UserInfo insertUser(UserInfo userInfo);

    UserInfo updateUser(UserInfo userInfo);

    int deleteUser(int userId);
}

/**
 * 用户信息业务逻辑类
 * @author hl
 * 缓存就在这层工作
 * @Cacheable,将查询结果缓存到redis中,(key="#p0")指定传入的第一个参数作为redis的key。
 * @CachePut,指定key,将更新的结果同步到redis中
 * @CacheEvict,指定key,删除缓存数据,allEntries=true,方法调用后将立即清除缓存
 **/
@CacheConfig(cacheNames = "userCache")
@Service
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = Exception.class)
public class UserServiceImpl implements UserService {
    @Autowired
    private UserMapper userMapper;
 
    /**
     * 根据用户ID,获取用户信息
     */
    @Override
    @Cacheable(key = "#p0") // #p0 表示第一个参数
    public UserInfo getUserById(int userId) {
        return userMapper.getUserById(userId);
    }
 
    /**
     * 新增用户,并获取自增主键
     */
    @Override
    @CachePut(key = "#p0.userId")
    public UserInfo insertUser(UserInfo userInfo) {
        userMapper.insertUser(userInfo);
        return userInfo;
    }
 
    /**
     * 修改用户
     */
    @Override
    @CachePut(key = "#p0.userId")
    public UserInfo updateUser(UserInfo userInfo) {
        userMapper.updateUser(userInfo);
        return userInfo;
    }
    /**
     * 删除用户
     * 如果在@CacheEvict注解中添加allEntries=true属性,
     * 将会删除所有的缓存
     */
    @Override
    @CacheEvict(key = "#p0")
    public int deleteUser(int userId) {
        return userMapper.deleteUser(userId);
    }
}

7.UserController.java

@Controller
@RequestMapping("/user")
public class UserController {
    @Autowired
    private UserService userService;
 
    /**
     * 获取用户信息
     */
    @RequestMapping(value = "getUserById",method = RequestMethod.GET)
    @ResponseBody
    public HttpResponseTemp<?> getUserById(int userId) {
        UserInfo userInfo = userService.getUserById(userId);
        return ResultStat.OK.wrap(userInfo,"获取用户信息成功");
    }
 
    /**
     * 新增用户
     */
    @ResponseBody
    @RequestMapping("insertUser")
    public HttpResponseTemp<?> insertUser() {
        //创建新用户
        UserInfo userInfo = new UserInfo();
        userInfo.setUserName("hl的博客");
        userInfo.setBlogUrl("www.baidu.com");
        userInfo.setBlogRemark("您好,欢迎访问 hl的博客");

        UserInfo userInfo1 = userService.insertUser(userInfo);
        return ResultStat.OK.wrap(userInfo1.getUserId(),"新增用户成功");
    }
 
    /**
     * 修改用户
     */
    @ResponseBody
    @RequestMapping("updateUser")
    public HttpResponseTemp<?> updateUser(int userId) {
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId(userId);
        userInfo.setUserName("hl的博客_02");
        userInfo.setBlogUrl("www.baidu.com");
        userInfo.setBlogRemark("您好,欢迎访问 hl的博客");


        UserInfo userInfo1 = userService.updateUser(userInfo);
        return ResultStat.OK.wrap(userInfo1.getUserId(),"修改用户成功");
    }
 
    /**
     * 删除用户
     */
    @ResponseBody
    @RequestMapping("deleteUser")
    public HttpResponseTemp<?> deleteUser(int userId) {
        int result = userService.deleteUser(userId);
        return ResultStat.OK.wrap(result,"删除用户成功");
    }
}

8.注意

  • 实体类要实现序列化 public class UserInfo implements Serializable
  • 在项目启动类加上注解@EnableCaching开启缓存

三、测试

1.测试查询

在这里插入图片描述

redis中也有数据了

在这里插入图片描述

查看控制台的sql语句,只有一条打印,说明是只有第一条是从数据库中查询的其他的是从redis中获取的

在这里插入图片描述

2.测试新增

在这里插入图片描述

在这里插入图片描述

3.测试修改

在这里插入图片描述

在这里插入图片描述

这里博客名称变成02了

4.测试删除

在这里插入图片描述

在这里插入图片描述