（spring redis应用第一章）Spring+Redis的简单应用

这几天，在学习Redis，关于Redis的好处网上有很多的介绍，我不做太多赘述，作为开发人员，首先关心的是怎么用，如何整合到我们的Spring框架中。这里面我简单的将Redis整合到Spring框架，并且做存，取的功能。好了，下面来步骤吧。

第一步：安装Redis数据库。我直接从同事那里要了一个免安装的包。直接在电脑里面启动打开的。怎么装Redis,网上有教程。

第二步：在Spring配置Redis的相关配置，在applicationContext.xml配置

<!-- 6.配置redis服务 -->
<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" />

第二步：新建一个spring-redis.xml的xml文件。并且在里面做相关配置,其中hostName是你redis所在的IP地址。redis默认是没有密码的

<?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:p=
4000
"http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
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://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">

<!--（1）如果你有多个数据源需要通过<context:property-placeholder管理，且不愿意放在一个配置文件里，那么一定要加上ignore-unresolvable=“true"-->
<!--（2）注意新版的（具体从哪个版本开始不清楚，有兴趣可以查一下）JedisPoolConfig的property name，不是maxActive而是maxTotal，而且没有maxWait属性，建议看一下Jedis源码。-->

<!-- redis连接池 -->
<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>

<!-- redis连接工厂 -->
<bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
<property name="poolConfig" ref="jedisPoolConfig"></property>
<property name="hostName" value="192.168.1.**"></property>
<property name="port" value="6379"></property>
<property name="timeout" value="15000"></property>
<property name="usePool" value="true"></property>
</bean>

<!-- redis封装的Template API -->
<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>

第三步：建立RedisTemplateUtil.java

package com.util.base;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
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.Component;
import org.springframework.stereotype.Service;

@Service
public class RedisTemplateUtil<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
b202
: 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;
}
}

第四步：写一个测试的Demo

package com.controller.user;

import java.util.HashMap;
import java.util.Map;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.model.User;
import com.util.base.RedisTemplateUtil;

@Controller
@RequestMapping(value = "/user")
@Scope("prototype")
public class RedisTest {

@Resource
private RedisTemplateUtil<Object> redisCache;

//Map的方式
@RequestMapping(value = "/setmymap")
public void setmymap(HttpServletRequest request,HttpServletResponse response){
Map<Integer,String> Map = new HashMap<Integer,String>();
for(int i = 0 ; i < 20 ; i ++ )
{
Map.put(i, "value"+i);
}

redisCache.setCacheIntegerMap("cityMap", Map);
}

@RequestMapping(value = "/getmymap")
public void getmymap(HttpServletRequest request,HttpServletResponse response){
Map<Integer,String> Map = redisCache.getCacheIntegerMap("cityMap");

System.out.println("------------city");
for(int key : Map.keySet())
{
System.out.println("key = " + key + ",value=" + Map.get(key));
}
}

//实体类，基本对象
@RequestMapping(value = "/setmy")
public void setmy(HttpServletRequest request,HttpServletResponse response){
User user=new User();//实体类要进行序列化
user.setName("张三");
user.setAge("35");
user.setSex("男");
redisCache.setCacheObject("user", user);
}

@RequestMapping(value = "/getmy")
public void getmy(HttpServletRequest request,HttpServletResponse response){
User user=redisCache.getCacheObject("user");
System.out.println(user.getName()+","+user.getAge());
}

}

第五步：运行项目。访问url。查看后台控制，先存，后取，下面是控制台打印出来的

张三,35

PS：这是经过我测试且可运行的Demo，有兴趣的同学可以下载下来，自己跑一跑。我的项目里面本身是连接sql server数据库的。如果有同学是其他类型数据库的话，可以在applicationContext.xml文件把数据库连接的地方给注释掉 http://download.csdn.net/download/qq_35515521/10037359