SSM(Spring + Spring MVC +Mybatis)的Redis缓存，JedisPool配置

<!-- redis客户端：jedis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.7.3</version>
</dependency>

<!-- 对象序列化依赖 -->
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifactId>protostuff-core</artifactId>
<version>1.0.8</version>
</dependency>
<dependency>
<groupId>com.dyuproject.protostuff</groupId>
<artifa
4000
ctId>protostuff-runtime </artifactId>
<version>1.0.8</version>
</dependency>

<!-- redis数据源 -->
<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
<property name="maxIdle" value="${redis.maxIdle}" />
<property name="maxTotal" value="${redis.maxActive}" />
<property name="maxWaitMillis" value="${redis.maxWait}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
</bean>

<!-- redis连接池 -->
<bean id="jedisPool" class="redis.clients.jedis.JedisPool" destroy-method="destroy"  depends-on="poolConfig">
<constructor-arg name="poolConfig" ref="poolConfig" /> <!-- 加载jedisPool配置信息 -->
<constructor-arg name="host" value="${redis.host}" /><!-- redis主机地址 -->
<constructor-arg name="port" value="${redis.port}"/> <!-- redis连接端口 -->
<!-- <constructor-arg name="password" value="${redis.pass}"/> 密码 -->
<!--<constructor-arg name="database" value="${redis.database}"/> 数据库 -->
<!--<constructor-arg name="timeout" value="${redis.timeout}"/> 连接超时 -->
</bean>

#redis缓存配置
redis.host=你的地址
redis.port=你的端口
redis.pass=你的密码
redis.database=2
redis.timeout=2000

#redis连接池配置
redis.maxIdle=300
redis.maxActive=600
redis.maxWait=1000
redis.testOnBorrow=true

package com.mvc.dao.redis;

import com.dyuproject.protostuff.LinkedBuffer;
import com.dyuproject.protostuff.ProtobufIOUtil;
import com.dyuproject.protostuff.runtime.RuntimeSchema;
import com.mvc.common.Config;
import com.mvc.entity.Applications;
import com.mvc.enums.SSOEnum;
import com.mvc.exception.RedisException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.util.ArrayList;
import java.util.List;

/**
* Created by yuyu on 2017/4/17.
* 用户缓存用户可操作系统的redis
*/
public class RedisApplicationsDao {

//日志记录对象
private Logger logger = LoggerFactory.getLogger(this.getClass());

//redis连接池
@Autowired
public JedisPool jedisPool;
//将要序列化的类转换成图
private RuntimeSchema<Applications> schema = RuntimeSchema.createFrom(Applications.class);

//根据用户id获取当前用户可登入的系统
public List<Applications> getListApplications(String userId) throws Exception {
//返回数据初始化
List<Applications> list=new ArrayList<Applications>();
try {
//获取redis操作对象
Jedis jedis = jedisPool.getResource();
try {
//选择redis的db2
jedis.select(2);
//redis的key
String key = "ListApplications:" + userId+":";
String keySize = "ListApplicationsSize:" + userId;
//取得byte[]反序列取得相应的对象
//获取list长度遍历获取list
String listSize=jedis.get(keySize);

if(null!=listSize){
int size=Integer.parseInt(listSize);
if(size>0){
//获取对应的实例对象
for(int x=0;x<size;x++){
byte[] bytes=jedis.get((key+x).getBytes());
//获取缓存，操作
if(null!=bytes){
//空对象
Applications applications=schema.newMessage();
//空对象被反序列
ProtobufIOUtil.mergeFrom(bytes,applications,schema);
//添加返回list
list.add(applications);
}else{
//抛出一个自定义的异常
throw new RedisException(SSOEnum.NOT_REDIS_EMPTY.getInfo()+key+x);
}
}
}else{
//用户配置为空
throw new RedisException(userId+SSOEnum.NOT_APP_CANT_USE.getInfo());
}
}else{
throw new RedisException(SSOEnum.NOT_REDIS_EMPTY.getInfo()+keySize);
}
} finally {
//关闭连接
jedis.close();
}
} catch (Exception e) {
//记录错误日志
logger.error(e.getMessage(), e);
//redis。连接失败，不用redis
throw new RedisException(e.getMessage());
}
return list;
}

//将数据库生成的查询缓存到redis
public void putListApplications(List<Applications> list,String userId) throws Exception{
//获取list的长度保存起来
try{
//获取redis操作对象
Jedis jedis=jedisPool.getResource();
try {
jedis.select(2);
//redis的key
String key = "ListApplications:" + userId + ":";
String keySize = "ListApplicationsSize:" + userId;
//保存list的长度
String back=jedis.setex(keySize,Config.REDIS_TIMEOUT,Integer.toString(list.size()));

if("OK".equals(back)){
//存储实例对象
int x=0;
for(Applications data:list){
//将对象序列化
byte[] bytes=ProtobufIOUtil.toByteArray(data,schema,
LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));

//存储相应的数据
back=jedis.setex((key+x).getBytes(),Config.REDIS_TIMEOUT,bytes);

//判断是否成功
if(!"OK".equals(back)){
throw new RedisException(SSOEnum.NOT_REDIS_CACHE_ERROR.getInfo()+key+x);
}
x++;
}
}else{
throw new RedisException(SSOEnum.NOT_REDIS_CACHE_ERROR.getInfo()+keySize);
}
}finally {
//关闭redis连接
jedis.close();
}
}catch (Exception e){
//记录错误信息到日志
logger.error(e.getMessage(),e);
//redis。连接失败，不用redis
throw new RedisException(e.getMessage());
}
}

