java怎麼做緩存
Java的應用緩存cache入門：
java常用的緩存有：ehcache, oscache,jcache，這些cache都是單機的，即存在本機的內存中，另外分布式的cache我用過memcache，它被獨立部署在一台伺服器上，可以實現多個客戶端共用緩存；
一般用到緩存的場景：
1.在處理並發請求，需要及時響應的。
2.加快系統響應速度。舉個例子：比如購物網站有 售賣物品的排行榜，這種數據都是由資料庫中N多表關聯查詢排序得到的，那麼就可以存在緩存當中，當頁面請求查看排行榜時直接取緩存中的數據。後台定時任務根據一定的時間間隔計算好排行結果，再替換到當前緩存中。
這就是一個簡單的緩存應用示例。
B. 使用java實現以個簡單的緩存機制
你這個分數太少了吧，程序到是有，不過給你有點可惜
CacheMgr.java
import java.util.*;
import cn.javass.framework.cache.vo.CacheConfModel;
public class CacheMgr {
private static Map cacheMap = new HashMap();
private static Map cacheConfMap = new HashMap();
private CacheMgr(){
}
private static CacheMgr cm = null;
public static CacheMgr getInstance(){
if(cm==null){
cm = new CacheMgr();
Thread t = new ClearCache();
t.start();
}
return cm;
}
/**
* 增加緩存
* @param key
* @param value
* @param ccm 緩存對象
* @return
*/
public boolean addCache(Object key,Object value,CacheConfModel ccm){
boolean flag = false;
cacheMap.put(key, value);
cacheConfMap.put(key, ccm);
System.out.println("now addcache=="+cacheMap.size());
return true;
}
/**
* 刪除緩存
* @param key
* @return
*/
public boolean removeCache(Object key){
cacheMap.remove(key);
cacheConfMap.remove(key);
System.out.println("now removeCache=="+cacheMap.size());
return true;
}
/**
* 清除緩存的類
* @author wanglj
* 繼承Thread線程類
*/
private static class ClearCache extends Thread{
public void run(){
while(true){
Set tempSet = new HashSet();
Set set = cacheConfMap.keySet();
Iterator it = set.iterator();
while(it.hasNext()){
Object key = it.next();
CacheConfModel ccm = (CacheConfModel)cacheConfMap.get(key);
//比較是否需要清除
if(!ccm.isForever()){
if((new Date().getTime()-ccm.getBeginTime())>= ccm.getDurableTime()*60*1000){
//可以清除，先記錄下來
tempSet.add(key);
}
}
}
//真正清除
Iterator tempIt = tempSet.iterator();
while(tempIt.hasNext()){
Object key = tempIt.next();
cacheMap.remove(key);
cacheConfMap.remove(key);
}
System.out.println("now thread================>"+cacheMap.size());
//休息
try {
Thread.sleep(60*1000L);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
CacheConfModel.java
public class CacheConfModel implements java.io.Serializable{
private long beginTime;
private boolean isForever = false;
private int rableTime;
public long getBeginTime() {
return beginTime;
}
public void setBeginTime(long beginTime) {
this.beginTime = beginTime;
}
public boolean isForever() {
return isForever;
}
public void setForever(boolean isForever) {
this.isForever = isForever;
}
public int getDurableTime() {
return rableTime;
}
public void setDurableTime(int rableTime) {
this.rableTime = rableTime;
}
}
順便說一句，緩存的管理不是靠時間久來計算的，是靠最大不活動間隔計算的，你的設計思想有問題
C. ehcache java 對象緩存怎麼實現
Java EE和應用緩存
為普通緩存場景和模式提供高質量的實現。
阻塞緩存：它的機制避免了復制進程並發操作的問題。
SelfPopulatingCache在緩存一些開銷昂貴操作時顯得特別有用，它是一種針對讀優化的緩存。它不需要調用者知道緩存元素怎樣被返回，也支持在不阻塞讀的情況下刷新緩存條目。
CachingFilter：一個抽象、可擴展的cache filter。
SimplePageCachingFilter：用於緩存基於request URI和Query String的頁面。它可以根據HTTP request header的值來選擇採用或者不採用gzip壓縮方式將頁面發到瀏覽器端。你可以用它來緩存整個Servlet頁面，無論你採用的是JSP、velocity，或者其他的頁面渲染技術。
：緩存頁面片段，基於request URI和Query String。在JSP中使用jsp:include標簽包含。
已經使用Orion和Tomcat測試過，兼容Servlet 2.3、Servlet 2.4規范。
Cacheable命令：這是一種老的命令行模式，支持非同步行為、容錯。
兼容Hibernate，兼容Google App Engine。
基於JTA的事務支持，支持事務資源管理，二階段提交和回滾，以及本地事務。
D. Java實現簡單的緩存機制原理
package qinbo hui;
/*
設計思想來自－回欽波（qq: )
*/
public class CacheConfModel implements java io Serializable{
private long beginTime;
private boolean isForever = false;
private int rableTime;
public long getBeginTime() {
return beginTime;
}
public void setBeginTime(long beginTime) {
this beginTime = beginTime;
}
public boolean isForever() {
return isForever;
}
public void setForever(boolean isForever) {
this isForever = isForever;
}
public int getDurableTime() {
return rableTime;
}
public void setDurableTime(int rableTime) {
this rableTime = rableTime;
}
}
package qinbo hui;
import java util *;
import test CacheConfModel;
/*
設計思想來自－回欽波（qq: )
*/
public class CacheMgr {
private static Map cacheMap = new HashMap();
private static Map cacheConfMap = new HashMap();
private CacheMgr(){
}
private static CacheMgr cm = null;
public static CacheMgr getInstance(){
if(cm==null){
cm = new CacheMgr();
Thread t = new ClearCache();
t start();
}
return cm;
}
/**
* 增加緩存
* @param key
* @param value
* @param ccm 緩存對象
* @return
*/
public boolean addCache(Object key Object value CacheConfModel ccm){
boolean flag = false;
cacheMap put(key value);
cacheConfMap put(key ccm);
System out println( now addcache== +cacheMap size());
return true;
}
/**
* 刪除緩存
* @param key
* @return
*/
public boolean removeCache(Object key){
cacheMap remove(key);
cacheConfMap remove(key);
System out println( now removeCache== +cacheMap size());
return true;
}
/**
* 清除緩存的類
* @author wanglj
* 繼承Thread線程類
*/
private static class ClearCache extends Thread{
public void run(){
while(true){
Set tempSet = new HashSet();
Set set = cacheConfMap keySet();
Iterator it = erator();
while(it hasNext()){
Object key = it next();
CacheConfModel ccm = (CacheConfModel)cacheConfMap get(key);
//比較是否需要清除
if(!ccm isForever()){
if((new Date() getTime() ccm getBeginTime())>= ccm getDurableTime()* * ){
//可以清除 先記錄下來
tempSet add(key);
}
}
}
//真正清除
Iterator tempIt = erator();
while(tempIt hasNext()){
Object key = tempIt next();
cacheMap remove(key);
cacheConfMap remove(key);
}
System out println( now thread================> +cacheMap size());
//休息
try {
Thread sleep( * L);
} catch (InterruptedException e) {
// TODO Auto generated catch block
e printStackTrace();
}
}
}
}
lishixin/Article/program/Java/hx/201311/25737
E. ehcache java 對象緩存怎麼實現
1.技術背景：
系統緩存是位於應用程序與物理數據源之間，用於臨時存放復制數據的內存區域，目的是為減少應用程序對物理數據源訪問的次數，從而提高應用程序的運行性能。緩存設想內存是有限的，緩存的時效性也是有限的，所以可以設定內存數量的大小可以執行失效演算法，可以在內存滿了的情況下，按照最少訪問等演算法將緩存直接移除或切換到硬碟上。
Ehcache從Hibernate發展而來，逐漸涵蓋了Cache界的全部功能，是目前發展勢頭最好的一個項目，具有快速、簡單、低消耗、擴展性強、支持對象或序列化緩存，支持緩存或元素的失效，提供LRU、LFU和FIFO緩存策略，支持內存緩存和硬碟緩存和分布式緩存機制等特點。其中Cache的存儲方式為內存或磁碟（ps：無須擔心容量問題）
2.EhCahe的類層次介紹：
主要分為三層，最上層是CacheManager，它是操作Ehcache的入口。可以通過CacheManager.getInstance()獲得一個單子的CacheManager，或者通過CacheManager的構造函數創建一個新的CacheManager。每個CacheManger都管理多個Cache。每個Cache都以一種類Hash的方式，關聯多個Element。Element就是我們用於存放緩存內容的地方。
3.環境搭建：
很簡單只需要將ehcache-2.1.0-distribution.tar.gz和ehcache-web-2.0.2-distribution.tar.gz擠壓的jar包放入WEB-INF/lib下。
再創建一個重要的配置文件ehcache.xml，可以從ehcache組件包中拷貝一個，也可以自己建立一個，需要放到classpath下，一般放於/WEB-INF/classed/ehcache.xml；具體的配置文件可以網上搜一下
4.實際運用
一個網站的首頁估計是被訪問次數最多的，我們可以考慮給首頁做一個頁面緩存；
緩存策略：應該是某個固定時間之內不變的，比如說2分鍾更新一次，以應用結構page-filter-action-service--db為例。
位置：頁面緩存做到盡量靠近客戶的地方，就是在page和filter之間，這樣的優點就是第一個用戶請求後，頁面被緩存，第二個用戶在請求，走到filter這個請求就結束了，需要在走到action-service--db，好處當然是伺服器壓力大大降低和客戶端頁面響應速度加快。
首頁頁面緩存存活時間定為2分鍾，也就是參數timeToLiveSeconds（緩存的存活時間）應該設置為120，同時timeToIdleSeconds（多長時間不訪問緩存，就清楚該緩存）最好也設為2分鍾或者小於2分鍾。
接著我們來看一下SimplePageCachingFilter的配置，
<filter>
<filter-name>indexCacheFilterfilter-name>
<filter-class>
net.sf.ehcache.constructs.web.filter.SimplePageCachingFilter
<filter-class>
<filter>
<filter-mapping>
<filter-name>indexCacheFilterfilter-name>
<url-pattern>*index.actionurl-pattern>
<filter-mapping>
將上述代碼加入到web.xml，那麼當打開首頁時，你會發現2分鍾才會有一堆sql語句出現在控制台，也可以調整為5分鍾，總之一切盡在掌控之中。
當然，如果你像緩存首頁的部分內容時，你需要使用這個filter，我看一下：
<filter>
<filter-name>indexCacheFilterfilter-name>
<filter-class>
net.sf.ehcache.constructs.web.filter.
<filter-class>
filter>
<filter-mapping>
<filter-name>indexCacheFilterfilter-name>
<url-pattern>*/index_right.jsp<url-pattern>
<filter-mapping>
如此我們將jsp頁面通過jsp：include到其他頁面，這樣就做到了頁面局部緩存的效果，這一點貌似沒有oscache的tag好用。
此外cachefilter中還有一個特性，就是gzip，也就是緩存中的元素是被壓縮過的，如果客戶端瀏覽器支持壓縮的話，filter會直接返回壓縮過的流，這樣節省了帶寬，把解壓的工作交給了客戶端瀏覽即可，當然如果客戶端不支持gzip，那麼filter會把緩存的元素拿出來解壓後在返回給客戶端瀏覽器（大多數爬蟲是不支持gzip的，所以filter也會解壓後在返迴流）。
總之，Ehcache是一個非常輕量級的緩存實現，而且從1.2之後支持了集群，而且是hibernate默認的緩存provider，本文主要介紹Ehcahe對頁面緩存的支持，但是它的功能遠不止如此，要用好緩存，對J2ee中緩存的原理、適用范圍、適用場景等等都需要比較深刻的理解，這樣才能用好用對緩存。
為了大家通過實際例子加深了解與場景運用，在奉獻一個實例：
*在Spring中運用EhCache
適用任意一個現有開源CacheFramework，要求可以Cache系統中service或者DAO層的get/find等方法返回結果，如果數據更新（適用了Create/update/delete），則刷新cache中相應的內容。
根據需求，計劃適用SpringAOP+enCache來實現這個功能，採用ehCache原因之一就是Spring提供了enCache的支持，至於為何僅僅支持ehcache而不支持oscache和jbosscache就無從得知了。
AOP少不了攔截器，先創建一個實現了MethodInterceptor介面的攔截器，用來攔截Service/DAO的方法調用，攔截到方法後，搜索該方法的結果在cache中是否存在，如果存在，返回cache中結果，如果不存在返回資料庫查詢結果，並將結果返回到緩存。
,InitializingBean
{
privatestaticfinalLoglogger=LogFactory.getLog(MethodCacheInterceptor.class);
privateCachecache;
publicvoidsetCache(Cachecache){
this.cache=cache;
}
publicMethodCacheInterceptor(){
super();
}
/**
*攔截Service/DAO的方法，並查找該結果是否存在，如果存在就返回cache中的值，
*否則，返回資料庫查詢結果，並將查詢結果放入cache
*/
publicObjectinvoke(MethodInvocationinvocation)throwsThrowable{
StringtargetName=invocation.getThis().getClass().getName();
StringmethodName=invocation.getMethod().getName();
Object[]arguments=invocation.getArguments();
Objectresult;
logger.debug("Findobjectfromcacheis"+cache.getName());
StringcacheKey=getCacheKey(targetName,methodName,arguments);
Elementelement=cache.get(cacheKey);
Page13of26
if(element==null){
logger.debug("Holpmethod,Getmethodresultandcreatecache........!");
result=invocation.proceed();
element=newElement(cacheKey,(Serializable)result);
cache.put(element);
}
returnelement.getValue();
}
/**
*獲得cachekey的方法，cachekey是Cache中一個Element的唯一標識
*cachekey包括包名+類名+方法名，如com.co.cache.service.UserServiceImpl.getAllUser
*/
privateStringgetCacheKey(StringtargetName,StringmethodName,Object[]arguments){
StringBuffersb=newStringBuffer();
sb.append(targetName).append(".").append(methodName);
if((arguments!=null)&&(arguments.length!=0)){
for(inti=0;i<arguments.length;i++){
sb.append(".").append(arguments[i]);
}
}
returnsb.toString();
}
/**
*implementInitializingBean，檢查cache是否為空
*/
publicvoidafterPropertiesSet()throwsException{
Assert.notNull(cache,"Needacache.PleaseusesetCache(Cache)createit.");
}
}
上面的代碼可以看到，在方法invoke中，完成了搜索cache/新建cache的功能
隨後，再建立一個攔截器MethodCacheAfterAdvice，作用是在用戶進行create/update/delete操作時來刷新、remove相關cache內容，這個攔截器需要實現AfterRetruningAdvice介面，將會在所攔截的方法執行後執行在afterReturning（objectarg0，Methodarg1，Object[]arg2,objectarg3)方法中所預定的操作
,InitializingBean
{
privatestaticfinalLoglogger=LogFactory.getLog(MethodCacheAfterAdvice.class);
privateCachecache;
Page15of26
publicvoidsetCache(Cachecache){
this.cache=cache;
}
publicMethodCacheAfterAdvice(){
super();
}
publicvoidafterReturning(Objectarg0,Methodarg1,Object[]arg2,Objectarg3)throws
Throwable{
StringclassName=arg3.getClass().getName();
Listlist=cache.getKeys();
for(inti=0;i<list.size();i++){
StringcacheKey=String.valueOf(list.get(i));
if(cacheKey.startsWith(className)){
cache.remove(cacheKey);
logger.debug("removecache"+cacheKey);
}
}
}
publicvoidafterPropertiesSet()throwsException{
Assert.notNull(cache,"Needacache.PleaseusesetCache(Cache)createit.");
}
}
該方法獲取目標class的全名，如：com.co.cache.test.TestServiceImpl，然後循環cache的keylist，刷新/removecache中所有和該class相關的element。
接著就是配置encache的屬性，如最大緩存數量、cache刷新的時間等等。
<ehcache>
<diskStorepath="c:\myapp\cache"/>
<defaultCache
maxElementsInMemory="1000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
/>
<cachename="DEFAULT_CACHE"
maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="300000"
timeToLiveSeconds="600000"
overflowToDisk="true"
/>
</ehcache>
這里需要注意的是defaultCache定義了一個默認的cache，這個Cache不能刪除，否則會拋出Nodefaultcacheisconfigured異常。另外由於使用攔截器來刷新Cache內容，因此在定義cache生命周期時可以定義較大的數值，timeToIdleSeconds="30000000",timeToLiveSeconds="6000000"，好像還不夠大？
然後再將Cache和兩個攔截器配置到Spring的配置文件cache.xml中即可，需要創建兩個「切入點」，分別用於攔截不同方法名的方法。在配置application.xml並且導入cache.xml。這樣一個簡單的Spring+Encache框架就搭建完成。
F. java怎麼實現map 緩存技術
/**
*緩存池
*@authorxiaoquan
*@create2015年3月13日上午10:32:13
*@see
*/
publicclassCachePool{
;//緩存池唯一實例
privatestaticMap<String,Object>cacheItems;//緩存Map
privateCachePool(){
cacheItems=newHashMap<String,Object>();
}
/**
*得到唯一實例
*@return
*/
(){
if(instance==null){
instance=newCachePool();
}
returninstance;
}
/**
*清除所有Item緩存
*/
(){
cacheItems.clear();
}
/**
*獲取緩存實體
*@paramname
*@return
*/
(Stringname){
if(!cacheItems.containsKey(name)){
returnnull;
}
CacheItemcacheItem=(CacheItem)cacheItems.get(name);
if(cacheItem.isExpired()){
returnnull;
}
returncacheItem.getEntity();
}
/**
*存放緩存信息
*@paramname
*@paramobj
*@paramexpires
*/
(Stringname,Objectobj,longexpires){
if(!cacheItems.containsKey(name)){
cacheItems.put(name,newCacheItem(obj,expires));
}
CacheItemcacheItem=(CacheItem)cacheItems.get(name);
cacheItem.setCreateTime(newDate());
cacheItem.setEntity(obj);
cacheItem.setExpireTime(expires);
}
(Stringname,Objectobj){
putCacheItem(name,obj,-1);
}
/**
*移除緩存數據
*@paramname
*/
(Stringname){
if(!cacheItems.containsKey(name)){
return;
}
cacheItems.remove(name);
}
/**
*獲取緩存數據的數量
*@return
*/
publicintgetSize(){
returncacheItems.size();
}
}
publicclassCacheItem{
privateDatecreateTime=newDate();//創建緩存的時間
privatelongexpireTime=1;//緩存期滿的時間
privateObjectentity;//緩存的實體
publicCacheItem(Objectobj,longexpires){
this.entity=obj;
this.expireTime=expires;
}
publicbooleanisExpired(){
return(expireTime!=-1&&newDate().getTime()-createTime.getTime()>expireTime);
}
/**
*省略getter、setter方法
*/
}
G. java 中如何進行頁面緩存
可以在要執行的頁面中通過set方法設置要緩存的內容，之後通過get方式獲取到設置的內容
舉例：
第一個訪問頁面：
request.setAttribute("username",zhangsan");
第二個跳轉頁面：
Srting username = request.getAttribute(''username'');
此時即可獲取到username的存儲信息。
H. java內存或者是緩存管理怎麼實現
我不太清楚你為什麼用map來存放數據？你用什麼作為key呢？如果是我做的話我會自定義一個對象，裡面大體上有如下屬性：發言人、發言時間、發言內容等。然後用list存放這些對象，list是由順序的。如果長度到達一定值可以把最先放進去的對象清除掉或移動到其他地方。