自己實現一個記憶體快取

最近了解了下快取技術，主要分為記憶體快取和磁碟快取，然後分散式裡面有一些訊息的推送，節點的一些處理。現在很多的用OSCache,EhCache 等等，資料很多，暫時就不多說了，我這裡僅僅為了瞭解快取框架的的知識，自己臨時寫一個快取，後面可以實現AOP 和spring 結合。

實現功能：
1.資料都快取到記憶體中
2.實現對每個元素Element的快取時間進行控制
3.對每個快取Cache 進行建立，以及銷燬的管理
4.能對快取存放個數進行管理
5.通過執行緒定時檢查元素是否過期
6.可以定義快取清除策略

實現思路：
1.Store 介面：定義常用的存取元素get,put的介面
2.AbstractStore:對介面基本方法進行實現
3.MemoryCache:對具體快取的存取方法進行實現，並執行一定的邏輯控制
4.Cache:增加對快取整體進行監聽，銷燬等操作
5.CacheManager：快取管理器，負責管理快取的容器

6.CacheConfiguration ：一些快取的配置屬性
7.CheckManager：一些檢查快取內容的策略方法
8.EvictionType：列舉清空策略
9.CacheListener：快取的監聽，每次建立快取就啟動，然後定時檢查快取元素是否過期
10.Element: 元素的單元

Java程式碼

package com.cache;
import java.util.Collection;
public interface Store {
// 獲得快取名字
public String getName();
// 存放元素
public Element put(Element e);
public Collection<Element> putAll(Collection<Element> elements);
// 獲取元素
public Element get(Object key);
// 清除元素
public void clear();
// 移除元素
public void remove(Object key);
public void removeAll(Object[] keys);
// 獲得的元素長度
public Integer size();
}

Java程式碼

package com.cache;
import java.util.Map;
/**
* 抽象類實現
*/
public abstract class AbstractStore implements Store{
protected Map<Object, Element> map;
public AbstractStore(){}
public AbstractStore(Map<Object, Element> map){
this.map = map;
}
@Override
public Element get(Object key) {
Element e = map.get(key);
return e;
}
public Map<Object, Element> getAll(){
return map;
}
@Override
public void clear() {
map.clear();
}
@Override
public Element put(Element e) {
return map.put(e.getKey(), e);
}
@Override
public void remove(Object key) {
map.remove(key);
}
@Override
public Integer size() {
return map.size();
}
@Override
public void removeAll(Object[] keys) {
for(int i =0;i<keys.length;i++){
remove(keys[i]);
}
}
}

Java程式碼

package com.cache;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
/**
* 快取的基本方法
*/
public class MemoryCache extends AbstractStore implements Store{
private final CacheConfiguration configure;
private final static Map<Object, Element> map = new HashMap<Object, Element>();
private final CheckManager checkManager;
// 暫時僅弄一個構造
public MemoryCache(CacheConfiguration configure){
super(map);
this.configure = configure;
this.checkManager = new CheckManager(configure, map);
}
@Override
public String getName() {
return configure.getCacheName();
}
@Override
public Collection<Element> putAll(Collection<Element> elements) {
if(elements == null){
throw new NullPointerException("elements can't be null");
}
check(elements.size());
for(Element e : elements){
putElementStatus(e);
super.put(e);
}
return elements;
}
@Override
public synchronized Element put(Element e) {
check(1);
putElementStatus(e);
return super.put(e);
}
// 使用一次之後重新整理使用過期時間，以及使用次數
// 並檢查該元素是否過期
public void changeElement(Element e){
e.addHitCount();
if(!configure.getEternal()){
e.refreshLastAccessTime();
}
}
// 如果eternal 為true，表示元素永不過期,預設忽略最小元素控制
public void putElementStatus(Element e){
if(!configure.getEternal() && ! e.getIsOpen()){
e.setTimeToIdle(configure.getTimeToIdleSeconds());
e.setTimeToLive(configure.getTimeToLiveSeconds());
}else{
e.setTimeToIdle(0);
e.setTimeToLive(0);
}
}
@Override
public Element get(Object key) {
Element e = super.get(key);
if(e != null){
if(!e.isExpired()){
changeElement(e);
}else{
synchronized (this) {
remove(e.getKey());
e = null;
}
}
}
return e;
}
// 檢查元素是否為空
public boolean checkElement(Element e){
if(e == null){
throw new NullPointerException("Element can't be null ");
}
if(e.getKey() == null){
throw new NullPointerException("Element key can't be null ");
}
return true;
}
@Override
public synchronized void removeAll(Object[] keys) {
super.removeAll(keys);
}
// 檢查元素是否超過了
public void check(int checkSize){
if(checkSize <= 0){
return;
}
Object[] keys = checkManager.checkConfigure(checkSize);
if(keys !=null) {
removeAll(keys);
}
}
}

Java程式碼

