Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解

时间 2019-11-13

标签 spring data redis 简介以及项目 demo redistemplate serializer 详解栏目 Spring 繁體版

原文原文链接

1、概念简介：java

Redis：git

　　Redis是一款开源的Key-Value数据库，运行在内存中，由ANSI C编写，详细的信息在Redis官网上面有，由于我本身经过google等各类渠道去学习Redis，走了很多弯路，因此总结一条我认为不错的学习路径给你们：github

　　1.《The Little Redis Book》web

是一本开源PDF，只有29页的英文文档，看完后对Redis的基本概念应该差很少熟悉了，剩下的能够去Redis官网熟悉相关的命令。redis

　　2.《Redis设计与实现》spring

若是想继续深刻，推荐这本书，如今已经出到第二版了，有纸质版书籍能够购买。上面详细介绍了Redis的一些设计理念，而且给出了一些内部实现方式，和数据结构的C语言定义，有一些基本C语言基础，就能看明白。数据库

　　3.Redis 2.6源代码：apache

《Redis设计与实现》的做者发布在Github上的一个开源项目，有做者详细的注释。编程

https://github.com/huangz1990/annotated_redis_source数组

Jedis:

　　Jedis是Redis官方推出的一款面向Java的客户端，提供了不少接口供Java语言调用。能够在Redis官网下载，固然还有一些开源爱好者提供的客户端，如Jredis、SRP等等，推荐使用Jedis。

Spring Data Redis

　　SDR是Spring官方推出，能够算是Spring框架集成Redis操做的一个子框架，封装了Redis的不少命令，能够很方便的使用Spring操做Redis数据库，Spring对不少工具都提供了相似的集成，如Spring Data MongDB…

　　这三个究竟有什么区别呢？能够简单的这么理解，Redis是用ANSI C写的一个基于内存的Key-Value数据库，而Jedis是Redis官方推出的面向Java的Client，提供了不少接口和方法，可让Java操做使用Redis，而Spring Data Redis是对Jedis进行了封装，集成了Jedis的一些命令和方法，能够与Spring整合。在后面的配置文件（redis-context.xml）中能够看到，Spring是经过Jedis类来初始化connectionFactory的。

2、Spring Data Redis Demo

项目目录：

Pom.xml配置：　

　　Spring jar由于比较多，就不贴出来了，读者能够下载后面的项目源码查看详细配置，其实pom.xml能够精简，并不是必定须要写的这么细，我之因此这么写，是为了看得更清楚。

 1 <!-- config junit jar -->
 2         <dependency>
 3             <groupId>junit</groupId>
 4             <artifactId>junit</artifactId>
 5             <version>4.8.2</version>
 6             <scope>test</scope>
 7         </dependency>
 8         <!-- config redis data and client jar -->        
 9         <dependency>
10             <groupId>org.springframework.data</groupId>
11             <artifactId>spring-data-redis</artifactId>
12             <version>1.0.2.RELEASE</version>
13         </dependency>
14         <dependency>
15             <groupId>redis.clients</groupId>
16             <artifactId>jedis</artifactId>
17             <version>2.1.0</version>
18         </dependency>
19 
20         <!-- config need jar -->
21         <dependency>
22             <groupId>commons-lang</groupId>
23             <artifactId>commons-lang</artifactId>
24             <version>2.6</version>
25         </dependency>
26         <dependency>
27             <groupId>org.apache.geronimo.specs</groupId>
28             <artifactId>geronimo-servlet_3.0_spec</artifactId>
29             <version>1.0</version>
30         </dependency>
31     <!-- cofig spring jar -->
32         <dependency>
33             <groupId>org.springframework</groupId>
34             <artifactId>spring-core</artifactId>
35             <version>${org.springframework.version}</version>
36         </dependency>
37     ……

redis.properties配置（WEB-INF/property/redis.properties）

　　从properties文件的内容就知道这个文件是干吗的了，主要是redis链接池基本配置，详细的配置能够查看redis文档。

redis.host=127.0.0.1
redis.port=6379
redis.pass=
  
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true

spring-context.xml(WEB-INF/config/spring-context.xml)

　　Spring配置，这个也没什么说的，就是springMVC的一些基本配置，开启注解扫描功能和扫描路径。

 1 <!-- 激活@Controller模式 -->
 2     <mvc:annotation-driven />
 3     
 4     <context:annotation-config />  
 5     
 6     <!-- 对包中的全部类进行扫描，以完成Bean建立和自动依赖注入的功能 -->
 7     <context:component-scan base-package="com.chr" />
 8 
 9     
10     <!-- 引入redis属性配置文件 -->
11     <import resource="redis-context.xml"/>

redis-context.xml(WEB/config/redis-context.xml)

　　Spring配置redis，这些配置都比较基本，看文档就行了，可是有一个比较重要的点，就是redistemplate的Serializer配置，在后面经过SDR（Spring Data Redis）封装的一些方法操做Redis时会说到。

 1 <!-- scanner redis properties -->
 2     <context:property-placeholder location="classpath:property/redis.properties" />
 3 <!—注意此处注入的是JedisPoolConfig，说明SDR还依赖与Jedis -->
 4     <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
 5         <property name="maxIdle" value="${redis.maxIdle}" />
 6         <property name="maxActive" value="${redis.maxActive}" />
 7         <property name="maxWait" value="${redis.maxWait}" />
 8         <property name="testOnBorrow" value="${redis.testOnBorrow}" />
 9     </bean>
