分布式缓存技术redis学习—— 深入理解Spring Redis的使用

时间：2022-02-03 23:46:29

关于spring redis框架的使用，网上的例子很多很多。但是在自己最近一段时间的使用中，发现这些教程都是入门教程，包括很多的使用方法，与spring redis丰富的api大相径庭，真是浪费了这么优秀的一个框架。
Spring-data-redis为spring-data模块中对redis的支持部分，简称为“SDR”，提供了基于jedis客户端API的高度封装以及与spring容器的整合，事实上jedis客户端已经足够简单和轻量级，而spring-data-redis反而具有“过度设计”的嫌疑。
    jedis客户端在编程实施方面存在如下不足：
    1) connection管理缺乏自动化，connection-pool的设计缺少必要的容器支持。
    2) 数据操作需要关注“序列化”/“反序列化”，因为jedis的客户端API接受的数据类型为string和byte，对结构化数据(json,xml,pojo)操作需要额外的支持。
    3) 事务操作纯粹为硬编码
    4) pub/sub功能，缺乏必要的设计模式支持，对于开发者而言需要关注的太多。
1. Redis使用场景
Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
我们都知道，在日常的应用中，数据库瓶颈是最容易出现的。数据量太大和频繁的查询，由于磁盘IO性能的局限性，导致项目的性能越来越低。
这时候，基于内存的缓存框架，就能解决我们很多问题。例如Memcache，Redis等。将一些频繁使用的数据放入缓存读取，大大降低了数据库的负担。提升了系统的性能。其实，对于hibernate以及Mybatis的二级缓存，是同样的道理。利用内存高速的读写速度，来解决硬盘的瓶颈。

2. 配置使用Redis

项目的整体结构如下：

分布式缓存技术redis学习—— 深入理解Spring Redis的使用

在applicationContext-dao.xml中配置如下:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:mongo="http://www.springframework.org/schema/data/mongo"
  6. xmlns:aop="http://www.springframework.org/schema/aop"
  7. xsi:schemaLocation="http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  9. http://www.springframework.org/schema/data/mongo
  10. http://www.springframework.org/schema/data/mongo/spring-mongo.xsd
  11. http://www.springframework.org/schema/context
  12. http://www.springframework.org/schema/context/spring-context-3.0.xsd
  13. http://www.springframework.org/schema/aop
  14. http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
  15. <context:property-placeholder location="classpath:database.properties" />
  16. <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
  17. <property name="maxIdle" value="${redis.maxIdle}" />
  18. <property name="maxTotal" value="${redis.maxActive}" />
  19. <property name="maxWaitMillis" value="${redis.maxWait}" />
  20. <property name="testOnBorrow" value="${redis.testOnBorrow}" />
  21. </bean>
  22. <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
  23. <property name="hostName" value="${redis.host}"/>
  24. <property name="port" value="${redis.port}"/>
  25. <property name="password" value="${redis.pass}"/>
  26. <property name="poolConfig" ref="poolConfig"/>
  27. </bean>
  28. <bean id="stringSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
  29. <bean id="hashSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
  30. <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
  31. <property name="connectionFactory" ref="connectionFactory" />
  32. <property name="keySerializer" ref="stringSerializer"/>
  33. <property name="valueSerializer" ref="stringSerializer"/>
  34. <property name="hashKeySerializer" ref="stringSerializer" />
  35. <property name="hashValueSerializer" ref="hashSerializer"/>
  36. </bean>
  37. </beans>

database.properties配置文件如下：

  1. redis.maxIdle=10
  2. redis.maxActive=20
  3. redis.maxWait=10000
  4. redis.testOnBorrow=true
  5. redis.host=192.168.1.76
  6. redis.port=6379
  7. redis.pass=password1

spring-data-Redis提供了多种serializer策略，这对使用jedis的开发者而言，实在是非常便捷。sdr提供了4种内置的serializer：

  • JdkSerializationRedisSerializer：使用JDK的序列化手段(serializable接口，ObjectInputStrean，ObjectOutputStream)，数据以字节流存储，POJO对象的存取场景，使用JDK本身序列化机制，将pojo类通过ObjectInputStream/ObjectOutputStream进行序列化操作，最终redis-server中将存储字节序列，是目前最常用的序列化策略。
  • StringRedisSerializer：字符串编码，数据以string存储，Key或者value为字符串的场景，根据指定的charset对数据的字节序列编码成string，是“new String(bytes, charset)”和“string.getBytes(charset)”的直接封装。是最轻量级和高效的策略。
  • JacksonJsonRedisSerializer：json格式存储，jackson-json工具提供了javabean与json之间的转换能力，可以将pojo实例序列化成json格式存储在redis中，也可以将json格式的数据转换成pojo实例。因为jackson工具在序列化和反序列化时，需要明确指定Class类型，因此此策略封装起来稍微复杂。【需要jackson-mapper-asl工具支持】
  • OxmSerializer：xml格式存储，提供了将javabean与xml之间的转换能力，目前可用的三方支持包括jaxb，apache-xmlbeans；redis存储的数据将是xml工具。不过使用此策略，编程将会有些难度，而且效率最低；不建议使用。【需要spring-oxm模块的支持】

