SpringMVC Cache注解+Redis

依赖jar包:
Xml代码  收藏代码

<!-- redis -->  
            <dependency>  
                <groupId>org.springframework.data</groupId>  
                <artifactId>spring-data-redis</artifactId>  
                <version>1.3.4.RELEASE</version>  
            </dependency>  
      
            <dependency>  
                <groupId>redis.clients</groupId>  
                <artifactId>jedis</artifactId>  
                <version>2.5.2</version>  
            </dependency>

applicationContext-cache-redis.xml

Xml代码  收藏代码

<context:property-placeholder  
            location="classpath:/config/properties/redis.properties" />  
      
        <!-- 启用缓存注解功能,这个是必须的,否则注解不会生效,另外,该注解一定要声明在spring主配置文件中才会生效 -->  
        <cache:annotation-driven cache-manager="cacheManager" />  
      
        <!-- spring自己的换管理器,这里定义了两个缓存位置名称 ,既注解中的value -->  
        <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">  
            <property name="caches">  
                <set>  
                    <bean class="org.cpframework.cache.redis.RedisCache">  
                        <property name="redisTemplate" ref="redisTemplate" />  
                        <property name="name" value="default"/>  
                    </bean>  
                    <bean class="org.cpframework.cache.redis.RedisCache">  
                        <property name="redisTemplate" ref="redisTemplate02" />  
                        <property name="name" value="commonCache"/>  
                    </bean>  
                </set>  
            </property>  
        </bean>  
      
        <!-- redis 相关配置 -->  
        <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
            <property name="maxIdle" value="${redis.maxIdle}" />        
            <property name="maxWaitMillis" value="${redis.maxWait}" />  
            <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
        </bean>  
      
        <bean id="connectionFactory"  
            class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
            p:host-name="${redis.host}" p:port="${redis.port}" p:pool-config-ref="poolConfig"  
            p:database="${redis.database}" />  
      
        <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">  
            <property name="connectionFactory" ref="connectionFactory" />  
        </bean>  
          
        <bean id="connectionFactory02"  
            class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
            p:host-name="${redis.host}" p:port="${redis.port}" p:pool-config-ref="poolConfig"  
            p:database="${redis.database}" />  
      
        <bean id="redisTemplate02" class="org.springframework.data.redis.core.RedisTemplate">  
            <property name="connectionFactory" ref="connectionFactory02" />  
        </bean>

redis.properties

Java代码  收藏代码

# Redis settings    
    # server IP  
    redis.host=192.168.xx.xx  
    # server port  
    redis.port=6379     
    # use dbIndex  
    redis.database=0  
    # 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例  
    redis.maxIdle=300    
    # 表示当borrow(引入)一个jedis实例时,最大的等待时间,如果超过等待时间(毫秒),则直接抛出JedisConnectionException;  
    redis.maxWait=3000    
    # 在borrow一个jedis实例时,是否提前进行validate操作;如果为true,则得到的jedis实例均是可用的  
    redis.testOnBorrow=true

RedisCache.java

Java代码  收藏代码

package org.cpframework.cache.redis;  
      
    import java.io.ByteArrayInputStream;  
    import java.io.ByteArrayOutputStream;  
    import java.io.IOException;  
    import java.io.ObjectInputStream;  
    import java.io.ObjectOutputStream;  
      
    import org.springframework.cache.Cache;  
    import org.springframework.cache.support.SimpleValueWrapper;  
    import org.springframework.dao.DataAccessException;  
    import org.springframework.data.redis.connection.RedisConnection;  
    import org.springframework.data.redis.core.RedisCallback;  
    import org.springframework.data.redis.core.RedisTemplate;  
      
      
    public class RedisCache implements Cache {  
      
        private RedisTemplate<String, Object> redisTemplate;  
        private String name;  
      
        public RedisTemplate<String, Object> getRedisTemplate() {  
            return redisTemplate;  
        }  
      
        public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {  
            this.redisTemplate = redisTemplate;  
        }  
      
        public void setName(String name) {  
            this.name = name;  
        }  
      
        @Override  
        public String getName() {  
            // TODO Auto-generated method stub  
            return this.name;  
        }  
      
        @Override  
        public Object getNativeCache() {  
            // TODO Auto-generated method stub  
            return this.redisTemplate;  
        }  
      
        @Override  
        public ValueWrapper get(Object key) {  
            // TODO Auto-generated method stub  
            final String keyf = (String) key;  
            Object object = null;  
            object = redisTemplate.execute(new RedisCallback<Object>() {  
                public Object doInRedis(RedisConnection connection)  
                        throws DataAccessException {  
      
                    byte[] key = keyf.getBytes();  
                    byte[] value = connection.get(key);  
                    if (value == null) {  
                        return null;  
                    }  
                    return toObject(value);  
      
                }  
            });  
            return (object != null ? new SimpleValueWrapper(object) : null);  
        }  
      
        @Override  
        public void put(Object key, Object value) {  
            // TODO Auto-generated method stub  
            final String keyf = (String) key;  
            final Object valuef = value;  
            final long liveTime = 86400;  
      
            redisTemplate.execute(new RedisCallback<Long>() {  
                public Long doInRedis(RedisConnection connection)  
                        throws DataAccessException {  
                    byte[] keyb = keyf.getBytes();  
                    byte[] valueb = toByteArray(valuef);  
                    connection.set(keyb, valueb);  
                    if (liveTime > 0) {  
                        connection.expire(keyb, liveTime);  
                    }  
                    return 1L;  
                }  
            });  
        }  
      
        /**
         * 描述 : <Object转byte[]>. <br>
         * <p>
         * <使用方法说明>
         * </p>
         *  
         * @param obj
         * @return
         */  
        private byte[] toByteArray(Object obj) {  
            byte[] bytes = null;  
            ByteArrayOutputStream bos = new ByteArrayOutputStream();  
            try {  
                ObjectOutputStream oos = new ObjectOutputStream(bos);  
                oos.writeObject(obj);  
                oos.flush();  
                bytes = bos.toByteArray();  
                oos.close();  
                bos.close();  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            }  
            return bytes;  
        }  
      
        /**
         * 描述 : <byte[]转Object>. <br>
         * <p>
         * <使用方法说明>
         * </p>
         *  
         * @param bytes
         * @return
         */  
        private Object toObject(byte[] bytes) {  
            Object obj = null;  
            try {  
                ByteArrayInputStream bis = new ByteArrayInputStream(bytes);  
                ObjectInputStream ois = new ObjectInputStream(bis);  
                obj = ois.readObject();  
                ois.close();  
                bis.close();  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            } catch (ClassNotFoundException ex) {  
                ex.printStackTrace();  
            }  
            return obj;  
        }  
      
        @Override  
        public void evict(Object key) {  
            // TODO Auto-generated method stub  
            final String keyf = (String) key;  
            redisTemplate.execute(new RedisCallback<Long>() {  
                public Long doInRedis(RedisConnection connection)  
                        throws DataAccessException {  
                    return connection.del(keyf.getBytes());  
                }  
            });  
        }  
      
        @Override  
        public void clear() {  
            // TODO Auto-generated method stub  
            redisTemplate.execute(new RedisCallback<String>() {  
                public String doInRedis(RedisConnection connection)  
                        throws DataAccessException {  
                    connection.flushDb();  
                    return "ok";  
                }  
            });  
        }  
      
    }

