Cache

java.lang.Object
- okhttp3.Cache

All Implemented Interfaces:

java.io.Closeable, java.io.Flushable, java.lang.AutoCloseable
```
public final class Cache
extends java.lang.Object
implements java.io.Closeable, java.io.Flushable
```
Caches HTTP and HTTPS responses to the filesystem so they may be reused, saving time and bandwidth.
Cache Optimization

To measure cache effectiveness, this class tracks three statistics:
- 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.
Sometimes a request will result in a conditional cache hit. If the cache contains a stale copy of the response, the client will issue a conditional 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 7234) cache headers, it doesn't cache partial responses.
Force a Network Response

In some situations, such as after a user clicks a 'refresh' button, it may be necessary to skip the cache, and fetch data directly from the server. To force a full refresh, add the no-cache directive:
```
   

   Request request = new Request.Builder()
       .cacheControl(new CacheControl.Builder().noCache().build())
       .url("http://publicobject.com/helloworld.txt")
       .build();
 
```
If it is only necessary to force a cached response to be validated by the server, use the more efficient max-age=0 directive instead:
```
   

   Request request = new Request.Builder()
       .cacheControl(new CacheControl.Builder()
           .maxAge(0, TimeUnit.SECONDS)
           .build())
       .url("http://publicobject.com/helloworld.txt")
       .build();
 
```
Force a Cache Response

Sometimes you'll want to show resources if they are available immediately, but not otherwise. This can be used so your application can show something while waiting for the latest data to be downloaded. To restrict a request to locally-cached resources, add the only-if-cached directive:
```
   

     Request request = new Request.Builder()
         .cacheControl(new CacheControl.Builder()
             .onlyIfCached()
             .build())
         .url("http://publicobject.com/helloworld.txt")
         .build();
     Response forceCacheResponse = client.newCall(request).execute();
     if (forceCacheResponse.code() != 504) {
       // The resource was cached! Show it.
     } else {
       // 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:
```
   

   Request request = new Request.Builder()
       .cacheControl(new CacheControl.Builder()
           .maxStale(365, TimeUnit.DAYS)
           .build())
       .url("http://publicobject.com/helloworld.txt")
       .build();
 
```
The CacheControl class can configure request caching directives and parse response caching directives. It even offers convenient constants CacheControl.FORCE_NETWORK and CacheControl.FORCE_CACHE that address the use cases above.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private class Cache.CacheRequestImpl

private static class Cache.CacheResponseBody

private static class Cache.Entry

Nested Classes
Modifier and Type	Class and Description
`private class`	`Cache.CacheRequestImpl`
`private static class`	`Cache.CacheResponseBody`
`private static class`	`Cache.Entry`

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) DiskLruCache`	`cache`
`private static int`	`ENTRY_BODY`
`private static int`	`ENTRY_COUNT`
`private static int`	`ENTRY_METADATA`
`private int`	`hitCount`
`(package private) InternalCache`	`internalCache`
`private int`	`networkCount`
`private int`	`requestCount`
`private static int`	`VERSION`
`(package private) int`	`writeAbortCount`
`(package private) int`	`writeSuccessCount`

Constructor Summary

Constructors
Constructor and Description

Cache(java.io.File directory, long maxSize)

Cache(java.io.File directory, long maxSize, FileSystem fileSystem)

Constructors
Constructor and Description
`Cache(java.io.File directory, long maxSize)`
`Cache(java.io.File directory, long maxSize, FileSystem fileSystem)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`abortQuietly(DiskLruCache.Editor editor)`
`void`	`close()`
`void`	`delete()` Closes the cache and deletes all of its stored values.
`java.io.File`	`directory()`
`void`	`evictAll()` Deletes all values stored in the cache.
`void`	`flush()`
`(package private) Response`	`get(Request request)`
`int`	`hitCount()`
`void`	`initialize()` Initialize the cache.
`boolean`	`isClosed()`
`static java.lang.String`	`key(HttpUrl url)`
`long`	`maxSize()`
`int`	`networkCount()`
`(package private) CacheRequest`	`put(Response response)`
`(package private) static int`	`readInt(okio.BufferedSource source)`
`(package private) void`	`remove(Request request)`
`int`	`requestCount()`
`long`	`size()`
`(package private) void`	`trackConditionalCacheHit()`
`(package private) void`	`trackResponse(CacheStrategy cacheStrategy)`
`(package private) void`	`update(Response cached, Response network)`
`java.util.Iterator<java.lang.String>`	`urls()` Returns an iterator over the URLs in this cache.
`int`	`writeAbortCount()`
`int`	`writeSuccessCount()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - VERSION
```
private static final int VERSION
```
    See Also:
    
    Constant Field Values
  - ENTRY_METADATA