10 
11     <bean id="connectionFactory"
12         class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
13         p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"
14         p:pool-config-ref="poolConfig" />
15 
16     <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
17         <property name="connectionFactory" ref="connectionFactory" />
18 <!--         若是不配置Serializer，那么存储的时候智能使用String，若是用User类型存储，那么会提示错误User can't cast to String！！！
19  -->        <property name="keySerializer">
20             <bean
21                 class="org.springframework.data.redis.serializer.StringRedisSerializer" />
22         </property>
23         <property name="valueSerializer">
24             <bean
25                 class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
26         </property>
27     </bean>
28     
29     <bean id="viewResolver"  
30         class="org.springframework.web.servlet.view.InternalResourceViewResolver" />

web.xml

　　web.xml中只配置了spring-context.Xml，这是由于我在spring-context.xml中加了一条语句：<import resource="redis-context.xml"/>，因此看起来有两个配置，其实只须要配置spring-context.xml。这样作的好处是：项目的层次比较清晰，方便后期改动。

 1     <listener>
 2         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 3     </listener>
 4 
 5     <context-param>
 6         <param-name>contextConfigLocation</param-name>
 7         <param-value>/WEB-INF/config/spring-context.xml</param-value>
 8     </context-param>
 9 
10      <servlet>
11         <servlet-name>SpringMVC</servlet-name>
12         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
13         <init-param>
14                  <param-name>contextConfigLocation</param-name>
15                  <param-value>/WEB-INF/config/spring-context.xml</param-value>
16          </init-param>
17          <load-on-startup>2</load-on-startup>
18     </servlet>
19     
20     <servlet-mapping>
21         <servlet-name>SpringMVC</servlet-name>
22         <url-pattern>/</url-pattern>
23     </servlet-mapping>

下面是Spring MVC的java实现了：

User.java（实体类， com.chr.domain.User.java）

　　注意User类必须实现Serializable接口，后面会解释。User类总共定义了三个字段：id、name、password。省略了相应的setter/getter方法。

 1 public class User implements Serializable {
 2     private static final long serialVersionUID = 522889572773714584L;
 3     
 4     private String id;
 5     private String name;
 6     private String password;
 7     
 8     public User() {}
 9     
10     public User(String id,String name,String password) {
11         this.id = id;
12         this.name = name;
13         this.password = password;
14     }

UserOperationsService.java（service接口，com.chr.service.UserOperationsService.java）

　　在service接口中定义了两个方法：

　　Add方法用于向redis中添加User实例，getUser则从redis中取出User实例。

1 public interface UserOperationsService {
2     void add(User user);
3     User getUser(String key);
4     
5 }

UserOperationsServiceImpl.java（service的实现类，实现service借口 com.chr.service.impl. UserOperationsServiceImpl.java）

 1 @Service
 2 public class UserOperationsServiceImpl implements UserOperationsService {
 3     @Autowired
 4     private RedisTemplate redisTemplate;
 5 
 6     @Override
 7     public void add(User user) {
 8         // TODO Auto-generated method stub
 9         /*
10          * boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
11          * public Boolean doInRedis(RedisConnection redisConnection) throws
12          * DataAccessException { RedisSerializer<String> redisSerializer =
13          * redisTemplate .getStringSerializer(); byte[] key =
14          * redisSerializer.serialize(user.getId()); byte[] value =
15          * redisSerializer.serialize(user.getName()); return
16          * redisConnection.setNX(key, value); } }); return result;
17          */
18         ValueOperations<String, User> valueops = redisTemplate
19                 .opsForValue();
20         valueops.set(user.getId(), user);
21     }
22 
23 
24     @Override
25     public User getUser(String key) {
26         ValueOperations<String, User> valueops = redisTemplate
27                 .opsForValue();
28         User user = valueops.get(key);
29         return user;
30     }
31 
32 }

　　RedisTemplate和 Serializer详解

　　能够看到我在代码中注释掉了一段代码，如今能够解释上面留下的两个问题了，第一个是在redis.xml中配置redistemplate的时候，同时配置了两个Serializer：keySerializer实现了StringRedisSerializer，valueSerializer实现了JdkSerializationRedisSerializer。

　　1、为何要使用Serializer

　　由于redis是以key-value的形式将数据存在内存中，key就是简单的string，key彷佛没有长度限制，不过原则上应该尽量的短小且可读性强，不管是否基于持久存储，key在服务的整个生命周期中都会在内存中，所以减少key的尺寸能够有效的节约内存，同时也能优化key检索的效率。

　　value在redis中，存储层面仍然基于string，在逻辑层面，能够是string/set/list/map，不过redis为了性能考虑，使用不一样的“encoding”数据结构类型来表示它们。(例如：linkedlist，ziplist等)。

　　因此能够理解为，其实redis在存储数据时，都把数据转化成了byte[]数组的形式，那么在存取数据时，须要将数据格式进行转化，那么就要用到序列化和反序列化了，这也就是为何须要配置Serializer的缘由。

　　2、SDR支持的序列化策略：

（详细可查阅API文档）

JdkSerializationRedisSerializer：
StringRedisSerializer：
JacksonJsonRedisSerializer：
OxmSerializer：

　　其中JdkSerializationRedisSerializer和StringRedisSerializer是最基础的序列化策略，其中“JacksonJsonRedisSerializer”与“OxmSerializer”都是基于stirng存储，所以它们是较为“高级”的序列化(最终仍是使用string解析以及构建java对象)。

　　基本推荐使用JdkSerializationRedisSerializer和StringRedisSerializer，由于其余两个序列化策略使用起来配置很麻烦，若是实在有须要序列化成Json和XML格式，可使用java代码将String转化成相应的Json和XML。

　　3、使用Serializer

　　在本项目中，是在配置文件中直接配置了相应的Serializer，key用的是StringRedisSerializer，value用的是JdkSerializationRedisSerializer，由于在此项目中，key为userId,为String类型，value为user为java类，即POJO，因此使用JdkSerializationRedisSerializer。

　　在redistemplate中直接配置Serializer固然比较方便，由于在后面想redis中存取数据时，就不用再次配置Serializer，可是这仅限于只有一种数据类型的状况，好比在本项目中只有<String userId,User user>类型的数据须要存储，若是有多种数据类型时，在配置文件中配置就显得不方便了，那么咱们能够在存取数据时，即Service的实现类存取数据操做时分别指定相应的Serializer。

　　因此在编程时有两种选择：

　　　　1.在redistemplate中配置Serializer（本项目即采用这种方式）

ValueOperations<String, User> valueops = redisTemplate
                .opsForValue();
valueops.set(user.getId(), user);

　　　　2.不在redistemplate中配置Serializer，而是在Service的实现类中单独指定Serializer。就如同UserOperationsServiceImpl.java注释的代码：

1 boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
2      public Boolean doInRedis(RedisConnection redisConnection) throws DataAccessException { 
3          RedisSerializer<String> redisSerializer = redisTemplate .getStringSerializer(); 
4          byte[] key = redisSerializer.serialize(user.getId());
5          byte[] value = redisSerializer.serialize(user.getName()); 
6          return redisConnection.setNX(key, value); } }); 
7     return result;
8 }