//根据查询到的单条实例进行缓存
public Applications getApplications(String id,String code)throws Exception{

try{
//获取redis操作对象
Jedis jedis = jedisPool.getResource();
try {
jedis.select(2);
//设置去得的key
String key="Applications:"+id+":"+code;

//取得缓存信息
byte[] bytes=jedis.get(key.getBytes());
//判断取得的数据
if(null!=bytes){
//新建空对象
Applications applications=schema.newMessage();
//取得缓存对象
ProtobufIOUtil.mergeFrom(bytes,applications,schema);
//返回对象
return applications;
}else{
throw new RedisException(SSOEnum.NOT_REDIS_EMPTY.getInfo()+key);
}
}finally {
jedis.close();
}
}catch (Exception e){
//记录错误信息到日志
logger.error(e.getMessage(),e);
//redis。连接失败，不用redis
throw new RedisException(e.getMessage());
}
}

//获取单条数据的缓存
public void putApplications(Applications data,String id,String code)throws Exception{
try{
//获取redis连接对象
Jedis jedis=jedisPool.getResource();
try{
//选择数据库
jedis.select(2);
//创建key
String key="Applications:"+id+":"+code;

//将对象序列化
byte[] bytes=ProtobufIOUtil.toByteArray(data,schema,
LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
//将数据缓存
String back=jedis.setex(key.getBytes(),Config.REDIS_TIMEOUT,bytes);
//判断是否缓存成功
if(!"OK".equals(back)){
throw new RedisException(SSOEnum.NOT_REDIS_CACHE_ERROR.getInfo()+key);
}
}finally {
//关闭redis连接
jedis.close();
}
}catch (Exception e){
//将错误记录日志
logger.error(e.getMessage(),e);
//redis。连接失败，不用redis
throw new RedisException(e.getMessage());
}
}
}

<bean id="redisApplicationsDao" class="com.mvc.dao.redis.RedisApplicationsDao"/>

package com.mvc.dao.redis;

import com.mvc.dao.ApplicationsDAO;
import com.mvc.entity.Applications;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;

import java.util.List;

import static org.junit.Assert.*;

/**
* Created by yuyu on 2017/4/18.
*/
@RunWith(SpringJUnit4ClassRunner.class)
//告诉junit spring的配置文件
@ContextConfiguration({"classpath:spring/spring-dao.xml"})

public class RedisApplicationsDaoTest {

@Autowired
public RedisApplicationsDao redisApplicationsDao;

@Autowired
public ApplicationsDAO applicationsDAO;

@Test
public void getListApplications() throws Exception {
List<Applications> list= redisApplicationsDao.getListApplications("3");
for(Applications data:list){

System.out.println(data);

}

}

@Test
public void putListApplications() throws Exception {
String id="3";
List<Applications> list=applicationsDAO.selectByUserid(id);
redisApplicationsDao.putListApplications(list,id);
}

@Test
public void putApplications() throws Exception {
String id="1";
String code="TEST";
Applications applications=applicationsDAO.selectByUserIdAndAppCode(id,code);
System.out.println(applications);
redisApplicationsDao.putApplications(applications,id,code);
}

@Test
public void getApplications() throws Exception {
String id="1";
String code="TEST";
Applications applications=redisApplicationsDao.getApplications(id,code);
System.out.println(applications);
}

}