redis+ssm集成

<!-- 缓存的依赖包 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.4.1</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.6.0.RELEASE</version>
</dependency>


<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.8.2</version>

</dependency>

<!-- 配置映射处理器Handlermapping（该配置会告诉前端控制器，请求路径和控制器之间的关系） -->
<mvc:annotation-driven/>
<!-- 配置注解扫描 -->
<context:component-scan base-package="cn.tedu.rs"/>
<!-- 配置视图解析器 -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/"></property>
<property name="suffix" value=".jsp"></property>

</bean>

<!-- redis和缓存配置开始 -->
<!-- jedis 配置 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="100" />
<property name="maxWaitMillis" value="1000" />
<property name="testOnBorrow" value="true" />
</bean>
<!-- 再次将settinel配置集成到redis连接池中 -->
<bean id="jedisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
destroy-method="destroy">
<property name="poolConfig" ref="jedisPoolConfig" />
<property name="hostName" value="127.0.0.1" />
<property name="port" value="6379" />
<property name="timeout" value="15000" />
</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>

测试类：

package cn.tedu.rs;


import java.util.HashMap;


import java.util.Map;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;




@Controller
public class ControllerTest {
@Autowired
private JobRedisUtil redis;
@RequestMapping("listUI")
public String listUI(){
redis.setCacheHsahMap("ZH", "nihao", "你好");
return "main";
}
@RequestMapping("listUI1")
public String listUI1(){
String map=redis.getCacheHsahMap("ZH", "nihao");

System.out.println(map);
return "main3";
}



}

工具类：

package cn.tedu.rs.common.util;


import java.io.Serializable;
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 java.util.concurrent.TimeUnit;


import javax.annotation.Resource;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
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.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;


import cn.tedu.rs.main.entity.JobInfo;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;


@Service
public class JobRedisUtil{
@Autowired
private RedisTemplate redisTemplate;




public RedisTemplate getRedisTemplate() {
return redisTemplate;
}

public void setRedisTemplate(RedisTemplate redisTemplate) {
this.redisTemplate = redisTemplate;
}


/**
    * 根据key值清除缓存
    * 
    * @param keys
    */
 /**
* 缓存基本的对象，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;
}










/**
* 缓存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;
}

                public <T> HashOperations<String,String,T> setCacheHsahMap(String key,String hash,String value)
{


HashOperations hashOperations = redisTemplate.opsForHash();
hashOperations.put(key,hash,value);


return hashOperations;
}
public <T> String getCacheHsahMap(String key,String hash)
{


HashOperations hashOperations = redisTemplate.opsForHash();
String str=(String) hashOperations.get(key, hash);




return str;
}
//根据序号判断，该id是否存在

public void isExistsIdBySerialNumber(String serialNumber){

}
//根据key判断，判断是否存在
public boolean isExistsObject(final String key){
return redisTemplate.hasKey(key);
}



}