服务器之家:专注于服务器技术及软件下载分享
分类导航

Mysql|Mssql|Oracle|Redis|

服务器之家 - 数据库 - Redis - Redis整合Spring结合使用缓存实例

Redis整合Spring结合使用缓存实例

2019-10-27 16:50林炳文Evankaka Redis

这篇文章主要介绍了Redis整合Spring结合使用缓存实例,介绍了如何在Spring中配置redis,并通过Spring中AOP的思想,将缓存的方法切入到有需要进入缓存的类或方法前面。需要的朋友可以参考下

一、Redis介绍
什么是Redis?
      redis是一个key-value存储系统。和Memcached类似,它支持存储的value类型相对更多,包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash(哈希类型)。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的。在此基础上,redis支持各种不同方式的排序。与memcached一样,为了保证效率,数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件,并且在此基础上实现了master-slave(主从)同步。
它有什么特点?
(1)Redis数据库完全在内存中,使用磁盘仅用于持久性。
(2)相比许多键值数据存储,Redis拥有一套较为丰富的数据类型。
(3)Redis可以将数据复制到任意数量的从服务器。
Redis 优势?
 (1)异常快速:Redis的速度非常快,每秒能执行约11万集合,每秒约81000+条记录。
 (2)支持丰富的数据类型:Redis支持最大多数开发人员已经知道像列表,集合,有序集合,散列数据类型。这使得它非常容易解决各种各样的问题,因为我们知道哪些问题是可以处理通过它的数据类型更好。
(3)操作都是原子性:所有Redis操作是原子的,这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。
(4)多功能实用工具:Redis是一个多实用的工具,可以在多个用例如缓存,消息,队列使用(Redis原生支持发布/订阅),任何短暂的数据,应用程序,如Web应用程序会话,网页命中计数等。
Redis 缺点?
(1)单线程
(2)耗内存
二、使用实例
本文使用maven+eclipse+sping
1、引入jar包

 
?
1
 
2
3
4
5
6
7
8
9
10
11
12
  <!--Redis start -->
<dependency>
  <groupId>org.springframework.data</groupId>
  <artifactId>spring-data-redis</artifactId>
  <version>1.6.1.RELEASE</version>
</dependency>
<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
  <version>2.7.3</version>
</dependency>
  <!--Redis end -->

2、配置bean
在application.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
31
<!-- jedis 配置 -->
  <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig" >
     <property name="maxIdle" value="${redis.maxIdle}" />
     <property name="maxWaitMillis" value="${redis.maxWait}" />
     <property name="testOnBorrow" value="${redis.testOnBorrow}" />
  </bean >
 <!-- redis服务器中心 -->
  <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" >
     <property name="poolConfig" ref="poolConfig" />
     <property name="port" value="${redis.port}" />
     <property name="hostName" value="${redis.host}" />
     <property name="password" value="${redis.password}" />
     <property name="timeout" value="${redis.timeout}" ></property>
  </bean >
  <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
     <property name="connectionFactory" ref="connectionFactory" />
     <property name="keySerializer" >
       <bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
     </property>
     <property name="valueSerializer" >
       <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
     </property>
  </bean >
   
  <!-- cache配置 -->
  <bean id="methodCacheInterceptor" class="com.mucfc.msm.common.MethodCacheInterceptor" >
     <property name="redisUtil" ref="redisUtil" />
  </bean >
  <bean id="redisUtil" class="com.mucfc.msm.common.RedisUtil" >
     <property name="redisTemplate" ref="redisTemplate" />
  </bean >

其中配置文件redis一些配置数据redis.properties如下:

 
?
1
 
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#redis中心
redis.host=10.75.202.11
redis.port=6379
redis.password=123456
redis.maxIdle=100
redis.maxActive=300
redis.maxWait=1000
redis.testOnBorrow=true
redis.timeout=100000
 
# 不需要加入缓存的类
targetNames=xxxRecordManager,xxxSetRecordManager,xxxStatisticsIdentificationManager
# 不需要缓存的方法
methodNames=
 
#设置缓存失效时间
com.service.impl.xxxRecordManager= 60
com.service.impl.xxxSetRecordManager= 60
defaultCacheExpireTime=3600
 
fep.local.cache.capacity =10000

要扫这些properties文件,在application.xml加入如下配置

 
?
1
 
