快上网专注成都网站设计 成都网站制作 成都网站建设
成都网站建设公司服务热线：028-86922220

网站建设知识

十年网站开发经验 + 多家企业客户 + 靠谱的建站团队

量身定制 + 运营维护+专业推广+无忧售后，网站问题一站解决

详解redis与spring的整合（使用缓存）

1、实现目标

成都创新互联是专业的秀洲网站建设公司，秀洲接单;提供网站建设、成都网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行秀洲网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!

通过redis缓存数据。（目的不是加快查询的速度，而是减少数据库的负担）

2、所需jar包

详解redis与spring的整合（使用缓存）

注意：jdies和commons-pool两个jar的版本是有对应关系的，注意引入jar包是要配对使用，否则将会报错。因为commons-pooljar的目录根据版本的变化，目录结构会变。前面的版本是org.apache.pool，而后面的版本是org.apache.pool2...

3、redis简介

redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)

3、编码实现

1）、配置的文件（properties）

将那些经常要变化的参数配置成独立的propertis，方便以后的修改redis.properties

redis.hostName=127.0.0.1

redis.port=6379

redis.timeout=15000

redis.usePool=true

redis.maxIdle=6

redis.minEvictableIdleTimeMillis=300000

redis.numTestsPerEvictionRun=3

redis.timeBetweenEvictionRunsMillis=60000

2)、spring-redis.xml

redis的相关参数配置设置。参数的值来自上面的properties文件

 3）、applicationContext.xml

spring的总配置文件，在里面假如一下的代码



 

 

 

 
 classpath*:/META-INF/config/redis.properties

4）web.xml

设置spring的总配置文件在项目启动时加载



 contextConfigLocation

 classpath*:/META-INF/applicationContext.xml

5）、redis缓存工具类

ValueOperations　　——基本数据类型和实体类的缓存

ListOperations　　   ——list的缓存

SetOperations　　  ——set的缓存

HashOperations　　Map的缓存

import java.io.Serializable;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

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

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.data.redis.core.BoundSetOperations;

import org.springframework.data.redis.core.HashOperations;

import org.springframework.data.redis.core.ListOperations;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.core.SetOperations;

import org.springframework.data.redis.core.ValueOperations;

import org.springframework.stereotype.Service;

@Service

public class RedisCacheUtil

{

 @Autowired @Qualifier("jedisTemplate")

 public RedisTemplate redisTemplate;
 /**

 * 缓存基本的对象，Integer、String、实体类等

 * @param key 缓存的键值

 * @param value 缓存的值

 * @return 缓存的对象

 */

 public  ValueOperations setCacheObject(String key,T value)

 {

 ValueOperations operation = redisTemplate.opsForValue(); 

 operation.set(key,value);

 return operation;

 }
 /**

 * 获得缓存的基本对象。

 * @param key 缓存键值

 * @param operation

 * @return 缓存键值对应的数据

 */

 public  T getCacheObject(String key/*,ValueOperations operation*/)

 {

 ValueOperations operation = redisTemplate.opsForValue(); 

 return operation.get(key);

 }

 /**

 * 缓存List数据

 * @param key 缓存的键值

 * @param dataList 待缓存的List数据

 * @return 缓存的对象

 */

 public  ListOperations setCacheList(String key,List dataList)

 {

 ListOperations listOperation = redisTemplate.opsForList();

 if(null != dataList)

 {

 int size = dataList.size();

 for(int i = 0; i < size ; i ++)

 {

  

 listOperation.rightPush(key,dataList.get(i));

 }

 }
 return listOperation;

 }

 /**

 * 获得缓存的list对象

 * @param key 缓存的键值

 * @return 缓存键值对应的数据

 */

 public  List getCacheList(String key)

 {

 List dataList = new ArrayList();

 ListOperations listOperation = redisTemplate.opsForList();

 Long size = listOperation.size(key);

 

 for(int i = 0 ; i < size ; i ++)

 {

 dataList.add((T) listOperation.leftPop(key));

 }

 

 return dataList;

 }

 /**

 * 缓存Set

 * @param key 缓存键值

 * @param dataSet 缓存的数据

 * @return 缓存数据的对象

 */

 public  BoundSetOperations setCacheSet(String key,Set dataSet)

 {

 BoundSetOperations setOperation = redisTemplate.boundSetOps(key); 

 /*T[] t = (T[]) dataSet.toArray();

 setOperation.add(t);*/

 Iterator it = dataSet.iterator();

 while(it.hasNext())

 {

 setOperation.add(it.next());

 }

 

 return setOperation;

 }

 /**

 * 获得缓存的set

 * @param key

 * @param operation

 * @return

 */

 public Set getCacheSet(String key/*,BoundSetOperations operation*/)

