spring redis 存储对象 redis在spring中的配置

转载

幸福的地图 2023-06-28 16:13:18

文章标签 spring redis 存储对象 redis spring ide 文章分类 Redis 数据库

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

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

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

spring redis 存储对象 redis在spring中的配置_spring 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应该在这个状态：

spring redis 存储对象 redis在spring中的配置_ide_02

@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"));

    }

结果：

spring redis 存储对象 redis在spring中的配置_spring redis 存储对象_03