Redis及Spring-Data-Redis入门学习

Redis及Spring-Data-Redis入门学习

九月 24, 2018

继上一篇Solr和Spring Data Solr学习,我们思考一个问题,使用Solr的目的是什么?肯定是为了加快服务器的相应速度。因为即使不适用Solr,通过请求数据库我们一样能完成搜索功能,但是这样会给服务器造成很大的压力。

而Solr仅仅是在搜索功能中用到了,但是大量请求的数据不仅仅出现在搜索中,比如用户的登录信息,虽然数据量很小,但是整个项目每刷新一次页面都要请求一次用户登录的Token信息,也会拖慢服务器的响应速度。我们通常有两中解决方式:1.数据缓存;2.网页静态化。

其实我们在Shiro实现用户-角色-权限管理系统中已经用到了缓存技术,今天我们了解一下Redis缓存技术。

安装Redis

Redis是一款开源的Key-Value数据库。首先我们要去 官网 下载Redis,由于笔者使用的是MacOS系统,和Windows系统有所不同。

安装过程不再叙述,这里提供两个教程:


启动Redis

1
2
redis-server 
redis-server &

建议使用第二个命令,用第二个命令启动了redis server后能继续输入命令,使用第一个命令则不行。

如果终端中显示如下logo表示redis启动成功:


操纵Redis

上面仅仅是启动了Redis Server,但Redis是一种Key-Value型数据库,也包含了一些查询数据库的命令,操作redis命令的入口就是: redis/bin/redis-cli

1
2
3
./bin/redis-cli

redis-cli

  1. 查看当前(db0)数据库中所有的key值: keys *
  2. 清空当前数据库中所有的数据: flushall

更多的Redis命令可以参看:redis中文文档


Spring Data Redis

之前学习Solr的时候用到了Spring Data Solr,现在学习Redis,Spring提供了Spring Data Redis用来实现通过配置文件的方式访问redis服务。Spring Data Redis对Redis底层开发包(Jedis, JRedis, and RJC)进行了高度封装,RedisTemplate提供了redis各种操作、异常处理及序列化。

Jedis

Jedis是Redis官方推出的一款面向Java的客户端,提供了很多借口供Java语言调用。

Spring Data Redis针对Jedis提供了如下功能:

  • 1.连接池自动管理,提供了一个高度封住的RedisTemplate类。
  • 2.针对jedis客户端中大量api进行归类封装,将同一类型操作封装为operation接口:
    ValueOperations: 简单的K-V操作
    SetOperations: set类型数据操作
    ZSetOperations: zset类型数据操作
    HashOperations: 针对Map类型的数据操作
    ListOperations: 针对List类型的数据操作
    

准备

导入依赖

1
2
3
4
5
6
7
8
9
10
<dependency> 
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.8.1</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.7.2.RELEASE</version>
</dependency>

创建redis-config.properties

1
2
3
4
5
6
7
redis.host=127.0.0.1 
redis.port=6379
redis.pass=
redis.database=0
redis.maxIdle=300
redis.maxWait=3000
redis.testOnBorrow=true

解释

  1. redis.host是安装redis server的客户端IP地址,如果安装在本机上就是127.0.0.1,如果安装在服务器上请修改为服务器的IP地址。
  2. redis.port是redis server的默认端口,你安装了redis,就默认使用这个端口号。
  3. redis.pass是访问redis server的密码,一般我们不设置。
  4. redis.database=0代表使用的是redis默认提供的db0这个数据库。
  5. redis-maxIdle是redis server的最大空闲数。
  6. redis-maxWait是连接redis时的最大等待毫秒数。
  7. redis-testOnBorrow在提取一个redis实例时,是否提前进行验证操作;如果为true,则得到的jedis实例均是可用的。

创建spring-redis.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<context:property-placeholder location="classpath:other/*.properties"/>
<!-- redis 相关配置 -->
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!-- 最大空闲数 -->
<property name="maxIdle" value="${redis.maxIdle}"/>
<!-- 连接时最大的等待时间(毫秒) -->
<property name="maxWaitMillis" value="${redis.maxWait}"/>
<!-- 在提取一个jedis实例时,是否提前进行验证操作;如果为true,则得到的jedis实例均是可用的 -->
<property name="testOnBorrow" value="${redis.testOnBorrow}"/>
</bean>
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="hostName" value="${redis.host}"/>
<property name="port" value="${redis.port}"/>
<property name="password" value="${redis.pass}"/>
<property name="poolConfig" ref="poolConfig"/>
</bean>

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory"/>
</bean>
</bean>

实例

本实例源码:Github

首先加载配置文件spring-redis.xml,注入RedisTemplate模板类:

1
2
@Autowired
private RedisTemplate redisTemplate;

值类型

RedisTemplate提供的很多操作redis数据库的方法都是boundxxOps这种。

添加

1
2
3
4
@Test
public void setValue(){
redisTemplate.boundValueOps("name").set("tycoding");
}

如果配置都正常的情况下,运行此方法就能向db0数据库中添加一条key为name的记录;那么我们在redis命令行中查看所有的key:

奇怪,我添加的key明明是name,为什么查出来的确实一堆乱码值呢?我们再使用redis命令行单独添加一条记录:

1
set testK testV

此时我们又发现,使用redis原生命令添加的数据是不会乱码的;那么就肯定是Spring Data Redis的原因了。经查询是因为redisTemplate模板类在操作redis序列化的原因,我们要手动配置序列化方式为:StringRedisSerializer

