浅析redis缓存 在spring中的配置 及其简单的使用

一：如果你需要在你的本地项目中配置redis。那么你首先得需要在你的本地安装redis

参考链接【http://www.runoob.com/redis/redis-install.html】

下载redis在网上有很多 我这里就不多做解释了 下载以后 找到这样的三个文件  这是我们需要操作的 每个版本可能不一样 但这几个肯定是有的

然后 安装这个http://www.runoob.com/redis/redis-install.html  

进行配置 当然很重要的一步是你需要在 redis.windows.conf 加入

#200MB
maxmemory 209715200

#300MB maxheap=1.5*maxmemory  
maxheap 314572800

两句 防止 内存问题 导致的启动不成功。

二：安装redis成功之后 。需要在项目中 进行redis配置

首先 参数如下图所示： 配置完成后 需要在 你的spring.xml中 载入redis-xml ：<import resource="spring-redis.xml"/>

redis_ip=127.0.0.1
redis_port=6379

#当池内没有返回对象时，最大等待时间
redis_maxWaitMillis=10000
#当调用borrow Object方法时，是否进行有效性检查
redis_testOnBorrow=false  
#当调用return Object方法时，是否进行有效性检查
redis_testOnReturn=false

redis_testWhileIdle = true

redis_maxTotal=100  
#最大能够保持idel状态的对象数
redis_maxIdle=10 


#是否开启缓存
enableCache=true

<?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="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
        >
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis_ip}" />
        <property name="port" value="${redis_port}" />
        <property name="poolConfig" ref="jedisPoolConfig" />
    </bean>
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
        <property name="connectionFactory" ref="jedisConnectionFactory"></property>
    </bean>

    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxWaitMillis" value="${redis_maxWaitMillis}"/>
        <property name="testOnBorrow" value="${redis_testOnBorrow}"/>
        <property name="testOnReturn" value="${redis_testOnReturn}"/>
        <property name="testWhileIdle" value="${redis_testWhileIdle}"/>
        <property name="maxTotal" value="${redis_maxTotal}"/>
        <property name="maxIdle" value="${redis_maxIdle}"/>
        <property name="timeBetweenEvictionRunsMillis" value="30000"/>
        <property name="minEvictableIdleTimeMillis" value="30000"/>
    </bean>

    <!--只想操作类 并且把redisTemplate注入进去-->
    <bean class="com.cdms.service.cache.impl.IRedisCacheServiceImpl">
        <property name="redisTemplate" ref="redisTemplate"></property>
        <property name="enableCache" value="${enableCache}"></property>
    </bean>
</beans>

对于在代码中的操作 只需要定义一个借口 和 一个实现类就行

package com.cdms.service.cache;


import com.alibaba.fastjson.TypeReference;

/**
 * 创建 by 草帽boy on 2017/3/31.
 */
public interface ICacheService{

    /**
     * 存入缓存数据
     * @param key 在缓存中的key值
     * @param value 待储存的value值
     * @param liveTime 存活时间 单位是秒
     */
    void set(final String key,final Object value,final long liveTime);

    /**
     * 获取到缓存数据
     * @param key 获取的key值
     * @param type 获取的类型
     * @param <T> 泛型
     * @return 你所需要的类型值
     */
    <T> T get(final String key, final TypeReference<T> type );

    /**
     * 获取剩余存活时间
     * @param key 返回
     * @return
     */
    long getLiveTime(final String key);

    /**
     * 删除缓存中的缓存数据
     * @param key key值
     */
    void del(final String key);
}

package com.cdms.service.cache.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.cdms.service.cache.ICacheService;
import com.cdms.util.SerializeUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.UnsupportedEncodingException;

/**
 * 创建 by 草帽boy on 2017/3/31.
 */
public class IRedisCacheServiceImpl implements ICacheService{

    public final Logger logger = LoggerFactory.getLogger(this.getClass());

    //是否缓存。默认是不缓存
    private static boolean enableCache = false;

    private static RedisTemplate redisTemplate;

    public  boolean isEnableCache() {
        return enableCache;
    }

    public  void setEnableCache(boolean enableCache) {
        IRedisCacheServiceImpl.enableCache = enableCache;
    }

    public  RedisTemplate getRedisTemplate() {
        return redisTemplate;
    }

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



    private void set(final byte[] key, final byte[] value, final long ttl) {
        if (enableCache == false) {
            return;
        }
        redisTemplate.execute(new RedisCallback<Void>() {
            @Override
            public Void doInRedis(RedisConnection con) {
                try {
                    con.set(key, value);
                    if (ttl != 0) con.expire(key, ttl);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                return null;
            }
        });
    }

    protected byte[] get(final byte[] key) {
        if (enableCache == false) {
            return null;
        }
        try {
            return (byte[]) redisTemplate.execute(new RedisCallback<byte[]>() {
                @Override
                public byte[] doInRedis(RedisConnection con) {

                    return con.get(key);

                }
            });
        } catch (Exception ex) {
            ex.printStackTrace();
            return null;
        }
    }

    private long ttl(final byte[] key) {
        if (enableCache == false) {
            return 0;
        }
        try {
            Long t = (Long) redisTemplate.execute(new RedisCallback<Long>() {
                @Override
                public Long doInRedis(RedisConnection con) {
                    return con.ttl(key);
                }
            });

            return t.longValue();

        }catch (Exception ex){
            logger.error(ex.getMessage(), ex);
            return 0;
        }
    }

    protected void del(final byte[]... key) {
        if (enableCache == false || key == null) {
            return;
        }
        try {
            redisTemplate.execute(new RedisCallback<Void>() {
                @Override
                public Void doInRedis(RedisConnection con) {
                    con.del(key);
                    return null;
                }
            });
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    @Override
    public void set(String key, Object value, long liveTime) {
        byte[] keys = key.getBytes();
        String valString = JSON.toJSONString(value);
        byte[] values = valString.getBytes();
        set(keys,values,liveTime);
    }

    @Override
    public <T> T get(String key, TypeReference<T> type) {
        byte[] valueData = get(key.getBytes());
        if(valueData==null||valueData.length<0){
            return null;
        }
        String valString = "";
        try {
            valString = new String(valueData,"UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        T data = JSON.parseObject(valString,type);
        return data;
    }

    @Override
    public long getLiveTime(String key) {
        return ttl(key.getBytes());
    }

    @Override
    public void del(String key) {
        del(key.getBytes());
    }


}

三:测试 当你需要进行写入redis缓存的时候 你的redis服务器必须是开着的

就是 你的reids应该在这个状态：

@Test
    public void tests(){


        List<String> mm = new ArrayList<String>();
        mm.add("你好啊");
        mm.add("tests");
        iCacheService.set("test",mm,60);
        List<String> tesss = iCacheService.get("test",new TypeReference<List<String>>(){});
       if(tesss!=null){
           System.out.println(">>>>>>>>>>>"+tesss);
       }
        System.out.println(">>>>>>>>>>>>>"+iCacheService.getLiveTime("test"));

    }

 结果：