面向对象-设计原则

1.设计原则-之Volley



    (1)单一职责原则（S）

          定义：一个类有多个方法，多个方法应是相关的，有共同的职责。

          范围：适用于基础类，不适用于聚合类。聚合类应优先使用组合，再选择继承

          Cache类：

           1.获取缓存

           2.添加缓存

           3.初始化缓存

           4.废除缓存

           5.移除

/**
* An interface for a cache keyed by a String with a byte array as data.
*/
public interface Cache {
/**
* Retrieves an entry from the cache.
* @param key Cache key
* @return An {@link Entry} or null in the event of a cache miss
*/
public Entry get(String key);

/**
* Adds or replaces an entry to the cache.
* @param key Cache key
* @param entry Data to store and metadata for cache coherency, TTL, etc.
*/
public void put(String key, Entry entry);

/**
* Performs any potentially long-running actions needed to initialize the cache;
* will be called from a worker thread.
*/
public void initialize();

/**
* Invalidates an entry in the cache.
* @param key Cache key
* @param fullExpire True to fully expire the entry, false to soft expire
*/
public void invalidate(String key, boolean fullExpire);

/**
* Removes an entry from the cache.
* @param key Cache key
*/
public void remove(String key);

/**
* Empties the cache.
*/
public void clear();

/**
* Data and metadata for an entry returned by the cache.
*/
public static class Entry {
/** The data returned from cache. */
public byte[] data;

/** ETag for cache coherency. */
public String etag;

/** Date of this response as reported by the server. */
public long serverDate;

/** TTL for this record. */
public long ttl;

/** Soft TTL for this record. */
public long softTtl;

/** Immutable response headers as received from server; must be non-null. */
public Map<String, String> responseHeaders = Collections.emptyMap();

/** True if the entry is expired. */
public boolean isExpired() {
return this.ttl < System.currentTimeMillis();
}

/** True if a refresh is needed from the original data source. */
public boolean refreshNeeded() {
return this.softTtl < System.currentTimeMillis();
}
}

}

     
    (2) 开闭原则（O）

        定义：对修改关闭，对扩展开放。（A调用B，对A修改关闭，对B扩展开放），

                      提供者B增加功能，调用者A不要修改代码。

           范围：接口不变的情况之下

           原因：减少变化

