Springboot整合Redis作为Mybatis的二级缓存

0. 环境准备

以下是我本机的环境:


SpringBoot2.3.x

Mybatis3.x

Redis5.x

本机或者服务器中搭建好redis环境,并启动成功!这里我用的是阿里云学生机上部署的redis5.x

IDEA2020.x ,Eclipse2020也是可以的,编辑器选择无所谓!

1. 新版本springboot和IDEA编辑器踩坑(可以直接跳过该章节,遇到类似的错误再回头看)

如果您在实操过程中,使用的是IDEA2020 和springboot2.3.x 版本及以上,可能会出现以下和我一样的问题:


问题1:

SpringBoot启动报错: -Property 'configuration' and 'configLocation' can not specified with together


这个问题我头一次碰到,因为我之前一直使用的是 yaml 配置文件中配置 mybatis,如图:


Springboot整合Redis作为Mybatis的二级缓存

Springboot整合Redis作为Mybatis的二级缓存

而实操时候我使用SSM的方式,引入mybatis-comfig.xml 全局配置:


Springboot整合Redis作为Mybatis的二级缓存

所以运行springboot项目时候就报错了!


解决方式:


检查一下application.yaml文件,如果确实是configuration和config-location同时出现在了配置文件中,将configuration配置的内容放入到config-location指向的配置文件中,再次重启项目,文件解决!

Springboot整合Redis作为Mybatis的二级缓存

建议

  • SpringBoot整合mybatis时,建议将所有mybatis的配置都放入mybatis-config中,这样application.yaml文件内容也会简洁清晰!

问题2

@EnableAutoConfiguration注解报红

Springboot整合Redis作为Mybatis的二级缓存

这其实是IDEA自动识别的问题,并不是错误,解决方法:

Springboot整合Redis作为Mybatis的二级缓存

@EnableAutoConfiguration注解的作用

参考文章 @EnableAutoConfiguration注解的作用

同理,如果出现下图问题:

Springboot整合Redis作为Mybatis的二级缓存

解决方式:

Springboot整合Redis作为Mybatis的二级缓存

包括其他类似问题(idea 识别报红,可以使用组合功能键ALT+ENTER ),选中如图所示:

Springboot整合Redis作为Mybatis的二级缓存

取消选中对应复选框即可:

Springboot整合Redis作为Mybatis的二级缓存

OK,下面我们进入正题!


2. SpringBoot整合Redis作为Mybatis的二级缓存

问题:什么是mybatis的一/二级缓存?


详情请参考文章:浅谈 MyBatis 三级缓存


一级缓存是:sqlSession,sql建立连接到关闭连接的数据缓存

二级缓存是:全局的缓存

2.1 数据库SQL:

CREATE TABLE `score_flow` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `score` bigint(19) unsigned NOT NULL COMMENT '用户积分流水',
  `user_id` int(11) unsigned NOT NULL COMMENT '用户主键id',
  `user_name` varchar(30) NOT NULL DEFAULT '' COMMENT '用户姓名',
  PRIMARY KEY (`id`),
  KEY `idx_userid` (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8mb4;

CREATE TABLE `sys_user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `user_name` varchar(11) CHARACTER SET utf8mb4 DEFAULT NULL COMMENT '用户名',
  `image` varchar(11) CHARACTER SET utf8mb4 DEFAULT NULL COMMENT '用户头像',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;

CREATE TABLE `user_score` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_id` int(11) unsigned NOT NULL COMMENT '用户ID',
  `user_score` bigint(19) unsigned NOT NULL COMMENT '用户积分',
  `name` varchar(30) NOT NULL DEFAULT '' COMMENT '用户姓名',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

2.2 Springboot相关配置:application.yaml

# 端口
server:
  port: 8080
  #  项目访问名称
  servlet:
    context-path: /demo
#=====================================数据库相关配置=====================================
spring:
  #=====================================Redis=========================================
  redis:
    # Redis数据库索引(默认为0)
    database: 0
    # Redis服务器地址
    host: 8.XXXXXX.136
    # Redis服务器连接端口
    port: 6379
    # Redis服务器连接密码(默认为空)
    password: cspXXXXXX29
    jedis:
      pool:
        # 连接池最大连接数(使用负值表示没有限制)
        max-active: 8
        # 连接池最大阻塞等待时间(使用负值表示没有限制)
        max-wait: -1
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池中的最小空闲连接
        min-idle: 0
    # 连接超时时间(毫秒)
    timeout: 8000
  #=====================================Mysql=========================================
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test2?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource # 德鲁伊
    minIdle: 5
    maxActive: 100
    initialSize: 10
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: select 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 50
    removeAbandoned: true
    filters: stat # ,wall,log4j # 配置监控统计拦截的filters,去掉后监控界面sql无法统计,'wall'用于防火墙
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000 # 通过connectProperties属性来打开mergeSql功能;慢SQL记录
    useGlobalDataSourceStat: true # 合并多个DruidDataSource的监控数据
    druidLoginName: wjf # 登录druid的账号
    druidPassword: wjf # 登录druid的密码
    cachePrepStmts: true  # 开启二级缓存

# 开启控制台打印sql日志
mybatis:
  # 配置mapper文件扫描
  mapper-locations: com.haust.redisdemo.mapper/*.xml
  # 配置实体类扫描
  type-aliases-package: com.haust.redisdemo.domain
  # 指定全局mybatis 配置文件位置
  config-location: classpath:/mybatis-config.xml

2.3 mybatis-config.xml配置:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!-- 打印sql语句 -->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!-- 使全局的映射器启用或禁用缓存。 -->
        <setting name="cacheEnabled" value="true"/>
        <!-- 全局启用或禁用延迟加载。当禁用时,所有关联对象都会即时加载。 -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 当启用时,有延迟加载属性的对象在被调用时将会完全加载任意属性。否则,每种属性将会按需要加载。 -->
        <setting name="aggressiveLazyLoading" value="true"/>
        <!-- 是否允许单条sql 返回多个数据集  (取决于驱动的兼容性) default:true -->
        <setting name="multipleResultSetsEnabled" value="true"/>
        <!-- 是否可以使用列的别名 (取决于驱动的兼容性) default:true -->
        <setting name="useColumnLabel" value="true"/>
        <!-- 允许JDBC 生成主键。需要驱动器支持。如果设为了true,这个设置将强制使用被生成的主键,
                                有一些驱动器不兼容不过仍然可以执行。  default:false  -->
        <setting name="useGeneratedKeys" value="false"/>
        <!-- 指定 MyBatis 如何自动映射 数据基表的列 NONE:不隐射 PARTIAL:部分  FULL:全部  -->
        <setting name="autoMappingBehavior" value="PARTIAL"/>
        <!-- 这是默认的执行类型  (SIMPLE: 简单; REUSE: 执行器可能重复使用prepared statements语句;
                                            BATCH: 执行器可以重复执行语句和批量更新)  -->
        <setting name="defaultExecutorType" value="SIMPLE"/>
        <!-- 设置超时时间,它决定驱动等待数据库响应的秒数 -->
        <setting name="defaultStatementTimeout" value="25"/>
        <!-- 为驱动的结果集获取数量(fetchSize)设置一个提示值。此参数只可以在查询设置中被覆盖 -->
        <setting name="defaultFetchSize" value="100"/>
        <!-- 允许在嵌套语句中使用分页(RowBounds)。如果允许使用则设置为 false -->
        <setting name="safeRowBoundsEnabled" value="false"/>
        <!-- 使用驼峰命名法转换字段。 -->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 设置本地缓存范围 session:就会有数据的共享  statement:语句范围 (这样就不会有数据的共享 ) 
                                                                    defalut:session -->
        <setting name="localCacheScope" value="SESSION"/>
        <!-- 默认为OTHER,为了解决oracle插入null报错的问题要设置为NULL -->
        <setting name="jdbcTypeForNull" value="NULL"/>
        <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
    </settings>
</configuration>

2.4 主启动类

@SpringBootApplication
@EnableAutoConfiguration
@MapperScan("com.haust.redisdemo.mapper")
public class XdRedisDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(XdRedisDemoApplication.class, args);
    }
}

2.5 User实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
/**
 * 用户实体类
 */
public class User implements Serializable {// 必须实现序列化接口!

    /**
     * 序列号版本号
     */
    private static final long serialVersionUID = -4415438719697624729L;

    /**
     * 用户id
     */
    private String id;

    /**
     * 用户名
     */
    private String userName;
}


2.6 UserMapper.java 与UserMapper.xml

/**
 * @Auther: csp1999
 * @Date: 2020/11/17/10:36
 * @Description: UserMapper
 */
@Repository
public interface UserMapper {

    void insert(User user);

    void update(User user);

    void delete(@Param("id") String id);

    User find(@Param("id") String id);

    List<User> query(@Param("userName") String userName);

    void deleteAll();
}


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.haust.redisdemo.mapper.UserMapper">
    <select id="query" resultType="com.haust.redisdemo.domain.User">
        select id ,user_name
        from sys_user
        where 1=1
        <if test="userName != null">
            and user_name like CONCAT('%',#{userName},'%')
        </if>
    </select>

    <insert id="insert" parameterType="com.haust.redisdemo.domain.User">
        insert sys_user(id,user_name) values(#{id},#{userName})
    </insert>

    <update id="update" parameterType="com.haust.redisdemo.domain.User">
        update sys_user set user_name = #{userName} where id=#{id}
    </update>

    <delete id="delete" parameterType="string">
        delete from sys_user where id= #{id}
    </delete>

    <select id="find" resultType="com.haust.redisdemo.domain.User" parameterType="string">
        select id,user_name from sys_user where id=#{id}
    </select>

    <delete id="deleteAll">
         delete from sys_user
    </delete>
</mapper>

2.7 redis操作工具类

这个工具类就是为了操作redis时候相对比较方便而已,其实就是封装了一下RedisTemplete,可以选择不用封装的工具类,直接使用RedisTemplete

/**
 * @Auther: csp1999
 * @Date: 2020/11/17/10:08
 * @Description: redis操作工具类
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    private static double size = Math.pow(2, 32);

    /**
     * 写入缓存
     *
     * @param key
     * @param offset 位 8Bit=1Byte
     * @return
     */
    public boolean setBit(String key, long offset, boolean isShow) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.setBit(key, offset, isShow);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param offset
     * @return
     */
    public boolean getBit(String key, long offset) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            result = operations.getBit(key, offset);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存设置时效时间
     *
     * @param key
     * @param value
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key
     * @return
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 哈希 添加
     *
     * @param key
     * @param hashKey
     * @param value
     */
    public void hmSet(String key, Object hashKey, Object value) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        hash.put(key, hashKey, value);
    }

    /**
     * 哈希获取数据
     *
     * @param key
     * @param hashKey
     * @return
     */
    public Object hmGet(String key, Object hashKey) {
        HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
        return hash.get(key, hashKey);
    }

    /**
     * 列表添加
     *
     * @param k
     * @param v
     */
    public void lPush(String k, Object v) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        list.rightPush(k, v);
    }

    /**
     * 列表获取
     *
     * @param k
     * @param l
     * @param l1
     * @return
     */
    public List<Object> lRange(String k, long l, long l1) {
        ListOperations<String, Object> list = redisTemplate.opsForList();
        return list.range(k, l, l1);
    }

    /**
     * 集合添加
     *
     * @param key
     * @param value
     */
    public void add(String key, Object value) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        set.add(key, value);
    }

    /**
     * 集合获取
     *
     * @param key
     * @return
     */
    public Set<Object> setMembers(String key) {
        SetOperations<String, Object> set = redisTemplate.opsForSet();
        return set.members(key);
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void zAdd(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.add(key, value, scoure);
    }

    /**
     * 有序集合获取
     *
     * @param key
     * @param scoure
     * @param scoure1
     * @return
     */
    public Set<Object> rangeByScore(String key, double scoure, double scoure1) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        redisTemplate.opsForValue();
        return zset.rangeByScore(key, scoure, scoure1);
    }

    //第一次加载的时候将数据加载到redis中
    public void saveDataToRedis(String name) {
        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        boolean availableUsers = setBit("availableUsers", indexLong, true);
    }

    //第一次加载的时候将数据加载到redis中
    public boolean getDataToRedis(String name) {

        double index = Math.abs(name.hashCode() % size);
        long indexLong = new Double(index).longValue();
        return getBit("availableUsers", indexLong);
    }

    /**
     * 有序集合获取排名
     *
     * @param key   集合名称
     * @param value 值
     */
    public Long zRank(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rank(key, value);
    }


    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> zRankWithScore(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.rangeWithScores(key, start, end);
        return ret;
    }

    /**
     * 有序集合添加
     *
     * @param key
     * @param value
     */
    public Double zSetScore(String key, Object value) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.score(key, value);
    }

    /**
     * 有序集合添加分数
     *
     * @param key
     * @param value
     * @param scoure
     */
    public void incrementScore(String key, Object value, double scoure) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        zset.incrementScore(key, value, scoure);
    }

    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithScore(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeByScoreWithScores(key, start, end);
        return ret;
    }

    /**
     * 有序集合获取排名
     *
     * @param key
     */
    public Set<ZSetOperations.TypedTuple<Object>> reverseZRankWithRank(String key, long start, long end) {
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<Object>> ret = zset.reverseRangeWithScores(key, start, end);
        return ret;
    }
}