时间: 2024-11-05 21:50:01

SpringMVC Cache注解+Redis的相关文章

SpringBoot2.0 基础案例(13):基于Cache注解模式,管理Redis缓存

本文源码 GitHub地址:知了一笑 https://github.com/cicadasmile/spring-boot-base 一.Cache缓存简介 从Spring3开始定义Cache和CacheManager接口来统一不同的缓存技术:Cache接口为缓存的组件规范定义,包含缓存的各种操作集合:Cache接口下Spring提供了各种缓存的实现:如RedisCache,EhCacheCache ,ConcurrentMapCache等: 二.核心API 1.Cache缓存接口定义缓存操作.

springMVC+Spring+Mybatis+Redis

SPRINGMVC+MYBATIS+SPRING+REDIS 只作参考,以防忘记使用! mybatis的配置文件: <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd&

Spring Cache集成redis

Redis是一个key-value存储系统.和Memcached类似,它支持存储的value类型相对更多,包括string(字符串).list(链表).set(集合).zset(sorted set –有序集合)和hash(哈希类型).这些数据类型都支持push/pop.add/remove及取交集并集和差集及更丰富的操作,而且这些操作都是原子性的.在此基础上,redis支持各种不同方式的排序.与memcached一样,为了保证效率,数据都是缓存在内存中.区别的是redis会周期性的把更新的数据

Spring Boot (24) 使用Spring Cache集成Redis

Spring 3.1引入了基于注解(annotation)的缓存(cache)技术,它本质不是一个具体的缓存实现方案,而是一个对缓存使用的抽象,通过在既有代码中添加少量它定义的个助攻annotation,就能够达到缓存方法的返回对象的效果. 特点 具备相当好的灵活性,不仅能够使用SpEL来定义缓存的key和各种condition,还提供开箱即用的缓存临时存储方案,也支持和主流的专业缓存例如EHCache.Redis.Guava的集成. 基于annotation即可使得现有代码支持缓存 开箱即用O

Spring Boot(八)集成Spring Cache 和 Redis

在Spring Boot中添加spring-boot-starter-data-redis依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 在application.properties中指定redis服务器IP.端口和密码.

springboot整合spring @Cache和Redis

转载请注明出处:https://www.cnblogs.com/wenjunwei/p/10779450.html spring基于注解的缓存 对于缓存声明,spring的缓存提供了一组java注解: @Cacheable:触发缓存写入. @CacheEvict:触发缓存清除. @CachePut:更新缓存(不会影响到方法的运行). @Caching:重新组合要应用于方法的多个缓存操作. @CacheConfig:设置类级别上共享的一些常见缓存设置. @Cacheable注解 顾名思义,@Cac

SpringMVC的注解方式

mvc-servlet.xml <?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:context="http://www.springf

springMvc的注解注入方式

springMvc的注解注入方式 最近在看springMvc的源码,看到了该框架的注入注解的部分觉的有点吃力,可能还是对注解的方面的知识还认识的不够深刻,所以特意去学习注解方面的知识.由于本人也是抱着学习的态度来阅读源码,若文章在表述和代码方面如有不妥之处,欢迎批评指正.留下你的脚印,欢迎评论!希望能互相学习. 1,首先定义三个常用的注解Service,Autowired,Contrller:(主要的解释都在代码中有,在这里就不多陈述) Service: package com.lishun.A

04springMVC结构,mvc模式,spring-mvc流程,spring-mvc的第一个例子,三种handlerMapping,几种控制器,springmvc基于注解的开发,文件上传,拦截器,s

 1. Spring-mvc介绍 1.1市面上流行的框架 Struts2(比较多) Springmvc(比较多而且属于上升的趋势) Struts1(即将被淘汰) 其他 1.2  spring-mvc结构 DispatcherServlet:中央控制器,把请求给转发到具体的控制类 Controller:具体处理请求的控制器(配置文件方式需要配置,注解方式不用配置) handlerMapping:映射处理器,负责映射中央处理器转发给controller时的映射策略 ModelAndView:服务