修改之前创建的spring-redis.xml配置文件:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory"/>

<!-- 序列化策略 推荐使用StringRedisSerializer -->
<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
</property>
<property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
</property>
</bean>

再次添加数据

查询

1
2
3
4
5
@Test
public void getValue(){
Object name = redisTemplate.boundValueOps("name").get();
System.out.println(name);
}

删除

1
2
3
4
@Test
public void deleteValue(){
redisTemplate.delete("name");
}

Set类型

添加

1
2
3
4
@Test
public void setValueBySet(){
redisTemplate.boundSetOps("nameset").add("tycoding");
}

查询

1
2
3
4
5
@Test
public void getValueBySet(){
Set nameset = redisTemplate.boundSetOps("nameset").members();
System.out.println(nameset);
}

删除Set中某一个值

1
2
3
4
@Test
public void deleteValueBySet(){
redisTemplate.boundSetOps("nameset").remove("涂陌");
}

删除整个Set

1
2
3
4
@Test
public void deleteAllValueByset(){
redisTemplate.delete("nameset");
}

List类型

右压栈

右压栈,后添加的对象排在后边

1
2
3
4
5
@Test
public void setRightValueByList(){
redisTemplate.boundListOps("namelist").rightPush("tycoding");
redisTemplate.boundListOps("namelist").rightPush("涂陌");
}

显示右压栈集合

1
2
3
4
5
@Test
public void getRightValueByListI(){
List namelist = redisTemplate.boundListOps("namelist").range(0, 10);
System.out.println(namelist);
}

左压栈

左压栈,后添加的对象排在前面

1
2
3
4
5
@Test
public void setLeftValueByList(){
redisTemplate.boundListOps("namelist2").leftPush("tycoding");
redisTemplate.boundListOps("namelist2").leftPush("涂陌");
}

显示左压栈的集合:

1
2
3
4
5
@Test
public void getLeftValueByList(){
List name2 = redisTemplate.boundListOps("namelist2").range(0, 10);
System.out.println(name2);
}

根据索引查询集合中的元素

1
2
3
4
5
@Test
public void searchByIndex(){
Object namelist = redisTemplate.boundListOps("namelist").index(1);
System.out.println(namelist);
}

Hash类型

添加

1
2
3
4
@Test
public void setValueByHash(){
redisTemplate.boundHashOps("namehash").put("a","tycoding");
}

提取所有的KEY

1
2
3
4
5
@Test
public void getKeysByHash(){
Set namehash = redisTemplate.boundHashOps("namehash").keys();
System.out.println(namehash);
}

提取所有的VALUE

1
2
3
4
5
@Test
public void getValuesByHash(){
List namehash = redisTemplate.boundHashOps("namehash").values();
System.out.println(namehash);
}

根据KEY取值

1
2
3
4
5
@Test
public void getValueByHash(){
Object o = redisTemplate.boundHashOps("namehash").get("a");
System.out.println(o);
}

根据KEY移除值

1
2
3
4
@Test
public void deleteValueByHash(){
redisTemplate.boundHashOps("namehash").delete("a");
}


测试

上面说了一大堆,没有实际的测试,着实不清楚Redis究竟效果如何,是不是真的提高了访问速度?

下面我们以查询数据库所有值的功能来看一下使用Redis缓存和未使用缓存直接查询数据库所用时间。

本例源码地址:Github

未使用Redis缓存,直接请求数据库

1
2
3
public List<Goods> findAll() {
return goodsMapper.findAll();
}

使用了Redis缓存

首先通过boundHashOps获取Redis数据库中是否存在KEY为all的数据,有的话就返回;没有的话就查询数据库并将查询到的数据添加到Redis数据库中,且KEY为all

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public List<Goods> findAll() {
List<Goods> contentList = (List<Goods>) redisTemplate.boundHashOps("goods").get("all");
if (contentList == null) {
//说明缓存中没有数据
System.out.println("从数据库中读取数据放入redis...");
contentList = goodsMapper.findAll();
redisTemplate.boundHashOps("goods").put("all", contentList); //存入redis中
} else {
System.out.println("从缓存中读取数据...");
}

// return goodsMapper.findAll();
return contentList;
}

TestTime.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void run1() {
Long startTime = System.currentTimeMillis(); //开始时间
goodsMapper.findAll();
Long endTime = System.currentTimeMillis(); //结束时间
System.out.println("查询数据库--共耗时:" + (endTime - startTime) + "毫秒"); //1007毫秒
}

@Test
public void run2() {
Long startTime = System.currentTimeMillis(); //开始时间
goodsService.findAll();
Long endTime = System.currentTimeMillis(); //结束时间
System.out.println("从redis中读取所有数据,共耗时:" + (endTime - startTime) + "毫秒");
}

在测试类中调用Service层的这两个方法,得到的结果如下:

1
2
3
查询数据库--共耗时:1047毫秒

从redis中读取所有数据,共耗时:197毫秒


交流

如果大家有兴趣,欢迎大家加入我的Java交流群:671017003 ,一起交流学习Java技术。博主目前一直在自学JAVA中,技术有限,如果可以,会尽力给大家提供一些帮助,或是一些学习方法,当然群里的大佬都会积极给新手答疑的。所以,别犹豫,快来加入我们吧!


联系

If you have some questions after you see this article, you can contact me or you can find some info by clicking these links.