一块儿来学SpringBoot | 第十篇：使用Spring Cache集成Redis

时间  2019-12-08
标签 一块儿 springboot 第十 使用 spring cache 集成 redis 栏目 Spring 繁體版
原文   原文链接
SpringBoot 是为了简化 Spring 应用的建立、运行、调试、部署等一系列问题而诞生的产物， 自动装配的特性让咱们能够更好的关注业务自己而不是外部的XML配置，咱们只需遵循规范，引入相关的依赖就能够轻易的搭建出一个 WEB 工程

Spring 3.1 引入了激动人心的基于注释（annotation）的缓存（cache）技术，它本质上不是一个具体的缓存实现方案（例如 EHCache 或者 Redis），而是一个对缓存使用的抽象，经过在既有代码中添加少许它定义的各类 annotation，即可以达到缓存方法的返回对象的效果。html

<!-- more -->java

特色

具有至关的好的灵活性，不只可以使用 SpEL（Spring Expression Language）来定义缓存的 key 和各类 condition，还提供开箱即用的缓存临时存储方案，也支持和主流的专业缓存例如 EHCache、Redis、Guava 的集成。git

  • 基于 annotation 便可使得现有代码支持缓存
  • 开箱即用 Out-Of-The-Box，不用安装和部署额外第三方组件便可使用缓存
  • 支持 Spring Express Language，能使用对象的任何属性或者方法来定义缓存的 key 和 condition
  • 支持 AspectJ，并经过其实现任何方法的缓存支持
  • 支持自定义 key 和自定义缓存管理者，具备至关的灵活性和扩展性

使用先后

下面针对Spring Cache使用先后给出了伪代码部分，具体中也许比这要更加复杂，可是Spring Cache均可以很好的应对github

使用前

咱们须要硬编码，若是切换Cache Client还须要修改代码，耦合度高，不易于维护redis

public String get(String key) {
    String value = userMapper.selectById(key);
    if (value != null) {
        cache.put(key,value);
    }
    return value;
}
使用后

基于Spring Cache注解，缓存由开发者本身配置，但不用参与到具体编码spring

@Cacheable(value = "user", key = "#key")
public String get(String key) {
    return userMapper.selectById(key);
}

添加依赖

在 pom.xml 中添加 spring-boot-starter-data-redis的依赖数据库

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

属性配置

在 application.properties 文件中配置以下内容，因为Spring Boot2.x 的改动，链接池相关配置须要经过spring.redis.lettuce.pool 或者 spring.redis.jedis.pool 进行配置了。使用了Spring Cache后，能指定spring.cache.type就手动指定一下，虽然它会自动去适配已有Cache的依赖，但前后顺序会对Redis使用有影响（JCache -> EhCache -> Redis -> Guava）apache

spring.redis.host=localhost
spring.redis.password=battcn
# 通常来讲是不用配置的，Spring Cache 会根据依赖的包自行装配
spring.cache.type=redis
# 链接超时时间（毫秒）
spring.redis.timeout=10000
# Redis默认状况下有16个分片，这里配置具体使用的分片
spring.redis.database=0
# 链接池最大链接数（使用负值表示没有限制） 默认 8
spring.redis.lettuce.pool.max-active=8
# 链接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
spring.redis.lettuce.pool.max-wait=-1
# 链接池中的最大空闲链接 默认 8
spring.redis.lettuce.pool.max-idle=8
# 链接池中的最小空闲链接 默认 0
spring.redis.lettuce.pool.min-idle=0

具体编码

实体类

建立一个User类，目的是为了模拟对象存储缓存

package com.battcn.entity;

import java.io.Serializable;

/**
 * @author Levin
 * @since 2018/5/11 0007
 */
public class User implements Serializable {

    private static final long serialVersionUID = 8655851615465363473L;
    private Long id;
    private String username;
    private String password;
    // TODO  省略get set
}

定义接口

package com.battcn.service;

import com.battcn.entity.User;

