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

    }

结果:

时间: 2024-10-12 21:49:32

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

c3p0在spring中的配置

在大家的开发和学习当中应该经常用到数据库的连接和使用,不过连接 的方式就有很多种方式了,比方说用最最简单的JDBC 也好,还有用比 较复杂一点的就是数据库连接池,当然还有使用DBCP的连接的,各种方 法有各种方法的优势面和缺点,这据需要我们根据具体情况具体分析了 ,比方说要是一个并不是很大的项目的话,而且 使用的硬件机器的性 能也不是非常好的话,估计就没有必要使用数据库连接池了,毕竟连接 池平时总是管理着连接, 就会极大的占用这机器的运行性能和效率. (这里的C3P0的使用是基于Spring框架

39、生鲜电商平台-redis缓存在商品中的设计与架构

说明:Java开源生鲜电商平台-redis缓存在商品中的设计与架构. 1. 各种计数,商品维度计数和用户维度计数 说起电商,肯定离不开商品,而附带商品有各种计数(喜欢数,评论数,鉴定数,浏览数,etc),Redis的命令都是原子性的,你可以轻松地利用INCR,DECR等命令来计数. 商品维度计数(喜欢数,评论数,鉴定数,浏览数,etc)  采用Redis 的类型: Hash. 如果你对redis数据类型不太熟悉,可以参考 http://redis.io/topics/data-types-int

redis在spring中的配置及java代码实现

1.建一个redis.properties属性文件 # Redis Setting redis.addr = 127.0.0.1 redis.port = 6379 redis.auth = master redis.maxIdle = 200 redis.maxActive = 1024 redis.maxWait = 10000 redis.timeOut = 10000 redis.testOnBorrow = true 2.新建一个RedisUtil.java文件,文件代码如下: pac

redis缓存在项目中的使用

关于redis为什么能作为缓存这个问题我们就不说了,直接来说一下redis缓存到底如何在项目中使用吧: 1.redis缓存如何在项目中配置? 1.1redis缓存单机版和集群版配置?(redis的客户端jedis常用) <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:co

Velocity初探小结--Velocity在spring中的配置和使用

最近正在做的项目前端使用了Velocity进行View层的数据渲染,之前没有接触过,草草过了一遍,就上手开始写,现在又回头细致的看了一遍,做个笔记. velocity是一种基于java的模板引擎技术,有点类似与JSP,它允许页面设计者引用Java中定义的方法.前端页面设计者和后端Java开发者能够同时使用MVC的模式开发网站,这样前端能够把精力放在页面的设计上,后端也可以把精力放在代码开发上.Velocity把Java代码从Web页面中分离, 使网站可维护性更强. 注:项目使用的是Spring+

spring中xml配置和autowired混用

1.类的混用: 配置文件中的配置: <bean id="a" class="com.ab.cc.A" /> 类中的配置 @Autowired A a; 这样的好处,可以少掉get/set方法 [email protected]和@Resource的区别 Autowired默认是根据byType自动装配,所以有多个类型的xml或者注解某个类的时候,会报错,这时候可以再添加@Qualifier注解,指定名称.这个是spring自带的,换框架的时候,要spri

关于spring中注解配置的问题

今天写spring的时候,想用注解配置,但不巧的是用Junit工具测试的时候出错了,检查了很久的代码,发现并不是代码的问题,那就有些奇怪了. 后来去百度,回答的奇奇怪怪,和我的问题沾边的不多,最后还是FQ找到的答案,废话不多说,先贴出错误提示: org.springframework.beans.factory.BeanDefinitionStoreException: Unexpected exception parsing XML document from class path resou

spring-logger spring中日志配置

默认日志 Logback:默认情况下,Spring Boot会用Logback来记录日志,并用INFO级别输出到控制台.在运行应用程序和其他例子时,你应该已经看到很多INFO级别的日志了. 从上图可以看到,日志输出内容元素具体如下: 时间日期:精确到毫秒日志级别:ERROR, WARN, INFO, DEBUG or TRACE进程ID分隔符:— 标识实际日志的开始线程名:方括号括起来(可能会截断控制台输出)Logger名:通常使用源代码的类名日志内容添加日志依赖假如maven依赖中添加了spr

Spring中Hibernate配置笔记

ApplicatonContext.xml中的配置: <jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/global/ds" /> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <proper