2
3
4
5
6
7
8
9
<!-- 引入properties配置文件 -->
 <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations">
    <list>
      <value>classpath:properties/*.properties</value>
      <!--要是有多个配置文件,只需在这里继续添加即可 -->
    </list>
  </property>
</bean>

3、一些工具类
(1)RedisUtil
上面的bean中,RedisUtil是用来缓存和去除数据的实例

 
?
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
package com.mucfc.msm.common;
 
import java.io.Serializable;
import java.util.Set;
import java.util.concurrent.TimeUnit;
 
import org.apache.log4j.Logger;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
 
/**
 * redis cache 工具类
 *
 */
public final class RedisUtil {
  private Logger logger = Logger.getLogger(RedisUtil.class);
  private RedisTemplate<Serializable, Object> redisTemplate;
 
  /**
   * 批量删除对应的value
   *
   * @param keys
   */
  public void remove(final String... keys) {
    for (String key : keys) {
      remove(key);
    }
  }
 
  /**
   * 批量删除key
   *
   * @param pattern
   */
  public void removePattern(final String pattern) {
    Set<Serializable> keys = redisTemplate.keys(pattern);
    if (keys.size() > 0)
      redisTemplate.delete(keys);
  }
 
  /**
   * 删除对应的value
   *
   * @param key
   */
  public void remove(final String key) {
    if (exists(key)) {
      redisTemplate.delete(key);
    }
  }
 
  /**
   * 判断缓存中是否有对应的value
   *
   * @param key
   * @return
   */
  public boolean exists(final String key) {
    return redisTemplate.hasKey(key);
  }
 
  /**
   * 读取缓存
   *
   * @param key
   * @return
   */
  public Object get(final String key) {
    Object result = null;
    ValueOperations<Serializable, Object> operations = redisTemplate
        .opsForValue();
    result = operations.get(key);
    return result;
  }
 
  /**
   * 写入缓存
   *
   * @param key
   * @param value
   * @return
   */
  public boolean set(final String key, Object value) {
    boolean result = false;
    try {
      ValueOperations<Serializable, Object> operations = redisTemplate
          .opsForValue();
      operations.set(key, value);
      result = true;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return result;
  }
 
  /**
   * 写入缓存
   *
   * @param key
   * @param value
   * @return
   */
  public boolean set(final String key, Object value, Long expireTime) {
    boolean result = false;
    try {
      ValueOperations<Serializable, Object> operations = redisTemplate
          .opsForValue();
      operations.set(key, value);
      redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
      result = true;
    } catch (Exception e) {
      e.printStackTrace();
    }
    return result;
  }
 
  public void setRedisTemplate(
      RedisTemplate<Serializable, Object> redisTemplate) {
    this.redisTemplate = redisTemplate;
  }
}

(2)MethodCacheInterceptor
切面MethodCacheInterceptor,这是用来给不同的方法来加入判断如果缓存存在数据,从缓存取数据。否则第一次从数据库取,并将结果保存到缓存 中去。

 
?
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
package com.mucfc.msm.common;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
 
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;
 
 
public class MethodCacheInterceptor implements MethodInterceptor {
  private Logger logger = Logger.getLogger(MethodCacheInterceptor.class);
  private RedisUtil redisUtil;
  private List<String> targetNamesList; // 不加入缓存的service名称
  private List<String> methodNamesList; // 不加入缓存的方法名称
  private Long defaultCacheExpireTime; // 缓存默认的过期时间
  private Long xxxRecordManagerTime; //
  private Long xxxSetRecordManagerTime; //
 