/**
 * @author Levin
 * @since 2018/5/11 0011
 */
public interface UserService {

    /**
     * 删除
     *
     * @param user 用户对象
     * @return 操做结果
     */
    User saveOrUpdate(User user);

    /**
     * 添加
     *
     * @param id key值
     * @return 返回结果
     */
    User get(Long id);

    /**
     * 删除
     *
     * @param id key值
     */
    void delete(Long id);
}

实现类

为了方便演示数据库操做，直接定义了一个Map<Long, User> DATABASES，这里的核心就是@Cacheable、@CachePut、@CacheEvict 三个注解安全

package com.battcn.service.impl;

import com.battcn.entity.User;
import com.battcn.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.Map;

/**
 * @author Levin
 * @since 2018/5/11 0011
 */
@Service
public class UserServiceImpl implements UserService {

    private static final Map<Long, User> DATABASES = new HashMap<>();

    static {
        DATABASES.put(1L, new User(1L, "u1", "p1"));
        DATABASES.put(2L, new User(2L, "u2", "p2"));
        DATABASES.put(3L, new User(3L, "u3", "p3"));
    }


    private static final Logger log = LoggerFactory.getLogger(UserServiceImpl.class);

    @Cacheable(value = "user", key = "#id")
    @Override
    public User get(Long id) {
        // TODO 咱们就假设它是从数据库读取出来的
        log.info("进入 get 方法");
        return DATABASES.get(id);
    }

    @CachePut(value = "user", key = "#user.id")
    @Override
    public User saveOrUpdate(User user) {
        DATABASES.put(user.getId(), user);
        log.info("进入 saveOrUpdate 方法");
        return user;
    }

    @CacheEvict(value = "user", key = "#id")
    @Override
    public void delete(Long id) {
        DATABASES.remove(id);
        log.info("进入 delete 方法");
    }
}

主函数

@EnableCaching 必需要加，不然spring-data-cache相关注解不会生效...

package com.battcn;

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

/**
 * @author Levin
 */
@SpringBootApplication
@EnableCaching
public class Chapter9Application {

    public static void main(String[] args) {
        SpringApplication.run(Chapter9Application.class, args);
    }

}

测试

完成准备事项后，编写一个junit测试类来检验代码的正确性，有不少人质疑过Redis线程安全性，故下面也提供了响应的测试案例，若有疑问欢迎指正

package com.battcn;

import com.battcn.entity.User;
import com.battcn.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author Levin
 * @since 2018/5/10 0010
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class Chapter9ApplicationTest {

    private static final Logger log = LoggerFactory.getLogger(Chapter9ApplicationTest.class);


    @Autowired
    private UserService userService;


    @Test
    public void get() {
        final User user = userService.saveOrUpdate(new User(5L, "u5", "p5"));
        log.info("[saveOrUpdate] - [{}]", user);
        final User user1 = userService.get(5L);
        log.info("[get] - [{}]", user1);
        userService.delete(5L);
    }
}

启动测试类，结果和咱们指望的一致，能够看到增删改查中，查询是没有日志输出的，由于它直接从缓存中获取的数据，而添加、修改、删除都是会进入方法内执行具体的业务代码，而后经过切面去删除掉Redis中的缓存数据。其中 # 号表明这是一个 SpEL 表达式，此表达式能够遍历方法的参数对象，具体语法能够参考 Spring 的相关文档手册。

2018-05-14 09:20:55.303  INFO 21176 --- [           main] com.battcn.service.impl.UserServiceImpl  : 进入 saveOrUpdate 方法
2018-05-14 09:20:55.582  INFO 21176 --- [           main] io.lettuce.core.EpollProvider            : Starting without optional epoll library
2018-05-14 09:20:55.584  INFO 21176 --- [           main] io.lettuce.core.KqueueProvider           : Starting without optional kqueue library
2018-05-14 09:20:56.316  INFO 21176 --- [           main] com.battcn.Chapter9ApplicationTest       : [saveOrUpdate] - [User{id=5, username='u5', password='p5'}]
2018-05-14 09:20:56.320  INFO 21176 --- [           main] com.battcn.Chapter9ApplicationTest       : [get] - [User{id=5, username='u5', password='p5'}]
2018-05-14 09:20:56.322  INFO 21176 --- [           main] com.battcn.service.impl.UserServiceImpl  : 进入 delete 方法
其它类型

