package org.apache.ibatis.cache;
import java.util.concurrent.locks.ReadWriteLock;
public interface Cache
{
    public abstract String getId();
    public abstract int getSize();
    public abstract void putObject(Object obj, Object obj1);
    public abstract Object getObject(Object obj);
    public abstract Object removeObject(Object obj);
    public abstract void clear();
    public abstract ReadWriteLock getReadWriteLock();
}

public class PerpetualCache
    implements Cache
{
    private String id;
    private Map cache;
    private ReadWriteLock readWriteLock;
    public PerpetualCache(String id)
    {
        cache = new HashMap();
        readWriteLock = new ReentrantReadWriteLock();
        this.id = id;
    }
    public String getId()
    {
        return id;
    }
    public int getSize()
    {
        return cache.size();
    }
    public void putObject(Object key, Object value)
    {
        cache.put(key, value);
    }
    public Object getObject(Object key)
    {
        return cache.get(key);
    }
    public Object removeObject(Object key)
    {
        return cache.remove(key);
    }
    public void clear()
    {
        cache.clear();
    }
    public ReadWriteLock getReadWriteLock()
    {
        return readWriteLock;
    }
    public boolean equals(Object o)
    {
        if(getId() == null)
            throw new CacheException("Cache instances require an ID.");
        if(this == o)
            return true;
        if(!(o instanceof Cache))
        {
            return false;
        } else
        {
            Cache otherCache = (Cache)o;
            return getId().equals(otherCache.getId());
        }
    }
    public int hashCode()
    {
        if(getId() == null)
            throw new CacheException("Cache instances require an ID.");
        else
            return getId().hashCode();
    }
}

public class LruCache
    implements Cache
{
    private final Cache _flddelegate;//缓存代理
    private Map keyMap;//key Map
    private Object eldestKey;//最老的key
    public LruCache(Cache delegate)
    {
        _flddelegate = delegate;
        setSize(1024);
    }
    public String getId()
    {
        return _flddelegate.getId();
    }
    public int getSize()
    {
        return _flddelegate.getSize();
    }
    //设置缓存大小
    public void setSize(final int size)
    {
        //获取线程线程安全的LinkedHashMap集合
        keyMap = Collections.synchronizedMap(new LinkedHashMap(0.75F, true, size) {
            //同时重写removeEldestEntry，当这个方法返回为true是，则移除eldest
            protected boolean removeEldestEntry(java.util.Map.Entry eldest)
            {
                boolean tooBig = size() > size;
                if(tooBig)
		    //如果Map目前的size大于初始化Map大小，则将最老key赋给eldestKey
                    eldestKey = eldest.getKey();
                return tooBig;
            }

            private static final long serialVersionUID = 4267176411845948333L;
            final int val$size;
            final LruCache this$0;

            
            {
                this$0 = LruCache.this;
                size = i;
                super(x0, x1, x2);
            }
        });
    }
    //将KV对放入缓存
    public void putObject(Object key, Object value)
    {
        _flddelegate.putObject(key, value);
	//并将key放入LRUCache的Key Map中
        cycleKeyList(key);
    }
    public Object getObject(Object key)
    {
        keyMap.get(key);
        return _flddelegate.getObject(key);
    }
    public Object removeObject(Object key)
    {
        return _flddelegate.removeObject(key);
    }
    public void clear()
    {
        _flddelegate.clear();
	//在清除缓存的时候同时，清除Key Map
        keyMap.clear();
    }
    public ReadWriteLock getReadWriteLock()
    {
        return _flddelegate.getReadWriteLock();
    }
    //如果Key Map，已达到负载上限，则从缓存中移除eldestKey
    private void cycleKeyList(Object key)
    {
        keyMap.put(key, key);
        if(eldestKey != null)
        {
            _flddelegate.removeObject(eldestKey);
            eldestKey = null;
        }
    }
}

//LinkedHashMap
/**
     * Returns <tt>true</tt> if this map should remove its eldest entry.
     * This method is invoked by <tt>put</tt> and <tt>putAll</tt> after
     * inserting a new entry into the map.  It provides the implementor
     * with the opportunity to remove the eldest entry each time a new one
     * is added.  This is useful if the map represents a cache: it allows
     * the map to reduce memory consumption by deleting stale entries.
     *
     * <p>Sample use: this override will allow the map to grow up to 100
     * entries and then delete the eldest entry each time a new entry is
     * added, maintaining a steady state of 100 entries.
     * <pre>
     *     private static final int MAX_ENTRIES = 100;
     *
     *     protected boolean removeEldestEntry(Map.Entry eldest) {
     *        return size() > MAX_ENTRIES;
     *     }
     * </pre>
     *
     * <p>This method typically does not modify the map in any way,
     * instead allowing the map to modify itself as directed by its
     * return value.  It <i>is</i> permitted for this method to modify
     * the map directly, but if it does so, it <i>must</i> return
     * <tt>false</tt> (indicating that the map should not attempt any
     * further modification).  The effects of returning <tt>true</tt>
     * after modifying the map from within this method are unspecified.
     *
     * <p>This implementation merely returns <tt>false</tt> (so that this
     * map acts like a normal map - the eldest element is never removed).
     *
     * @param    eldest The least recently inserted entry in the map, or if
     *           this is an access-ordered map, the least recently accessed
     *           entry.  This is the entry that will be removed it this
     *           method returns <tt>true</tt>.  If the map was empty prior
     *           to the <tt>put</tt> or <tt>putAll</tt> invocation resulting
     *           in this invocation, this will be the entry that was just
     *           inserted; in other words, if the map contains a single
     *           entry, the eldest entry is also the newest.
     * @return   <tt>true</tt> if the eldest entry should be removed
     *           from the map; <tt>false</tt> if it should be retained.
     */
    protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

//Collections
/**
     * Returns a synchronized (thread-safe) map backed by the specified
     * map.  In order to guarantee serial access, it is critical that
     * [b]all[/b] access to the backing map is accomplished
     * through the returned map.<p>
     *
     * It is imperative that the user manually synchronize on the returned
     * map when iterating over any of its collection views:
     * <pre>
     *  Map m = Collections.synchronizedMap(new HashMap());
     *      ...
     *  Set s = m.keySet();  // Needn't be in synchronized block
     *      ...
     *  synchronized (m) {  // Synchronizing on m, not s!
     *      Iterator i = s.iterator(); // Must be in synchronized block
     *      while (i.hasNext())
     *          foo(i.next());
     *  }
     * </pre>
     * Failure to follow this advice may result in non-deterministic behavior.
     *
     * <p>The returned map will be serializable if the specified map is
     * serializable.
     *
     * @param  m the map to be "wrapped" in a synchronized map.
     * @return a synchronized view of the specified map.
     */
    public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
        return new SynchronizedMap<>(m);
    }