20springcloud如何使用spring-cache

Posted 2021-02-20

喜欢关注我的公众号： java乐园

学了springcloud如何操作数据库进行增删改查，又学了springcloud如何操作reids把数据存储到redis。今天结合数据库操作和reids操作，来看看如何使用SpringCache。SpringCache提供了基于注解的缓存配置方法。它本质上不是一个具体的缓存实现方案（例如EHCache），而是一个对缓存使用的抽象和封装，通过在已有代码中打上几个预定义的注释，就可以实现希望达到的缓存效果。SpringCache支持跟第三方缓存例如EHCache、Redis集成；另外也提供了开箱即用的默认实现，可以直接拿来使用。SpringCache支持使用SpEL（Spring Expression Language）来定义缓存的key和各种condition，因此具备相当的灵活性，并可以支持非常复杂的语义。

1、新建项目sc-redis-cache，对用的pom.xml文件如下

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>spring-cloud</groupId>
    <artifactId>sc-redis-cache</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>sc-redis-cache</name>
    <url>http://maven.apache.org</url>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Finchley.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>

        </dependencies>
    </dependencyManagement>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <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-web</artifactId>
        </dependency>

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

        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.3</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

2、新建springboot启动类RedisCacheApplication.java

package sc.redis.cache;

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

/**
 * 更多资源关注公众号： java乐园
 * 
 * @author Administrator
 *
 */
@SpringBootApplication
@EnableCaching // 启动缓存
@MapperScan(basePackages="sc.redis.cache.dao")
public class RedisCacheApplication {

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

}

备注：@MapperScan(basePackages="sc.redis.cache.dao")该注解的basePackages一定是DAO所在包最终报名。
如果写成@MapperScan(basePackages="sc.redis.cache ")这样在测试中将报错：

3、新建配置文件application.yml

server:
    port: 9003

spring:
    application:
        name: sc-redis-cache
    datasource:
        driverClassName: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/sc?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: root
        type: com.zaxxer.hikari.HikariDataSource
        hikari:
            minimum-idle: 5
            maximum-pool-size: 15
            auto-commit: true
            idle-timeout: 30000
            pool-name: DatebookHikariCP
            max-lifetime: 1800000
            connection-timeout: 30000
            connection-test-query: SELECT 1
    cache:
        type: REDIS
        redis:
            timeToLive: 200000 #缓存超时时间ms
            cache-null-values: false #是否缓存空值
    redis:
        host: 127.0.0.1
        password: 
        port: 6379
        timeout: 10000 # 连接超时时间（毫秒）
        database: 0 # Redis默认情况下有16个分片，这里配置具体使用的分片，默认是0
        lettuce:
            pool:
                max-active: 8 # 连接池最大连接数（使用负值表示没有限制） 默认 8
                max-wait: -1 # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
                max-idle: 8 # 连接池中的最大空闲连接 默认 8
                min-idle: 0 # 连接池中的最小空闲连接 默认 0

logging:
    level:
        sc.redis.cache.dao: debug

备注：配置文件中有连接数据库的配置信息和连接redis的配置信息，同时配置了打印sql语句的日志级别

4、新建自定义reids序列化方式RedisCacheSerializeConfiguration.java类

package sc.redis.cache.config;

import java.time.Duration;

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.RedisConnectionFactory;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisCacheSerializeConfiguration {

//  /**
//   *二选一
//   * 设置 redis 数据默认过期时间 设置@cacheable 序列化方式
//   * 
//   * @return
//   */
//  @Bean
//  public RedisCacheConfiguration redisCacheConfiguration() {
//      RedisCacheConfiguration configuration = RedisCacheConfiguration.defaultCacheConfig();
//      configuration = configuration.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
//              .entryTtl(Duration.ofDays(30));
//      configuration.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()));
//      return configuration;
//  }

    /**
     * 二选一
     * 设置 redis 数据默认过期时间 设置@cacheable 序列化方式
     * 
     * @param connectionFactory
     * @return
     */
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofDays(30))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
                .disableCachingNullValues();
        RedisCacheManager redisCacheManager = RedisCacheManager.builder(connectionFactory).cacheDefaults(config)
                .transactionAware().build();
        System.out.println("自定义RedisCacheManager加载完成");
        return redisCacheManager;
    }

    private RedisSerializer<String> keySerializer() {
        return new StringRedisSerializer();
    }

    private RedisSerializer<Object> valueSerializer() {
        return new GenericJackson2JsonRedisSerializer();
    }

}

5、启动相关类请参照源码，目录结构如下

6、编写单元测试类

package sc.redis.cache;

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;

import sc.redis.cache.model.User;
import sc.redis.cache.service.UserService;

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestRedis {

    private static final Logger logger = LoggerFactory.getLogger(TestRedis.class);

    @Autowired
    private UserService userService;

    @Test
    public void add() {
        User u = new User();
        u.setId(4L);
        u.setUserName("huangjinjin");
        u.setPosition("cto");
        u.setAge(24);
        userService.addUser(u);

    }

    @Test
    public void get() {
        User u =userService.getUser(4L);
        logger.debug("userName = "+ u.getUserName());
    }
}

7、进行单元测试
运行add方法添加一条数据到数据库：
日志：

第一次运行get方法：
日志：

使用redis-cli查看redis，数据已经插入缓存

第二次运行get方法：
日志：

发现没有打印任何sql语句，说明数据是从redis获取的，没有去数据库查询数据。