其中JdkSerializationRedisSerializer和StringRedisSerializer是最基础的序列化策略，其中“JacksonJsonRedisSerializer”与“OxmSerializer”都是基于stirng存储，因此它们是较为“高级”的序列化(最终还是使用string解析以及构建Java对象)。 针对“序列化和发序列化”中JdkSerializationRedisSerializer和StringRedisSerializer是最基础的策略，原则上，我们可以将数据存储为任何格式以便应用程序存取和解析(其中应用包括app，Hadoop等其他工具)，不过在设计时仍然不推荐直接使用“JacksonJsonRedisSerializer”和“OxmSerializer”，因为无论是json还是xml，他们本身仍然是String。如果你的数据需要被第三方工具解析，那么数据应该使用StringRedisSerializer而不是JdkSerializationRedisSerializer。

RedisTemplate中需要声明4种serializer，默认为“JdkSerializationRedisSerializer”：

1) keySerializer ：对于普通K-V操作时，key采取的序列化策略
    2) valueSerializer：value采取的序列化策略
    3) hashKeySerializer： 在hash数据结构中，hash-key的序列化策略
    4) hashValueSerializer：hash-value的序列化策略

无论如何，建议key/hashKey采用StringRedisSerializer。

 

spring-data-redis针对jedis提供了如下功能：

    1. 连接池自动管理，提供了一个高度封装的“RedisTemplate”类

2. 针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口

  • ValueOperations：简单K-V操作
  • SetOperations：set类型数据操作
  • ZSetOperations：zset类型数据操作
  • HashOperations：针对map类型的数据操作

  • ListOperations：针对list类型的数据操作

3. 提供了对key的“bound”(绑定)便捷化操作API，可以通过bound封装指定的key，然后进行一系列的操作而无须“显式”的再次指定Key，即BoundKeyOperations：

  • BoundValueOperations
  • BoundSetOperations
  • BoundListOperations
  • BoundSetOperations
  • BoundHashOperations

3. RedisTemplate的使用
这个类作为一个模版类，提供了很多快速使用redis的api，而不需要自己来维护连接，事务。最初的时候，我创建的BaseRedisDao是继承自这个类的。继承的好处是我的每个Dao中，都可以*的控制序列化器，*的控制自己是否需要事务，这个先不需要了解，跟着我目前的这种配置方法来即可。template提供了一系列的operation,比如valueOperation,HashOperation,ListOperation,SetOperation等，用来操作不同数据类型的Redis。并且，RedisTemplate还提供了对应的*OperationsEditor，用来通过RedisTemplate直接注入对应的Operation。
核心代码：

  1. package com.npf.dao.impl;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.Map;
  5. import java.util.Map.Entry;
  6. import javax.annotation.Resource;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.data.redis.core.HashOperations;
  9. import org.springframework.data.redis.core.RedisTemplate;
  10. import org.springframework.stereotype.Repository;
  11. import com.npf.dao.StudentDao;
  12. import com.npf.model.Student;
  13. @Repository
  14. public class StudentDaoImpl implements StudentDao{
  15. @Autowired
  16. private RedisTemplate<String,Student> redisTemplate;
  17. @Resource(name="redisTemplate")
  18. private HashOperations<String,String,Student> opsForHash;
  19. public static final String STUDENT = "student";
  20. @Override
  21. public void save(Student student) {
  22. opsForHash.put(STUDENT, student.getId(), student);
  23. }
  24. @Override
  25. public Student find(String id) {
  26. Student student = opsForHash.get(STUDENT, id);
  27. return student;
  28. }
  29. @Override
  30. public void delete(String id) {
  31. opsForHash.delete(STUDENT, id);
  32. }
  33. @Override
  34. public void update(Student student) {
  35. opsForHash.put(STUDENT, student.getId(), student);
  36. }
  37. @Override
  38. public List<Student> findAll() {
  39. Map<String, Student> entries = opsForHash.entries(STUDENT);
  40. List<Student> stuList = new ArrayList<Student>();
  41. for(Entry<String, Student> entry : entries.entrySet()){
  42. stuList.add(entry.getValue());
  43. }
  44. return stuList;
  45. }
  46. }