在RedisConfig中将RedisTemplate 注入IOC容器:

/**
 * @Auther: csp1999
 * @Date: 2020/11/14/18:44
 * @Description: Redis 相关配置类
 */
@Configuration
//@EnableCaching // 开启缓存
public class RedisConfig {

    /**
     * 将 redisTemplate 注入IOC
     *
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();

        // RedisTemplate 放入 RedisConnectionFactory 工厂
        redisTemplate.setConnectionFactory(factory);

        return redisTemplate;
    }
}


2.8 在UserController中使用redis缓存

方式一:

/**
 * @Auther: csp1999
 * @Date: 2020/11/17/11:38
 * @Description:
 */
@RestController
public class UserController {

    /**
     * 缓存盐值:key
     */
    private static final String key = "userCache_";

    @Resource
    private UserMapper userMapper;

    @Resource
    private RedisUtil redisUtil;

    /**
     * 根据id获取用户信息方式一:
     * 先从redis缓存查,如果有则取出,如果没有再从数据库查(查到后保存到缓存)
     * 注意:set值和get值的时候序列化方式必须保持一致
     *
     * @param id
     * @return
     */
    @RequestMapping("/getUserCache")
    public User getUseCache(String id) {
        // step1: 先从redis里面取值
        User user = (User) redisUtil.get(key + id);

        // step2: 如果拿不到则从DB取值
        if (user == null) {
            User userDB = userMapper.find(id);
            System.out.println("fresh value from DB id:" + id);

            // step3: DB非空情况刷新redis值
            if (userDB != null) {
                redisUtil.set(key + id, userDB);
                return userDB;
            }
        }
        return user;
    }
}


假设数据库中已经存在用户信息记录

Springboot整合Redis作为Mybatis的二级缓存

我们来访问下该接口(第一次访问):


Springboot整合Redis作为Mybatis的二级缓存


查看控制台打印:Springboot整合Redis作为Mybatis的二级缓存

如图,可以看出,第一次根据id查询user信息时候,redis缓存中不存在该user信息,所以直接去数据库中查询!

接下来我们清空控制台打印信息,并刷新一次 http://localhost:8080/demo/getExpire?id=1 链接,模拟第二次访问:

效果如图

Springboot整合Redis作为Mybatis的二级缓存

从图中得出,未打印sql日志,因此本次访问并未从数据库中获取user信息,而是直接从redis缓存中获取的user信息!


加缓存的好处:学过redis和mysql的应该都知道,MySQL读取的是磁盘中的数据,而redis读取的是内存中的数据(速度快),在大数据量高访问量的情况下,项目后端热点接口不用每次调用都去数据库中查询相关记录,如果缓存中存在相关数据则先从缓存中取,这样会提高了效率!


方式二:

在springboot中提供了简化redis缓存操作的注解:


1、springboot cache的使用:可以结合redis、ehcache等缓存


@CacheConfig(cacheNames=“userInfoCache”) 在同个redis里面必须唯一

@Cacheable(查) :来划分可缓存的方法 - 即,结果存储在缓存中的方法,以便在后续调用(具有相同的参数)时,返回缓存中的值而不必实际执行该方法;

@CachePut(修改、增加):当需要更新缓存而不干扰方法执行时,可以使用@CachePut注释。也就是说,始终执行该方法并将其结果放入缓存中(根据@CachePut选项)

@CacheEvict(删除) : 对于从缓存中删除陈旧或未使用的数据非常有用,指示缓存范围内的驱逐是否需要执行而不仅仅是一个条目驱逐

2、springboot cache的整合步骤:


1)引入pom.xml依赖:

