在spring boot2中使用redis作为缓存

发表于 | 分类于

1、简单的一个demo

spring boot2.0中使用Redis做为缓存，首选引入 依赖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
<?xml version="1.0" encoding="UTF-8"?>
<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>com.hu</groupId>
    <artifactId>data-cache-redis-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.42</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

</project>

配置文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
spring:
  datasource:
    #使用druid数据源
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://172.16.3.34:3306/fenxiao_test?useUnicode=true&characterEncoding=utf-8
      username: root
      password: root
      initialSize: 1
      minIdle: 3
      maxActive: 20
      #配置获取连接等待超时的时间
      maxWait: 6000
      #配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      #配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 30000
      validationQuery: select 'x'
      testWhileIdle: true
      testOnBorrow: false
      testOnReturn: false
      #配置监控统计拦截的filters去掉后监控界面sql无法统计wall用于防火墙
      filters: stat,wall,slf4j
      #通过connectProperties属性来打开mergeSql功能,慢SQL记录
      connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
      useGlobalDataSourceStat: true

  cache:
    type: redis
  #redis
  redis:
    host: 172.16.3.34
    port: 6379
    password:
    timeout: 100000

mybatis:
  mapper-locations: classpath:mybatis/*/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

构建数据源和缓存配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/**
 * 构建数据源对象
 */
@ConditionalOnClass({EnableTransactionManagement.class})
@Configuration
public class DataSourceConfig {
    private static Logger log = LoggerFactory.getLogger(DataSourceConfig.class);

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSource druidDataSource() {
        DruidDataSource druidDataSource = new DruidDataSource();
        return druidDataSource;
    }
}

/**
 * 使用Redis做为缓存，和spring boot1.x不同
 */
@Configuration
@EnableCaching
public class RedisConfig  extends CachingConfigurerSupport {

    /*@Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;*/

    //自定义缓存key生成策略
    @Bean
    public KeyGenerator keyGenerator(){
        return (o, method, params) ->{
            StringBuilder sb = new StringBuilder();
            sb.append(o.getClass().getName()); // 类目
            sb.append(method.getName()); // 方法名
            for(Object param: params){
                sb.append(param.toString()); // 参数名
            }
            return sb.toString();
        };
    }
    //缓存管理器Spring boot2.X 配置
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1)) // 设置缓存有效期一小时
                // 设置key的序列化方式
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 设置value的序列化方式
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                // 不缓存null值
                .disableCachingNullValues();

        RedisCacheManager redisCacheManager = RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(config)
                .transactionAware()
                .build();

        return redisCacheManager;
    }
    //以下是Spring boot1.X 配置
    /*@Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //设置缓存过期时间
        cacheManager.setDefaultExpiration(10000);
        return cacheManager;
    }*/
    /*@Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template = new StringRedisTemplate(factory);
        //设置序列化工具
        setSerializer(template);
        return template;
    }*/
   /* @SuppressWarnings("all")
    private void setSerializer(StringRedisTemplate template){
        Jackson2JsonRedisSerializer 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);
        //查看Redis的Bean定义发现，对key的序列化使用的是StringRedisSerializer系列化，value值的序列化是GenericJackson2JsonRedisSerializer的序列化方法。
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
    }*/
}

