使用Redis作缓存

在项目开发过程中，针对并发量较大、查询频率较高的数据，如果还是直接查询数据库，会使数据库压力过大造成系统响应速度下降。可以选择使用缓存技术对这些常用数据进行缓存，在查询这些数据时先从缓存中查，如果查询到数据，直接返回不用查询数据库。Redis就是一个优秀的nosql数据缓存技术。

Redis是nosql非关系型数据库，数据结构以key-value的形式，每个key对应唯一一个value，同时由于Redis数据是运行在内存中的，查询效率非常高，但是又因为是直接占用内存资源的，一般只对高频率的数据进行缓存。

在项目中使用Redis缓存原因：
1.减轻数据库压力
2.提高查询效率

Redis的数据结构为key-value，其中value支持五种格数数据：
1.字符串（strings）
2.字符串列表（lists）
3.字符串集合（sets）
4.有序字符串集合（sorted sets）
5.哈希（hashes）

在项目中使用Redis缓存流程：
1.查询时先从缓存中查询
2.缓存中如果没有数据再从数据库查询，并将数据保存进缓存
3.如果缓存中查询到数据，直接返回，不再需要查询数据库
1
2
3
4
5
6
7
8
9
10
11
12
13
数据的缓存同步问题
如果对数据进行了缓存，当查询数据时，如果缓存中有数据则直接返回缓存数据不会查询数据，当数据库数据改变时就有可能出现数据不一致的问题。可以考虑在每次修改数据库的时候同时将对应的缓存数据删除，这样重新查询的时候就会查询数据库并缓存（针对数据量比较小的情况）。

spring整合Redis

xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://code.alibabatech.com/schema/dubbo
http://code.alibabatech.com/schema/dubbo/dubbo.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-4.0.xsd">


<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxTotal" value="1000"></property>
<property name="maxIdle" value="20"></property>
</bean>

<bean class="redis.clients.jedis.JedisPool">
<constructor-arg name="poolConfig" ref="poolConfig"></constructor-arg>
<constructor-arg name="host" value="192.168.66.66"></constructor-arg>
<constructor-arg name="port" value="6379"></constructor-arg>
</bean>

<!-- <bean class="redis.clients.jedis.JedisCluster">
<constructor-arg name="nodes">
<set>
<bean class="redis.clients.jedis.HostAndPort">
<constructor-arg name="host" value="192.168.66.66"></constructor-arg>
<constructor-arg name="port" value="7001"></constructor-arg>
</bean>

</set>
</constructor-arg>
<constructor-arg name="poolConfig" ref="poolConfig"></constructor-arg>
</bean> -->
</beans>
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
jedis接口抽取

public interface JedisDao {

//抽取jedis访问redis服务器常用方法
//String
public String set(String key,String value);
public String get(String key);
//自增
public Long incr(String key);
//自减
public Long decr(String key);
//过期时间
public Long expire(String key, int seconds);
//查询过期剩余时间
public Long ttl(String key);
//HASH
public Long hset(String key, String field, String value);
public String hget(String key, String field);
//删除
public Long hdel(String key, String field);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
单机版Redis接口实现类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import cn.e3mall.content.dao.JedisDao;
@Repository
public class SingleJedisDaoImpl implements JedisDao {

//注入单机版jedis连接池对象
@Autowired
private JedisPool jp;

@Override
public String set(String key, String value) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
String set = jedis.set(key, value);
return set;
}

@Override
public String get(String key) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
String value = jedis.get(key);
return value;
}

@Override
public Long incr(String key) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
Long incr = jedis.incr(key);
return incr;
}

@Override
public Long decr(String key) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
Long decr = jedis.decr(key);
return decr;
}

@Override
public Long expire(String key, int seconds) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
Long expire = jedis.expire(key, seconds);
return expire;
}

@Override
public Long ttl(String key) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
Long ttl = jedis.ttl(key);
return ttl;
}

@Override
public Long hset(String key, String field, String value) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
Long hset = jedis.hset(key, field, value);

return hset;
}

@Override
public String hget(String key, String field) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
String hget = jedis.hget(key, field);
return hget;
}

@Override
public Long hdel(String key, String field) {
// TODO Auto-generated method stub
Jedis jedis = jp.getResource();
Long hdel = jedis.hdel(key, field);
return hdel;
}

}
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
集群版Redis接口实现类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import redis.clients.jedis.JedisCluster;
import cn.e3mall.content.dao.JedisDao;
@Repository
public class ClusterJedisDaoImpl implements JedisDao {

//注解集群对象
@Autowired
private JedisCluster jc;

@Override
public String set(String key, String value) {
// TODO Auto-generated method stub
String set = jc.set(key, value);
return set;
}

@Override
public String get(String key) {
// TODO Auto-generated method stub
String string = jc.get(key);
return string;
}

@Override
public Long incr(String key) {
// TODO Auto-generated method stub
Long incr = jc.incr(key);
return incr;
}

@Override
public Long decr(String key) {
// TODO Auto-generated method stub
Long decr = jc.decr(key);
return decr;
}

@Override
public Long expire(String key, int seconds) {
// TODO Auto-generated method stub
Long expire = jc.expire(key, seconds);
return expire;
}

@Override
public Long ttl(String key) {
// TODO Auto-generated method stub
Long ttl = jc.ttl(key);
return ttl;
}

@Override
public Long hset(String key, String field, String value) {
// TODO Auto-generated method stub
Long hset = jc.hset(key, field, value);
return hset;
}

@Override
public String hget(String key, String field) {
// TODO Auto-generated method stub
String value = jc.hget(key, field);
return value;
}

@Override
public Long hdel(String key, String field) {
// TODO Auto-generated method stub
Long hdel = jc.hdel(key, field);
return hdel;
}

}
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
Redis集群思想
备份（高可用）
分块（高效率、高并发）
---------------------
作者：chenhaotao
来源：CSDN
原文：https://blog.csdn.net/chenhaotao/article/details/78491558
版权声明：本文为博主原创文章，转载请附上博文链接！

猜你喜欢