public final class HttpResponseCache extends ResponseCache implements Closeable
HttpURLConnection
and HttpsURLConnection
;
there is no platform-provided cache for DefaultHttpClient
or
AndroidHttpClient
. Installation and instances are thread
safe.
application-specific
cache directory
of the filesystem}:
protected void onCreate(Bundle savedInstanceState) {
...
try {
File httpCacheDir = new File(context.getCacheDir(), "http");
long httpCacheSize = 10 * 1024 * 1024; // 10 MiB
HttpResponseCache.install(httpCacheDir, httpCacheSize);
} catch (IOException e) {
Log.i(TAG, "HTTP response cache installation failed:" + e);
}
}
protected void onStop() {
...
HttpResponseCache cache = HttpResponseCache.getInstalled();
if (cache != null) {
cache.flush();
}
}
This cache will evict entries as necessary to keep its size from exceeding
10 MiB. The best cache size is application specific and depends on the size
and frequency of the files being downloaded. Increasing the limit may improve
the hit rate, but it may also just waste filesystem space!
For some applications it may be preferable to create the cache in the
external storage directory. There are no access controls on the
external storage directory so it should not be used for caches that could
contain private data. Although it often has more free space,
external storage is optional and—even if available—can disappear
during use. Retrieve the external cache directory using Context.getExternalCacheDir()
. If this method returns null,
your application should fall back to either not caching or caching on
non-external storage. If the external storage is removed during use, the
cache hit rate will drop to zero and ongoing cache reads will fail.
Flushing the cache forces its data to the filesystem. This ensures that all responses written to the cache will be readable the next time the activity starts.
Request Count:
the number
of HTTP requests issued since this cache was created.
Network Count:
the
number of those requests that required network use.
Hit Count:
the number of
those requests whose responses were served by the cache.
GET
. The server will then send either the updated response if it has
changed, or a short 'not modified' response if the client's copy is still
valid. Such responses increment both the network count and hit count.
The best way to improve the cache hit rate is by configuring the web server to return cacheable responses. Although this client honors all HTTP/1.1 (RFC 2068) cache headers, it doesn't cache partial responses.
no-cache
directive:
connection.addRequestProperty("Cache-Control", "no-cache");
If it is only necessary to force a cached response to be validated by the
server, use the more efficient max-age=0
instead:
connection.addRequestProperty("Cache-Control", "max-age=0");
only-if-cached
directive:
try {
connection.addRequestProperty("Cache-Control", "only-if-cached");
InputStream cached = connection.getInputStream();
// the resource was cached! show it
} catch (FileNotFoundException e) {
// the resource was not cached
}
This technique works even better in situations where a stale response is
better than no response. To permit stale cached responses, use the max-stale
directive with the maximum staleness in seconds:
int maxStale = 60 * 60 * 24 * 28; // tolerate 4-weeks stale
connection.addRequestProperty("Cache-Control", "max-stale=" + maxStale);
try {
File httpCacheDir = new File(context.getCacheDir(), "http");
long httpCacheSize = 10 * 1024 * 1024; // 10 MiB
Class.forName("android.net.http.HttpResponseCache")
.getMethod("install", File.class, long.class)
.invoke(null, httpCacheDir, httpCacheSize);
} catch (Exception httpResponseCacheNotAvailable) {
}
Modifier and Type | Method and Description |
---|---|
void |
close()
Uninstalls the cache and releases any active resources.
|
void |
delete()
Uninstalls the cache and deletes all of its stored contents.
|
void |
flush()
Force buffered operations to the filesystem.
|
CacheResponse |
get(URI uri,
String requestMethod,
Map<String,List<String>> requestHeaders)
Retrieve the cached response based on the requesting uri,
request method and request headers.
|
Cache |
getCache() |
int |
getHitCount()
Returns the number of HTTP requests whose response was provided by the
cache.
|
static HttpResponseCache |
getInstalled()
Returns the currently-installed
HttpResponseCache , or null if
there is no cache installed or it is not a HttpResponseCache . |
int |
getNetworkCount()
Returns the number of HTTP requests that required the network to either
supply a response or validate a locally cached response.
|
int |
getRequestCount()
Returns the total number of HTTP requests that were made.
|
static HttpResponseCache |
install(File directory,
long maxSize)
Creates a new HTTP response cache and sets it as the system default cache.
|
long |
maxSize()
Returns the maximum number of bytes that this cache should use to store
its data.
|
CacheRequest |
put(URI uri,
URLConnection urlConnection)
The protocol handler calls this method after a resource has
been retrieved, and the ResponseCache must decide whether or
not to store the resource in its cache.
|
long |
size()
Returns the number of bytes currently being used to store the values in
this cache.
|
getDefault, setDefault
public static HttpResponseCache getInstalled()
HttpResponseCache
, or null if
there is no cache installed or it is not a HttpResponseCache
.public static HttpResponseCache install(File directory, long maxSize) throws IOException
directory
- the directory to hold cache data.maxSize
- the maximum size of the cache in bytes.IOException
- if directory
cannot be used for this cache.
Most applications should respond to this exception by logging a
warning.public CacheResponse get(URI uri, String requestMethod, Map<String,List<String>> requestHeaders) throws IOException
ResponseCache
get
in class ResponseCache
uri
- a URI
used to reference the requested
network resourcerequestMethod
- a String
representing the request
methodrequestHeaders
- - a Map from request header
field names to lists of field values representing
the current request headersCacheResponse
instance if available
from cache, or null otherwiseIOException
- if an I/O error occursURLConnection.setUseCaches(boolean)
,
URLConnection.getUseCaches()
,
URLConnection.setDefaultUseCaches(boolean)
,
URLConnection.getDefaultUseCaches()
public CacheRequest put(URI uri, URLConnection urlConnection) throws IOException
ResponseCache
put
in class ResponseCache
uri
- a URI
used to reference the requested
network resourceurlConnection
- - a URLConnection instance that is used to fetch
the response to be cachedCacheRequest
for recording the
response to be cached. Null return indicates that
the caller does not intend to cache the response.IOException
- if an I/O error occurspublic long size()
maxSize()
if a background
deletion is pending. -1
is returned if the size cannot be determined.public long maxSize()
public void flush()
public int getNetworkCount()
public int getHitCount()
GET
requests that were
validated over the network.public int getRequestCount()
public void close() throws IOException
close
in interface Closeable
close
in interface AutoCloseable
IOException
- if an I/O error occurspublic void delete() throws IOException
IOException
public Cache getCache()