  /**
   * 初始化读取不需要加入缓存的类名和方法名称
   */
  public MethodCacheInterceptor() {
    try {
       File f = new File("D:lunaJee-workspacemsmmsm_coresrcmainjavacommucfcmsmcommoncacheConf.properties"); 
       //配置文件位置直接被写死,有需要自己修改下
       InputStream in = new FileInputStream(f); 
//     InputStream in = getClass().getClassLoader().getResourceAsStream(
//         "D:lunaJee-workspacemsmmsm_coresrcmainjavacommucfcmsmcommoncacheConf.properties");
      Properties p = new Properties();
      p.load(in);
      // 分割字符串
      String[] targetNames = p.getProperty("targetNames").split(",");
      String[] methodNames = p.getProperty("methodNames").split(",");
 
      // 加载过期时间设置
      defaultCacheExpireTime = Long.valueOf(p.getProperty("defaultCacheExpireTime"));
      xxxRecordManagerTime = Long.valueOf(p.getProperty("com.service.impl.xxxRecordManager"));
      xxxSetRecordManagerTime = Long.valueOf(p.getProperty("com.service.impl.xxxSetRecordManager"));
      // 创建list
      targetNamesList = new ArrayList<String>(targetNames.length);
      methodNamesList = new ArrayList<String>(methodNames.length);
      Integer maxLen = targetNames.length > methodNames.length ? targetNames.length
          : methodNames.length;
      // 将不需要缓存的类名和方法名添加到list中
      for (int i = 0; i < maxLen; i++) {
        if (i < targetNames.length) {
          targetNamesList.add(targetNames[i]);
        }
        if (i < methodNames.length) {
          methodNamesList.add(methodNames[i]);
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
 
  @Override
  public Object invoke(MethodInvocation invocation) throws Throwable {
    Object value = null;
 
    String targetName = invocation.getThis().getClass().getName();
    String methodName = invocation.getMethod().getName();
    // 不需要缓存的内容
    //if (!isAddCache(StringUtil.subStrForLastDot(targetName), methodName)) {
    if (!isAddCache(targetName, methodName)) {
      // 执行方法返回结果
      return invocation.proceed();
    }
    Object[] arguments = invocation.getArguments();
    String key = getCacheKey(targetName, methodName, arguments);
    System.out.println(key);
 
    try {
      // 判断是否有缓存
      if (redisUtil.exists(key)) {
        return redisUtil.get(key);
      }
      // 写入缓存
      value = invocation.proceed();
      if (value != null) {
        final String tkey = key;
        final Object tvalue = value;
        new Thread(new Runnable() {
          @Override
          public void run() {
            if (tkey.startsWith("com.service.impl.xxxRecordManager")) {
              redisUtil.set(tkey, tvalue, xxxRecordManagerTime);
            } else if (tkey.startsWith("com.service.impl.xxxSetRecordManager")) {
              redisUtil.set(tkey, tvalue, xxxSetRecordManagerTime);
            } else {
              redisUtil.set(tkey, tvalue, defaultCacheExpireTime);
            }
          }
        }).start();
      }
    } catch (Exception e) {
      e.printStackTrace();
      if (value == null) {
        return invocation.proceed();
      }
    }
    return value;
  }
 
  /**
   * 是否加入缓存
   *
   * @return
   */
  private boolean isAddCache(String targetName, String methodName) {
    boolean flag = true;
    if (targetNamesList.contains(targetName)
        || methodNamesList.contains(methodName)) {
      flag = false;
    }
    return flag;
  }
 
  /**
   * 创建缓存key
   *
   * @param targetName
   * @param methodName
   * @param arguments
   */
  private String getCacheKey(String targetName, String methodName,
      Object[] arguments) {
    StringBuffer sbu = new StringBuffer();
    sbu.append(targetName).append("_").append(methodName);
    if ((arguments != null) && (arguments.length != 0)) {
      for (int i = 0; i < arguments.length; i++) {
        sbu.append("_").append(arguments[i]);
      }
    }
    return sbu.toString();
  }
 
  public void setRedisUtil(RedisUtil redisUtil) {
    this.redisUtil = redisUtil;
  }
}

4、配置需要缓存的类或方法
在application.xml加入如下配置,有多个类或方法可以配置多个

 
?
1
 
2
3
4
5
6
7
8
9
10
11
12
<!-- 需要加入缓存的类或方法 -->
<bean id="methodCachePointCut" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" >
   <property name="advice" >
     <ref local="methodCacheInterceptor" />
   </property>
   <property name="patterns" >
     <list>
      <!-- 确定正则表达式列表 -->
       <value>com.mucfc.msm.service.impl...*ServiceImpl.*</value >
     </list>
   </property>
</bean >

5、执行结果:
写了一个简单的单元测试如下:

 
?
1
 
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test
public void getSettUnitBySettUnitIdTest() {
  String systemId = "CES";
  String merchantId = "133";
  SettUnit configSettUnit = settUnitService.getSettUnitBySettUnitId(systemId, merchantId, "ESP");
  SettUnit configSettUnit1 = settUnitService.getSettUnitBySettUnitId(systemId, merchantId, "ESP");
  boolean flag= (configSettUnit == configSettUnit1);
  System.out.println(configSettUnit);
  logger.info("查找结果" + configSettUnit.getBusinessType());
  
 // localSecondFIFOCache.put("configSettUnit", configSettUnit.getBusinessType());
 // String string = localSecondFIFOCache.get("configSettUnit");
   logger.info("查找结果" + string);
}

这是第一次执行单元测试的过程:
MethodCacheInterceptor这个类中打了断点,然后每次查询前都会先进入这个方法

Redis整合Spring结合使用缓存实例

依次运行,发现没有缓存,所以会直接去查数据库

Redis整合Spring结合使用缓存实例

打印了出来的SQL语句:

Redis整合Spring结合使用缓存实例

第二次执行:
因为第一次执行时,已经写入缓存了。所以第二次直接从缓存中取数据

Redis整合Spring结合使用缓存实例

3、取两次的结果进行地址的对比:
发现两个不是同一个对象,没错,是对的。如果是使用ehcache的话,那么二者的内存地址会是一样的。那是因为redis和ehcache使用的缓存机制是不一样的。ehcache是基于本地电脑的内存使用缓存,所以使用缓存取数据时直接在本地电脑上取。转换成java对象就会是同一个内存地址,而redis它是在装有redis服务的电脑上(一般是另一台电脑),所以取数据时经过传输到本地,会对应到不同的内存地址,所以用==来比较会返回false。但是它确实是从缓存中去取的,这点我们从上面的断点可以看到。

Redis整合Spring结合使用缓存实例

以上就是本文的全部内容,希望对大家的学习有所帮助。

延伸 · 阅读

精彩推荐
  • RedisWindows下Redis的安装使用图解

    Windows下Redis的安装使用图解

    Redis是一个key-value存储系统。Redis的出现,很大程度补偿了memcached这类key/value存储的不足,在部分场合可以对关系数据库起到很好的补充作用。这篇文章小编...

    lijiao2362019-10-26
  • RedisCentOS下Redis数据库的基本安装与配置教程

    CentOS下Redis数据库的基本安装与配置教程

    这篇文章主要介绍了CentOS下Redis数据库的基本安装与配置教程,Redis一般被用作基于内存的缓存式数据存储,要的朋友可以参考下 ...

    Carlos Alberto1232019-10-27
  • RedisRedis教程(一):Redis简介

    Redis教程(一):Redis简介

    这篇文章主要介绍了Redis教程(一):Redis简介,本文是系列文章的第一篇,欢迎大家跟随本教程学习Redis数据库,需要的朋友可以参考下 ...

    Redis教程网2982019-10-23
  • RedisRedis教程(四):Hashes数据类型

    Redis教程(四):Hashes数据类型

    这篇文章主要介绍了Redis教程(四):Hashes数据类型,本文讲解了Hashes数据类型概述、相关命令列表和命令使用示例等内容,需要的朋友可以参考下 ...

    Redis教程网1242019-10-24
  • Redisredis中使用redis-dump导出、导入、还原数据实例

    redis中使用redis-dump导出、导入、还原数据实例

    这篇文章主要介绍了redis中使用redis-dump导出、导入、还原数据实例,本文直接给出操作命令,并给出注释加以说明,需要的朋友可以参考下 ...

    junjie1832019-10-21
  • RedisRedis主从复制问题和扩容问题的解决思路

    Redis主从复制问题和扩容问题的解决思路

    这篇文章主要介绍了Redis主从复制问题和扩容问题的解决思路,其中扩容问题的解决思路来自Redis作者,需要的朋友可以参考下 ...

    Redis教程网3572019-10-20
  • RedisRedis数据库的使用场景介绍(避免误用Redis)

    Redis数据库的使用场景介绍(避免误用Redis)

    这篇文章主要介绍了Redis数据库的使用场景介绍(避免误用Redis),本文用简要的语言总结了Redis数据库的适应场合,人而避免错误的使用它而产生昂贵的维护...

    Redis教程网4042019-10-22
  • RedisRedis教程(十):持久化详解

    Redis教程(十):持久化详解

    这篇文章主要介绍了Redis教程(十):持久化详解,本文讲解了Redis提供了哪些持久化机制、RDB机制的优势和劣势、AOF机制的优势和劣势、其它等内容,需要的朋...

    Redis教程网1512019-10-24