创建实体，mapper和service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
public class Student implements Serializable {
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student(String name) {
        this.name = name;
    }
    public Student(){}
    @Override
    public String toString() {
        return "\n{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

@Mapper
public interface StudentMapper {
    @Insert("insert into Student(name) values(#{name})")
    int insertStudent(Student student);

    @Select("select * from Student")
    List<Student> selectStudent();
}

/**
 * @Cacheable(cacheNames = "student") 这样就使用了缓存
 * 
 */
@Service
public class StudentService {

    @Autowired
    StudentMapper studentMapper;

    public int saveStudent(Student student){
        return studentMapper.insertStudent(student);
    }

    @Cacheable(cacheNames = "student")
    public List<Student> getStudents(){
        return studentMapper.selectStudent();
    }
}


测试类：
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class Test {
    @Autowired
    StudentService studentService;

    @org.junit.Test
    public void stu(){

        Random random = new Random();
        Student student = new Student("小米"+random.nextInt(100));

        //System.out.println(studentService.saveStudent(student));

        System.out.println(Arrays.toString(studentService.getStudents().toArray()));
    }
}

第一次运行如下：

20200423134656

可以看到由于缓存中没有数据，去数据库查询。并且Redis中有了数据：

20200423134738

第二次运行：

20200423134754

没有mybatis查询的日志，直接在redis中就有值存在。

io.lettuce.core.KqueueProvider是指Spring boot2中默认使用lettuce操作Redis

使用缓存的几种注解：

20200423134634

具体可以参考：缓存数据

@CacheConfig 每个缓存操作都要写cacheName,keygenerator，很麻烦，为了统一配置使用CacheConfig。

2、统一做缓存

第一种实现可以通过自定义注解，对读方法增加aop处理，同时对写方法做删除缓存处理
定义两个注解：

1
2
3
4
5
6
7
8
9
10
11
12
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ClearCache {
    String[] keys(); //需要清除的key
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisCache {
    Class type(); //用户存放类类型
}

切面：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
/**
 * 缓存切面
 */
@Aspect
@Component
public class RedisCacheAspect {
    @Autowired
    private RedisClient redisClient;

    /**
     * 方法调用前，先查询缓存。如果存在缓存，则返回缓存数据，如果没有缓存，查數據庫，然后将结果放到缓存中
     */
    @Around("execution(public * com.hu.service.StudentService.getStudent(..))")
    public Object cache(ProceedingJoinPoint jp) throws Throwable {
        //获取被代理的方法
        MethodSignature msig = (MethodSignature) jp.getSignature();
        Object target = jp.getTarget();
        Object[] args = jp.getArgs();
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        String clazzName = target.getClass().getName();
        //得到被代理方法上的注解
        RedisCache annotation = currentMethod.getAnnotation(RedisCache.class);
        //如果没有缓存注解直接放行,查询数据库
        if(annotation==null){
            return jp.proceed(args);
        }
        System.out.println("cache");
        //有缓存注解，查询redis
        //生成对应的key值
        String key = genKey(clazzName, currentMethod.getName(), args);
        //查询redis
        Student student = (Student) redisClient.get(key);
        //如果redis中有直接返回缓存中内容
        if(student!=null){
            return student;
        }
        //如果redis中没有，查询数据库
        Object  object=jp.proceed(args);
        //如果数据库中查询不为空，将数据添加到reids中
        if(object!=null){
            redisClient.set(key,object);
        }
        return object;
    }


    /**
     * 对于插入，在方法调用前清除缓存，然后调用业务方法
     */
    @Around("execution(public * com.hu.service.StudentService.saveStudent(..))")
    public Object clearCache(ProceedingJoinPoint jp) throws Throwable {
        MethodSignature msig = (MethodSignature) jp.getSignature();
        Object target = jp.getTarget();
        Object[] args = jp.getArgs();
        Method currentMethod = target.getClass().getMethod(msig.getName(), msig.getParameterTypes());
        String clazzName = target.getClass().getName();
        //得到被代理方法上的注解
        ClearCache annotation = currentMethod.getAnnotation(ClearCache.class);
        String[] keys =annotation.keys();
        System.out.println("clearCache");
        if(keys!=null&&keys.length>0){
            // 清除对应缓存
            for(String key :keys){
                redisClient.delete(key);
            }
        }
        return jp.proceed(jp.getArgs());
    }


    /**
     * 根据类名、方法名和参数生成key
     */
    protected String genKey(String clazzName, String methodName, Object[] args) {
        StringBuilder sb = new StringBuilder(clazzName);
        sb.append(":");
        sb.append(methodName);
        for (Object obj : args) {
            sb.append(":");
            sb.append(obj.toString());
        }

        return sb.toString();
    }
}

配置和操作Redis类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
@Configuration
@EnableAutoConfiguration
public class MyRedisTemplate {
    @Bean
    public RedisTemplate<String,String> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, String> template = new StringRedisTemplate(factory);
        //设置序列化工具
        setSerializer(template);
        return template;
    }
    @SuppressWarnings("all")
    private void setSerializer(RedisTemplate template){
        Jackson2JsonRedisSerializer 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);
        //查看Redis的Bean定义发现，对key的序列化使用的是StringRedisSerializer系列化，value值的序列化是GenericJackson2JsonRedisSerializer的序列化方法。
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
    }
}


/**
 * 操作方法
 */
@Component
public class RedisClient {

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

    @Autowired
    RedisTemplate redisTemplate;

    /**
     * 删除key
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void delete(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    /**
     * 获取key
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 存入key
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            log.info(e.getMessage());
            return false;
        }
    }

    /**
     * key存放并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            log.info(e.getMessage());
            return false;
        }
    }

}

业务类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@Service
public class StudentService {

    @Autowired
    StudentMapper studentMapper;

    //清除对应的缓存
    @ClearCache(keys={"com.hu.service.StudentService:saveStudent:10"})
    public int saveStudent(Student student){
        return studentMapper.insertStudent(student);
    }

    @RedisCache(type=Student.class)
    public Student getStudent(Long id){
        return studentMapper.selectStudent(id);
    }
}

测试：
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class Test {
    @Autowired
    StudentService studentService;

    @org.junit.Test
    public void stu(){

        Random random = new Random();
        Student student = new Student("小米"+random.nextInt(100));

        //System.out.println(studentService.saveStudent(student));

        System.out.println(studentService.getStudent(6L));
    }
}

其他和上面例子一致

第一次运行：

20200423135004

可以看到查询了数据库，并且吧结果放到缓存。

20200423135027

第二次运行：可以看到直接从缓存取。

第二种方式是，不用注解，直接通过AOP统一为部分或者全部的方法添加缓存或者删除更新缓存。

代码详见：https://github.com/huingsn/tech-point-record中的data-cache-redis-demo

分享到： 收藏夹 复制网址 邮件 微信 QQ空间 腾讯微博 豆瓣 一键分享 更多