SpringBoot中使用Redis的实践
Redis是一个高性能的内存数据库，在日常开发中运用非常的广泛，主要用作缓存。Redis提供了非常丰富的数据结构，有String，List，Set，ZSet，Hash，
Redis为这些数据结构提供了丰富的原子性操作。弥补了其他NoSQL如Memcached的不足。在SpringBoot中，由于Boot提供了强大的AutoConfiguration，
集成Redis变得非常简单。本文将介绍Redis在SpringBoot中的应用，包括手动使用RedisTemplate进行操作，和使用注解（@Cacheable等）把业务数据缓存到Redis中。
开始
环境：JDK1.8，Maven3+，Redis3
需要预先安装好Redis，也可以使用Docker快速部署一个Redis，可以参考我之前的文章
新建一个SpringBoot项目，引入需要用到的相关maven依赖
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!--SpringBoot的Redis支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--SpringBoot缓存支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
在yaml文件中配置redis连接：
spring:
redis:
#Redis服务器地址，默认localhost
host: localhost
#Redis服务器端口，默认6379
port: 6379
pool:
#连接池最大连接数
max-active: 8
#最大阻塞等待时间，-1表示没有限制
max-wait: -1
#最大空闲连接
max-idle: 8
#最小空闲连接
min-idle: 0
#连接超时时间
timeout: 0
使用RedisTemplate操作Redis
spring-data-redis提供了一个RedisTemplate类，这个类封装了对Redis基本数据结构的常用操作，它的子类StringRedisTemplate提供了对字符串的常用
操作，接下来将使用StringRedisTemplate来操作Redis中的String和List类型。
注入StringRedisTemplate
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 操作字符串
*/
private void operateString() {
stringRedisTemplate.opsForValue().set("author", "luoliang");
String value = stringRedisTemplate.opsForValue().get("author");
log.info("stringRedisTemplate输出值：{}", value);
}
/**
* Redis List操作，Redis列表是简单的字符串列表，按照插入顺序排序。可以添加一个元素到列表的头部（左边）或者尾部（右边）
*/
private void operateList() {
String key = "website";
ListOperations<String, String> listOperations = stringRedisTemplate.opsForList();
//从左压入栈
listOperations.leftPush(key, "Github");
listOperations.leftPush(key, "CSDN");
//从右压入栈
listOperations.rightPush(key, "SegmentFault");
log.info("list size:{}", listOperations.size(key));
List<String> list = listOperations.range(key, 0, 2);
list.forEach(log::info);
}
上面涉及到的两种类型的操作，都是针对的字符串，可不可以存取对象呢？答案当然是可以的。我们使用Hash来存取对象，首先新建一个User类，用于存取
使用。
此处需要注意，User类需要实现Serializable接口，否则无法序列化
@Data
@Builder
public class User implements Serializable {
private String id;
private String name;
private Integer age;
}
这时候就不能再使用StringRedisTemplate了，所以需要配置针对Object的RedisTemplate实例，这里可以使用默认的JdkSerializationRedisSerializer
序列化，也可以自己实现RedisSerializer接口来自定义序列化
@Configuration
public class RedisConfig {
@Resource
private JedisConnectionFactory jedisConnectionFactory;
@Bean
public RedisTemplate<String, Object> objRedisTemplate() {
RedisTemplate<String, Object> template = new RedisTemplate<>();
template.setConnectionFactory(jedisConnectionFactory);
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new JdkSerializationRedisSerializer());
return template;
}
}
操作Hash
@Resource
private RedisTemplate<String, Object> objRedisTemplate;
/**
* 操作hash，存放User对象
*/
private void operateHash() {
String key = "user";
HashOperations<String, String, User> hashOperations = objRedisTemplate.opsForHash();
hashOperations.put(key, "user1", User.builder().name("Hulk").age(50).build());
hashOperations.put(key, "user2", User.builder().name("Thor").age(1500).build());
hashOperations.put(key, "user3", User.builder().name("Rogers").age(150).build());
log.info("hash size:{}", hashOperations.size(key));
log.info("--------拿到Map的key集合--------");
Set<String> keys = hashOperations.keys(key);
keys.forEach(log::info);
log.info("--------拿到Map的value集合--------");
List<User> users = hashOperations.values(key);
users.forEach(user -> log.info(user.toString()));
log.info("--------拿到user1的value--------");
User user = hashOperations.get(key, "user1");
log.info(user.toString());
}
最后，验证我们的操作，可以看到，结果和预期相同。
2018-05-22 10:45:07.754 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : ----------Operate String----------
2018-05-22 10:45:07.820 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : stringRedisTemplate输出值：luoliang
2018-05-22 10:45:07.821 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : ----------Operate List----------
2018-05-22 10:45:07.832 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : list size:57
2018-05-22 10:45:07.836 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : CSDN
2018-05-22 10:45:07.836 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : Github
2018-05-22 10:45:07.836 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : CSDN
2018-05-22 10:45:07.836 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : ----------Operate Hash----------
2018-05-22 10:45:07.858 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : hash size:3
2018-05-22 10:45:07.858 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : --------拿到Map的key集合--------
2018-05-22 10:45:07.865 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : user2
2018-05-22 10:45:07.866 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : user1
2018-05-22 10:45:07.866 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : user3
2018-05-22 10:45:07.866 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : --------拿到Map的value集合--------
2018-05-22 10:45:07.870 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : User(id=null, name=Thor, age=1500)
2018-05-22 10:45:07.870 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : User(id=null, name=Hulk, age=50)
2018-05-22 10:45:07.870 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : User(id=null, name=Rogers, age=150)
2018-05-22 10:45:07.870 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : --------拿到user1的value--------
2018-05-22 10:45:07.873 INFO 42127 --- [ main] org.boot.redis.BootRedisApplication : User(id=null, name=Hulk, age=50)
使用Annotation缓存数据
上面的操作方式，是手动操作Redis进行存取，在真实的业务场景中，我们并不想这样去使用，而是把Redis当做一种缓存来使用，把service或者dao层的数据进行缓存，
最简单的方式就是通过注解。在SpringBoot中使用Redis做缓存也非常简单，只需要在pom中引入spring-boot-starter-cache即可。
下面列出的是Spring缓存的常用注解（来自@程序猿DD）：
- @CacheConfig：主要用于配置该类中会用到的一些共用的缓存配置。在这里@CacheConfig(cacheNames = “users”)：配置了该数据访问对象中返回的
内容将存储于名为users的缓存对象中，我们也可以不使用该注解，直接通过@Cacheable自己配置缓存集的名字来定义。 - @Cacheable：配置了findByName函数的返回值将被加入缓存。同时在查询时，会先从缓存中获取，若不存在才再发起对数据库的访问。该注解主要有下面几个参数：
- value、cacheNames：两个等同的参数（cacheNames为Spring4新增，作为value的别名），用于指定缓存存储的集合名。由于Spring 4中新增了@CacheConfig，
因此在Spring 3中原本必须有的value属性，也成为非必需项了 - key：缓存对象存储在Map集合中的key值，非必需，缺省按照函数的所有参数组合作为key值，若自己配置需使用SpEL表达式，比如：@Cacheable(key = “#p0”)：
使用函数第一个参数作为缓存的key值，更多关于SpEL表达式的详细内容可参考官方文档 - condition：缓存对象的条件，非必需，也需使用SpEL表达式，只有满足表达式条件的内容才会被缓存，比如：@Cacheable(key = “#p0”, condition = “#p0.length() < 3”)，
表示只有当第一个参数的长度小于3的时候才会被缓存，若做此配置上面的AAA用户就不会被缓存，读者可自行实验尝试。 - unless：另外一个缓存条件参数，非必需，需使用SpEL表达式。它不同于condition参数的地方在于它的判断时机，该条件是在函数被调用之后才做判断的，
所以它可以通过对result进行判断。 - keyGenerator：用于指定key生成器，非必需。若需要指定一个自定义的key生成器，我们需要去实现org.springframework.cache.interceptor.KeyGenerator接口，
并使用该参数来指定。需要注意的是：该参数与key是互斥的 - cacheManager：用于指定使用哪个缓存管理器，非必需。只有当有多个时才需要使用
- cacheResolver：用于指定使用那个缓存解析器，非必需。需通过org.springframework.cache.interceptor.CacheResolver接口来实现自己的
缓存解析器，并用该参数指定。
- value、cacheNames：两个等同的参数（cacheNames为Spring4新增，作为value的别名），用于指定缓存存储的集合名。由于Spring 4中新增了@CacheConfig，
- @CachePut：配置于函数上，能够根据参数定义条件来进行缓存，它与@Cacheable不同的是，它每次都会真实调用函数，所以主要用于数据新增和修改操作上
。它的参数与@Cacheable类似，具体功能可参考上面对@Cacheable参数的解析。 - @CacheEvict：配置于函数上，通常用在删除方法上，用来从缓存中移除相应数据。除了同@Cacheable一样的参数之外，它还有下面两个参数：
- allEntries：非必需，默认为false。当为true时，会移除所有数据
- beforeInvocation：非必需，默认为false，会在调用方法之后移除数据。当为true时，会在调用方法之前移除数据。
由于本项目没有涉及到数据库的链接，下面，我们来模拟数据库的操作，并把结果缓存到Redis中
@Service
@Slf4j
@CacheConfig(cacheNames = "users")
public class RedisCacheServiceImpl implements RedisCacheService {
@Override
@CachePut(key = "#p0.id")
public User save(User user) {
log.info("-----执行数据库更新操作");
log.info("-----数据库更新完成，返回结果");
return user;
}
@Override
@Cacheable(key = "#p0")
public User get(String id) {
log.info("-----执行数据库查询操作");
User user = User.builder().id(id).name("spring").age(18).build();
log.info("-----数据库查询完成，返回结果");
return user;
}
@Override
@CacheEvict(key = "#p0")
public void delete(String id) {
log.info("-----执行数据库删除操作");
log.info("-----数据库删除完成，返回结果");
}
}
在Junit中进行测试
@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
@Slf4j
public class RedisCacheServiceTest {
@Resource
private RedisCacheService redisCacheService;
@Test
public void testGet() {
User user = redisCacheService.get("1111111");
log.info(user.toString());
}
@Test
public void testSave() {
User user = User.builder().id("1111111").name("spring").age(20).build();
redisCacheService.save(user);
}
@Test
public void testDelete() {
redisCacheService.delete("1111111");
}
}
先调用get方法，此时，Redis中没有此数据，会进入方法，拿到数据之后返回，并且把数据缓存到Redis中，结果如下：
2018-05-22 10:57:57.532 INFO 42313 --- [ main] o.b.r.s.impl.RedisCacheServiceImpl : -----执行数据库查询操作
2018-05-22 10:57:57.533 INFO 42313 --- [ main] o.b.r.s.impl.RedisCacheServiceImpl : -----数据库查询完成，返回结果
2018-05-22 10:57:57.557 INFO 42313 --- [ main] o.b.redis.service.RedisCacheServiceTest : User(id=1111111, name=spring, age=18)
再调用一次get方法，此时将不会进入方法中，直接从缓存中拿到数据并返回，结果如下：
2018-05-22 10:57:57.557 INFO 42313 --- [ main] o.b.redis.service.RedisCacheServiceTest : User(id=1111111, name=spring, age=18)
再调用save方法，会把缓存中ID为1111111的User年龄更新为20，调用delete方法会删除缓存，和预期的结果一致，这里就不贴结果了，感兴趣的同学可以自行验证。
总结
至此，整篇文章就结束了，文章包含了RedisTemplate的使用，以及Spring提供的@Cacheable等注解的使用，都是日常开发中常常用到的东西。
最后，附上github源码，欢迎star，一起交流。boot-redis