package com.cache;
/**
* 這是對快取級的控制判斷
*/
public class Cache extends MemoryCache{
private CacheConfiguration configure;
相關推薦

自己實現一個記憶體快取

最近了解了下快取技術，主要分為記憶體快取和磁碟快取，然後分散式裡面有一些訊息的推送，節點的一些處理。現在很多的用OSCache,EhCache 等等，資料很多，暫時就不多說了，我這裡僅僅為了瞭解快取框架的的知識，自己臨時寫一個快取，後面可以實現AOP 和spring 結合。

自己實現一個each叠代器

所在導致應該分享一個不用結構 llb blog 什麽是叠代器？　　其實就是對一個對象內部進行遍歷的方法，比如jquery的each方法，或者原生js的foreach方法。叠代器的特點　　針對叠代器，這裏有幾個特點：　　 ? 訪問一個聚合對象的內容而無

初學線程池--1，自己實現一個線程池

exec nta get() 線程初始化 throw clas 忽略 cti 自己實現一個簡單的線程池 public interface ThreadPool<Job extends Runnable> { // 啟動 void execute

自己實現一個內存緩存

推送 lca reat 總數 red shu map.entry 屬性 clas 最近了解了下緩存技術，主要分為內存緩存和磁盤緩存，然後分布式裏面有一些消息的推送，節點的一些處理。現在很多的用OSCache,EhCache 等等，資料很多，暫時就不多說了，我這裏僅僅為了了

自己實現一個Redux。

Redux核心 Redux核心概念 redux核心api 逐步程式碼實現（涉及ES6語法）： createStore combineReducers Redux是一個用於狀態管理的js框架，是Flux架構的一

自己實現一個SpringIOC——（1）

Spring框架中最重要也是最廣為人知的就是AOP和IOC了吧，AOP我已經講過了，今天我們就講講IOC，對於一些基本概念我就不贅述了，而且講了也很難深刻的理解，今天我們就自己編寫一個簡易的框架來實現IOC，至於我是怎麼知道的，嘿嘿，我是看了這裡的視訊：https:/

python只使用Queue和Thread自己實現一個最簡單的執行緒池

我的思路就是就是寫一個TifCutting類繼承自Thread，這個類裡有個屬性Queue；有一個addTask新增任務的方法，這個方法是把需要執行的函式放到Queue裡；因為繼承自Thread類，一定有一個重寫的run方法，這個方法是從自己的Queue屬性裡

如何自己實現一個scrapy框架——框架雛形（一）

#一、瞭解框架 ##1、首先明確一下，什麼是框架：框架是為了為解決一類問題而開發的程式，框架兩個字可以分開理解，框：表示指定解決問題的邊界，明確要解決的問題；架：表達的是能夠提供一定的支撐性和可擴充套件性；從而實現解決這類問題達到快速開發的目的。 ##2、實現

springboot原始碼解析：自己實現一個springboot自動配置

上兩篇將到了springboot自動配置和條件註解是如何實現，這篇在前兩篇的基礎上自己實現一個springboot的自動配置，用到條件註解。需求：加入自己手寫的jar。直接就可以使用StringRedisTemplate。 1.新建一個maven專案，pom.xml如下：

自己實現一個簡單版的HashMap

public class MyHashMap { //預設初始化大小 16 private static final int DEFAULT_INITIAL_CAPACITY = 16; //預設負載因子

利用HashMap，自己實現一個簡易版的HashSet

簡介 HashSet是常用的容器類，主要特徵表現為不可重複性其內部實現主要用到了HashMap，利用了HashMap的鍵的不可重複性使用HashMap的鍵作為其元素，同時令HashMap的所有的

java中自己實現一個ArrayList

public class MyList<T> implements Iterable<T>{ /* * 設計一種容器:可以不初始化長度,長度可以自動拓展 */ private int length = 10;//定義初始化容量大小的變數 private Object[]

自己實現一個二叉查詢樹BinarySearchTree

需求自己實現一個簡單的二叉查詢樹BinarySearchTree 二叉排序樹或者是一棵空樹，或者是具有下列性質的二叉樹：若左子樹不空，則左子樹上所有結點的值均小於或等於它的根結點的值；若右子樹不空，則右子樹上所有結點的值均大於或等於它的根結點的值；

自己實現一個簡單ArrayList

廢話不多說直接上程式碼package com.zgs.utils; import java.util.ArrayList; import org.aspectj.weaver.patterns.ExactAnnotationFieldTypePattern; /**

自己實現一個字串拼接函式

今天去面試了一家公司，其中有一個程式設計題：實現字串拼接函式，要求不呼叫庫函式。說來慚愧，自己審題不嚴，理解成了字串複製函式。粗心是我的另一大缺點，現在我在努力改進，雖然面試的不太好，但是這個函式我還是要實現一遍。程式碼如下： #include <stdio.h> t

自己實現一個Spring 框架

我們在模擬一個Spring 框架時，肯定要先清楚Spring 的原理。大家普遍熟悉的就是IOC 和 AOP。IOC 控制反轉，就是Spring 在託管整個bean ，AOP 面向切面的程式設計，就是一個動態代理，在方法執行時，動態的生成一些程式碼邏輯進行執行。一、IOC

利用pushState, popState和location.hash等方法自己實現一個小型路由

這篇文章主要是記錄下HTML5中history提供的pushState, replaceStateAPI。最後通過這些API自己實現小型的路由。關於window.history提供的API請參見Mozilla文件其中history提供的pushState和replace

自己實現一個簡單的RPC框架

RPC的全稱是Remote Procedure Call，它是一種程序間的通訊方式。允許像呼叫本地服務一樣呼叫遠端服務。對於RPC的總結：簡單：RPC概念的語義十分簡單和清晰，這樣建立分散式計算更容易。高效：過程呼叫看起來十分簡單而且十分高效。

如何自己實現一個可自定義業務流程步驟的工作流

專案功能需求簡述由於業務需要，需要一個申請-審批的工作流，並且業務流程是不固定的，需要能靈活配置，比如現在是：開始->部門經理審批->結束，可能之後就會變為開始->部門經理審批->部門領導審批->結束。因此不能把程式碼寫死，必須

python裝飾器,自己實現一個簡單的裝飾器

裝飾器演變過程 1.先來看個方法: def add(x,y): return x+y 其功能顯而易見,實現一個加法,boss覺得這個功能太單一,需要加些功能1,校驗(因為python是強型別語言,int 和str

自己實現一個記憶體快取

相關推薦