　　4、Redistemplate

　　SDR官方文档中对Redistemplate的介绍：the template is in fact the central class of the Redis module due to its rich feature set. The template offers a high-level abstraction for Redis interactions.

　　经过Redistemplate能够调用ValueOperations和ListOperations等等方法，分别是对Redis命令的高级封装。

　　可是ValueOperations等等这些命令最终是要转化成为RedisCallback来执行的。也就是说经过使用RedisCallback能够实现更强的功能，SDR文档对RedisCallback的介绍：RedisTemplate and StringRedisTemplate allow the developer to talk directly to Redis through the RedisCallback interface. This gives complete control to the developer as it talks directly to the RedisConnection。

　　具体的使用方法能够参考Api文档。

UserController.java（控制器类,com.chr.controller）

 1 @Controller
 2 @RequestMapping(value = "/redis")
 3 public class UserController {
 4     @Autowired
 5     private UserOperationsServiceImpl userOperationsService;
 6     private User user;
 7 
 8     @RequestMapping(value = "/addUser", method = RequestMethod.POST)
 9     public String addUser(
10             @RequestParam(value = "Id", required = true) String Id,
11             @RequestParam(value = "name", required = true) String name,
12             @RequestParam(value = "password", required = true) String password) {
13         user = new User(Id, name, password);
14         userOperationsService.add(user);
15         return "/WEB-INF/jsp/AddUserSuccess.jsp";
16     }
17 
18     @RequestMapping(value = "/addUser", method = RequestMethod.GET)
19     public String addUser() {
20         return "/WEB-INF/jsp/AddUser.jsp";
21     }
22 }

　　这里只贴出了部分代码（addUser的代码），剩下的getUser代码相似，能够下载源码查看。

其中分为两种方法，get和post，get方法直接return到表单填写页面，从而实现post到addUser添加User。

AddUser.jsp

<form id="addUser" name="addUser" action="redis/addUser" method="post">
                ID:<input id="Id" name="Id" type="text" /><br/>
                Name:<input id="name" name="name" type="text" /><br/> 
                Password:<input id="password" name="password" type="password" /><br/>
                <input value="添加"
                    type="submit" />
</form>

3、部署运行

最后部署到Tomcat中，浏览器运行：http://localhost:8080/redis-web/redis/addUser

填写信息，单击添加Button后，即跳转到结果页面

整个项目只是一个展现Spring整合Redis基本使用的Demo，因本人知识有限，如文中有错误或偏颇之处，请各位提出。很是感谢：）

4、项目源码：

http://files.cnblogs.com/edwinchen/redis-web.rar

Jdk 1.7

MyEclipse 10.1