下列的就是Redis其它类型所对应的操做方式

  • opsForValue： 对应 String（字符串）
  • opsForZSet： 对应 ZSet（有序集合）
  • opsForHash： 对应 Hash（哈希）
  • opsForList： 对应 List（列表）
  • opsForSet： 对应 Set（集合）
  • opsForGeo： 对应 GEO（地理位置）

根据条件操做缓存

根据条件操做缓存内容并不影响数据库操做，条件表达式返回一个布尔值，true/false，当条件为 true，则进行缓存操做，不然直接调用方法执行的返回结果。

  • 长度： @CachePut(value = "user", key = "#user.id",condition = "#user.username.length() < 10") 只缓存用户名长度少于10的数据
  • 大小： @Cacheable(value = "user", key = "#id",condition = "#id < 10") 只缓存ID小于10的数据
  • 组合： @Cacheable(value="user",key="#user.username.concat(##user.password)")
  • 提早操做： @CacheEvict(value="user",allEntries=true,beforeInvocation=true) 加上beforeInvocation=true后，无论内部是否报错，缓存都将被清除，默认状况为false

注解介绍

@Cacheable(根据方法的请求参数对其结果进行缓存)
  • key： 缓存的 key，能够为空，若是指定要按照 SpEL 表达式编写，若是不指定，则缺省按照方法的全部参数进行组合（如：@Cacheable(value="user",key="#userName")）
  • value： 缓存的名称，必须指定至少一个（如：@Cacheable(value="user") 或者 @Cacheable(value={"user1","use2"})）
  • condition： 缓存的条件，能够为空，使用 SpEL 编写，返回 true 或者 false，只有为 true 才进行缓存（如：@Cacheable(value = "user", key = "#id",condition = "#id < 10")）
@CachePut(根据方法的请求参数对其结果进行缓存，和 @Cacheable 不一样的是，它每次都会触发真实方法的调用)
  • key： 同上
  • value： 同上
  • condition： 同上
@CachEvict(根据条件对缓存进行清空)
  • key： 同上
  • value： 同上
  • condition： 同上
  • allEntries： 是否清空全部缓存内容，缺省为 false，若是指定为 true，则方法调用后将当即清空全部缓存（如：@CacheEvict(value = "user", key = "#id", allEntries = true)）
  • beforeInvocation： 是否在方法执行前就清空，缺省为 false，若是指定为 true，则在方法尚未执行的时候就清空缓存，缺省状况下，若是方法执行抛出异常，则不会清空缓存（如：@CacheEvict(value = "user", key = "#id", beforeInvocation = true)）

总结

spring-cache文档： https://docs.spring.io/spring/docs/5.0.5.RELEASE/spring-framework-reference/integration.html#cache-introduction
spring-data-redis文档： https://docs.spring.io/spring-data/redis/docs/2.0.1.RELEASE/reference/html/#new-in-2.0.0
Redis 文档： https://redis.io/documentation
Redis 中文文档： http://www.redis.cn/commands.html

目前不少大佬都写过关于 SpringBoot 的教程了，若有雷同，请多多包涵，本教程基于最新的 spring-boot-starter-parent：2.0.1.RELEASE编写，包括新版本的特性都会一块儿介绍...

说点什么

  • 我的QQ：1837307557
  • battcn开源群（适合新手）：391619659
  • 微信公众号（欢迎调戏）：battcn

公众号

我的博客：http://blog.battcn.com/

全文代码：https://github.com/battcn/spring-boot2-learning/tree/master/chapter9

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程