public static RequestQueue newRequestQueueInDisk(Context context, String dir, HttpStack stack) {
File cacheDir = new File(dir, DEFAULT_CACHE_DIR);

String userAgent = "volley/0";
try {
String packageName = context.getPackageName();
PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
userAgent = packageName + "/" + info.versionCode;
} catch (NameNotFoundException e) {
}

if (stack == null) {
if (Build.VERSION.SDK_INT >= 9) {
stack = new HurlStack();
} else {
// Prior to Gingerbread, HttpUrlConnection was unreliable.
// See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}

Network network = new BasicNetwork(stack); //对修改关闭，对拓展开放
Cache cache =  new DiskBasedCache(cacheDir);//对修改关闭，对拓展开放
RequestQueue queue = new RequestQueue(cache, network);
queue.start();

return queue;
}

 假如Cache还要拓展一个功能，XCache。那么调用者不要修改代码，提供者也不要修改原有存在代码，只要添加实现Cache类即可。

  (3) 里氏替换（L）

            定义：子类必须能替换成父类

            原因：避免破坏继承结构

               里氏替换原则通俗的来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。它包含以下4层含义：
子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
子类中可以增加自己特有的方法。
当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

        看上去很不可思议，因为我们会发现在自己编程中常常会违反里氏替换原则，程序照样跑的好好的。所以大家都会产生这样的疑问，假如我非要不遵循里氏替换原则会有什么后果？

        后果就是：你写的代码出问题的几率将会大大增加。

   （4）接口隔离（I）

                      定义：客户端不要依赖他不需要的接口。接口细化

              原因：如果依赖过多不用的方法，会导致一些不可预知的改变

   (5) 依赖倒置：
           定义：高层模块不应直接依赖底层模块，而是依赖抽象模块。
           抽象不应依赖细节，细节必须依赖抽象
           原因：高层模块依赖底层模块：高层模块调用底层方法。
           高层模块依赖抽象：基于抽象层编程

           底层模块依赖抽象：继承或实现抽象层

          高层模块是业务复杂的模块，底层模块负责基本的原子操作。

     

public class RequestQueue {

/** Used for generating monotonically-increasing sequence numbers for requests. */
//http://www.cnblogs.com/baizhanshi/p/5662376.html 原子操作，硬件保障
private AtomicInteger mSequenceGenerator = new AtomicInteger();

/**
* Staging area for requests that already have a duplicate request in flight.
* 为什呢要给请求分段，是因为他在队列中有一个重复的请求
* <ul>
*     <li>containsKey(cacheKey) indicates that there is a request in flight for the given cache
*          key.</li>
*     <li>get(cacheKey) returns waiting requests for the given cache key. The in flight request
*          is <em>not</em> contained in that list. Is null if no requests are staged.</li>
* </ul>
*/
private final Map<String, Queue<Request>> mWaitingRequests =
new HashMap<String, Queue<Request>>();

/**
* The set of all requests currently being processed by this RequestQueue. A Request
* will be in this set if it is waiting in any queue or currently being processed by
* any dispatcher.
*/
private final Set<Request> mCurrentRequests = new HashSet<Request>();

/** The cache triage queue. */
private final PriorityBlockingQueue<Request> mCacheQueue =
new PriorityBlockingQueue<Request>();

/** The queue of requests that are actually going out to the network. */
private final PriorityBlockingQueue<Request> mNetworkQueue =
new PriorityBlockingQueue<Request>();

/** Number of network request dispatcher threads to start. */
private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;

/** Cache interface for retrieving and storing respones. */
private final Cache mCache;

/** Network interface for performing requests. */
private final Network mNetwork;

/** Response delivery mechanism. */
private final ResponseDelivery mDelivery;

/** The network dispatchers. */
private NetworkDispatcher[] mDispatchers;

/** The cache dispatcher. */
private CacheDispatcher mCacheDispatcher;

/**
* Creates the worker pool. Processing will not begin until {@link #start()} is called.
*
* @param cache A Cache to use for persisting responses to disk
* @param network A Network interface for performing HTTP requests
* @param threadPoolSize Number of network dispatcher threads to create
* @param delivery A ResponseDelivery interface for posting responses and errors
* 传递响应和错误信息
*/
public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery) {
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
}

Cache.java/** * An interface for a cache keyed by a String with a byte array as data. */ public interface Cache { /** * Retrieves an entry from the cache. * @param key Cache key * @return An {@link Entry} or null in the event of a cache miss */ public Entry get(String key); /** * Adds or replaces an entry to the cache. * @param key Cache key * @param entry Data to store and metadata for cache coherency, TTL, etc. */ public void put(String key, Entry entry); /** * Performs any potentially long-running actions needed to initialize the cache; * will be called from a worker thread. */ public void initialize(); /** * Invalidates an entry in the cache. * @param key Cache key * @param fullExpire True to fully expire the entry, false to soft expire */ public void invalidate(String key, boolean fullExpire); /** * Removes an entry from the cache. * @param key Cache key */ public void remove(String key); /** * Empties the cache. */ public void clear(); /** * Data and metadata for an entry returned by the cache. */ public static class Entry { /** The data returned from cache. */ public byte[] data; /** ETag for cache coherency. */ public String etag; /** Date of this response as reported by the server. */ public long serverDate; /** TTL for this record. */ public long ttl; /** Soft TTL for this record. */ public long softTtl; /** Immutable response headers as received from server; must be non-null. */ public Map<String, String> responseHeaders = Collections.emptyMap(); /** True if the entry is expired. */ public boolean isExpired() { return this.ttl < System.currentTimeMillis(); } /** True if a refresh is needed from the original data source. */ public boolean refreshNeeded() { return this.softTtl < System.currentTimeMillis(); } } }


Network.java

/**
* An interface for performing requests.
*/
public interface Network {
/**
* Performs the specified request.
* @param request Request to process
* @return A {@link NetworkResponse} with data and caching metadata; will never be null
* @throws VolleyError on errors
*/
public NetworkResponse performRequest(Request<?> request) throws VolleyError;
}

ResponseDelivery.java

public interface ResponseDelivery {
/**
* Parses a response from the network or cache and delivers it.
*/
public void postResponse(Request<?> request, Response<?> response);

/**
* Parses a response from the network or cache and delivers it. The provided
* Runnable will be executed after delivery.
*/
public void postResponse(Request<?> request, Response<?> response, Runnable runnable);

/**
* Posts an error for the given request.
*/
public void postError(Request<?> request, VolleyError error);
}

CacheDispatcher.java 缓存调度，高层模块不依赖细节，全是依赖抽象编程

public class CacheDispatcher extends Thread {

private static final boolean DEBUG = VolleyLog.DEBUG;

/** The queue of requests coming in for triage. */
private final BlockingQueue<Request> mCacheQueue;

/** The queue of requests going out to the network. */
private final BlockingQueue<Request> mNetworkQueue;

/** The cache to read from. */
private final Cache mCache;

/** For posting responses. */
private final ResponseDelivery mDelivery;

/** Used for telling us to die. */
private volatile boolean mQuit = false;

/**
* Creates a new cache triage dispatcher thread.  You must call {@link #start()}
* in order to begin processing.
*
* @param cacheQueue Queue of incoming requests for triage
* @param networkQueue Queue to post requests that require network to
* @param cache Cache interface to use for resolution
* @param delivery Delivery interface to use for posting responses
*/
public CacheDispatcher(
BlockingQueue<Request> cacheQueue, BlockingQueue<Request> networkQueue,
Cache cache, ResponseDelivery delivery) {
mCacheQueue = cacheQueue;
mNetworkQueue = networkQueue;
mCache = cache;
mDelivery = delivery;
}

/**
* Forces this dispatcher to quit immediately.  If any requests are still in
* the queue, they are not guaranteed to be processed.
*/
public void quit() {
mQuit = true;
interrupt();
}

@Override
public void run() {
if (DEBUG) VolleyLog.v("start new dispatcher");
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);//设置进程优先级

// Make a blocking call to initialize the cache.
//初始化缓存
mCache.initialize();

while (true) {
try {
// Get a request from the cache triage queue, blocking until
// at least one is available.
//从缓存队列中取一个可以用的
final Request request = mCacheQueue.take();
request.addMarker("cache-queue-take");

// If the request has been canceled, don't bother dispatching it.
//如果request已经被取消，不要打扰到传递
if (request.isCanceled()) {
request.finish("cache-discard-canceled");
continue;
}

// Attempt to retrieve this item from cache.
//取回缓存
Cache.Entry entry = mCache.get(request.getCacheKey());
if (entry == null) {
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
//缓存不存在，则加入到网络请求队列中
mNetworkQueue.put(request);
continue;
}

// If it is completely expired, just send it to the network.
//如果缓存过期了，则加入到网络请求队列中
if (entry.isExpired()) {
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
mNetworkQueue.put(request);
continue;
}

// We have a cache hit; parse its data for delivery back to the request.
//我们找到了cache（不过期，没取消），解析数据传递到请求中区
request.addMarker("cache-hit");
Response<?> response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
request.addMarker("cache-hit-parsed");

if (!entry.refreshNeeded()) {
// Completely unexpired cache hit. Just deliver the response.
//获取到没过期的缓存，传输这个响应
mDelivery.postResponse(request, response);
} else {
// Soft-expired cache hit. We can deliver the cached response,
// but we need to also send the request to the network for
// refreshing.
//缓存需要刷新
request.addMarker("cache-hit-refresh-needed");
request.setCacheEntry(entry);

// Mark the response as intermediate.
response.intermediate = true;

// Post the intermediate response back to the user and have
// the delivery then forward the request along to the network.
//缓存过期之后，把请求放入到网络队列中去
mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
//加入到网络队列里面去
mNetworkQueue.put(request);
} catch (InterruptedException e) {
// Not much we can do about this.
}
}
});
}

} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
continue;
}
}
}
}

都是依赖抽象

参考文章：
http://blog.csdn.net/zhengzhb/article/details/7281833