Spring Boot实战（六）：Spring Boot 2.x整合Redis

时间  2019-11-09
标签 spring boot 实战 2.x 整合 redis 栏目 Spring 繁體版
原文   原文链接

最近在学习Spring Boot 2.x整合Redis，在这里和你们分享一下，但愿对你们有帮助。html

Redis是什么

Redis 是开源免费高性能的key-value数据库。有如下的优点（源于Redis官网）：java

  • 性能极高 – Redis能读的速度是110000次/s,写的速度是81000次/s 。redis

  • 丰富的数据类型 – Redis支持二进制案例的 Strings, Lists, Hashes, Sets 及 Ordered Sets 数据类型操做。spring

  • 原子 – Redis的全部操做都是原子性的，意思就是要么成功执行要么失败彻底不执行。单个操做是原子性的。多个操做也支持事务，即原子性，经过MULTI和EXEC指令包起来。数据库

  • 丰富的特性 – Redis还支持 publish/subscribe, 通知, key 过时等等特性。缓存

若是想了解更多关于Redis是什么，能够参考：Redis初识服务器

为何要使用Redis

为何要使用Redis？21世纪以来信息技术的飞速发展，咱们已经迎来了大数据时代，数据较以前爆炸增加，并发访问量激增；由之带来的就是系统设计由单体架构向分布式架构的转变和演进。对于缓存这个问题，若是系统是单体的系统，能够在单个的JVM里面进行本地缓存，例如能够用HashMap来缓存一些数据。可是到了分布式系统里面，一个大系统里面有不少个子系统，那他们之间如何共享缓存？这就须要Redis，用Redis来实现缓存系统。都说“时势造英雄”，其实我想说Redis的大规模使用也是这个道理，用Redis作缓存系统从性能和并发两方面考虑都是值得确定的。架构

  1. 性能：若是碰到须要执行耗时特别久，且结果不频繁变更的SQL，就特别适合将运行结果放入缓存。这样，后面的请求就去缓存中读取，使得请求可以迅速响应。并发

  2. 并发： 在大并发的状况下，全部的请求直接访问数据库，数据库会出现链接异常。这个时候，就须要使用redis作一个缓冲操做，让请求先访问到Redis，而不是直接访问数据库。app

更多关于“为何要使用Redis”，博客园【原创】分布式之redis复习精讲 ，这篇博文关于Redis的讲解我以为超赞，谢谢做者的耐心分享。

Spring Boot 2.x如何整合Redis

我使用的Spring Boot版本是2.1.0，根据网上的一些旧的教程进行整合Redis 3.2的时候，会有许多地方有错误提示。这是由于Spring Boot 2.x作了一些修改，这些修改对使用而有没有影响呢？咱们改怎么整合呢？下面就进入正式的整合过程。

1. pom.xnl引入依赖

这是以前的依赖：

<dependency>
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-redis</artifactId>
        </dependency>  
复制代码

如今会提示Project build error: 'dependencies.dependency.version' for org.springframework.boot:spring-boot-starter-redis:jar is missing. 提示spring-boot-starter-redis:jar找不到。

这是由于Spring Boot 1.4以后再也不支持spring-boot-starter-redis，更换spring-boot-starter-data-redis以后就能够了。若是你的pom文件报错，请检查是否将spring-boot-starter-redis 改为了spring-boot-starter-data-redis。

Spring Boot 2.x要使用下面的依赖：

<dependency>
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency> 
复制代码

2. application.properties添加配置文件

这是以前版本的配置文件：

# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器链接端口
spring.redis.port=6379  
# Redis服务器链接密码（默认为空）
spring.redis.password=  
# 链接池最大链接数（使用负值表示没有限制）
spring.redis.pool.max-active=8  
# 链接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1 
# 链接池中的最大空闲链接
spring.redis.pool.max-idle=8  
# 链接池中的最小空闲链接
spring.redis.pool.min-idle=0  
# 链接超时时间（毫秒）
spring.redis.timeout=0  
复制代码

若是Spring Boot 2.x这么配置，有错误提示 Property 'spring.redis.pool.max-active' is Deprecated: Use 'spring.redis.jedis.pool.max-idle' instead. 'spring.redis.pool.max-active'已经被弃用了，推荐使用'spring.redis.jedis.pool.max-idle'来代替。

这是由于在2.x中配置redis的链接池信息时，再也不使用spring.redis.pool的属性，而是直接使用redis的lettuce或jedis客户端来配置。如今的配置以下：

# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0  
# Redis服务器地址
spring.redis.host=127.0.0.1
# Redis服务器链接端口
spring.redis.port=6379  
# Redis服务器链接密码（默认为空）
spring.redis.password=  
# 链接池最大链接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8  
# 链接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 链接池中的最大空闲链接
spring.redis.jedis.pool.max-idle=8  
# 链接池中的最小空闲链接
spring.redis.jedis.pool.min-idle=0  
# 链接超时时间（毫秒）
spring.redis.timeout=0  
复制代码

3. 配置CacheManager

这是以前的RedisConfig配置类：

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    @Bean
    public CacheManager cacheManager(RedisTemplate<?, ?> redisTemplate) {
        CacheManager cacheManager = new  RedisCacheManager(redisTemplate);
        return cacheManager;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, String> redisTemplate = new  RedisTemplate<String, String>();
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }
}
复制代码

如今这么写会有报错The constructor RedisCacheManager(RedisTemplate<capture#1-of ?,capture#2-of ?>) is undefined。

这是由于Spring Boot 2.x版本删除了RedisCacheManager这个构造器， 也不能够经过以前的setDefaultExpiration方法设置默认的缓存过时时间等。

那么要怎样构造一个 RedisCacheManager？看看官方文档中怎么说？文档地址：docs.spring.io/spring-data…

官方文档5.13.1. Support for the Spring Cache Abstraction（对Spring Cache Abstraction的支持）是关于怎么配置缓存的说明，我尝试着翻译了一下（蓝色部分），英文水平有限，各位轻喷。

Spring Redis provides an implementation for the Spring cache abstraction through the org.springframework.data.redis.cache package. To use Redis as a backing implementation, add RedisCacheManager to your configuration, as follows:

Spring Redis在 org.springframework.data.redis.cache 包中为Spring缓存抽象提供了一个实现方案。要使用Redis做为支持实现，须要将RedisCacheManager添加到配置中，以下所示:

@Bean
public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
    return RedisCacheManager.create(connectionFactory);
}
复制代码

RedisCacheManager behavior can be configured with RedisCacheManagerBuilder, letting you set the default RedisCacheConfiguration, transaction behavior, and predefined caches.

RedisCacheManager能够用 RedisCacheManagerBuilder 进行配置，容许自定义设置默认的RedisCacheConfiguration、事务行为和预约义的缓存。

RedisCacheManager cm = RedisCacheManager.builder(connectionFactory)
    .cacheDefaults(defaultCacheConfig())
    .initialCacheConfigurations(singletonMap("predefined", defaultCacheConfig().disableCachingNullValues()))
    .transactionAware()
    .build();
复制代码

As shown in the preceding example, RedisCacheManager allows definition of configurations on a per-cache basis.

正如上面的例子所示，RedisCacheManager 容许基于每一个缓存进行配置。

The behavior of RedisCache created with RedisCacheManager is defined with RedisCacheConfiguration. The configuration lets you set key expiration times, prefixes, and RedisSerializer implementations for converting to and from the binary storage format, as shown in the following example:

RedisCacheManager建立RedisCache的行为被定义为RedisCacheConfiguration。该配置容许设置键值过时时间、前缀和RedisSerializer实现等属性，以便与二进制存储格式进行转换，以下所示:

RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(Duration.ofSeconds(1))
    .disableCachingNullValues();
复制代码

RedisCacheManager defaults to a lock-free RedisCacheWriter for reading and writing binary values. Lock-free caching improves throughput. The lack of entry locking can lead to overlapping, non-atomic commands for the putIfAbsent and clean methods, as those require multiple commands to be sent to Redis. The locking counterpart prevents command overlap by setting an explicit lock key and checking against presence of this key, which leads to additional requests and potential command wait times.

RedisCacheManager默认是无锁的，用于读写二进制值的RedisCacheWriter。无锁缓存可提升吞吐量。缺乏锁定可能致使putIfAbsent和clean方法的非原子命令重叠，由于这些方法须要向Redis发送多条命令。锁对应程序经过设置显式锁定的key并检查是否存在该key来防止命令重叠，这会致使额外的请求和潜在的命令等待时间。

It is possible to opt in to the locking behavior as follows:

也能够选择锁定行为，以下所示：

RedisCacheManager cm = RedisCacheManager.build(RedisCacheWriter.lockingRedisCacheWriter())
    .cacheDefaults(defaultCacheConfig())
    ...
复制代码

By default, any key for a cache entry gets prefixed with the actual cache name followed by two colons. This behavior can be changed to a static as well as a computed prefix.

