public final class DiskLruCache extends Object implements Closeable, Flushable
0
and Integer.MAX_VALUE
bytes in length.
The cache stores its data in a directory on the filesystem. This directory must be exclusive to the cache; the cache may delete or overwrite files from its directory. It is an error for multiple processes to use the same cache directory at the same time.
This cache limits the number of bytes that it will store on the filesystem. When the number of stored bytes exceeds the limit, the cache will remove entries in the background until the limit is satisfied. The limit is not strict: the cache may temporarily exceed it while waiting for files to be deleted. The limit does not include filesystem overhead or the cache journal so space-sensitive applications should set a conservative limit.
Clients call edit(java.lang.String)
to create or update the values of an entry. An entry may have only
one editor at one time; if a value is not available to be edited then edit(java.lang.String)
will return
null.
Every edit(java.lang.String)
call must be matched by a call to DiskLruCache.Editor.commit()
or DiskLruCache.Editor.abort()
. Committing is atomic: a read observes the full set of values as they were before
or after the commit, but never a mix of values.
Clients call get(java.lang.String)
to read a snapshot of an entry. The read will observe the value at
the time that get(java.lang.String)
was called. Updates and removals after the call do not impact ongoing
reads.
This class is tolerant of some I/O errors. If files are missing from the filesystem, the
corresponding entries will be dropped from the cache. If an error occurs while writing a cache
value, the edit will fail silently. Callers should handle other problems by catching IOException
and responding appropriately.
Modifier and Type | Class and Description |
---|---|
class |
DiskLruCache.Editor
Edits the values for an entry.
|
class |
DiskLruCache.Snapshot
A snapshot of the values for an entry.
|
Modifier and Type | Method and Description |
---|---|
void |
close()
Closes this cache.
|
static DiskLruCache |
create(FileSystem fileSystem,
File directory,
int appVersion,
int valueCount,
long maxSize)
Create a cache which will reside in
directory . |
void |
delete()
Closes the cache and deletes all of its stored values.
|
DiskLruCache.Editor |
edit(String key)
Returns an editor for the entry named
key , or null if another edit is in progress. |
void |
evictAll()
Deletes all stored values from the cache.
|
void |
flush()
Force buffered operations to the filesystem.
|
DiskLruCache.Snapshot |
get(String key)
Returns a snapshot of the entry named
key , or null if it doesn't exist is not currently
readable. |
File |
getDirectory()
Returns the directory where this cache stores its data.
|
long |
getMaxSize()
Returns the maximum number of bytes that this cache should use to store its data.
|
void |
initialize() |
boolean |
isClosed()
Returns true if this cache has been closed.
|
boolean |
remove(String key)
Drops the entry for
key if it exists and can be removed. |
void |
setMaxSize(long maxSize)
Changes the maximum number of bytes the cache can store and queues a job to trim the existing
store, if necessary.
|
long |
size()
Returns the number of bytes currently being used to store the values in this cache.
|
Iterator<DiskLruCache.Snapshot> |
snapshots()
Returns an iterator over the cache's current entries.
|
public void initialize() throws IOException
IOException
public static DiskLruCache create(FileSystem fileSystem, File directory, int appVersion, int valueCount, long maxSize)
directory
. This cache is lazily initialized on
first access and will be created if it does not exist.directory
- a writable directoryvalueCount
- the number of values per cache entry. Must be positive.maxSize
- the maximum number of bytes this cache should use to storepublic DiskLruCache.Snapshot get(String key) throws IOException
key
, or null if it doesn't exist is not currently
readable. If a value is returned, it is moved to the head of the LRU queue.IOException
@Nullable public DiskLruCache.Editor edit(String key) throws IOException
key
, or null if another edit is in progress.IOException
public File getDirectory()
public long getMaxSize()
public void setMaxSize(long maxSize)
public long size() throws IOException
IOException
public boolean remove(String key) throws IOException
key
if it exists and can be removed. If the entry for key
is currently being edited, that edit will complete normally but its value will not be stored.IOException
public boolean isClosed()
public void flush() throws IOException
flush
in interface Flushable
IOException
public void close() throws IOException
close
in interface Closeable
close
in interface AutoCloseable
IOException
public void delete() throws IOException
IOException
public void evictAll() throws IOException
IOException
public Iterator<DiskLruCache.Snapshot> snapshots() throws IOException
ConcurrentModificationException
, but if new entries are added while iterating, those new
entries will not be returned by the iterator. If existing entries are removed during iteration,
they will be absent (unless they were already returned).
If there are I/O problems during iteration, this iterator fails silently. For example, if the hosting filesystem becomes unreachable, the iterator will omit elements rather than throwing exceptions.
The caller must close
each snapshot returned by
Iterator.next()
. Failing to do so leaks open files!
The returned iterator supports Iterator.remove()
.
IOException
Copyright © 2019. All rights reserved.