spring結合redis如何實現資料的快取

spring結合redis如何實現資料的快取
1 Star2 Stars3 Stars4 Stars5 Stars 給文章打分!
Loading...

1、實現目標

  通過redis快取資料。(目的不是加快查詢的速度,而是減少資料庫的負擔)  

2、所需jar包

 

  注意:jdies和commons-pool兩個jar的版本是有對應關係的,注意引入jar包是要配對使用,否則將會報錯。因為commons-pooljar的目錄根據版本的變化,目錄結構會變。前面的版本是org.apache.pool,而後面的版本是org.apache.pool2…

style=”background-color: #0098dd; color: white; font-size: 17px; font-weight: bold;”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檔案


<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName"> 
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> 
<!-- <property name="maxIdle" value="6"></property> 
<property name="minEvictableIdleTimeMillis" value="300000"></property> 
<property name="numTestsPerEvictionRun" value="3"></property> 
<property name="timeBetweenEvictionRunsMillis" value="60000"></property> -->
<property name="maxIdle" value="${redis.maxIdle}"></property> 
<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"></property> 
<property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"></property> 
<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"></property>
</bean> 
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy"> 
<property name="poolConfig" ref="jedisPoolConfig"></property> 
<property name="hostName" value="${redis.hostName}"></property> 
<property name="port" value="${redis.port}"></property> 
<property name="timeout" value="${redis.timeout}"></property> 
<property name="usePool" value="${redis.usePool}"></property> 
</bean> 
<bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate"> 
<property name="connectionFactory" ref="jedisConnectionFactory"></property> 
<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> 
</beans> 

3)、applicationContext.xml

  spring的總配置檔案,在裡面假如一下的程式碼


<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
<property name="ignoreResourceNotFound" value="true" />
<property name="locations">
<list>
<value>classpath*:/META-INF/config/redis.properties</value>
</list>
</property>
</bean>
<import resource="spring-redis.xml" />

4)、web.xml

  設定spring的總配置檔案在專案啟動時載入


<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:/META-INF/applicationContext.xml</param-value><!-- -->
</context-param>

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<T>
{
@Autowired @Qualifier("jedisTemplate")
public RedisTemplate redisTemplate;
/**
* 快取基本的物件,Integer、String、實體類等
* @param key 快取的鍵值
* @param value 快取的值
* @return  快取的物件
*/
public <T> ValueOperations<String,T> setCacheObject(String key,T value)
{
ValueOperations<String,T> operation = redisTemplate.opsForValue(); 
operation.set(key,value);
return operation;
}
/**
* 獲得快取的基本物件。
* @param key  快取鍵值
* @param operation
* @return   快取鍵值對應的資料
*/
public <T> T getCacheObject(String key/*,ValueOperations<String,T> operation*/)
{
ValueOperations<String,T> operation = redisTemplate.opsForValue(); 
return operation.get(key);
}
/**
* 快取List資料
* @param key  快取的鍵值
* @param dataList 待快取的List資料
* @return   快取的物件
*/
public <T> ListOperations<String, T> setCacheList(String key,List<T> 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 <T> List<T> getCacheList(String key)
{
List<T> dataList = new ArrayList<T>();
ListOperations<String,T> 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 <T> BoundSetOperations<String,T> setCacheSet(String key,Set<T> dataSet)
{
BoundSetOperations<String,T> setOperation = redisTemplate.boundSetOps(key); 
/*T[] t = (T[]) dataSet.toArray();
setOperation.add(t);*/
Iterator<T> it = dataSet.iterator();
while(it.hasNext())
{
setOperation.add(it.next());
}
return setOperation;
}
/**
* 獲得快取的set
* @param key
* @param operation
* @return
*/
public Set<T> getCacheSet(String key/*,BoundSetOperations<String,T> operation*/)
{
Set<T> dataSet = new HashSet<T>();
BoundSetOperations<String,T> 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 <T> HashOperations<String,String,T> setCacheMap(String key,Map<String,T> dataMap)
{
HashOperations hashOperations = redisTemplate.opsForHash();
if(null != dataMap)
{
for (Map.Entry<String, T> 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 <T> Map<String,T> getCacheMap(String key/*,HashOperations<String,String,T> hashOperation*/)
{
Map<String, T> map = redisTemplate.opsForHash().entries(key);
/*Map<String, T> map = hashOperation.entries(key);*/
return map;
}
/**
* 快取Map
* @param key
* @param dataMap
* @return
*/
public <T> HashOperations<String,Integer,T> setCacheIntegerMap(String key,Map<Integer,T> dataMap)
{
HashOperations hashOperations = redisTemplate.opsForHash();
if(null != dataMap)
{
for (Map.Entry<Integer, T> 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 <T> Map<Integer,T> getCacheIntegerMap(String key/*,HashOperations<String,String,T> hashOperation*/)
{
Map<Integer, T> map = redisTemplate.opsForHash().entries(key);
/*Map<String, T> 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<ContextRefreshedEvent>
{
//日誌
private final Logger log= Logger.getLogger(StartAddCacheListener.class);
@Autowired
private RedisCacheUtil<Object> 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<City> cityList = brandStoreService.selectAllCityMessage();
List<Country> countryList = brandStoreService.selectAllCountryMessage();
Map<Integer,City> cityMap = new HashMap<Integer,City>();
Map<Integer,Country> countryMap = new HashMap<Integer, Country>();
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<User> redisCache;
@RequestMapping("testGetCache")
public void testGetCache()
{
/*Map<String,Country> countryMap = redisCacheUtil1.getCacheMap("country");
Map<String,City> cityMap = redisCacheUtil.getCacheMap("city");*/
Map<Integer,Country> countryMap = redisCacheUtil1.getCacheIntegerMap("countryMap");
Map<Integer,City> 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結合使用快取例項php操作redis快取方法分享圖文詳解Windows下使用Redis快取工具的方法Python的Flask框架使用Redis做資料快取的配置方法PHP使用redis實現統計快取mysql壓力的方法Spring Boot 基於註解的 Redis 快取使用詳解Nginx配置srcache_nginx模組搭配Redis建立快取系統CI框架中redis快取相關操作檔案示例程式碼Redis快取詳解redis快取的簡單操作(get、put)

相關文章

程式語言 最新文章