```
private static final int ENTRY_METADATA
```
    See Also:
    
    Constant Field Values
  - ENTRY_BODY
```
private static final int ENTRY_BODY
```
    See Also:
    
    Constant Field Values
  - ENTRY_COUNT
```
private static final int ENTRY_COUNT
```
    See Also:
    
    Constant Field Values
  - internalCache
```
final InternalCache internalCache
```
  - cache
```
final DiskLruCache cache
```
  - writeSuccessCount
```
int writeSuccessCount
```
  - writeAbortCount
```
int writeAbortCount
```
  - networkCount
```
private int networkCount
```
  - hitCount
```
private int hitCount
```
  - requestCount
```
private int requestCount
```
- Constructor Detail
  - Cache
```
public Cache(java.io.File directory,
             long maxSize)
```
  - Cache
```
Cache(java.io.File directory,
      long maxSize,
      FileSystem fileSystem)
```
- Method Detail
  - key
```
public static java.lang.String key(HttpUrl url)
```
  - get
```
@Nullable
Response get(Request request)
```
  - put
```
@Nullable
CacheRequest put(Response response)
```
  - remove
```
void remove(Request request)
     throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - update
```
void update(Response cached,
            Response network)
```
  - abortQuietly
```
private void abortQuietly(@Nullable
                          DiskLruCache.Editor editor)
```
  - initialize
```
public void initialize()
                throws java.io.IOException
```
    Initialize the cache. This will include reading the journal files from the storage and building up the necessary in-memory cache information.
    The initialization time may vary depending on the journal file size and the current actual cache size. The application needs to be aware of calling this function during the initialization phase and preferably in a background worker thread.
    Note that if the application chooses to not call this method to initialize the cache. By default, the okhttp will perform lazy initialization upon the first usage of the cache.
    
    Throws:
    
    java.io.IOException
  - delete
```
public void delete()
            throws java.io.IOException
```
    Closes the cache and deletes all of its stored values. This will delete all files in the cache directory including files that weren't created by the cache.
    
    Throws:
    
    java.io.IOException
  - evictAll
```
public void evictAll()
              throws java.io.IOException
```
    Deletes all values stored in the cache. In-flight writes to the cache will complete normally, but the corresponding responses will not be stored.
    
    Throws:
    
    java.io.IOException
  - urls
```
public java.util.Iterator<java.lang.String> urls()
                                          throws java.io.IOException
```
    Returns an iterator over the URLs in this cache. This iterator doesn't throw ConcurrentModificationException, but if new responses are added while iterating, their URLs will not be returned. If existing responses are evicted during iteration, they will be absent (unless they were already returned).
    The iterator supports Iterator.remove(). Removing a URL from the iterator evicts the corresponding response from the cache. Use this to evict selected responses.
    
    Throws:
    
    java.io.IOException
  - writeAbortCount
```
public int writeAbortCount()
```
  - writeSuccessCount
```
public int writeSuccessCount()
```
  - size
```
public long size()
          throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - maxSize
```
public long maxSize()
```
  - flush
```
public void flush()
           throws java.io.IOException
```
    Specified by:
    
    flush in interface java.io.Flushable
    
    Throws:
    
    java.io.IOException
  - close
```
public void close()
           throws java.io.IOException
```
    Specified by:
    
    close in interface java.io.Closeable
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    Throws:
    
    java.io.IOException
  - directory
```
public java.io.File directory()
```
  - isClosed
```
public boolean isClosed()
```
  - trackResponse
```
void trackResponse(CacheStrategy cacheStrategy)
```
  - trackConditionalCacheHit
```
void trackConditionalCacheHit()
```
  - networkCount
```
public int networkCount()
```
  - hitCount
```
public int hitCount()
```
  - requestCount
```
public int requestCount()
```
  - readInt
```
static int readInt(okio.BufferedSource source)
            throws java.io.IOException
```
    Throws:
    
    java.io.IOException

Class Cache

Cache Optimization

Force a Network Response

Force a Cache Response

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

VERSION

ENTRY_METADATA

ENTRY_BODY

ENTRY_COUNT

internalCache

cache

writeSuccessCount

writeAbortCount

networkCount

hitCount

requestCount

Constructor Detail

Cache

Cache

Method Detail

key

get

put

remove

update

abortQuietly

initialize

delete

evictAll

urls

writeAbortCount

writeSuccessCount

size

maxSize

flush

close

directory

isClosed

trackResponse

trackConditionalCacheHit

networkCount

hitCount

requestCount

readInt