com.lark.oapi.okhttp.internal.cache

类 DiskLruCache

java.lang.Object

com.lark.oapi.okhttp.internal.cache.DiskLruCache

所有已实现的接口:

Closeable, Flushable, AutoCloseable

public final class DiskLruCache
extends Object
implements Closeable, Flushable

A cache that uses a bounded amount of space on a filesystem. Each cache entry has a string key and a fixed number of values. Each key must match the regex [a-z0-9_-]{1,64}. Values are byte sequences, accessible as streams or files. Each value must be between 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.

• When an entry is being created it is necessary to supply a full set of values; the empty value should be used as a placeholder if necessary.
• When an entry is being edited, it is not necessary to supply data for every value; values default to their previous value.

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.

嵌套类概要

嵌套类

限定符和类型	类和说明
class	DiskLruCache.Editor Edits the values for an entry.
class	DiskLruCache.Snapshot A snapshot of the values for an entry.

方法概要

限定符和类型	方法和说明
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.

从类继承的方法 java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

方法详细资料

create

public static DiskLruCache create(FileSystem fileSystem,
                                  File directory,
                                  int appVersion,
                                  int valueCount,
                                  long maxSize)

Create a cache which will reside in directory. This cache is lazily initialized on first access and will be created if it does not exist.

参数:

directory - a writable directory

valueCount - the number of values per cache entry. Must be positive.

maxSize - the maximum number of bytes this cache should use to store

initialize

public void initialize()
                throws IOException

抛出:

IOException

get

public DiskLruCache.Snapshot get(String key)
                          throws IOException

Returns a snapshot of the entry named 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

edit

@Nullable
public DiskLruCache.Editor edit(String key)
                                   throws IOException

Returns an editor for the entry named key, or null if another edit is in progress.

抛出:

IOException

getDirectory

public File getDirectory()

Returns the directory where this cache stores its data.

getMaxSize

public long getMaxSize()

Returns the maximum number of bytes that this cache should use to store its data.

setMaxSize

public 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.

size

public long size()
          throws IOException

Returns the number of bytes currently being used to store the values in this cache. This may be greater than the max size if a background deletion is pending.

抛出:

IOException

remove

public boolean remove(String key)
               throws IOException

Drops the entry for 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.

返回:

true if an entry was removed.

抛出:

IOException

isClosed

public boolean isClosed()

Returns true if this cache has been closed.

flush

public void flush()
           throws IOException

Force buffered operations to the filesystem.

指定者:

flush 在接口中 Flushable

抛出:

IOException

close

public void close()
           throws IOException

Closes this cache. Stored values will remain on the filesystem.

指定者:

close 在接口中 Closeable

指定者:

close 在接口中 AutoCloseable

抛出:

IOException

delete

public void delete()
            throws 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.

抛出:

IOException

evictAll

public void evictAll()
              throws IOException

Deletes all stored values from the cache. In-flight edits will complete normally but their values will not be stored.

抛出:

IOException

snapshots

public Iterator<DiskLruCache.Snapshot> snapshots()
                                          throws IOException

Returns an iterator over the cache's current entries. This iterator doesn't throw 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