<!-- springboot cache -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

2)RedisConfig开启缓存注解: @EnableCaching

@Configuration
@EnableCaching // 开启缓存
public class RedisConfig {


  • 3)在方法上面加入SpEL spring的el表达式

UserService.java

/**
 * User表的增删改查
 */
@Service
// 本类内方法指定使用缓存时,默认的名称就是userInfoCache
@CacheConfig(cacheNames = "userInfoCache")
// 开启事务
@Transactional(propagation = Propagation.REQUIRED, readOnly = false, rollbackFor = Exception.class)
public class UserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 因为必须要有返回值,才能保存到数据库中。
     * 如果保存的对象的某些字段是需要数据库生成的,
     * 那保存对象进数据库的时候,就没必要放到缓存了
     * <p>
     * 数据库中增加某条数据时,缓存中也增加
     *
     * @param user
     * @return
     */
    // #p0表示第一个参数作为redis中的key
    // 如果是#p1表示第二个参数作为redis中的key... 这里只有1个参数user
    // #p0.id 就表示获取user的id作为redis中的key
    @CachePut(key = "#p0.id")
    // 必须要有返回值,否则没数据放到缓存中
    public User insertUser(User user) {
        userMapper.insert(user);
        // user对象中可能只有只几个有效字段,其他字段值靠数据库生成,比如id
        return userMapper.find(user.getId());
    }

    /**
     * 当需要更新缓存而不干扰方法执行时可以使用@CachePut注解。
     * 也就是说,数据库中对应内容更新时,需要同步更新缓存可使用该注解
     *
     * @param user
     * @return
     */
    @CachePut(key = "#p0.id")
    public User updateUser(User user) {
        userMapper.update(user);
        // 可能只是更新某几个字段而已,所以查次数据库把数据全部拿出来全部
        return userMapper.find(user.getId());
    }

    /**
     * 使用 @Cacheable注解 会先查询缓存,如果缓存中存在,则不执行查询数据库的方法
     * <p>
     * 使用 springboot cache 默认缓存配置
     *
     * @param id
     * @return
     */
    @Nullable// 如果可以传入NULL值,则标记为@Nullable,如果不可以,则标注为@Nonnull
    @Cacheable(key = "#p0")
    public User findById(String id) {
        System.err.println("根据id=" + id + "获取用户对象,从数据库中获取");
        Assert.notNull(id, "id不用为空");
        return userMapper.find(id);
    }

    /**
     * 删除缓存名称为userInfoCache,key等于指定的id对应的缓存
     * 数据库中删除某条数据时,缓存中也删除
     *
     * @param id
     */
    @CacheEvict(key = "#p0")
    public void deleteById(String id) {
        userMapper.delete(id);
    }

    /**
     * 清空缓存名称为userInfoCache(看类名上的注解)下的所有缓存
     * 如果数据失败了,缓存时不会清除的
     */
    @CacheEvict(allEntries = true)
    public void deleteAll() {
        userMapper.deleteAll();
    }
}