 {

 Set dataSet = new HashSet();

 BoundSetOperations operation = redisTemplate.boundSetOps(key); 

 

 Long size = operation.size();

 for(int i = 0 ; i < size ; i++)

 {

 dataSet.add(operation.pop());

 }

 return dataSet;

 }
 /**

 * 缓存Map

 * @param key

 * @param dataMap

 * @return

 */

 public  HashOperations setCacheMap(String key,Map dataMap)

 {

 HashOperations hashOperations = redisTemplate.opsForHash();

 if(null != dataMap)

 {

 for (Map.Entry entry : dataMap.entrySet()) { 
 /*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); */

 hashOperations.put(key,entry.getKey(),entry.getValue());

 } 
 }

 return hashOperations;

 }

 /**

 * 获得缓存的Map

 * @param key

 * @param hashOperation

 * @return

 */

 public  Map getCacheMap(String key/*,HashOperations hashOperation*/)

 {

 Map map = redisTemplate.opsForHash().entries(key);

 /*Map map = hashOperation.entries(key);*/

 return map;

 }

 

 /**

 * 缓存Map

 * @param key

 * @param dataMap

 * @return

 */

 public  HashOperations setCacheIntegerMap(String key,Map dataMap)

 {
 HashOperations hashOperations = redisTemplate.opsForHash();
 if(null != dataMap)
 {
 for (Map.Entry entry : dataMap.entrySet()) { 
 /*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue()); */

 hashOperations.put(key,entry.getKey(),entry.getValue());

 } 
 }
 return hashOperations;
 }
 /**

 * 获得缓存的Map

 * @param key

 * @param hashOperation

 * @return

 */

 public  Map getCacheIntegerMap(String key/*,HashOperations hashOperation*/)

 {

 Map map = redisTemplate.opsForHash().entries(key);

 /*Map map = hashOperation.entries(key);*/

 return map;

 }

}

 6）、测试

这里测试我是在项目启动的时候到数据库中查找出国家和城市的数据，进行缓存，之后将数据去除。

6.1  项目启动时缓存数据

import java.util.HashMap;

import java.util.List;

import java.util.Map; 

import org.apache.log4j.Logger;

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

import org.springframework.context.ApplicationListener;

import org.springframework.context.event.ContextRefreshedEvent;

import org.springframework.stereotype.Service;

import com.test.model.City;

import com.test.model.Country;

import com.zcr.test.User;

/*

 * 监听器，用于项目启动的时候初始化信息

 */

@Service

public class StartAddCacheListener implements ApplicationListener

{

 //日志

 private final Logger log= Logger.getLogger(StartAddCacheListener.class);
 @Autowired

 private RedisCacheUtil redisCache;
 @Autowired

 private BrandStoreService brandStoreService;

 @Override

 public void onApplicationEvent(ContextRefreshedEvent event) 

 {

 //spring 启动的时候缓存城市和国家等信息

 if(event.getApplicationContext().getDisplayName().equals("Root WebApplicationContext"))

 {

 System.out.println("\n\n\n_________\n\n缓存数据 \n\n ________\n\n\n\n");

 List cityList = brandStoreService.selectAllCityMessage();

 List countryList = brandStoreService.selectAllCountryMessage();

 Map cityMap = new HashMap();

 Map countryMap = new HashMap();

 int cityListSize = cityList.size();

 int countryListSize = countryList.size();

 for(int i = 0 ; i < cityListSize ; i ++ )

 {

 cityMap.put(cityList.get(i).getCity_id(), cityList.get(i));

 }
 for(int i = 0 ; i < countryListSize ; i ++ )

 {

 countryMap.put(countryList.get(i).getCountry_id(), countryList.get(i));

 }

 redisCache.setCacheIntegerMap("cityMap", cityMap);

 redisCache.setCacheIntegerMap("countryMap", countryMap);

 }
 } 

}


 6.2  获取缓存数据
@Autowired

private RedisCacheUtil redisCache; 

@RequestMapping("testGetCache")

public void testGetCache()

{

 /*Map countryMap = redisCacheUtil1.getCacheMap("country");

 Map cityMap = redisCacheUtil.getCacheMap("city");*/

 Map countryMap = redisCacheUtil1.getCacheIntegerMap("countryMap");

 Map cityMap = redisCacheUtil.getCacheIntegerMap("cityMap");
 for(int key : countryMap.keySet())

 {

 System.out.println("key = " + key + ",value=" + countryMap.get(key));

 }

 System.out.println("------------city");

 for(int key : cityMap.keySet())

 {

 System.out.println("key = " + key + ",value=" + cityMap.get(key));

 }
} 
由于Spring在配置文件中配置的bean默认是单例的，所以只需要通过Autowired注入，即可得到原先的缓存类。
以上就是spring+redis实现数据缓存的方法，希望对大家的学习有所帮助。也希望大家多多支持创新互联。
            
            
                        

            名称栏目：详解redis与spring的整合（使用缓存）            

            本文来源：http://6mz.cn/article/psppoc.html
        
    
    

        
其他资讯