控制层代码如下：

  1. package com.npf.controller;
  2. import java.util.List;
  3. import java.util.UUID;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.ui.Model;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RequestParam;
  9. import com.npf.model.Student;
  10. import com.npf.service.StudentService;
  11. @Controller
  12. public class StudentController {
  13. @Autowired
  14. private StudentService studentService;
  15. @RequestMapping("/student/save")
  16. public String saveStudent(Student student){
  17. String id = UUID.randomUUID().toString();
  18. System.out.println(id);
  19. student.setId(id);
  20. studentService.save(student);
  21. return "redirect:/student/find/all";
  22. }
  23. @RequestMapping("/student/update")
  24. public String updateStudent(Student student){
  25. studentService.update(student);
  26. return "redirect:/student/find/all";
  27. }
  28. @RequestMapping("/student/to/save/form")
  29. public String toSaveStudentForm(){
  30. return "save";
  31. }
  32. @RequestMapping("/student/delete")
  33. public String deleteStudent(@RequestParam("id") String id){
  34. studentService.delete(id);
  35. return "redirect:/student/find/all";
  36. }
  37. @RequestMapping("/student/to/update/form")
  38. public String toUpdateStudentForm(@RequestParam("id") String id,Model model){
  39. Student stu = studentService.find(id);
  40. model.addAttribute("stu", stu);
  41. return "update";
  42. }
  43. @RequestMapping("/student/find/all")
  44. public String findStudents(Model model){
  45. List<Student> stuList = studentService.findAll();
  46. model.addAttribute("stuList", stuList);
  47. return "list";
  48. }
  49. }

4. 测试

(1).访问：http://localhost:8080/springdataredis/student/find/all

分布式缓存技术redis学习—— 深入理解Spring Redis的使用

(2).点击create，去创建一个student.

分布式缓存技术redis学习—— 深入理解Spring Redis的使用

(3).点击submit,提交表单，保存刚创建的student,然后系统会跳转到list页面。

分布式缓存技术redis学习—— 深入理解Spring Redis的使用

(4).点击update,去更新student.

分布式缓存技术redis学习—— 深入理解Spring Redis的使用

(5).点击submit,保存刚才的更新，然后跳转到list页面。

分布式缓存技术redis学习—— 深入理解Spring Redis的使用

(6).点击delete,删除student

分布式缓存技术redis学习—— 深入理解Spring Redis的使用

些许总结：

1. RedisTemplate的事务：

  1. private boolean enableTransactionSupport = false;
  2. private boolean exposeConnection = false;
  3. private boolean initialized = false;
  4. private boolean enableDefaultSerializer = true;
  5. private RedisSerializer<?> defaultSerializer = new JdkSerializationRedisSerializer();
  6. private RedisSerializer keySerializer = null;
  7. private RedisSerializer valueSerializer = null;
  8. private RedisSerializer hashKeySerializer = null;
  9. private RedisSerializer hashValueSerializer = null;
  10. private RedisSerializer<String> stringSerializer = new StringRedisSerializer();
  11. private ScriptExecutor<K> scriptExecutor;
  12. // cache singleton objects (where possible)
  13. private ValueOperations<K, V> valueOps;
  14. private ListOperations<K, V> listOps;
  15. private SetOperations<K, V> setOps;
  16. private ZSetOperations<K, V> zSetOps;

enableTransactionSupport：是否启用事务支持。我们在代码中搜索下用到这个变量的地方，会看到，在调用RedisCallback之前，有一行代码是如果启用事务支持，那么conn = RedisConnectionUtils.bindConnection(factory, enableTransactionSupport)，也就是说，系统自动帮我们拿到了事务中绑定的连接。可以在一个方法的多次对Redis增删该查中，始终使用同一个连接。但是，即使使用了同样的连接，没有进行connection.multi()和connection.exec()，依然是无法启用事务的。我没有仔细的查阅代码，但是可以知道的是，Spring已经对这个，给了我们一个更好的支持：@Transactional ， 在调用RedisTempalte中的execute()方法的地方，加入这个注解(是spring包下面提供的，不要引用成rt包下的注解)，能让这个方法中的所有execute，自动加入multi()以及异常的回滚或者是正常运行时候的提交！
 2. RedisTempalte的Serializer
用过jedis操作的都知道，所有connection的操作方法，都是传入字节数组。那么，将一个对象和字节相互转换，就需要通过序列化和反序列化。模版方法中，Spring提供了默认的StringSerializer和JdkSerializer，第一个很简单，就是通过String.getBytes()来实现的。而且在Redis中，所有存储的值都是字符串类型的。所以这种方法保存后，通过Redis-cli控制台，是可以清楚的查看到我们保存了什么key,value是什么。但是对于JdkSerializationRedisSerializer来说，这个序列化方法就是Jdk提供的了。首先要求我们要被序列化的类继承自Serializeable接口，然后通过，然后通过Jdk对象序列化的方法保存。（注：这个序列化保存的对象，即使是个String类型的，在redis控制台，也是看不出来的，因为它保存了一些对象的类型什么的额外信息）。
keySerializer:这个是对key的默认序列化器。默认值是StringSerializer。
valueSerializer:这个是对value的默认序列化器，默认值是取自DefaultSerializer的JdkSerializationRedisSerializer。
hashKeySerializer:对hash结构数据的hashkey序列化器，默认值是取自DefaultSerializer的JdkSerializationRedisSerializer。

hashValueSerializer：对hash结构数据的hashvalue序列化器，默认值是取自DefaultSerializer的JdkSerializationRedisSerializer。

更多详细源码参考来源：http://minglisoft.cn/technology 欢迎大家一起学习研究相关技术，源码获取请加求求（企鹅）: 2042849237

相关文章