`

spring + redis 实现数据的缓存

 
阅读更多
http://www.cnblogs.com/0201zcr/p/4987561.html

通过redis缓存数据。（目的不是加快查询的速度，而是减少数据库的负担）　　

2、所需jar包

　　

　　注意：jdies和commons-pool两个jar的版本是有对应关系的，注意引入jar包是要配对使用，否则将会报错。因为commons-pooljar的目录根据版本的变化，目录结构会变。前面的版本是org.apache.pool，而后面的版本是org.apache.pool2...

style="background-color: #0098dd; color: white; font-size: 17px; font-weight: bold;"3、redis简介

　　redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)

4、编码实现

1）、配置的文件（properties）

　　将那些经常要变化的参数配置成独立的propertis，方便以后的修改

　　redis.properties

复制代码
redis.hostName=127.0.0.1
redis.port=6379
redis.timeout=15000
redis.usePool=true

redis.maxIdle=6
redis.minEvictableIdleTimeMillis=300000
redis.numTestsPerEvictionRun=3
redis.timeBetweenEvictionRunsMillis=60000
复制代码
2)、spring-redis.xml

　　redis的相关参数配置设置。参数的值来自上面的properties文件

复制代码
<beans xmlns="http://www.springframework.org/schema/beans"  
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName"> 
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> 
        <!-- <property name="maxIdle" value="6"></property> 
        <property name="minEvictableIdleTimeMillis" value="300000"></property> 
        <property name="numTestsPerEvictionRun" value="3"></property> 
        <property name="timeBetweenEvictionRunsMillis" value="60000"></property>   -->
       
        <property name="maxIdle" value="${redis.maxIdle}"></property> 
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"></property> 
        <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"></property> 
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"></property>
    </bean> 
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy"> 
        <property name="poolConfig" ref="jedisPoolConfig"></property> 
        <property name="hostName" value="${redis.hostName}"></property> 
        <property name="port" value="${redis.port}"></property> 
        <property name="timeout" value="${redis.timeout}"></property> 
        <property name="usePool" value="${redis.usePool}"></property> 
    </bean> 
    <bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate"> 
        <property name="connectionFactory" ref="jedisConnectionFactory"></property> 
        <property name="keySerializer"> 
            <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/> 
        </property> 
        <property name="valueSerializer"> 
            <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/> 
        </property> 
    </bean> 
</beans> 
复制代码
3）、applicationContext.xml

　　spring的总配置文件，在里面假如一下的代码

复制代码
<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
        <property name="ignoreResourceNotFound" value="true" />
        <property name="locations">
            <list>
               
                <value>classpath*:/META-INF/config/redis.properties</value>
            </list>
        </property>
    </bean>

<import resource="spring-redis.xml" />
复制代码
4）、web。xml

　　设置spring的总配置文件在项目启动时加载

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:/META-INF/applicationContext.xml</param-value><!--  -->
    </context-param>
5）、redis缓存工具类

ValueOperations　　——基本数据类型和实体类的缓存
ListOperations　　   ——list的缓存
SetOperations　　  ——set的缓存

HashOperations　　Map的缓存

复制代码
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

@Service
public class RedisCacheUtil<T>
{

   
    @Autowired @Qualifier("jedisTemplate")
    public RedisTemplate redisTemplate;
   

   
    /**
     * 缓存基本的对象，Integer、String、实体类等
     * @param key    缓存的键值
     * @param value    缓存的值
     * @return        缓存的对象
     */
    public <T> ValueOperations<String,T> setCacheObject(String key,T value)
    {
       
        ValueOperations<String,T> operation = redisTemplate.opsForValue();
        operation.set(key,value);
        return operation;
    }
   
    /**
     * 获得缓存的基本对象。
     * @param key        缓存键值
     * @param operation
     * @return            缓存键值对应的数据
     */
    public <T> T getCacheObject(String key/*,ValueOperations<String,T> operation*/)
    {
        ValueOperations<String,T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }
   
    /**
     * 缓存List数据
     * @param key        缓存的键值
     * @param dataList    待缓存的List数据
     * @return            缓存的对象
     */
    public <T> ListOperations<String, T> setCacheList(String key,List<T> dataList)
    {
        ListOperations listOperation = redisTemplate.opsForList();
        if(null != dataList)
        {
            int size = dataList.size();
            for(int i = 0; i < size ; i ++)
            {
               
                listOperation.rightPush(key,dataList.get(i));
            }
        }
       
        return listOperation;
    }
   
    /**
     * 获得缓存的list对象
     * @param key    缓存的键值
     * @return        缓存键值对应的数据
     */
    public <T> List<T> getCacheList(String key)
    {
        List<T> dataList = new ArrayList<T>();
        ListOperations<String,T> listOperation = redisTemplate.opsForList();
        Long size = listOperation.size(key);
       
        for(int i = 0 ; i < size ; i ++)
        {
            dataList.add((T) listOperation.leftPop(key));
        }
       
        return dataList;
    }
   
    /**
     * 缓存Set
     * @param key        缓存键值
     * @param dataSet    缓存的数据
     * @return            缓存数据的对象
     */
    public <T> BoundSetOperations<String,T> setCacheSet(String key,Set<T> dataSet)
    {
        BoundSetOperations<String,T> setOperation = redisTemplate.boundSetOps(key);   
        /*T[] t = (T[]) dataSet.toArray();
             setOperation.add(t);*/
       
       
        Iterator<T> it = dataSet.iterator();
        while(it.hasNext())
        {
            setOperation.add(it.next());
        }
       
        return setOperation;
    }
   
    /**
     * 获得缓存的set
     * @param key
     * @param operation
     * @return
     */
    public Set<T> getCacheSet(String key/*,BoundSetOperations<String,T> operation*/)
    {
        Set<T> dataSet = new HashSet<T>();
        BoundSetOperations<String,T> operation = redisTemplate.boundSetOps(key);   
       
        Long size = operation.size();
        for(int i = 0 ; i < size ; i++)
        {
            dataSet.add(operation.pop());
        }
        return dataSet;
    }
   
    /**
     * 缓存Map
     * @param key
     * @param dataMap
     * @return
     */
    public <T> HashOperations<String,String,T> setCacheMap(String key,Map<String,T> dataMap)
    {
       
        HashOperations hashOperations = redisTemplate.opsForHash();
        if(null != dataMap)
        {
           
            for (Map.Entry<String, T> entry : dataMap.entrySet()) { 
                 
                /*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  */
                hashOperations.put(key,entry.getKey(),entry.getValue());
            }
           
        }
       
        return hashOperations;
    }
   
    /**
     * 获得缓存的Map
     * @param key
     * @param hashOperation
     * @return
     */
    public <T> Map<String,T> getCacheMap(String key/*,HashOperations<String,String,T> hashOperation*/)
    {
        Map<String, T> map = redisTemplate.opsForHash().entries(key);
        /*Map<String, T> map = hashOperation.entries(key);*/
        return map;
    }
   
   
   
   
   
   
   
    /**
     * 缓存Map
     * @param key
     * @param dataMap
     * @return
     */
    public <T> HashOperations<String,Integer,T> setCacheIntegerMap(String key,Map<Integer,T> dataMap)
    {
        HashOperations hashOperations = redisTemplate.opsForHash();
        if(null != dataMap)
        {
           
            for (Map.Entry<Integer, T> entry : dataMap.entrySet()) { 
                 
                /*System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  */
                hashOperations.put(key,entry.getKey(),entry.getValue());
            }
           
        }
       
        return hashOperations;
    }
   
    /**
     * 获得缓存的Map
     * @param key
     * @param hashOperation
     * @return
     */
    public <T> Map<Integer,T> getCacheIntegerMap(String key/*,HashOperations<String,String,T> hashOperation*/)
    {
        Map<Integer, T> map = redisTemplate.opsForHash().entries(key);
        /*Map<String, T> map = hashOperation.entries(key);*/
        return map;
    }
}
   
复制代码
6）、测试

　　这里测试我是在项目启动的时候到数据库中查找出国家和城市的数据，进行缓存，之后将数据去出

6.1  项目启动时缓存数据

复制代码
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Service;

import com.test.model.City;
import com.test.model.Country;
import com.zcr.test.User;

/*
* 监听器，用于项目启动的时候初始化信息
*/
@Service
public class StartAddCacheListener implements ApplicationListener<ContextRefreshedEvent>
{
    //日志
    private final Logger log= Logger.getLogger(StartAddCacheListener.class);
   
    @Autowired
    private RedisCacheUtil<Object> redisCache;
   
    @Autowired
    private BrandStoreService brandStoreService;
   
    @Override
    public void onApplicationEvent(ContextRefreshedEvent  event)
    {
        //spring 启动的时候缓存城市和国家等信息
        if(event.getApplicationContext().getDisplayName().equals("Root WebApplicationContext"))
        {
            System.out.println("\n\n\n_________\n\n缓存数据 \n\n ________\n\n\n\n");
            List<City> cityList = brandStoreService.selectAllCityMessage();
            List<Country> countryList = brandStoreService.selectAllCountryMessage();
           
            Map<Integer,City> cityMap = new HashMap<Integer,City>();
           
            Map<Integer,Country> countryMap = new HashMap<Integer, Country>();
           
            int cityListSize = cityList.size();
            int countryListSize = countryList.size();
           
            for(int i = 0 ; i < cityListSize ; i ++ )
            {
                cityMap.put(cityList.get(i).getCity_id(), cityList.get(i));
            }
           
            for(int i = 0 ; i < countryListSize ; i ++ )
            {
                countryMap.put(countryList.get(i).getCountry_id(), countryList.get(i));
            }
           
            redisCache.setCacheIntegerMap("cityMap", cityMap);
            redisCache.setCacheIntegerMap("countryMap", countryMap);
        }
    }
   
}
复制代码
6.2  获取缓存数据

复制代码
    @Autowired
    private RedisCacheUtil<User> redisCache;

    @RequestMapping("testGetCache")
    public void testGetCache()
    {
        /*Map<String,Country> countryMap = redisCacheUtil1.getCacheMap("country");
        Map<String,City> cityMap = redisCacheUtil.getCacheMap("city");*/
        Map<Integer,Country> countryMap = redisCacheUtil1.getCacheIntegerMap("countryMap");
        Map<Integer,City> cityMap = redisCacheUtil.getCacheIntegerMap("cityMap");
       
        for(int key : countryMap.keySet())
        {
            System.out.println("key = " + key + ",value=" + countryMap.get(key));
        }
       
        System.out.println("------------city");
        for(int key : cityMap.keySet())
        {
            System.out.println("key = " + key + ",value=" + cityMap.get(key));
        }
    }    
复制代码
　　由于Spring在配置文件中配置的bean默认是单例的，所以只需要通过Autowired注入，即可得到原先的缓存类。
分享到：
| Redis 缓存 + Spring 的集成示例
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    springMybatis+redis三级缓存框架

    在Spring中，我们可以通过RedisTemplate或JedisTemplate操作Redis，实现数据的存取和缓存管理。 在实际开发中，我们需要关注以下关键点： 1. **缓存同步**：当多台服务器共享同一份缓存时，如何确保数据的一致性是...

    spring + ehcache + redis两级缓存

    在缓存管理方面，Spring 提供了 Spring Cache抽象层，可以方便地集成各种缓存实现，如Ehcache、Hazelcast或Redis。 **Ehcache** 是一个广泛使用的Java缓存库，适合在内存中存储数据。它提供了一种快速访问最近使用...

    spring+mybatis+redis缓存入门

    在IT行业中，构建高效、可扩展的Web应用是至关重要的，而Spring框架、MyBatis持久层框架以及Redis缓存系统的结合使用，是实现这一目标的常见方式。本教程主要针对初学者，介绍如何将这三者整合，实现数据缓存功能，...

    shiro+spring+data+session+redis实现单点登录

    本案例聚焦于使用Apache Shiro、Spring、Spring Data以及Redis来实现单点登录功能，下面将详细解释这些组件以及它们如何协同工作。 **Apache Shiro** Apache Shiro是一款轻量级的安全框架，提供了认证、授权、会话...

    spring+redis整合

    在IT行业中，Spring框架与Redis的整合是常见的数据缓存和会话管理解决方案。这个"spring+redis整合"项目展示了如何利用Spring框架和Redis数据库来实现一个高效的、高可用的登录系统，其中会话（Session）由Redis进行...

    Springboot+SpringSecurity+SpringSession+Redis+Mybatis-Plus+Swwager.zip

    Spring Session通过将会话数据存储在Redis这样的分布式缓存中，实现了跨服务器的会话共享，提高了系统的可扩展性。 Redis是一款高性能的Key-Value数据库，常用于缓存和会话管理。在这个项目中，Redis作为Spring ...

    maven+springmvc+redis+mybatis整合

    5. 集成Redis，配置Redis连接池，编写RedisTemplate或StringRedisTemplate的配置，实现数据缓存操作。 6. 编写Spring MVC的Controller，通过注解将HTTP请求映射到处理方法，调用服务层完成业务逻辑。 7. 运行项目，...

    Spring + Redis + 注解缓存 源码下载

    这是Maven项目，Spring集成Redis来实现注解缓存，代码配置方面都有详细代码，并在相关配置文件里添加了相关参考文档地址，都是博主自己一手敲出来的，如果觉得资源还可以，请五星好评哦，亲（づ￣3￣）づ╭❤～

    Spring+Struts2+hibernate+Redis整合

    通过Action类和拦截器，可以实现与Spring的无缝集成，同时也可以利用Spring的缓存功能，将频繁访问的数据存储在Redis中。 3. **Hibernate框架**：Hibernate是Java领域的一个对象关系映射(ORM)框架，它简化了数据库...

    springmvc+shiro+spring+hibernate+redis缓存管理示例

    本示例项目"springmvc+shiro+spring+hibernate+redis缓存管理示例"提供了一个全面的框架整合实例，它将几个关键的技术组件融合在一起，旨在帮助开发者实现更优的性能和安全性。以下是关于这些技术组件及其在项目中的...

    spring + redis集群

    Redis集群是Redis的一个重要特性，它允许你分散数据到多个节点上，实现数据的高可用性和水平扩展。构建Redis集群时，需要注意以下几点： 1. **集群配置**：至少需要6个节点（3主3从）来确保数据冗余和故障转移。每个...

    vue+springboot+redis+kaptcha实现登录验证码

    本教程将介绍如何结合Vue.js前端框架、Spring Boot后端框架、Redis缓存服务以及Kaptcha验证码技术，实现一个前后端分离的登录页面验证码功能。这个组合可以提供高效、安全且用户友好的验证机制。 首先，Vue.js是一...

    shiro+ springMVC + Redis+mysql 实现 单点登录

    - Redis是一个内存中的数据结构存储系统，常作为数据库、缓存和消息中间件使用。 - 在SSO系统中，Redis通常用作票据（Ticket）服务器，存储用户的登录票据（如JWT或TGT）。 - 当用户在任一子系统登录后，系统会在...

    Spring Session + redis实现session共享

    Spring Session的核心思想是将session数据从传统的JVM内存中移出，存储到一个独立的数据存储系统，如Redis，这样可以实现session在多台服务器之间的共享。 Redis是一个高性能的键值数据库，常用于缓存和消息代理。...

    spring+redis作为缓存，带springTest配置

    Spring框架与Redis的结合使用，正是为了实现高效的缓存管理。在这个项目中，“spring+redis作为缓存，带springTest配置”旨在展示如何在Spring应用中集成Redis作为缓存，并利用Spring Test进行测试。 首先，我们...

    spring + redis + sentinel 配置

    而Redis是一个高性能的键值数据存储系统，常被用作缓存和消息代理，提升应用程序的性能和响应速度。Sentinel是Redis的一个高可用性解决方案，它可以监控Redis实例，并在主节点出现问题时自动进行故障转移，确保服务...

    springmvc+mybatis+redis

    在IT行业中，SpringMVC、MyBatis和Redis是三个非常重要的技术组件，它们分别扮演着Web应用架构、数据持久层框架和高速缓存的角色。接下来，我们将详细探讨这三个技术如何整合并发挥协同作用。 首先，SpringMVC是...

    Springboot+Mybatis-plus+ SpringMvc+Shiro+Redis企业级报表后台管理系统.rar

    存储过程等），用Redis做中间缓存，缓存数据 实现异步处理，定时任务，整合Quartz Job以及Spring Task 邮件管理功能， 整合spring-boot-starter-mail发送邮件等， 数据源:druid 用户管理，菜单管理，角色管理，代码...

    基于Spring+Redis实现的缓存操作demo完整源码分享

    客户端使用Redisson 包含redission对分布式数据结构list，string，hashmap，zset，set和对象的读写实例 包含一个redission的分布式可重入锁RLock使用实例 分布式对象：地理空间对象、...实现分布式锁，解决并发问题

Magicbox
Global site tag (gtag.js) - Google Analytics