Java 中常用缓存Cache机制的实现
Cache_学习笔记
Java CacheCache缓存的意思。
如用户在浏览网页的时候,后退就不需要重新从服务器数据库中提取数据,这时就可以采用Cache机制。
其主要做法是在用户第一次访问的时候,从数据库中提取的数据保存到一个CacheMap中(这个CacheMap其实就是保存在内存中)。
当用户再一次访问的时候只需要从Map中提取数据,而不需要到服务器数据库中去提取,大大提高页面的访问速度。
Java实现cache的基本机制我这里说的cache不是指CPU和RAM之间的缓存,而是java应用中间常用的缓存。
最常使用的场合就是访问数据库的时候为了提高效率而使用的cache。
一般的用法就是把数据从数据库读到内存,然后之后的数据访问都从内存来读,从而减少对数据库的读取次数来提高效率。
在使用cache的时候最容易犯的错误就是cache涉及了业务逻辑。
使用cache的原意是只是提高程序效率,而不应该干涉程序结果。
按照cahce的定义,cache应该是对数据访问端透明地工作。
所以在使用cache的时候我们可以问一下自己:“我把cache拿掉后程序还能运行吗?” “cache拿掉前后程序运行的结果一直吗?”。
如果答案是否,那您就得重新考虑您的cache方案。
我自己就碰到过这样的bug:数据库的有个表里面都是些配置信息,也就是说是些读访问远大于写访问的数据。
然后这些数据被理所应当地在程序里面做成内存 cache。
问题是有个delete方法删除了一条数据,但是没有更新内存cache。
所以读操作的客户代码还是能读到这条数据。
问题的根本就是后台数据和cache不一致cache的容量一般相对后台数据量都比较有限。
一旦cache满了就势必要选择最没用的数据从cache里面删除掉,为新数据腾出空间。
这里就涉及cahce 算法cache algorithm或者叫替换算法。
在java的cache产品中一般叫evict policy。
下面我们来看一下常用的cache algorithm。
Java框架中的缓存技术解析
Java框架中的缓存技术解析Java框架中的缓存技术在现代软件开发中变得越来越重要。
在大型的应用程序中,数据的读取和写入是非常频繁的操作,而使用缓存可以有效地提高应用程序的性能和响应速度。
本文将对Java框架中常用的缓存技术进行解析,并介绍它们的特点和适用场景。
一、内存缓存内存缓存是最常见的缓存技术之一,它将数据存储在内存中,从而实现快速的数据访问。
在Java框架中,常用的内存缓存库包括Guava Cache、Ehcache和Caffeine等。
Guava Cache是Google开发的一款优秀的内存缓存库,它提供了丰富的缓存操作接口,能够灵活地配置缓存的行为。
相比之下,Ehcache是一款成熟的开源缓存库,拥有强大的缓存功能和广泛的社区支持。
而Caffeine则是一个基于Java 8的高性能缓存库,它通过使用一种称为"无锁"算法来提供出色的并发性能。
二、分布式缓存在分布式系统中,由于数据的分散存储在不同的节点上,使用单一的内存缓存并不足够。
因此,引入了分布式缓存技术来解决这个问题。
常用的分布式缓存解决方案有Redis、Memcached和Hazelcast等。
Redis是一款高性能的分布式缓存和持久化数据库,它支持多种数据结构和丰富的缓存操作。
作为一种开源的NoSQL数据库,Redis在分布式缓存中的应用非常广泛。
Memcached也是一种常用的分布式内存对象缓存系统,通过将数据存储在内存中来提高读取速度。
与Redis相比,Memcached更加简单和轻量,适用于一些对数据一致性要求不高的场景。
Hazelcast则是一个基于Java的开源分布式存储和计算平台,它提供了分布式缓存和分布式计算的功能,能够实现高性能和高可用性。
三、数据库缓存数据库缓存是一种常见的缓存技术,它通过将查询结果缓存到内存中,从而减少对数据库的访问次数,提升访问性能。
在Java框架中,常用的数据库缓存技术有Hibernate Second Level Cache和Spring Cache 等。
Java中的缓存技术
Java中的缓存技术缓存技术在软件开发中起着至关重要的作用。
它可以提高系统性能、降低对底层资源的访问频率,从而减轻服务器负载并改善用户体验。
在Java开发中,有许多可供选择的缓存技术。
本文将介绍几种常见的Java缓存技术,以及它们的应用场景和原理。
一、内存缓存内存缓存是最常见的缓存技术之一,它将数据保存在内存中,以提高读取速度。
在Java中,可以使用集合框架中的Map接口的实现类来实现内存缓存,如HashMap、ConcurrentHashMap等。
这些类提供了快速的Key-Value存储,通过Key快速查找对应的Value,以实现快速访问缓存数据。
内存缓存适用于数据读取频繁但不经常更新的场景,例如字典数据、配置信息等。
需要注意的是,内存缓存的容量是有限的,当缓存数据超过容量限制时,需要采取一些策略来处理,如LRU(最近最少使用)算法将最久未访问的数据移出缓存。
二、分布式缓存分布式缓存是一种将数据存储在多台服务器节点上的缓存技术。
Java中有多种分布式缓存框架可供选择,如Redis、Memcached等。
这些框架提供了高性能、可扩展的分布式缓存服务,可以在集群中存储大量的数据,并提供分布式缓存的管理和查询接口。
分布式缓存适用于需要同时服务大量客户端并具有高并发读写需求的场景,例如电商网站的商品信息、社交网络的用户数据等。
通过将数据存储在多台服务器上,可以提高系统的可用性和扩展性。
三、页面缓存页面缓存是将网页内容保存在缓存中,以减少对数据库或后端服务的访问频率,从而提高页面的加载速度。
在Java中,可以通过使用Web服务器或反向代理服务器的缓存功能,例如Nginx、Varnish等,来实现页面缓存。
页面缓存适用于内容相对静态或者不经常变化的场景,例如新闻网站的文章、博客网站的页面等。
通过将网页内容保存在缓存中,可以避免每次请求都重新生成页面,大大提高响应速度和系统的并发能力。
四、数据库缓存数据库缓存是将数据库查询结果保存在缓存中,以减少对数据库的频繁查询,提高系统的响应速度和并发能力。
java. cache 用法
Java 中的缓存(Cache)是一种提高应用程序性能的技术,它通过在内存中存储经常访问的数据,避免了频繁地访问速度较慢的数据源(如数据库或文件)。
在Java 中,有许多内置的缓存实现,如`java.util.Cache`和`java.util.ConcurrentMap`等。
以下是一个简单的Java 缓存用法示例:1. 首先,导入所需的缓存类:```javaimport java.util.Cache;import java.util.ConcurrentMap;```2. 创建一个缓存实例:```javaCache<String, String> cache = new ConcurrentMap<>();```这里,我们使用`ConcurrentMap`作为缓存实现。
它可以保证在高并发场景下的性能表现。
3. 向缓存中添加数据:```javacache.put("key1", "value1");cache.put("key2", "value2");```4. 从缓存中获取数据:```javaString value1 = cache.get("key1");String value2 = cache.get("key2");```5. 删除缓存中的数据:```javacache.remove("key1");```6. 检查缓存中是否包含某个键:```javaboolean containsKey = cache.containsKey("key1"); ```7. 获取缓存中的所有键:```javaSet<String> keys = cache.keySet();```8. 获取缓存中的所有值:```javaCollection<String> values = cache.values();```9. 清除缓存:```javacache.clear();```10. 关闭缓存:```javacache.invalidate();```此外,Java 还提供了`java.util.expiringmap`类,它可以在缓存中设置过期时间,从而在数据不再需要时自动删除。
java统计放缓存方案
java统计放缓存方案Java是一种流行的编程语言,广泛应用于各个领域。
在开发Java 应用程序时,一个常见的需求是提高程序的性能和响应速度。
为了实现这个目标,一种常见的做法是使用缓存方案。
本文将探讨如何在Java中实现一种高效的缓存方案,并介绍一些常见的缓存技术和最佳实践。
缓存是一种临时存储数据的技术,它可以将计算结果或数据存储在高速的存储介质中,以便在后续的计算中快速访问。
在Java中,可以使用各种缓存技术来提高程序的性能。
下面将介绍几种常见的缓存技术。
内存缓存是最常用的一种缓存技术。
它使用内存作为存储介质,将计算结果或数据保存在内存中,以便快速访问。
在Java中,可以使用ConcurrentHashMap或Caffeine等开源库来实现内存缓存。
这些库提供了线程安全的数据结构和高效的缓存算法,可以在多线程环境下安全地使用。
磁盘缓存是一种将数据存储在磁盘上的缓存技术。
它适用于大规模数据或长期存储的场景。
在Java中,可以使用Ehcache或Redis等开源库来实现磁盘缓存。
这些库提供了持久化存储和高性能的数据访问接口,可以在分布式环境中使用。
分布式缓存是一种将数据存储在多台服务器上的缓存技术。
它可以提供更高的容量和吞吐量,适用于高并发场景。
在Java中,可以使用Memcached或Redis等开源库来实现分布式缓存。
这些库提供了分布式存储和一致性哈希等算法,可以在集群环境中使用。
在使用缓存方案时,还需要考虑一些最佳实践。
首先,需要选择合适的缓存策略。
常见的策略包括先进先出(FIFO)、最近最少使用(LRU)和最不经常使用(LFU)等。
根据应用场景和需求,选择合适的策略可以提高缓存命中率和性能。
需要注意缓存的失效和更新机制。
当缓存中的数据发生变化时,需要及时更新缓存,以避免返回过期或错误的数据。
可以使用触发器、定时任务或事件通知等机制来实现缓存的失效和更新。
需要考虑缓存的容量和性能。
缓存的容量应根据数据量和内存大小来设置,以避免缓存溢出或性能下降。
Java缓存机制
在软件开发中,缓存是一种常用的优化技术,用于存储频繁访问的数据,使得下一次访问时可以更快地获取数据。
而在Java中,也存在着各种不同的缓存机制,用于提升程序的性能与效率。
一、内存缓存内存缓存是最常见的缓存机制之一。
在Java中,可以使用各种数据结构来实现内存缓存,比如Hashtable、HashMap、ConcurrentHashMap等。
使用内存缓存的好处是可以将数据存储在内存中,而不是频繁地访问数据库或者其他外部存储介质,从而提升访问速度。
同时,内存缓存还可以减轻数据库的负载,提高系统的并发能力。
二、CPU缓存CPU缓存是指CPU内部的高速缓存,用于暂时存储处理器频繁访问的数据。
在Java中,可以通过使用局部变量和静态变量来利用CPU缓存。
局部变量存储在方法栈帧中,相对于对象的实例变量来说,访问局部变量的速度更快。
因此,在开发过程中,应该尽量使用局部变量来存储频繁访问的数据。
静态变量是存储在方法区中的,与对象的实例无关。
由于静态变量只有一个副本,所以可以减少对CPU缓存的竞争,提高程序的性能。
三、磁盘缓存磁盘缓存是将数据存储在磁盘中,并使用相应的缓存算法来提高数据的读写速度。
在Java中,可以通过使用文件缓存或者数据库缓存来实现磁盘缓存。
文件缓存是将数据存储在本地文件系统中,比如将一些配置文件加载到内存中进行处理。
数据库缓存是将数据存储在数据库中,并使用缓存算法来提高数据的访问速度。
一般情况下,数据库缓存会使用LRU(最近最少使用)算法来决定何时移除某个数据。
四、网络缓存网络缓存是将数据存储在网络中,通过网络进行传输。
在Java中,可以通过使用HTTP缓存或者CDN来实现网络缓存。
HTTP缓存是浏览器和服务器之间的缓存,用于存储HTTP请求和响应的数据。
通过合理设定HTTP头信息,可以实现数据的缓存,减少带宽的消耗。
CDN(内容分发网络)是一种将数据分布到全球多台服务器的网络架构,用于存储静态文件,提供更快的数据访问速度。
java cache用法
java cache用法Java中的缓存是一种常用的数据结构,用于提高应用程序的性能和响应速度。
Java提供了多种缓存实现,如JavaCache、Ehcache、GuavaCache等,这些缓存可以存储数据并在需要时快速检索。
本篇文章将介绍JavaCache的使用方法。
JavaCache是一个简单的缓存实现,它提供了一个易于使用的API,可以方便地添加、获取和移除缓存数据。
JavaCache的设计目标是易于使用、高性能和可扩展性。
它支持通过多个存储引擎来扩展缓存,每个存储引擎都具有不同的性能特点。
1.添加缓存数据使用JavaCache添加缓存数据非常简单。
首先,需要创建一个Cache对象,并指定存储引擎的类型和名称。
然后,可以使用put方法将数据添加到缓存中。
例如:```javaCachecache=newCache("myCache",100);//创建一个缓存对象,存储引擎类型为Memory,容量为100个字节cache.put("key","value");//将数据添加到缓存中```2.获取缓存数据使用JavaCache获取缓存数据也非常简单。
可以使用get方法从缓存中获取数据。
如果数据不存在于缓存中,则返回null。
例如:```javaStringvalue=cache.get("key");//从缓存中获取数据```3.移除缓存数据使用JavaCache移除缓存数据也非常简单。
可以使用remove方法从缓存中移除指定的数据。
例如:```javacache.remove("key");//从缓存中移除数据```4.配置存储引擎和缓存容量JavaCache支持多个存储引擎,每个存储引擎具有不同的性能特点。
可以通过配置存储引擎的类型和名称来扩展缓存。
此外,还可以配置缓存的容量,以确保缓存不会因为存储空间不足而出现性能问题。
Java实现一个简单的缓存方法
Java实现⼀个简单的缓存⽅法缓存是在web开发中经常⽤到的,将程序经常使⽤到或调⽤到的对象存在内存中,或者是耗时较长但⼜不具有实时性的查询数据放⼊内存中,在⼀定程度上可以提⾼性能和效率。
下⾯我实现了⼀个简单的缓存,步骤如下。
创建缓存对象EntityCache.javapublic class EntityCache {/*** 保存的数据*/private Object datas;/*** 设置数据失效时间,为0表⽰永不失效*/private long timeOut;/*** 最后刷新时间*/private long lastRefeshTime;public EntityCache(Object datas, long timeOut, long lastRefeshTime) {this.datas = datas;this.timeOut = timeOut;stRefeshTime = lastRefeshTime;}public Object getDatas() {return datas;}public void setDatas(Object datas) {this.datas = datas;}public long getTimeOut() {return timeOut;}public void setTimeOut(long timeOut) {this.timeOut = timeOut;}public long getLastRefeshTime() {return lastRefeshTime;}public void setLastRefeshTime(long lastRefeshTime) {stRefeshTime = lastRefeshTime;}}定义缓存操作接⼝,ICacheManager.javapublic interface ICacheManager {/*** 存⼊缓存* @param key* @param cache*/void putCache(String key, EntityCache cache);/*** 存⼊缓存* @param key* @param cache*/void putCache(String key, Object datas, long timeOut);/*** 获取对应缓存* @param key* @return*/EntityCache getCacheByKey(String key);/*** 获取对应缓存* @param key* @return*/Object getCacheDataByKey(String key);/*** 获取所有缓存* @param key* @return*/Map<String, EntityCache> getCacheAll();/*** 判断是否在缓存中* @param key* @return*/boolean isContains(String key);/*** 清除所有缓存*/void clearAll();/*** 清除对应缓存* @param key*/void clearByKey(String key);/*** 缓存是否超时失效* @param key* @return*/boolean isTimeOut(String key);/*** 获取所有key* @return*/Set<String> getAllKeys();}实现接⼝ICacheManager,CacheManagerImpl.java这⾥我使⽤了ConcurrentHashMap来保存缓存,本来以为这样就是线程安全的,其实不然,在后⾯的测试中会发现它并不是线程安全的。
Java基于LoadingCache实现本地缓存的示例代码
Java基于LoadingCache实现本地缓存的⽰例代码⽬录⼀、添加 maven 依赖⼆、CacheBuilder ⽅法说明三、创建 CacheLoader四、⼯具类五、guava Cache数据移除⼀、添加 maven 依赖<dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>27.1-jre</version></dependency>⼆、CacheBuilder ⽅法说明1 LoadingCache build(CacheLoader loader)2 CacheBuilder.maximumSize(long size)配置缓存数量上限,快达到上限或达到上限,处理了时间最长没被访问过的对象或者根据配置的被释放的对象3 expireAfterAccess(long, TimeUnit)缓存项在给定时间内没有被读/写访问,则回收。
请注意这种缓存的回收顺序和基于⼤⼩回收⼀样4 expireAfterWrite(long, TimeUnit)缓存项在给定时间内没有被写访问(创建或覆盖),则回收。
如果认为缓存数据总是在固定时候后变得陈旧不可⽤,这种回收⽅式是可取的。
5 refreshAfterWrite(long duration, TimeUnit unit)定时刷新,可以为缓存增加⾃动定时刷新功能。
和expireAfterWrite相反,refreshAfterWrite通过定时刷新可以让缓存项保持可⽤,但请注意:缓存项只有在被检索时才会真正刷新,即只有刷新间隔时间到了再去get(key)才会重新去执⾏Loading,否则就算刷新间隔时间到了也不会执⾏loading操作。
因此,如果在缓存上同时声明expireAfterWrite和refreshAfterWrite,缓存并不会因为刷新盲⽬地定时重置,如果缓存项没有被检索,那刷新就不会真的发⽣,缓存项在过期时间后也变得可以回收。
java cache用法 -回复
java cache用法-回复Java中的缓存(Cache)是指将经常使用的数据存储在内存中,以便在需要时能够快速访问。
使用缓存可以大大提高程序的性能,减少对数据库或其他资源的频繁访问。
本文将详细介绍Java中缓存的用法,以及在不同场景下使用缓存的注意事项和优化方法。
首先,我们来了解Java中缓存的基本概念和原理。
缓存是一种存储数据的技术,其原理是将数据存储在临时存储器中,以便在需要时能够快速获取。
在Java中,缓存通常是指内存中的缓存,可以将经常访问的数据存储在内存中,以减少对硬盘或网络的访问时间。
在Java中,我们可以使用多种方式来实现缓存。
最常见的方式是使用集合类(如HashMap或ConcurrentHashMap)来存储缓存数据。
例如,我们可以创建一个HashMap对象来存储经常使用的数据,然后在需要时从该HashMap中获取数据。
这种方式简单、易用,适用于小规模的缓存场景。
除了使用集合类,我们还可以使用Java提供的缓存框架,如Ehcache、Guava Cache等。
这些框架提供了更多高级特性,如过期策略、容量限制、数据持久化等,可满足更复杂的缓存需求。
这些框架提供了高度自定义的缓存配置,可以通过配置文件或代码来设置缓存的特性,并提供了灵活的API来操作缓存数据。
接下来,让我们来看看在不同场景下如何使用缓存。
首先是单机应用的缓存使用。
在这种场景下,缓存通常是存在于应用内存中的,可以使用HashMap或其他集合类来实现。
例如,我们可以将经常访问的静态数据(如配置信息、字典表等)放入缓存中,在需要时直接从缓存中获取,避免每次都访问数据库或文件系统。
除了单机应用外,Java缓存还可以应用于分布式环境下。
在这种情况下,我们需要考虑缓存的一致性和并发访问的问题。
一种常见的做法是使用分布式缓存,如Ehcache、Redis等,这些缓存系统可以将数据存储在集群中的多个节点上,以便实现缓存的共享和协作。
SpringBoot中使用cache缓存的方法
SpringBoot中使用cache缓存的方法在Spring Boot中使用缓存可以提高应用程序的性能和响应速度,减少对数据库或外部服务的依赖。
Spring Boot提供了方便的注解来实现缓存功能,下面是使用缓存的方法。
步骤一:配置缓存管理器```javapublic class CacheConfigpublic CacheManager cacheManageSimpleCacheManager cacheManager = new SimpleCacheManager(;cacheManager.setCaches(Arrays.asList(new ConcurrentMapCache("exampleCache"))); // 设置一个缓存return cacheManager;}```步骤二:使用缓存注解在需要缓存的方法上添加缓存相关的注解。
Spring Boot提供了以下几个常用的缓存注解:```javapublic class ExampleServicepublic String getExampleData(String id)return "data for id " + id;}public void deleteExampleData(String id)}public String updateExampleData(String id, String newData)return newData;}})public void deleteMultipleExampleData(String id1, String id2) }```步骤三:配置缓存属性可以通过在application.properties或application.yml文件中配置缓存相关的属性。
以下是一些常用的配置选项:```properties#设置缓存的过期时间(单位毫秒)#设置缓存的最大数量spring.cache.redis.max-entries=1000#设置缓存的名称和类型spring.cache.cache-names=exampleCachespring.cache.type=simple```步骤四:使用缓存最后,在需要使用缓存的地方调用相关的方法即可。
java cachebuild 用法
java cachebuild 用法
Java中的CacheBuilder可以用于创建缓存容器,其`build()`方法可以传入一个CacheLoader实现类,以实现数据的加载和缓存。
下面是一个示例代码:```java
public LoadingCache<String, User> createUserCache() {
returnCacheBuilder.newBuilder()
.build(newCacheLoader<String, User>() {
@Override
public User load(String key) throws Exception {
System.out.println(key + " 用户缓存不存在,尝试CacheLoader回源查找并回填...");
return userDao.getUser(key);
}
});
}
```
在上述代码中,CacheBuilder创建了一个LoadingCache类型的缓存容器,并通过CacheLoader的load方法实现数据的加载和缓存。
当缓存中不存在某个键对应的值时,将会调用CacheLoader的load方法进行回源查找和回填。
你可以根据具体的业务需求和使用场景,灵活运用CacheBuilder和CacheLoader来构建和管理缓存。
如需了解更多关于CacheBuilder和CacheLoader的信息,可以查阅相关文档或源代码。
javaredis缓存实现方法
javaredis缓存实现方法Java Redis缓存实现方法Redis是一种基于内存的高性能键值数据库,常用于缓存、消息队列等场景。
在Java中,我们可以使用Java Redis客户端来操作Redis数据库,实现缓存功能。
本文将介绍如何使用Java Redis客户端实现缓存。
一、引入Java Redis客户端依赖我们需要在项目中引入Java Redis客户端的依赖。
常用的Java Redis客户端有Jedis、Lettuce等。
以Jedis为例,我们可以在Maven项目中添加以下依赖:```<dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.7.0</version></dependency>```二、连接Redis数据库在使用Java Redis客户端之前,我们需要先连接Redis数据库。
在Jedis中,可以通过以下代码实现连接:```javaimport redis.clients.jedis.Jedis;public class RedisCache {private Jedis jedis;public RedisCache() {jedis = new Jedis("localhost", 6379);}// 其他操作方法...}```以上代码中,我们通过Jedis的构造方法连接到本地的Redis数据库,指定了Redis服务器的IP地址和端口号。
三、设置缓存在连接Redis数据库之后,我们可以使用Java Redis客户端设置缓存。
Redis中的缓存是以键值对的形式存储的,我们可以使用Jedis 的`set`方法来设置缓存。
例如,设置一个名为`username`的缓存:```javapublic void setUsername(String username) {jedis.set("username", username);}```通过以上代码,我们将`username`作为键,`username`的值作为值,存储到Redis数据库中。
Java中常用缓存Cache机制的实现
Java中常⽤缓存Cache机制的实现⼀、什么是缓存? 缓存,就是将程序或系统经常要调⽤的对象存在内存中,以便其使⽤时可以快速调⽤,不必再去创建新的重复的实例。
这样做可以减少系统开销,提⾼系统效率。
⼆、缓存的实现⽅式: 实现⽅式1: 内存缓存,也就是实现⼀个类中静态Map,对这个Map进⾏常规的增删查.。
import ponent;import erInfo;import java.util.Calendar;import java.util.Date;import java.util.HashMap;/*** 基于hashMap实现的缓存管理*/@Componentpublic class UserCacheManager {/*** ⽤户信息缓存*/private static HashMap<String, UserInfo> userList = new HashMap<>();/*** 保存时间*/private static int liveTime = 60;/*** 添加⽤户信息缓存* @param sessionId* @param userInfo* @return*/public static boolean addCache(String sessionId,UserInfo userInfo){userList.put(sessionId,userInfo);return true;}/*** 删除⽤户缓存信息* @param sessionId* @return*/public static boolean delCache(String sessionId){userList.remove(sessionId);return true;}/*** 获取⽤户缓存信息* @param sessionId* @return*/public static UserInfo getCache(String sessionId){return userList.get(sessionId);}/*** 清除过期的⽤户缓存信息*/public static void clearData(){Calendar nowTime = Calendar.getInstance();nowTime.add(Calendar.MINUTE,-liveTime);Date time = nowTime.getTime();for(String key : userList.keySet()){UserInfo userInfo = userList.get(key);if(userInfo.getLogin_time() == null || time.after(userInfo.getLogin_time())){userList.remove(key);}}}实现⽅式2(使⽤spring⽀持的cache): 实现步骤: 第⼀步:导⼊spring-boot-starter-cache模块<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-cache</artifactId></dependency>第⼆步: @EnableCaching开启缓存@SpringBootApplication@EnableCachingpublic class Springboot07CacheApplication {public static void main(String[] args) {SpringApplication.run(Springboot07CacheApplication.class, args);}}第三步:使⽤缓存注解UserInfoCacheControllerimport org.springframework.beans.factory.annotation.Autowired;import org.springframework.cache.annotation.CacheEvict;import org.springframework.cache.annotation.CachePut;import org.springframework.context.annotation.Scope;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RequestMethod;import org.springframework.web.bind.annotation.RequestParam;import org.springframework.web.bind.annotation.ResponseBody;import ercache.dao.LoginMapper;import erInfo;import ercache.service.Impl.LoginServiceImpl;@Scope("prototype")@Controllerpublic class UserInfoCacheController {@Autowired(required = true)private LoginMapper loginMapper;@Autowiredprivate LoginServiceImpl loginService;@ResponseBody@RequestMapping(value = "/user/cache/login",method = RequestMethod.GET) public void userLoginByCache(String username,String password){UserInfo userInfo = erLoginByCache(username, password); System.out.println(userInfo);}/*** 通过username删除单个⽤户缓存信息* @param username*/@CacheEvict(value="userInfo",key="#username")@ResponseBody@RequestMapping(value = "/user/cache/delete",method = RequestMethod.GET) public void deleteUserInfoCache(String username) {System.out.println("清除⽤户信息缓存");}/*@Cacheable(value="userInfo",key="#username")@ResponseBody@RequestMapping(value = "/user/cache/select",method = RequestMethod.GET) public UserInfo selectUserInfoCache(String username) {System.out.println("清除⽤户信息缓存");}*//*** 通过username修改单个⽤户缓存信息* @param username* @param password* @param age* @param sex* @param user_id* @return@CachePut(value="userInfo",key = "#username")@ResponseBody@RequestMapping(value = "/user/cache/update",method = RequestMethod.GET)public UserInfo updateUserInfoCache(@RequestParam(required = false) String username,@RequestParam(required = false) String password,@RequestParam(required = false) Integer age,@RequestParam(required = false) String sex,@RequestParam(required = false) Long user_id) {UserInfo userInfo = loginMapper.updateUserInfoById(username, password, age, sex, user_id);System.out.println("1.更新⽤户缓存信息: " + userInfo);if(null == userInfo){userInfo = loginMapper.selectUserByUsernameAndPassword(username,password);}System.out.println("2.更新⽤户缓存信息: " + userInfo);return userInfo;}}LoginServiceImplimport org.springframework.beans.factory.annotation.Autowired;import org.springframework.cache.annotation.CacheConfig;import org.springframework.cache.annotation.Cacheable;import org.springframework.stereotype.Service;import ercache.dao.LoginMapper;import erInfo;import ercache.service.LoginService;import erCacheManager;/*定义缓存名称*/@CacheConfig(cacheNames = "userInfo")@Servicepublic class LoginServiceImpl implements LoginService {@Autowired(required = true)private LoginMapper loginMapper;/*将查询到的数据放⼊缓存,下次调⽤该⽅法会先去缓存中查询数据*/ @Cacheable(value = "userInfo", key = "#username")@Overridepublic UserInfo UserLoginByCache(String username, String password) {UserInfo userInfo = loginMapper.selectUserByUsernameAndPasswordWithCache(username, password);System.out.println("⽤户缓存信息: " + userInfo);return userInfo;}}LoginMapperimport org.apache.ibatis.annotations.Param;import org.apache.ibatis.annotations.Select;import org.springframework.stereotype.Repository;import erInfo;/*** 登陆dao层操作接⼝*/@Repositorypublic interface LoginMapper{@Select("select * from user_info where username=#{username} and password=#{password}")UserInfo selectUserByUsernameAndPassword(@Param("username") String username,@Param("password") String password);@Select("select * from user_info where username=#{username} and password=#{password}")UserInfo selectUserByUsernameAndPasswordWithCache(@Param("username") String username,@Param("password") String password);@Select("update user_info set username=#{username},password=#{password},age=#{age},sex=#{sex} where user_id=#{user_id}") UserInfo updateUserInfoById(@Param("username") String username,@Param("password") String password,@Param("age") int age,@Param("sex") String sex,@Param("user_id") long user_id);/*@Select("insert into user_info (username,password,age,sex,user_id) values(#{username},#{password},#{age},#{sex},#{user_id})") UserInfo saveUserInfo(@Param("username") String username,@Param("password") String password,@Param("sex") String sex,@Param("user_id") long user_id);*/ }UserInfo(实体类)import java.io.Serializable;import java.util.Date;public class UserInfo implements Serializable { private static final long serialVersionUID = 1L; private Long user_id;private String username;private String password;private String sex;private Integer age;private Date login_time;public Long getUser_id() {return user_id;}public void setUser_id(Long user_id) {er_id = user_id;}public String getUsername() {return username;}public void setUsername(String username) {ername = username;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public Integer getAge() {return age;}public void setAge(Integer age) {this.age = age;}public Date getLogin_time() {return login_time;}public void setLogin_time(Date login_time) {this.login_time = login_time;}@Overridepublic String toString() {return "UserInfo{" +"user_id=" + user_id +", username='" + username + '\'' +", password='" + password + '\'' +", sex='" + sex + '\'' +", age=" + age +'}';}} application.propertiesserver.port=8009spring.datasource.url=jdbc:mysql://localhost:3306/bank?useUnicode=true&characterEncoding=utf8 ername=rootspring.datasource.password=rootspring.datasource.driver-class-name=com.mysql.jdbc.Driver# ⽬标缓存管理器#spring.cache.type=SIMPLEspring.cache.type=ehcachespring.cache.ehcache.config=classpath:ehcache.xml# 打印sql语句ercache.dao=debugehcache.xml<ehcache><!--磁盘存储:将缓存中暂时不使⽤的对象,转移到硬盘,类似于Windows系统的虚拟内存path:指定在硬盘上存储对象的路径path可以配置的⽬录有:user.home(⽤户的家⽬录)user.dir(⽤户当前的⼯作⽬录)java.io.tmpdir(默认的临时⽬录)ehcache.disk.store.dir(ehcache的配置⽬录)绝对路径(如:d:\\ehcache)查看路径⽅法:String tmpDir = System.getProperty("java.io.tmpdir");--><diskStore path="java.io.tmpdir" /><!--defaultCache:默认的缓存配置信息,如果不加特殊说明,则所有对象按照此配置项处理maxElementsInMemory:设置了缓存的上限,最多存储多少个记录对象eternal:代表对象是否永不过期 (指定true则下⾯两项配置需为0⽆限期)timeToIdleSeconds:最⼤的发呆时间 /秒timeToLiveSeconds:最⼤的存活时间 /秒overflowToDisk:是否允许对象被写⼊到磁盘说明:下列配置⾃缓存建⽴起600秒(10分钟)有效。
Java程序设计中的哈希表与LRU缓存实现案例
Java程序设计中的哈希表与LRU缓存实现案例哈希表(Hash Table)和LRU缓存(Least Recently Used Cache)是Java程序设计中常用的数据结构和算法。
哈希表提供了快速的查找和插入操作,而LRU缓存则可以在有限的内存空间中保持常用数据的快速访问。
本文将介绍哈希表和LRU缓存的原理,并通过案例演示它们在Java程序设计中的实现方式。
一、哈希表的原理和实现哈希表是一种使用哈希函数将数据映射到固定大小的数组中的数据结构。
它通过将键(Key)映射到数组的索引来获取值(Value),从而实现了快速的查找和插入操作。
哈希函数的设计决定了键和索引之间的映射关系,好的哈希函数可以尽可能避免冲突,提高哈希表的性能。
在Java中,可以使用HashMap类来实现哈希表。
HashMap使用一个数组来存储键值对,通过键的哈希值计算出数组索引,并使用链表或红黑树来处理哈希冲突。
下面是一个简单的哈希表实现的例子:```javaimport java.util.HashMap;public class HashTableExample {public static void main(String[] args) {HashMap<String, Integer> hashTable = new HashMap<>();// 插入键值对hashTable.put("A", 1);hashTable.put("B", 2);hashTable.put("C", 3);// 获取值int value = hashTable.get("B");System.out.println(value); // 输出: 2// 遍历哈希表for (String key : hashTable.keySet()) {int val = hashTable.get(key);System.out.println(key + ": " + val);}}}```二、LRU缓存的原理和实现LRU缓存是一种常用的缓存淘汰策略,它根据数据的访问时间来决定淘汰哪些数据。
java bytecache用法
java bytecache用法(原创实用版)目录1.Java ByteCache 简介2.ByteCache 的主要功能3.ByteCache 的使用示例4.ByteCache 的优点与局限性正文【Java ByteCache 简介】Java ByteCache 是一个基于 Java 语言的内存缓存库,主要用于存储字节数据。
它可以将经常使用的数据存储在内存中,从而减少程序对磁盘文件的访问,提高运行速度。
ByteCache 适用于需要频繁读取和写入字节数据的应用程序,例如图像处理、文件压缩等。
【ByteCache 的主要功能】1.高效的缓存机制:ByteCache 采用哈希表作为数据存储结构,提供了高效的数据存取和查找功能。
2.支持多种数据类型:ByteCache 支持多种数据类型,包括字节、字符、整数、浮点数等。
3.灵活的缓存策略:ByteCache 支持多种缓存策略,如 LRU(最近最少使用)、LFU(最不经常使用)等。
4.可扩展性:ByteCache 支持动态扩容,当缓存容量不足时,可以自动增加缓存容量。
【ByteCache 的使用示例】下面是一个简单的 ByteCache 使用示例:```javaimport java.util.concurrent.ByteCache;public class ByteCacheExample {public static void main(String[] args) {// 创建一个 ByteCache 实例ByteCache byteCache = new ByteCache();// 向缓存中添加数据byteCache.put("key1", "value1");byteCache.put("key2", "value2");byteCache.put("key3", "value3");// 从缓存中获取数据String value1 = byteCache.get("key1"); String value2 = byteCache.get("key2"); String value3 = byteCache.get("key3");// 删除缓存中的数据byteCache.remove("key1");byteCache.remove("key2");byteCache.remove("key3");}}```【ByteCache 的优点与局限性】1.优点:ByteCache 具有高效的缓存机制、支持多种数据类型、灵活的缓存策略和可扩展性等优点,可以有效提高程序运行速度。
Java中常用缓存Cache机制的实现
Java中常⽤缓存Cache机制的实现/**所谓缓存,就是将程序或系统经常要调⽤的对象存在内存中,以便其使⽤时可以快速调⽤,不必再去创建新的重复的实例。
这样做可以减少系统开销,提⾼系统效率。
*内存缓存,也就是实现⼀个类中静态Map,对这个Map进⾏常规的增删查.*/package lhm.hcy.guge.frameset.cache;import java.util.*;//Description: 管理缓存//可扩展的功能:当chche到内存溢出时必须清除掉最早期的⼀些缓存对象,这就要求对每个缓存对象保存创建时间public class CacheManager {private static HashMap cacheMap = new HashMap();//单实例构造⽅法private CacheManager() {super();}//获取布尔值的缓存public static boolean getSimpleFlag(String key){try{return (Boolean) cacheMap.get(key);}catch(NullPointerException e){return false;}}public static long getServerStartdt(String key){try {return (Long)cacheMap.get(key);} catch (Exception ex) {return 0;}}//设置布尔值的缓存public synchronized static boolean setSimpleFlag(String key,boolean flag){if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖return false;}else{cacheMap.put(key, flag);return true;}}public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){if (cacheMap.get(key) == null) {cacheMap.put(key,serverbegrundt);return true;}else{return false;}}//得到缓存。
Java中各类Cache机制介绍
Java中各类Cache机制介绍
欢迎大家在这里学习Java中各类Cache机制这里是我们给大家整理出来的精彩内容。
我相信,这些问题也肯定是很多朋友在关心的,所以我就给大家谈谈这个!
Java Caching System
JSC(Java Caching System)是一个用分布式的缓存系统,是基于服务器的java应用程序。
它是通过提供管理各种动态缓存数据来加速动态web应用。
JCS和其他缓存系统一样,也是一个用于高速读取,低速写入的应用程序。
动态内容和报表系统能够获得更好的性能。
如果一个网站,有重复的网站结构,使用间歇性更新方式的数据库(而不是连续不断的更新数据库),被重复搜索出相同结果的,就能够通过执行缓存方式改进其性能和伸缩性。
EHCache
EHCache是一个纯Java的在进程中的缓存,它具有以下特性:快速,简单,为Hibernate 2.1充当可插入的缓存,最小的依赖性,全面的文档和测试。
JCache。
javacache过期策略两种实现,一个基于list轮询一个基于timer定时
javacache过期策略两种实现,⼀个基于list轮询⼀个基于timer定时最近项⽬要引⼊缓存机制,但是不想引⼊分布式的缓存框架,所以⾃⼰就写了⼀个轻量级的缓存实现,有两个版本,⼀个是通过timer实现其超时过期处理,另外⼀个是通过list轮询。
⾸先要了解下java1.6中的ConcurrentMap ,他是⼀个线程安全的Map实现,特别说明的是在没有特别需求的情况下可以⽤ConcurrentHashMap。
我是想学习⼀下读写锁的应⽤,就⾃⼰实现了⼀个SimpleConcurrentHashMap.[java]1. package com.cttc.cache.entity;2.3. import java.util.ArrayList;4. import java.util.Collection;5. import java.util.HashSet;6. import java.util.Map;7. import java.util.Set;8. import java.util.concurrent.locks.Lock;9. import java.util.concurrent.locks.ReadWriteLock;10. import java.util.concurrent.locks.ReentrantReadWriteLock;11.12. public class SimpleConcurrentMap<K, V> implements Map<K, V> {13. final ReadWriteLock lock = new ReentrantReadWriteLock();14. final Lock r = lock.readLock();15. final Lock w = lock.writeLock();16. final Map<K, V> map;17.18. public SimpleConcurrentMap(Map<K, V> map) {19. this.map = map;20. if (map == null) throw new NullPointerException();21. }22.23. public void clear() {24. w.lock();25. try {26. map.clear();27. } finally {28. w.unlock();29. }30. }31.32. public boolean containsKey(Object key) {33. r.lock();34. try {35. return map.containsKey(key);36. } finally {37. r.unlock();38. }39. }40.41. public boolean containsValue(Object value) {42. r.lock();43. try {44. return map.containsValue(value);45. } finally {46. r.unlock();47. }48. }49.50. public Set<java.util.Map.Entry<K, V>> entrySet() {51. throw new UnsupportedOperationException();52. }53.54. public V get(Object key) {55. r.lock();56. try {57. return map.get(key);58. } finally {59. r.unlock();60. }61. }62.63. public boolean isEmpty() {64. r.lock();65. try {66. return map.isEmpty();67. } finally {68. r.unlock();69. }70. }71.72. public Set<K> keySet() {73. r.lock();74. try {75. return new HashSet<K>(map.keySet());76. } finally {77. r.unlock();78. }79. }80.81. public V put(K key, V value) {82. w.lock();83. try {84. return map.put(key, value);85. } finally {86. w.unlock();87. }88. }89.90. public void putAll(Map<? extends K, ? extends V> m) {91. w.lock();92. try {93. map.putAll(m);94. } finally {95. w.unlock();96. }97. }98.99. public V remove(Object key) {100. w.lock();101. try {102. return map.remove(key);103. } finally {104. w.unlock();105. }106. }107.108. public int size() {109. r.lock();110. try {111. return map.size();112. } finally {113. r.unlock();114. }115. }116.117. public Collection<V> values() {118. r.lock();119. try {120. return new ArrayList<V>(map.values());121. } finally {122. r.unlock();123. }124. }125.126. }缓存对象CacheEntity.为:[html]1. package com.cttc.cache.entity;2.3. import java.io.Serializable;4.5. public class CacheEntity implements Serializable{6. private static final long serialVersionUID = -3971709196436977492L;7. private final int DEFUALT_VALIDITY_TIME = 20;//默认过期时间 20秒8.9. private String cacheKey;10. private Object cacheContext;11. private int validityTime;//有效期时长,单位:秒12. private long timeoutStamp;//过期时间戳13.14. private CacheEntity(){15. this.timeoutStamp = System.currentTimeMillis() + DEFUALT_VALIDITY_TIME * 1000;16. this.validityTime = DEFUALT_VALIDITY_TIME;17. }18.19. public CacheEntity(String cacheKey, Object cacheContext){20. this();21. this.cacheKey = cacheKey;22. this.cacheContext = cacheContext;23. }24.25. public CacheEntity(String cacheKey, Object cacheContext, long timeoutStamp){26. this(cacheKey, cacheContext);27. this.timeoutStamp = timeoutStamp;28. }29.30. public CacheEntity(String cacheKey, Object cacheContext, int validityTime){31. this(cacheKey, cacheContext);32. this.validityTime = validityTime;33. this.timeoutStamp = System.currentTimeMillis() + validityTime * 1000;34. }35.36. public String getCacheKey() {37. return cacheKey;38. }39. public void setCacheKey(String cacheKey) {40. this.cacheKey = cacheKey;41. }42. public Object getCacheContext() {43. return cacheContext;44. }45. public void setCacheContext(Object cacheContext) {46. this.cacheContext = cacheContext;47. }48. public long getTimeoutStamp() {49. return timeoutStamp;50. }51. public void setTimeoutStamp(long timeoutStamp) {52. this.timeoutStamp = timeoutStamp;53. }54. public int getValidityTime() {55. return validityTime;56. }57. public void setValidityTime(int validityTime) {58. this.validityTime = validityTime;59. }60. }List缓存处理对象:[java]1. package com.cttc.cache.handler;2.3. import java.util.ArrayList;4. import java.util.HashMap;5. import java.util.List;6.7. import com.cttc.cache.entity.CacheEntity;8. import com.cttc.cache.entity.SimpleConcurrentMap;9.10. /**11. * @projName:WZServer12. * @className:CacheHandler13. * @description:缓存操作类,对缓存进⾏管理,采⽤处理队列,定时循环清理的⽅式14. * @creater:Administrator15. * @creatTime:2013年7⽉22⽇上午9:18:5416. * @alter:Administrator17. * @alterTime:2013年7⽉22⽇上午9:18:5418. * @remark:19. * @version20. */21. public class CacheListHandler {22. private static final long SECOND_TIME = 1000;23. private static final SimpleConcurrentMap<String, CacheEntity> map;24. private static final List<CacheEntity> tempList;25.26. static{27. tempList = new ArrayList<CacheEntity>();28. map = new SimpleConcurrentMap<String, CacheEntity>(new HashMap<String, CacheEntity>(1<<18));29. new Thread(new TimeoutTimerThread()).start();30. }31.32. /**33. * 增加缓存对象34. * @param key35. * @param ce36. */37. public static void addCache(String key, CacheEntity ce){38. addCache(key, ce, ce.getValidityTime());39. }40.41. /**42. * 增加缓存对象43. * @param key44. * @param ce45. * @param validityTime 有效时间46. */47. public static synchronized void addCache(String key, CacheEntity ce, int validityTime){48. ce.setTimeoutStamp(System.currentTimeMillis() + validityTime * SECOND_TIME);49. map.put(key, ce);50. //添加到过期处理队列51. tempList.add(ce);52. }53.54. /**55. * 获取缓存对象56. * @param key57. * @return58. */59. public static synchronized CacheEntity getCache(String key){60. return map.get(key);61. }62.63. /**64. * 检查是否含有制定key的缓冲65. * @param key66. * @return67. */68. public static synchronized boolean isConcurrent(String key){69. return map.containsKey(key);70. }71.72. /**73. * 删除缓存74. * @param key75. */76. public static synchronized void removeCache(String key){77. map.remove(key);78. }79.80. /**81. * 获取缓存⼤⼩82. * @param key83. */84. public static int getCacheSize(){85. return map.size();86. }87.88. /**89. * 清除全部缓存90. */91. public static synchronized void clearCache(){92. tempList.clear();93. map.clear();94. System.out.println("clear cache");95. }96.97. static class TimeoutTimerThread implements Runnable {98. public void run(){99. while(true){100. try {101. checkTime();102. } catch (Exception e) {103. e.printStackTrace();104. }105. }106. }107.108. /**109. * 过期缓存的具体处理⽅法110. * @throws Exception111. */112. private void checkTime() throws Exception{113. //"开始处理过期 ";114. CacheEntity tce = null;115. long timoutTime = 1000L;116.117. //" 过期队列⼤⼩ : "+tempList.size());118. if(1 > tempList.size()){119. System.out.println("过期队列空,开始轮询");120. timoutTime = 1000L;121. Thread.sleep(timoutTime);122. return;123. }124.125. tce = tempList.get(0);126. timoutTime = tce.getTimeoutStamp() - System.currentTimeMillis();127. //" 过期时间 : "+timoutTime);128. if(0 < timoutTime){129. //设定过期时间130. Thread.sleep(timoutTime);131. return;132. }133. System.out.print(" 清除过期缓存: "+tce.getCacheKey());134. //清除过期缓存和删除对应的缓存队列135. tempList.remove(tce);136. removeCache(tce.getCacheKey());137. }138. }139. }Timer⽅式[java]1. package com.cttc.cache.handler;2.3. import java.util.HashMap;4. import java.util.Timer;5. import java.util.TimerTask;6.7. import com.cttc.cache.entity.CacheEntity;8. import com.cttc.cache.entity.SimpleConcurrentMap;9.10. /**11. * @projName:WZServer12. * @className:CacheHandler13. * @description:缓存操作类,对缓存进⾏管理,清除⽅式采⽤Timer定时的⽅式14. * @creater:Administrator15. * @creatTime:2013年7⽉22⽇上午9:18:5416. * @alter:Administrator17. * @alterTime:2013年7⽉22⽇上午9:18:5418. * @remark:19. * @version20. */21. public class CacheTimerHandler {22. private static final long SECOND_TIME = 1000;//默认过期时间 20秒23. private static final int DEFUALT_VALIDITY_TIME = 20;//默认过期时间 20秒24. private static final Timer timer ;25. private static final SimpleConcurrentMap<String, CacheEntity> map;26.27. static{28. timer = new Timer();29. map = new SimpleConcurrentMap<String, CacheEntity>(new HashMap<String, CacheEntity>(1<<18));30. }31.32. /**33. * 增加缓存对象34. * @param key35. * @param ce36. */37. public static void addCache(String key, CacheEntity ce){38. addCache(key, ce, DEFUALT_VALIDITY_TIME);39. }40.41. /**42. * 增加缓存对象43. * @param key44. * @param ce45. * @param validityTime 有效时间47. public static synchronized void addCache(String key, CacheEntity ce, int validityTime){48. map.put(key, ce);49. //添加过期定时50. timer.schedule(new TimeoutTimerTask(key), validityTime * SECOND_TIME);51. }52.53. /**54. * 获取缓存对象55. * @param key56. * @return57. */58. public static synchronized CacheEntity getCache(String key){59. return map.get(key);60. }61.62. /**63. * 检查是否含有制定key的缓冲64. * @param key65. * @return66. */67. public static synchronized boolean isConcurrent(String key){68. return map.containsKey(key);69. }70.71. /**72. * 删除缓存73. * @param key74. */75. public static synchronized void removeCache(String key){76. map.remove(key);77. }78.79. /**80. * 获取缓存⼤⼩81. * @param key82. */83. public static int getCacheSize(){84. return map.size();85. }86.87. /**88. * 清除全部缓存89. */90. public static synchronized void clearCache(){91. if(null != timer){92. timer.cancel();93. }94. map.clear();95. System.out.println("clear cache");96. }97.98. /**99. * @projName:WZServer100. * @className:TimeoutTimerTask101. * @description:清除超时缓存定时服务类102. * @creater:Administrator103. * @creatTime:2013年7⽉22⽇上午9:34:39104. * @alter:Administrator105. * @alterTime:2013年7⽉22⽇上午9:34:39106. * @remark:107. * @version108. */109. static class TimeoutTimerTask extends TimerTask{110. private String ceKey ;111.112. public TimeoutTimerTask(String key){113. this.ceKey = key;115.116. @Override117. public void run() {118. CacheTimerHandler.removeCache(ceKey);119. System.out.println("remove : "+ceKey);120. }121. }122. }timer⽅式有点是适⽤性更强,因为每个缓存的过期时间都可以独⽴配置的;ist只能适⽤于缓存时间都⼀样的线性过期。
java缓存机制(上)
java缓存机制(上)缓存的⽬的在于节省访问时间以及减轻⼤并发量访问带来资源上的消耗。
缓存的深度从前端到数据库都有涉及,页⾯缓存效果最好,因其占⽤的资源⽐较少基于WEB应⽤下的系统架构图:在系统架构的不同层级之间,为了加快访问速度,都可以存在缓存操作系统磁盘缓存->减少磁盘机械操作数据库缓存->减少⽂件系统I/O应⽤程序缓存->减少对数据库的查询Web服务器缓存->减少应⽤服务器请求客户端浏览器缓存->减少对⽹站的访问操作系统磁盘缓存 1、⽂件系统提供的Disk Cache:操作系统会把经常访问到的⽂件内容放⼊到内存当中,由⽂件系统来管理 2、当应⽤程序通过⽂件系统访问磁盘⽂件的时候,操作系统从Disk Cache当中读取⽂件内容,加速了⽂件读取速度 3、Disk Cache由操作系统来⾃动管理,⼀般不⽤⼈⼯⼲预,但应当保证物理内存充⾜,以便于操作系统可以使⽤尽量多的内存充当Disk Cache,加速⽂件读取速度 4、特殊的应⽤程序对⽂件系统Disk Cache有很⾼的要求,会绕开⽂件系统Disk Cache,直接访问磁盘分区,⾃⼰实现Disk 5、Cache策略Oracle的raw device(裸设备) – 直接抛弃⽂件系统MySQL的InnoDB: innodb_flush_method = O_DIRECT数据库缓存a、Query Cache以SQL作为key值缓存查询结果集⼀旦查询涉及的表记录被修改,缓存就会被⾃动删除设置合适的Query Cache会极⼤提⾼数据库性能Query Cache并⾮越⼤越好,过⼤的Qquery Cache会浪费内存。
MySQL: query_cache_size= 128Mb、Data Bufferdata buffer是数据库数据在内存中的容器data buffer的命中率直接决定了数据库的性能data buffer越⼤越好,多多益善MySQL的InnoDB buffer:innodb_buffer_pool_size = 2GMySQL建议buffer pool开⼤到服务器物理内存60-80%应⽤程序缓存对象缓存 由O/R Mapping框架例如Hibernate提供,透明性访问,细颗粒度缓存数据库查询结果,⽆需业务代码显式编程,是最省事的缓存策略当软件结构按照O/R Mapping框架的要求进⾏针对性设计,使⽤对象缓存将会极⼤降低Web系统对于数据库的访问请求良好的设计数据库结构和利⽤对象缓存,能够提供极⾼的性能,对象缓存适合OLTP(联机事务处理)应⽤插叙缓存 对数据库查询结果集进⾏缓存,类似数据库的Query Cache适⽤于⼀些耗时,但是时效性要求⽐较低的场景。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Cache所谓缓存,就是将程序或系统经常要调用的对象存在内存中,一遍其使用时可以快速调用,不必再去创建新的重复的实例。
这样做可以减少系统开销,提高系统效率。
缓存主要可分为二大类:一、通过文件缓存,顾名思义文件缓存是指把数据存储在磁盘上,不管你是以XML格式,序列化文件DAT格式还是其它文件格式;二、内存缓存,也就是实现一个类中静态Map,对这个Map进行常规的增删查.代码如下:package lhm.hcy.guge.frameset.cache;import java.util.*;//Description: 管理缓存//可扩展的功能:当chche到内存溢出时必须清除掉最早期的一些缓存对象,这就要求对每个缓存对象保存创建时间public class CacheManager {private static HashMap cacheMap = new HashMap();//单实例构造方法private CacheManager() {super();}//获取布尔值的缓存public static boolean getSimpleFlag(String key){try{return (Boolean) cacheMap.get(key);}catch(NullPointerException e){return false;}public static long getServerStartdt(String key){try {return (Long)cacheMap.get(key);} catch (Exception ex) {return 0;}}//设置布尔值的缓存public synchronized static boolean setSimpleFlag(String key,boolean flag){ if (flag && getSimpleFlag(key)) {//假如为真不允许被覆盖return false;}else{cacheMap.put(key, flag);return true;}}public synchronized static boolean setSimpleFlag(String key,long serverbegrundt){ if (cacheMap.get(key) == null) {cacheMap.put(key,serverbegrundt);return true;}else{return false;}}//得到缓存。
同步静态方法private synchronized static Cache getCache(String key) {return (Cache) cacheMap.get(key);}//判断是否存在一个缓存private synchronized static boolean hasCache(String key) {return cacheMap.containsKey(key);}//清除所有缓存public synchronized static void clearAll() {cacheMap.clear();}//清除某一类特定缓存,通过遍历HASHMAP下的所有对象,来判断它的KEY与传入的TYPE是否匹配public synchronized static void clearAll(String type) {Iterator i = cacheMap.entrySet().iterator();String key;ArrayList arr = new ArrayList();try {while (i.hasNext()) {java.util.Map.Entry entry = (java.util.Map.Entry) i.next();key = (String) entry.getKey();if (key.startsWith(type)) { //如果匹配则删除掉arr.add(key);}}for (int k = 0; k < arr.size(); k++) {clearOnly(arr.get(k));}} catch (Exception ex) {ex.printStackTrace();}}//清除指定的缓存public synchronized static void clearOnly(String key) {cacheMap.remove(key);}//载入缓存public synchronized static void putCache(String key, Cache obj) { cacheMap.put(key, obj);}//获取缓存信息public static Cache getCacheInfo(String key) {if (hasCache(key)) {Cache cache = getCache(key);if (cacheExpired(cache)) { //调用判断是否终止方法cache.setExpired(true);}return cache;}elsereturn null;}//载入缓存信息public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) { Cache cache = new Cache();cache.setKey(key);cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存cache.setValue(obj);cache.setExpired(expired); //缓存默认载入时,终止状态为FALSEcacheMap.put(key, cache);}//重写载入缓存信息方法public static void putCacheInfo(String key,Cache obj,long dt){Cache cache = new Cache();cache.setKey(key);cache.setTimeOut(dt+System.currentTimeMillis());cache.setValue(obj);cache.setExpired(false);cacheMap.put(key,cache);}//判断缓存是否终止public static boolean cacheExpired(Cache cache) {if (null == cache) { //传入的缓存不存在return false;}long nowDt = System.currentTimeMillis(); //系统当前的毫秒数long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数if (cacheDt <= 0||cacheDt>nowDt) { //过期时间小于等于零时,或者过期时间大于当前时间时,则为FALSEreturn false;} else { //大于过期时间即过期return true;}}//获取缓存中的大小public static int getCacheSize() {return cacheMap.size();}//获取指定的类型的大小public static int getCacheSize(String type) {int k = 0;Iterator i = cacheMap.entrySet().iterator();try {while (i.hasNext()) {java.util.Map.Entry entry = (java.util.Map.Entry) i.next();key = (String) entry.getKey();if (key.indexOf(type) != -1) { //如果匹配则删除掉k++;}}} catch (Exception ex) {ex.printStackTrace();}return k;}//获取缓存对象中的所有键值名称public static ArrayList getCacheAllkey() {ArrayList a = new ArrayList();try {Iterator i = cacheMap.entrySet().iterator();while (i.hasNext()) {java.util.Map.Entry entry = (java.util.Map.Entry) i.next();a.add((String) entry.getKey());}} catch (Exception ex) {} finally {return a;}}//获取缓存对象中指定类型的键值名称public static ArrayList getCacheListkey(String type) {ArrayList a = new ArrayList();String key;try {Iterator i = cacheMap.entrySet().iterator();while (i.hasNext()) {java.util.Map.Entry entry = (java.util.Map.Entry) i.next();key = (String) entry.getKey();if (key.indexOf(type) != -1) {a.add(key);}}} catch (Exception ex) {} finally {}}}package lhm.hcy.guge.frameset.cache;public class Cache {private String key;//缓存IDprivate Object value;//缓存数据private long timeOut;//更新时间private boolean expired; //是否终止public Cache() {super();}public Cache(String key, Object value, long timeOut, boolean expired) { this.key = key;this.value = value;this.timeOut = timeOut;this.expired = expired;}public String getKey() {return key;}public long getTimeOut() {return timeOut;}public Object getV alue() {return value;}public void setKey(String string) {key = string;}public void setTimeOut(long l) {timeOut = l;}public void setValue(Object object) {value = object;}public boolean isExpired() {return expired;}public void setExpired(boolean b) {expired = b;}}//测试类,class Test {public static void main(String[] args) {System.out.println(CacheManager.getSimpleFlag("alksd"));// CacheManager.putCache("abc", new Cache());// CacheManager.putCache("def", new Cache());// CacheManager.putCache("ccc", new Cache());// CacheManager.clearOnly("");// Cache c = new Cache();// for (int i = 0; i < 10; i++) {// CacheManager.putCache("" + i, c);// }// CacheManager.putCache("aaaaaaaa", c);// CacheManager.putCache("abchcy;alskd", c);// CacheManager.putCache("cccccccc", c);// CacheManager.putCache("abcoqiwhcy", c);// System.out.println("删除前的大小:"+CacheManager.getCacheSize()); // CacheManager.getCacheAllkey();// CacheManager.clearAll("aaaa");// System.out.println("删除后的大小:"+CacheManager.getCacheSize()); // CacheManager.getCacheAllkey();}}。