开源项目学习：Android-Universal-Image-Loader-Part2

这次就是专门学习内存储存了。

从内部储存这块要学习的内容有

1.     简单了解类的继承关系

2.     关注里面的一些熟悉的语法但是陌生的用法    --嵌入到了代码部分用红色标注了

3.     关注函数的命名规律；

4.     关注里面出现的比较常用的算法

5、  接口作为参数

/*******************************************************************************
package com.nostra13.universalimageloader.cache.memory;
import android.graphics.Bitmap;
import java.util.Collection;
/**
 * Interface for memory cache
 *
 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
 * @since 1.9.2
 */
public interface MemoryCache {
	/**
	 * Puts value into cache by key
	 *
	 * @return <b>true</b> - if value was put into cache successfully, <b>false</b> - if value was <b>not</b> put into
	 * cache
	 */
	boolean put(String key, Bitmap value);

	/** Returns value by key. If there is no value for key then null will be returned. */
	Bitmap get(String key);

	/** Removes item by key */
	Bitmap remove(String key);

	/** Returns all keys of cache */
	Collection<String> keys();

	/** Remove all items from cache */
	void clear();
}

1.继承关系

首先，最重要的就是要了解为什么MemoryCache 要有这些方法呢？

         我们从缓存里面存、取数据那么就要有一个key对应去索引；

接下来，知道了key，那么怎么去得到缓存数据、放数据到缓存呢？

在BaseMemoryCache里面就有这么一个：

/** Stores not strong references to objects */
private final Map<String, Reference<Bitmap>> softMap = Collections.synchronizedMap(new HashMap<String, Reference<Bitmap>>());

Collections是集合的接口，里面提供了一个synchronizedMap的方法；这个方法的特点是函数返回的线程安全的HashMap，所以保证多线程访问数据的一致性；

比如我们如果要存数据

@Override
	public boolean put(String key, Bitmap value) {
		softMap.put(key, createReference(value));
		return true;
	}

对应的createReference是一个抽象方法，在FIFOLimitMemoryCache中的具体实现就是一个弱引用。

           注意--毕竟不是所有的子类都是需要这个弱引用，所以不在基类里面去实现而是放到子类去实现比较适合

@Override
protected Reference<Bitmap> createReference(Bitmap value) {
return new WeakReference<Bitmap>(value);
}

如果要取出缓存图片

public Bitmap get(String key) {
		Bitmap result = null;
		Reference<Bitmap> reference = softMap.get(key);
		if (reference != null) {
			result = reference.get();
		}
		return result;
	}

这里就涉及到了内存的储存方式，引用下人家的话：

【

回顾：

　　(1)StrongReference(强引用)

　　　　强引用就是平时经常使用的，如常规new Object()。如果一个对象具有强引用，那垃圾回收器绝不会回收。内存不足，甚至出现OOM时，也不会随意回收强引用的对象。

　　(2)SoftReference(软引用)

　　　　在内存空间足够，垃圾回收器不会回收它；如果内存空间不足，垃圾回收器就会回收软引用的对象。

　　(3)WeakReference(弱引用)

　　　　弱引用相对软引用，具有更短暂的生命周期。常规的GC，只要被扫描到，都会直接被回收。

　　(4)PhantomReference(虚引用)

　　　　虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。没用过。。。

　　选其一FIFOLimitedMemoryCache进行分析，构造时，必须要指定大小(单位：字节)。当设置的大小超过16MB(Android默认分配的大小好像也是这个)时，会有警告。

】

扩展下：

基本的存储关系搞清楚了，再简单了解下LimitMemoryCache，其他的类就不分析了，道理差不多；

这个类依然还是抽象类，还有一些类是要继承于它的，自然我们在使用的时候不会直接用这个类（抽象类不能实例化），但是了解它是必要的；

首先，如果我们要做一个限制大小的缓存类，那么首先我们要得到：要设置的缓存最大是多少，要缓存的内容是多大，

eg:在放入缓存的时候，肯定有个判断