在UserController使用UserService来操作redis缓存:

/**
 * 根据id获取用户信息方式二:
 *
 * userService中加入了springboot cache缓存相关注解
 * @param id
 * @return
 */
@RequestMapping("/getByCache")
public User getByCache(String id) {
    User user = userService.findById(id);
    return user;
}


以看出方式二,简化了方式一的代码!


方式三:

提问:springboot cache 存在什么问题:


第一:生成key过于简单,例如:userCache::3,容易造成冲突


第二:无法设置过期时间,默认过期时间为永久不过期(如果数据过多且不过期,会造成内存泄漏)


第三:配置序列化方式,默认的是序列化JDKSerialazable


解决方式:


springboot cache 自定义项:


1)自定义KeyGenerator :解决springboot cache默认生成的key过于简单,容易冲突userCache::3问题;


2)自定义cacheManager,设置缓存过期时间:解决springboot cache 默认无法设置过期时间,默认过期时间为永久不过期;


3)自定义序列化方式为,Jackson或者Gson(我们这里使用jackson即可):不适用springboot cache默认序列化方式JDKSerialazable,为什么要更换默认序列号方式呢?因为boot默认的序列化方式可能不支持 日期时间、空值这些变量的序列化,会导致一些错乱乱码问题;


步骤:


1. 在RedisConfig中添加配置:

/**
 * 自定义KeyGenerator:解决springboot cache默认生成的key过于简单,容易造成重复和冲突的问题
 *
 * @return
 */
@Bean
public KeyGenerator simpleKeyGenerator() {
    return (o, method, objects) -> {// o:类 method:方法 objects:方法参数
        /**
         * 我们可以使用如下方式(保证唯一性),来自定义KeyGenerator:
         * 类名 + 方法名 + 参数
         * eg: UserInfoList::UserService.findByIdTtl[1]
         *
         * 扩展:JVM定位是否是同一个方法的方式 和 这种方式类似
         */
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(o.getClass().getSimpleName());
        stringBuilder.append(".");
        stringBuilder.append(method.getName());
        stringBuilder.append("[");
        for (Object obj : objects) {
            stringBuilder.append(obj.toString());
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    };
}
/**
 * 设置缓存的过期时间
 *
 * @param redisConnectionFactory
 * @return
 */
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
    return new RedisCacheManager(
            RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory),
            // 如果未配置指定的 key 就会使用这个默认策略,过期时间600s
            this.getRedisCacheConfigurationWithTtl(600),
            // 如果配置了指定的 key 就会使用指定 key 策略
            this.getRedisCacheConfigurationMap()
    );
}

// 指定相应 key 过期时间策略的Map: key:键值 value:缓存过期时间
private Map<String, RedisCacheConfiguration> getRedisCacheConfigurationMap() {
    Map<String, RedisCacheConfiguration> redisCacheConfigurationMap = new HashMap<>();
    // key为UserInfoList时: 过期时间100s
    redisCacheConfigurationMap.put("UserInfoList", this.getRedisCacheConfigurationWithTtl(100));
    // key为UserInfoListAnother时: 过期时间18000s == 5h
    redisCacheConfigurationMap.put("UserInfoListAnother", this.getRedisCacheConfigurationWithTtl(18000));
    return redisCacheConfigurationMap;
}

// 指定jackson序列化方式
private RedisCacheConfiguration getRedisCacheConfigurationWithTtl(Integer seconds) {
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
    redisCacheConfiguration = redisCacheConfiguration.serializeValuesWith(
            RedisSerializationContext
                    .SerializationPair
                    .fromSerializer(jackson2JsonRedisSerializer)
    ).entryTtl(Duration.ofSeconds(seconds));
    return redisCacheConfiguration;
}


在UserService.java中添加方法:

/**
 * 使用 @Cacheable注解 会先查询缓存,如果缓存中存在,则不执行方法
 * <p>
 * 自定义了 springboot cache 缓存相关的配置
 *
 * @param id
 * @return
 */
@Nullable
@Cacheable(value = "UserInfoList", keyGenerator = "simpleKeyGenerator")
public User findByIdTtl(String id) {
    // 日志打印
    System.err.println("根据id=" + id + "获取用户对象,从数据库中获取");
    Assert.notNull(id, "id不用为空");
    return userMapper.find(id);
}


在controller中使用

/**
 * 根据id获取用户信息方式三:
 * 自定义了 springboot cache 缓存相关的配置
 *      有过期时间策略
 *      自定义了key: UserInfoList::UserService.findByIdTtl[1]
 *      自定义序列化方式为jackson
 * @param id
 * @return
 */
