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

时间：2023-02-03 10:11:59

一、概念简介：

Redis：

　　Redis是一款开源的Key-Value数据库，运行在内存中，由ANSI C编写，详细的信息在Redis官网上面有，因为我自己通过google等各种渠道去学习Redis，走了不少弯路，所以总结一条我认为不错的学习路径给大家：

　　1.《The Little Redis Book》

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

　　2.《Redis设计与实现》

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

　　3.Redis 2.6源代码：

《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的。

 

二、Spring Data Redis Demo

本来是通过转账别人的文章来记录的，发现都不是很全面，所以只有靠自己来玩耍了，结合目前公司实际用例来写java redis。

点击打开链接下载项目 https://github.com/yangchangyong0/spring-redis-web

1、首先配置pom

demo是最简单了，但是来的最实际。项目是我用网络别人的例子但是做一些基础讲解 首先引入pom文件，如果你嫌弃就不看pom文件吧 [java] view plain copy Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  3.     <modelVersion>4.0.0</modelVersion>  
  4.     <groupId>redis-web</groupId>  
  5.     <artifactId>redis-web</artifactId>  
  6.     <version>1.0.0-SNAPSHOT</version>  
  7.     <packaging>war</packaging>  
  8.     <name/>  
  9.     <description/>  
  10.     <properties>  
  11.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>  
  12.         <org.springframework.version>4.2.2.RELEASE</org.springframework.version>  
  13.     </properties>  
  14.     <dependencies>  
  15.         <!-- config junit jar -->  
  16.         <dependency>  
  17.             <groupId>junit</groupId>  
  18.             <artifactId>junit</artifactId>  
  19.             <version>4.12</version>  
  20.             <scope>test</scope>  
  21.         </dependency>  
  22.         <!-- config need jar -->  
  23.         <dependency>  
  24.             <groupId>commons-lang</groupId>  
  25.             <artifactId>commons-lang</artifactId>  
  26.             <version>2.6</version>  
  27.         </dependency>  
  28.         <!-- cofig spring jar -->  
  29.         <dependency>  
  30.             <groupId>org.springframework</groupId>  
  31.             <artifactId>spring-core</artifactId>  
  32.             <version>${org.springframework.version}</version>  
  33.         </dependency>  
  34.         <dependency>  
  35.             <groupId>org.springframework</groupId>  
  36.             <artifactId>spring-web</artifactId>  
  37.             <version>${org.springframework.version}</version>  
  38.         </dependency>  
  39.         <dependency>  
  40.             <groupId>org.springframework</groupId>  
  41.             <artifactId>spring-webmvc</artifactId>  
  42.             <version>${org.springframework.version}</version>  
  43.         </dependency>  
  44.   
  45.         <dependency>  
  46.             <groupId>org.springframework</groupId>  
  47.             <artifactId>spring-test</artifactId>  
  48.             <version>${org.springframework.version}</version>  
  49.             <scope>test</scope>  
  50.         </dependency>  
  51.         <!--servlet-->  
  52.         <dependency>  
  53.             <groupId>javax.servlet</groupId>  
  54.             <artifactId>servlet-api</artifactId>  
  55.             <version>2.5</version>  
  56.             <scope>provided</scope>  
  57.         </dependency>  
  58.         <dependency>  
  59.             <groupId>javax.servlet</groupId>  
  60.             <artifactId>jsp-api</artifactId>  
  61.             <version>2.0</version>  
  62.             <scope>provided</scope>  
  63.         </dependency>  
  64.         <dependency>  
  65.             <groupId>javax.servlet</groupId>  
  66.             <artifactId>jstl</artifactId>  
  67.             <version>1.2</version>  
  68.         </dependency>  
  69.   
  70.         <!-- config redis data and client jar -->  
  71.         <dependency>  
  72.             <groupId>org.springframework.data</groupId>  
  73.             <artifactId>spring-data-redis</artifactId>  
  74.             <version>1.6.4.RELEASE</version>  
  75.         </dependency>  
  76.         <dependency>  
  77.             <groupId>redis.clients</groupId>  
  78.             <artifactId>jedis</artifactId>  
  79.             <version>2.8.1</version>  
  80.         </dependency>  
  81.     </dependencies>  
  82.   
  83. </project>  

2、spring-redis配置文件

 spring的配置文件当然首当其冲

2.1 spring-context.xml

[java] view plain copy Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解
  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" xmlns:p="http://www.springframework.org/schema/p"  
  4.        xmlns:mvc="http://www.springframework.org/schema/mvc"  
  5.        xmlns:context="http://www.springframework.org/schema/context"  
  6.        xmlns:util="http://www.springframework.org/schema/util"  
  7.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  8.             http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd    
  9.             http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd                
  10.             http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">  
  11.     <!-- 激活@Controller模式 -->  
  12.     <mvc:annotation-driven/>  
  13.     <!--注册BeanPostProcessor-->  
  14.     <context:annotation-config/>  
  15.     <!-- 对包中的所有类进行扫描，以完成Bean创建和自动依赖注入的功能 -->  
  16.     <context:component-scan base-package="com.ycy"/>  
  17.   
  18.     <!-- 引入redis属性配置文件 -->  
  19.     <import resource="redis-context.xml"/>  
  20.   
  21. </beans>  