@Override
	public boolean put(String key, Bitmap value) {
		boolean putSuccessfully = false;
		// Try to add value to hard cache
		int valueSize = getSize(value);   //得到需要缓存的数据的大小
		int sizeLimit = getSizeLimit();  //得到要设置的最大缓存是多少
		int curCacheSize = cacheSize.get();
		if (valueSize < sizeLimit) {
			while (curCacheSize + valueSize > sizeLimit) {
				Bitmap removedValue = removeNext();
				if (hardCache.remove(removedValue)) {
					curCacheSize = cacheSize.addAndGet(-getSize(removedValue));
				}
			}
			hardCache.add(value);
			cacheSize.addAndGet(valueSize);

			putSuccessfully = true;
		}

另外，注意的是LimitMemoryCache虽然继承的是BaseMemoryCache，但是内存所有数据结构变了， 用的是Collections.synchronizedList(new LinkedList<Bitmap>()) ，

/**
* Contains strong references to stored objects. Each next object is added last. If hard cache size will exceed
* limit then first object is deleted (but it continue exist at {@link #softMap} and can be collected by GC at any
* time)
*/
private final List<Bitmap> hardCache = Collections.synchronizedList(new LinkedList<Bitmap>());

道理和上面的synchronizedHashMap一样，Collections.synchronizedList的话参考这个：写的比较详细       http://my.oschina.net/infiniteSpace/blog/305425

所以说参考的这篇文章说BaseMemoryCache的子类都是弱引用，这个地方值得商榷~

2、命名规范问题

在类的命名上比较规范，包的命名都很好，一看就知道那个包里面是接口，哪里是实现接口的类；

有一点个人觉得不舒服就是，memory这个包里面有几个抽象类，所以我觉得要么把这几个类移到memory.impl这个包，要么在接口类的名字后面加个interface的标注；

类里面的函数的命名的规范：很符合基本的规范

静态常量名称大写

private static final int MAX_NORMAL_CACHE_SIZE_IN_MB = 16;

每个方法都有参数标注说明

/** @param sizeLimit Maximum size for cache (in bytes) */
public LimitedMemoryCache(int sizeLimit) {
this.sizeLimit = sizeLimit;
cacheSize = new AtomicInteger();
if (sizeLimit > MAX_NORMAL_CACHE_SIZE) {
L.w("You set too large memory cache size (more than %1$d Mb)", MAX_NORMAL_CACHE_SIZE_IN_MB);
}
}

方法名首字母小写；

类首字母大写；

...

这些虽然都懂我，但是很多时候，在写的过程中就忘了或者懒得去标注说明；看来以后得慢慢养成刷牙般的习惯；

3、出现的算法

出现了FIFO，Fuzzy,使用频率UsingFreq,Lru算法

算法部分原理目前还很难掌握~对算法不怎么样，以后有时间再系统学下，目前能简单看得懂就行；

这个部分用一个FuzzyKeyMemoryCache简单说明下怎么利用JAVA已经做好的算法来写程序吧

<span style="color:#333333;">import android.graphics.Bitmap;
import com.nostra13.universalimageloader.cache.memory.MemoryCache;
import java.util.Collection;
import java.util.Comparator;
/**
 * Decorator for {@link MemoryCache}. Provides special feature for cache: some different keys are considered as
 * equals (using {@link Comparator comparator}). And when you try to put some value into cache by key so entries with
 * "equals" keys will be removed from cache before.<br />
 * <b>NOTE:</b> Used for internal needs. Normally you don't need to use this class.
 */
public class FuzzyKeyMemoryCache implements MemoryCache {

	private final MemoryCache cache;
	private final Comparator<String> keyComparator;

	public FuzzyKeyMemoryCache(</span><span style="color:#ff0000;">MemoryCache </span><span style="color:#333333;">cache, </span><span style="color:#ff0000;">Comparator</span><span style="color:#333333;"><String> keyComparator) {
		this.cache = cache;
		this.keyComparator = keyComparator;
	}

	@Override
	public boolean put(String key, Bitmap value) {
		// Search equal key and remove this entry
		synchronized (cache) {
			String keyToRemove = null;
			for (String cacheKey : cache.keys()) {
				//-1代表o1里的某一个属性比o2的小 0代表等于 1代表大于
				if (keyComparator.compare(key, cacheKey) == 0) {
					keyToRemove = cacheKey;
					break;
				}
			}
			//如果判断出目前的MemoryCache里面有这个key,说明已经缓存了，所以就不用再去存了
			if (keyToRemove != null) {
				cache.remove(keyToRemove);
			}
		}
		return cache.put(key, value);
	}

	@Override
	public Bitmap get(String key) {
		return cache.get(key);
	}

	@Override
	public Bitmap remove(String key) {
		return cache.remove(key);
	}

	@Override
	public void clear() {
		cache.clear();
	}

	@Override
	public Collection<String> keys() {
		return cache.keys();
	}
}</span>

4、最后，总结一下一个很迷惑我的地方：接口作为参数  --可以看到MemoryCache 和Comparator<String>是一个接口作为参数传入进来的；

在实际用的时候，接口作为参数非常有用：这样便根据传进入的参数的不同而实现不同的功能；可以把自己内部的数据暴露给外部；

比如：我们最简单的按钮监听器

button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.d("BButton", "pressed button 1");
//change button 1's text, left icon, and type
button1.setText("hello");
button1.setLeftIcon("fa-star");
button1.setBootstrapType("success");
}
});

这个View v是怎么暴露给你的呢？

写个简单的DEMO--你可以传入参数进行不同的功能；可以获得类暴露给你的数据

public interface House {
<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>String window();
<span style="white-space:pre">	</span>int Bigdoor(String str);
<span style="white-space:pre">	</span>void smallDoor(String str);


}

public class TestHouse {

	void test(House house){
		
		String windowStr=house.window();
		System.out.println("从外面的窗户得到的数据"+windowStr);
		String str_samll="用smallDoor向外暴露数据";
		house.smallDoor(str_samll);
		String str_big="用bigdoor向外暴露数据";
		String str_int_big=house.Bigdoor(str_big)+"";
		System.out.println(str_int_big);
		
	}
	public static void main(String[] args) {
		TestHouse instance=new TestHouse();
		instance.test(new House() {
			//只能进去
			@Override
			public String window() {
				// TODO Auto-generated method stub
				return "window";
			}
			
			//只能出去
			@Override
			public void smallDoor(String str) {
				System.out.println(str);
				
			}
			
			//既能进去又能出来
			@Override
			public int Bigdoor(String str) {
				System.out.println(str);
				return 2;
			}
		});
	}

}