默认状况下，缓存条目的任何key目以实际缓存名称为前缀，后跟两个冒号。此行为能够更改成静态前缀和计算前缀。

The following example shows how to set a static prefix:

如下示例显示如何设置静态前缀：

// static key prefix
RedisCacheConfiguration.defaultCacheConfig().prefixKeysWith("( ͡° ᴥ ͡°)");

The following example shows how to set a computed prefix:

// computed key prefix
RedisCacheConfiguration.defaultCacheConfig().computePrefixWith(cacheName -> "¯\_(ツ)_/¯" + cacheName);
复制代码

The following table lists the default settings for RedisCacheManager:

下表列出了RedisCacheManager的默认设置：

Setting Value
Cache Writer Non-locking
Cache Configuration RedisCacheConfiguration#defaultConfiguration
Initial Caches None
Trasaction Aware No

The following table lists the default settings for RedisCacheConfiguration:

下表列出了RedisCacheConfiguration的默认设置：

Key Expiration None
Cache null Yes
Prefix Keys Yes
Default Prefix The actual cache name
Key Serializer StringRedisSerializer
Value Serializer JdkSerializationRedisSerializer
Conversion Service DefaultFormattingConversionService with default cache key converters

对于Spring Boot 2.x，这里我使用RedisCacheConfiguration简单配置一下缓存时间，完成RedisCacheManager的配置，代码以下:

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config =  RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofSeconds(1));
        RedisCacheManager cacheManager =  RedisCacheManager.builder(factory).cacheDefaults(config).build();
        return cacheManager;
    }
}
复制代码

4. Service层

使用缓存的状况通常是这样的：第一次访问的时候先从数据库读取数据，而后将数据写入到缓存，再次访问同一内容的时候就从缓存中读取，若是缓存中没有则从数据库中读取。

添加缓存逻辑的时候，从数据库中将内容读取出来以后，先set入缓存，而后再从缓存中添加读取行为，若是缓存为空则从数据库中进行读取。

在这里仅建立一个简单的RedisService，来进行存取缓存数据。

@Service
public class RedisService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    public void set(String key, Object value) {
        //更改在redis里面查看key编码问题
        RedisSerializer redisSerializer = new  StringRedisSerializer();
        redisTemplate.setKeySerializer(redisSerializer);
        ValueOperations<String, Object> vo =  redisTemplate.opsForValue();
        vo.set(key, value);
    }

    public Object get(String key) {
        ValueOperations<String, Object> vo =  redisTemplate.opsForValue();
        return vo.get(key);
    }
}
复制代码

5. Model层

实体类没有修改，和以前文章里面用的同样：

@Entity
@Table(name = "user")
public class User implements Serializable {

    private static final long serialVersionUID = 1L;

    @Id
    @GeneratedValue
    private Long id;
    @Column(name = "username")
    private String userName;
    @Column(name = "password")
    private String passWord;

    public User() {
        super();
    }

    public User(String userName, String passWord) {
        super();
        this.userName = userName;
        this.passWord = passWord;
    }

    public User(Long id, String userName, String passWord) {
        super();
        this.id = id;
        this.userName = userName;
        this.passWord = passWord;
    }
    //省略getter和setter方法
    
}
复制代码

6. Controller层

在user.Controller添加两个测试方法，一个写入Redis，一个从Redis读取：

@RestController
@RequestMapping("user")
public class UserController {
    @Autowired
    private UserRepository userRepository;

    @Autowired
    private RedisService redisService;

    @RequestMapping("/saveUser")
    public String saveUser(Long id, String userName, String passWord) {
        User user = new User(id, userName, passWord);
        redisService.set(id + "", user);
        return "success";
    }

    @RequestMapping("/getUserById")
    public User getUserById(Long id) {
        User res = (User) redisService.get(id + "");
        return res;
    }
}
复制代码

7. 测试

使用Postman进行测试，访问http://localhost:8080//user/saveUser?id=12&userName=Howard&passWord=magician，添加了一个User。

看看Redis数据库，使用get key查看，获得一个对象：

image

http://localhost:8080//user/getUserById?id=12，经过id获取User。

image

这是过滤器和拦截器的日志信息，能够看到没有进行MySQL数据库的操做，直接从缓存中读取，说明Redis配置生效了：

image

若是访问以前的接口，是有操做数据库的：

image

总结

以上就是Spring Boot 2.x整合Redis的全过程，和Spring Boot以前的版本在使用上有些细微的差异。

因为水平有限，文中或多或少有欠妥之处，还望各位大佬指正！

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