淺析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"));

    }

 

 結果：