@RequestMapping(value = "/getExpire", method = RequestMethod.GET)
public User findByIdTtl(String id) {
    User user = new User();
    try {
        user = userService.findByIdTtl(id);
    } catch (Exception e) {
        System.err.println(e.getMessage());
    }
    return user;
}

测试访问该接口:

Springboot整合Redis作为Mybatis的二级缓存

当显示出数据后,说明后端已经从数据库/缓存中读取到了数据,下面我们来看一下redis缓存中对应的key的声明周期:

Springboot整合Redis作为Mybatis的二级缓存

当redis缓存中key过期后:

Springboot整合Redis作为Mybatis的二级缓存

我们再次访问该接口查看效果:

Springboot整合Redis作为Mybatis的二级缓存

由图可得出,这时候redis缓存没有要查询的用户数,这时候是从数据库中查询的!


3. 扩展: redis 面试题

2018支付宝面试题之缓存雪崩:

1、什么是缓存雪崩?你有什么解决方案来防止缓存雪崩?


如果缓存集中在一段时间内失效,发生大量的缓存穿透,所有的查询都落在数据库上,造成了缓存雪崩。由于原有缓存失效,新缓存未到期间所有原本应该访问缓存的请求都去查询数据库了,而对数据库CPU 和内存造成巨大压力,严重的会造成数据库宕机!

2、你有什么解决方案来防止缓存雪崩?


1、加锁排队key: whiltList value:1000w个uid 指定setNx whiltList value nullValue mutex互斥锁解决,Redis的SETNX去set一个mutex key,当操作返回成功时,再进行load db的操作并回设缓存;否则,就重试整个get缓存的方法;

2、数据预热:缓存预热就是系统上线后,将相关的缓存数据直接加载到缓存系统。这样就可以避免在用户请求的时候,先查询数据库,然后再将数据缓存的问题!用户直接查询事先被预热的缓存数据!可以通过缓存reload机制,预先去更新缓存,再即将发生大并发访问前手动触发加载缓存不同的key;

3、双层缓存策略: C1为原始缓存,C2为拷贝缓存,C1失效时,可以访问C2,C1缓存失效时间设置为短期,C2设置为长期;

4、定时更新缓存策略:失效性要求不高的缓存,容器启动初始化加载,采用定时任务更新或移除缓存

5、设置不同的过期时间,让缓存失效的时间点尽量均匀

2018支付宝面试题之缓存穿透:

1、什么是缓存穿透?你有什么解决方案来防止缓存穿透?

缓存穿透是指用户查询数据,在数据库没有,自然在缓存中也不会有。这样就导致用户查询的时候,在缓存中找不到对应key的value,每次都要去数据库再查询一遍,然后返回空(相当于进行了两次无用的查询)。这样请求就绕过缓存直接查数据库;

2、你有什么解决方案来防止缓存穿透?

1、缓存空值:如果一个查询返回的数据为空(不管是数据不 存在,还是系统故障)我们仍然把这个空结果进行缓存,但它的过期时间会很短,最长不超过五分钟。 通过这个直接设置的默认值存放到缓存,这样第二次到缓冲中获取就有值了,而不会继续访问数据库;

2、采用布隆过滤器BloomFilter:优势占用内存空间很小,bit存储。性能特别高。 将所有可能存在的数据哈希到一个足够大的 bitmap 中,一个一定不存在的数据会被这个bitmap 拦截掉,从而避免了对底层存储系统的查询压力;

2018支付宝面试题之redis特性:

1、问题1:redis有哪些特性?

1、丰富的数据类型

2、可用于缓存,消息按key设置过期时间,过期后自动删除 setex set expire时间

3、支持持久化方式rdb和aof

4、主从分布式,redis支持主从支持读写分离 redis cluster,动态扩容方式

2、问题2:你用过redis的哪几种特性?

1、用sorted Set实现过排行榜项目

2、用过期key结合springboot cache实现过缓存存储

3、redis实现分布式环境seesion共享

4、用布隆过滤器解决过缓存穿透

5、redis实现分布式锁

6、redis实现订单重推系统

如果文章对您有帮助,点个赞或者点个关注支持下谢谢~


上一篇:LINUX 定时任务


下一篇:如何让CloudStack使用KVM创建Windows实例成功识别并挂载数据盘