`
neil-jh
  • 浏览: 148108 次
  • 性别: Icon_minigender_1
  • 来自: 上海
文章分类
社区版块
存档分类
最新评论

Spring Cache

阅读更多

Spring 2.0.6,Ehcache用spring2.0.6带的1.2.4
加入的jar
Spring.jar
commons-logging.jar
ehcache-1.2.4.jar
log4j-1.2.14.jar
junit3.8.1.jar

      示例描述:通过省ID找它下面的市,缓存市.

1.我用IdAndName类封装市,可以替换成String.

package com.chenlb.study.ehcache;

/**
 * 2007-8-2
 * 
@author chenlb
 * 
 
*/
public class IdAndName {

    
private Integer id;
    
private String name;
    
    
public IdAndName() {}
    
    
    
/**
     * 
@param id
     * 
@param name
     
*/
    
public IdAndName(Integer id, String name) {
        
super();
        
this.id = id;
        
this.name = name;
    }
    
    
public Integer getId() {
        
return id;
    }
    
public void setId(Integer id) {
        
this.id = id;
    }
    
public String getName() {
        
return name;
    }
    
public void setName(String name) {
        
this.name = name;
    }    
}


2.定义一个接口CityCache

package com.chenlb.study.ehcache;

import java.util.List;

/**
 * 2007-8-2
 * 
@author chenlb
 * 
 
*/
public interface CityCache {
    
public List<IdAndName> getCitys(Integer provinceId);
}


3.定义数据类CityData,

/*
 * 
 
*/
package com.chenlb.study.ehcache;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 2007-8-2
 * 
@author chenlb
 * 
 
*/
public class CityData {

    
static Map<Integer, List<IdAndName>> provinces = new HashMap<Integer, List<IdAndName>>();
    
    
static {
        ArrayList
<IdAndName> al = new ArrayList<IdAndName>();    //广东
        al.add(new IdAndName(1,"广州市"));    al.add(new IdAndName(2,"梅州市"));
        provinces.put(
1, al);
        
        al 
= new ArrayList<IdAndName>();    //上海
        al.add(new IdAndName(1,"黄浦"));    al.add(new IdAndName(2,"卢湾"));
        provinces.put(
2, al);
    }
    
    
/**
     * 此方法可以换成从数据库得到数据
     * 
@param provinceId
     * 
@return
     
*/
    
public static List<IdAndName> getCityByProvince(Integer provinceId) {
        
return provinces.get(provinceId);
    }
}


4.市缓存实现CityCacheMemoryImpl

/*
 * 
 
*/
package com.chenlb.study.ehcache;

import java.util.List;

import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 2007-8-2
 * 
@author chenlb
 * 
 
*/
public class CityCacheMemoryImpl implements CityCache{
    
private static final Log logger = LogFactory.getLog(CityCacheMemoryImpl.class);
    
private Cache cityCache;
    
    
/* (non-Javadoc)
     * @see com.chenlb.study.ehcache.CityCache#getCitys(java.lang.Integer)
     
*/
    
public List<IdAndName> getCitys(Integer provinceId) {
        
// TODO Auto-generated method stub
        Element element = cityCache.get(provinceId);
        
if(element == null) {
            List
<IdAndName> lt = CityData.getCityByProvince(provinceId);//可以认为是数据查询
            element 
= new Element(provinceId, lt);
            cityCache.put(element);
            
if(logger.isInfoEnabled()) {
                logger.info(
"城市加载到缓存");
            }
        }
        
return (List<IdAndName>) element.getValue();
    }


    
public void setCityCache(Cache cityCache) {
        
this.cityCache = cityCache;
    }

}

说明:getcitys()方法重要,要加载没有的内容


5.ehcache.xml同时把ehcache.xsd放到同一目录

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ehcache.xsd">
    
<diskStore path="java.io.tmpdir"/>
    
<defaultCache
            
maxElementsInMemory="10000"
            eternal
="false"
            timeToIdleSeconds
="120"
            timeToLiveSeconds
="120"
            overflowToDisk
="true"
            maxElementsOnDisk
="10000000"
            diskPersistent
="false"
            diskExpiryThreadIntervalSeconds
="120"
            memoryStoreEvictionPolicy
="LRU"
            
/>
    
<cache name="cityCache"
           maxElementsInMemory
="10"   //最大缓存10个对象
           eternal
="false"   //不是永久有效
           overflowToDisk
="false" //缓存满了不写的磁盘
           timeToIdleSeconds
="1"   //1秒后没有读就失效
           timeToLiveSeconds
="2" //2秒后失效
           memoryStoreEvictionPolicy
="LFU"
            
/>
</ehcache>


6.Spring 配置文件夹applicationContext.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"
    xsi:schemaLocation
="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

    
<bean id="cacheManager"
        class
="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
        
<property name="configLocation"
            value
="classpath:com/chenlb/study/ehcache/ehcache.xml">
        
</property>
    
</bean>
    
    
<bean id="cityCacheBean" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
        
<property name="cacheManager" ref="cacheManager"></property>
        
<property name="cacheName" value="cityCache"></property>
    
</bean>

    
<bean id="cityCache" class="com.chenlb.study.ehcache.CityCacheMemoryImpl">
        
<property name="cityCache" ref="cityCacheBean"></property>
    
</bean>
</beans>


7.测试用例CityCacheTest

/*
 * 
 
*/
package com.chenlb.study.ehcache;

import java.util.List;
import java.util.Random;

import junit.framework.TestCase;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 2007-8-2
 * 
@author chenlb
 * 
 
*/
public class CityCacheTest extends TestCase {

    
protected final Log logger = LogFactory.getLog(getClass());

    
private ApplicationContext context;
    
private Random random;
    
/**
     * 
@throws java.lang.Exception
     
*/
    
protected void setUp() throws Exception {
        context 
= new ClassPathXmlApplicationContext(
                
new String[] {"application*.xml"}
            );
        random 
= new Random();
    }

    
/**
     * 
@throws java.lang.Exception
     
*/
    
protected void tearDown() throws Exception {
    }

    
/**
     * Test method for {
@link com.chenlb.study.ehcache.CityCache#getCitys(java.lang.Integer)}.
     
*/
    
public void testGetCitys() {
        CityCache cityCache 
= (CityCache) context.getBean("cityCache");
        
        List
<IdAndName> citys = cityCache.getCitys(1);
        
        assertNotNull(citys);
        assertTrue(citys.size() 
> 0);
        
for(IdAndName inn : citys) {
            logger.info(
"省1 : "+inn.getName());
        }
        
        citys 
= cityCache.getCitys(2);
        assertNotNull(citys);
        assertTrue(citys.size() 
> 0);
        
for(IdAndName inn : citys) {
            logger.info(
"省2 : "+inn.getName());
        }
    }

    
public void testGetCitysWithLoop() {
        CityCache cityCache 
= (CityCache) context.getBean("cityCache");
        
        List
<IdAndName> citys, citys_2;
        
int loopNum = 5;
        
int totelTimes = 0;
        
do {
            logger.info(
"===============第 "+(6-loopNum)+"次循环===============");
            citys 
= cityCache.getCitys(1);
            assertNotNull(citys);
            assertTrue(citys.size() 
> 0);
            
for(IdAndName inn : citys) {
                logger.info(
"省1 : "+inn.getName());
            }
            citys_2 
= cityCache.getCitys(2);
            assertNotNull(citys_2);
            assertTrue(citys_2.size() 
> 0);
            
for(IdAndName inn : citys_2) {
                logger.info(
"省2 : "+inn.getName());
            }
            loopNum    
--;
            
try {
                
int times = random.nextInt(800+ 400;//400 - 1200 ms
                Thread.sleep(times);
                totelTimes 
+= times;
                logger.info(totelTimes 
+ " ms 后, 间隔: "+times+" ms");
            } 
catch (InterruptedException e) {
                
// TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
while(loopNum > 0);
        
        loopNum 
= 5;
        
do {    //省2
            logger.info("===============第 "+(6-loopNum)+"次循环===============");
            citys 
= cityCache.getCitys(2);
            assertNotNull(citys);
            assertTrue(citys.size() 
> 0);
            
for(IdAndName inn : citys) {
                logger.info(
"省2 : "+inn.getName());
            }
            loopNum    
--;
            
try {
                
int times = random.nextInt(400+ 400;//400 - 800 ms
                Thread.sleep(times);
                totelTimes 
+= times;
                logger.info(totelTimes
+" ms 后, 间隔: "+times+" ms");
            } 
catch (InterruptedException e) {
                
// TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
while(loopNum > 0);
        
    }
}
分享到:
评论

相关推荐

    springboot 使用spring cache缓存 和 使用fastjson配置redis系列化

    在Spring Boot应用中,Spring Cache是一个强大的工具,用于在应用程序中实现缓存抽象,它可以减少对数据库或远程服务的重复调用,从而提高性能。在本篇文档中,我们将探讨如何使用Spring Cache来缓存数据,并结合...

    SSM与memcached整合项目Spring Cache

    在本项目中,我们主要探讨的是如何将Spring Cache与memcached进行整合,以提升应用程序的性能和效率。Spring Cache是Spring框架的一部分,它提供了一种抽象的缓存管理机制,可以方便地集成到各种缓存解决方案中,如...

    springcache+redis springboot maven

    在这个项目中,"springcache+redis"的整合意味着我们要利用Spring Cache的特性,将缓存存储在Redis中,以提升应用的性能。 首先,Spring Cache提供了`@Cacheable`、`@CacheEvict`和`@Caching`等注解,允许我们在...

    SpringCache与redis集成,优雅的缓存解决方案.docx

    SpringCache与Redis集成,优雅的缓存解决方案 SpringCache是一种基于Java的缓存解决方案,它可以与Redis集成,提供了一种优雅的缓存解决方案。在本文中,我们将对SpringCache与Redis集成的优雅缓存解决方案进行详细...

    Redis整合SpringCache实例

    **Redis整合SpringCache实例** 在现代的Web应用中,数据缓存是提高系统性能的关键技术之一。本示例主要探讨如何将开源的内存数据结构存储系统Redis与Spring Cache框架结合,实现高效的分布式缓存解决方案。Redis以...

    springCache

    Spring Cache 是 Spring 框架的一个重要组成部分,它提供了一种在应用程序中统一管理缓存的能力,无需依赖特定的缓存实现,如 Ehcache、Redis 或 Hibernate 二级缓存等。通过 Spring Cache,开发者可以方便地在方法...

    spring cache + redis 主从

    此外,还需要掌握如何将Spring Cache与Redis整合,以便在应用中高效使用缓存机制。 一、Redis的主从配置 1. 准备工作: - 操作系统要求:Ubuntu 16.04。 - Redis版本:选择适合的稳定版本,例如redis-4.0.9.tar....

    Spring cache

    ### Spring Cache核心知识点 #### 一、Spring Cache简介与特性 Spring Cache 是 Spring 3.1 版本引入的一项重要特性,它不是一种具体的缓存实现(如 EHCache 或 OSCache),而是一种缓存使用的抽象层。通过在现有...

    spring-cache(通过key值更新缓存)

    Spring Cache是一个抽象层,它允许开发者在不关注具体缓存实现的情况下,轻松地在应用程序中添加缓存功能。本篇文章将详细探讨如何通过key值更新Spring Cache中的指定缓存,以及相关的缓存管理策略。 首先,让我们...

    JAVA编程之spring cache本机缓存应用

    1、SpringCache是Spring提供的一个缓存框架,在Spring3.1版本开始支持将缓存添加到现有的spring应用程序中,在4.1开始,缓存已支持JSR-107注释和更多自定义的选项 2、Spring Cache利用了AOP,实现了基于注解的缓存...

    springboot使用springCache和不使用springCache的对比.zip

    在Spring Boot应用中,Spring Cache是一个强大的功能,它允许我们以声明式的方式管理应用程序的缓存,从而提高性能。Spring Cache抽象了缓存提供者的具体实现,如 EhCache、Redis 或 Hazelcast,使得开发者可以方便...

    SpringCache缓存初探共5页.pdf.zip

    SpringCache是Spring框架提供的一种轻量级的缓存解决方案,旨在简化在应用程序中集成缓存的能力,以提高性能和响应速度。在这个“SpringCache缓存初探共5页.pdf.zip”压缩包中,很可能是对SpringCache的基础知识进行...

    Spring Cache 复合缓存管理器

    在Spring框架中,Spring Cache是用于提供统一的缓存抽象层的一个重要组件,它使得开发者能够在不修改代码的情况下,方便地在应用中引入缓存机制,以提高性能和响应速度。"Spring Cache 复合缓存管理器"指的是通过...

    springboot 使用spring cache缓存 和 缓存数据落地到redis

    【Spring Boot 使用 Spring Cache 缓存与数据落地到 Redis】\n\n在Spring Boot应用中,Spring Cache是一个强大的工具,可以极大地提升应用的性能,通过缓存非计算性或者昂贵的计算结果。Spring Cache抽象了缓存管理...

    redis与springcache集成

    Redis是一款高性能的键值对数据存储系统,常用于构建分布式缓存系统,而Spring Cache是Spring框架提供的一个抽象层,允许我们使用不同的缓存技术,如Redis, EhCache等。在Spring Boot应用中,集成Redis作为缓存机制...

    springcache-1.1.0.zip

    《SpringCache深度解析与实战应用》 在Java开发领域,Spring框架因其强大的功能和灵活性而备受推崇。SpringCache是Spring框架的一部分,它提供了一种在应用程序中统一管理和使用缓存的解决方案,使得开发者能够轻松...

    spring cache

    spring cacke spring cacke

    redis-string-springcache.zip

    《SpringCache与Redis结合在Mybatis中的应用》 在当今的Web开发中,缓存技术是提高系统性能、减轻数据库压力的重要手段。本教程将详细探讨如何将SpringCache与Redis集成,结合Mybatis进行高效的数据缓存。我们将从...

    springboot_springcache_redis入门实例

    SpringBoot、SpringCache和Redis是Java开发中常用的三大技术组件,它们在构建高效、可扩展的应用程序中扮演着重要角色。让我们深入探讨一下这三个技术及其整合使用的入门实例。 SpringBoot是由Pivotal团队开发的...

Global site tag (gtag.js) - Google Analytics