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

在SSM(Spring + Spring MVC +Mybatis)项目中使用到Redis缓存，在网上查找了一些方法和文档后总结出自己可用的一些配置如下：

1、pom.xml文件中引入需要的依赖

<!-- 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>
      <artifactId>protostuff-runtime </artifactId>
      <version>1.0.8</version>
    </dependency>

2、在spring配置文件中配置添加如下配置，配置文件中配置

<!-- 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

3、在DAO层中新建redis包，新建RedisApplicationsDao.java(需要缓存的对象)

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());
        }
    }
}

4、在对应spring配置文件中加入该文件的依赖

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

5、创建单元测试类检测当前的编码是否可行

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);
    }

}

6、运行的结果