2.2 reis-context.xml

spring-data-redis非常简单一共就三步骤
  •  配置连接池
  • 配置连接工厂
  • 配置redis模板
[java] view plain copy Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解
  1. <beans xmlns="http://www.springframework.org/schema/beans"  
  2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
  3.        xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"  
  4.        xsi:schemaLocation="  
  5.             http://www.springframework.org/schema/beans   
  6.             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7.             http://www.springframework.org/schema/tx   
  8.             http://www.springframework.org/schema/tx/spring-tx-3.0.xsd  
  9.             http://www.springframework.org/schema/context  
  10.             http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  11.                ">  
  12.   
  13.     <!-- scanner redis properties1\配置连接池 -->  
  14.     <context:property-placeholder location="classpath:property/redis.properties"/>  
  15.   
  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.     <!--配置连接工厂-->  
  23.     <bean id="connectionFactory"  
  24.           class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
  25.           p:hostName="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}"  
  26.           p:poolConfig-ref="poolConfig"/>  
  27.     <!--配置redis模板-->  
  28.     <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">  
  29.         <property name="connectionFactory" ref="connectionFactory"/>  
  30.         <!--         默认如下(只列出key与value)-->  
  31.         <property name="keySerializer">  
  32.             <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>  
  33.         </property>  
  34.         <property name="valueSerializer">  
  35.             <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>  
  36.         </property>  
  37.     </bean>  
  38.   
  39. </beans>  

3、redis模板的使用

3.1 序列化

实践表明存储更小的字节，对于redis更快，所以我们key使用string，value使用序列号与反序列化,
我们可以观察上面的keySerializer 与valueSerializer，就是这么使用的，当然还有很多序列号类型 我用的目前比较新的如下， Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解

  • keySerializer:这个是对key的默认序列化器。默认值是StringSerializer。
  • 　　valueSerializer:这个是对value的默认序列化器，默认值是取自DefaultSerializer的JdkSerializationRedisSerializer。
  • 　　hashKeySerializer:对hash结构数据的hashkey序列化器，默认值是取自DefaultSerializer的JdkSerializationRedisSerializer。
  • 　　hashValueSerializer：对hash结构数据的hashvalue序列化器，默认值是取自DefaultSerializer的JdkSerializationRedisSerializer。

3.2 事物

 目前即使使用事物，它也不会回滚，反正我试了一下。使用spring的话就用springjdbc的事物回滚吧，执行不到就OK。所以redis事物本身没有什么可以讲解

4、使用模板编程

例子中我们使用redis模板实现添加用户和得到用户，至于其他代码，可以下载项目看一看就懂了 [java] view plain copy Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解Spring Data Redis简介以及项目Demo，RedisTemplate和 Serializer详解
  1. package com.ycy.service.impl;  
  2.   
  3. import org.springframework.beans.factory.annotation.Autowired;  
  4. import org.springframework.data.redis.core.*;  
  5. import org.springframework.stereotype.Service;  
  6.   
  7. import com.ycy.domain.User;  
  8. import com.ycy.service.UserOperationsService;  
  9. import org.springframework.transaction.annotation.Transactional;  
  10.   
  11. /** 
  12.  * @author ycy 
  13.  * 
  14.  */  
  15. @Service  
  16. public class UserOperationsServiceImpl implements UserOperationsService {  
  17.     @Autowired  
  18.     private RedisTemplate redisTemplate;  
  19.   
  20.     @Transactional  
  21.     @Override  
  22.     public void add(User user) {  
  23.         // TODO Auto-generated method stub  
  24.         /* 
  25.          * boolean result = redisTemplate.execute(new RedisCallback<Boolean>() { 
  26.          * public Boolean doInRedis(RedisConnection redisConnection) throws 
  27.          * DataAccessException { RedisSerializer<String> redisSerializer = 
  28.          * redisTemplate .getStringSerializer(); byte[] key = 
  29.          * redisSerializer.serialize(user.getId()); byte[] value = 
  30.          * redisSerializer.serialize(user.getName()); return 
  31.          * redisConnection.setNX(key, value); } }); return result; 
  32.          */  
  33.         ValueOperations<String, User> valueops = redisTemplate  
  34.                 .opsForValue();  
  35.         valueops.set(user.getId(), user);  
  36.     }  
  37.   
  38.   
  39.     @Override  
  40.     public User getUser(String key) {  
  41.         ValueOperations<String, User> valueops = redisTemplate  
  42.                 .opsForValue();  
  43.         User user = valueops.get(key);  
  44.         return user;  
  45.     }  
  46.   
  47. }  
点击打开链接下载项目 https://github.com/yangchangyong0/spring-redis-web
标签：

相关文章