HttpResponseCache Classe

Riferimento

Definizione

Spazio dei nomi:: Android.Net.Http

Assembly:: Mono.Android.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda.

[Android.Runtime.Register("android/net/http/HttpResponseCache", DoNotGenerateAcw=true)]
public sealed class HttpResponseCache : Java.Net.ResponseCache, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ICloseable

[<Android.Runtime.Register("android/net/http/HttpResponseCache", DoNotGenerateAcw=true)>]
type HttpResponseCache = class
    inherit ResponseCache
    interface ICloseable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Ereditarietà: Object

Object

ResponseCache
HttpResponseCache

Attributi: RegisterAttribute

Implementazioni: IJavaObject IJavaPeerable ICloseable IDisposable

Commenti

Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. Questa classe supporta java.net.HttpURLConnection e javax.net.ssl.HttpsURLConnection; non è disponibile alcuna cache fornita dalla piattaforma per DefaultHttpClient o AndroidHttpClient. L'installazione e le istanze sono thread-safe.

<h3>Installazione di una cache< di risposta HTTP/h3> Abilitare la memorizzazione nella cache di tutte le richieste HTTP dell'applicazione installando la cache all'avvio dell'applicazione. Ad esempio, questo codice installa una cache 10 MiB nel android.content.Context#getCacheDir() application-specific cache directory file system}:

{@code
              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();
                  }
              }}

Questa cache rimuove le voci in base alle esigenze per evitare che le dimensioni superino 10 MiB. Le dimensioni migliori della cache sono specifiche dell'applicazione e dipendono dalle dimensioni e dalla frequenza dei file scaricati. L'aumento del limite può migliorare il tasso di riscontri, ma può anche solo sprecare spazio nel file system!

Per alcune applicazioni può essere preferibile creare la cache nella directory di archiviazione esterna. <sicuro>Non ci sono controlli di accesso nella directory di archiviazione esterna, quindi non deve essere usato per le cache che potrebbero contenere dati privati.</strong> Anche se spesso ha più spazio libero, l'archiviazione esterna è facoltativa e— anche se disponibile— può scomparire durante l'uso. Recuperare la directory della cache esterna usando android.content.Context#getExternalCacheDir(). Se questo metodo restituisce Null, l'applicazione deve eseguire il fallback a non memorizzare nella cache o memorizzare nella cache nell'archiviazione non esterna. Se l'archiviazione esterna viene rimossa durante l'uso, la frequenza di riscontri della cache scenderà a zero e le letture della cache in corso avranno esito negativo.

Lo scaricamento della cache forza i dati nel file system. In questo modo tutte le risposte scritte nella cache saranno leggibili al successivo avvio dell'attività.

<h3>Ottimizzazione< cache/h3> Per misurare l'efficacia della cache, questa classe tiene traccia di tre statistiche: <ul<>li><strong#getRequestCount() Request Count:></strong> il numero di richieste HTTP inviate dopo la creazione della cache. <li><strong>#getNetworkCount() Network Count:</strong> il numero di richieste che richiedevano l'uso della rete. <li><strong/strong>>#getHitCount() Hit Count:< il numero di richieste le cui risposte sono state gestite dalla cache. </ul> A volte una richiesta genererà un riscontro nella cache condizionale. Se la cache contiene una copia non aggiornata della risposta, il client emetterà un oggetto condizionale GET. Il server invierà quindi la risposta aggiornata se è stata modificata o una breve risposta "non modificata" se la copia del client è ancora valida. Tali risposte incrementino sia il numero di riscontri di rete che il numero di passaggi.

Il modo migliore per migliorare la frequenza di riscontri nella cache consiste nel configurare il server Web per restituire risposte memorizzabili nella cache. Anche se questo client rispetta tutte le intestazioni della cache HTTP/1.1 (RFC 2068), non memorizza nella cache le risposte parziali.

<h3>Forzare una risposta< di rete/h3> In alcune situazioni, ad esempio dopo che un utente fa clic su un pulsante "aggiorna", potrebbe essere necessario ignorare la cache e recuperare i dati direttamente dal server. Per forzare un aggiornamento completo, aggiungere la no-cache direttiva :

{@code
                    connection.addRequestProperty("Cache-Control", "no-cache");
            }

Se è necessario solo forzare la convalida di una risposta memorizzata nella cache dal server, usare invece quanto più efficiente max-age=0 :

{@code
                    connection.addRequestProperty("Cache-Control", "max-age=0");
            }

<h3>Forzare una risposta< cache/h3> A volte è necessario mostrare le risorse se sono disponibili immediatamente, ma non in caso contrario. Questa operazione può essere usata in modo che l'applicazione possa visualizzare un elemento durante l'attesa del download dei dati più recenti. Per limitare una richiesta alle risorse memorizzate nella cache locale, aggiungere la only-if-cached direttiva :

{@code
                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
                }
            }

Questa tecnica funziona ancora meglio nelle situazioni in cui una risposta non aggiornata è migliore di nessuna risposta. Per consentire risposte memorizzate nella cache non aggiornate, usare la max-stale direttiva con la massima decadimento in secondi:

{@code
                    int maxStale = 60 * 60 * 24 * 28; // tolerate 4-weeks stale
                    connection.addRequestProperty("Cache-Control", "max-stale=" + maxStale);
            }

<h3>Working With Earlier Releases</h3> This class was added in Android 4.0 (Ice Cream Sandwich). Usare la reflection per abilitare la cache delle risposte senza influire sulle versioni precedenti:

{@code
                  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) {
                  }}

Documentazione java per android.net.http.HttpResponseCache.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.

Proprietà

Class	Restituisce la classe di runtime di questo `Object`oggetto . (Ereditato da Object)
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
HitCount	Restituisce il numero di richieste HTTP la cui risposta è stata fornita dalla cache.
Installed	Restituisce l'oggetto attualmente `HttpResponseCache`installato o null se non è installata alcuna cache o non è un oggetto `HttpResponseCache`.
JniIdentityHashCode	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
JniPeerMembers	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda.
NetworkCount	Restituisce il numero di richieste HTTP che richiedevano alla rete di fornire una risposta o convalidare una risposta memorizzata nella cache locale.
PeerReference	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
RequestCount	Restituisce il numero totale di richieste HTTP effettuate.
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da ResponseCache)
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da ResponseCache)

Metodi

Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Close()	Disinstalla la cache e rilascia tutte le risorse attive.
Delete()	Disinstalla la cache ed elimina tutto il contenuto archiviato.
Dispose()	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
Dispose(Boolean)	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
Flush()	Forzare le operazioni memorizzate nel buffer nel file system.
Get(URI, String, IDictionary<String,IList<String>>)	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda.
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
Install(File, Int64)	Crea una nuova cache delle risposte HTTP e la imposta come cache predefinita del sistema.
JavaFinalize()	Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object)
MaxSize()	Restituisce il numero massimo di byte che la cache deve utilizzare per archiviare i dati.
Notify()	Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitor dell'oggetto. (Ereditato da Object)
Put(URI, URLConnection)	Consente al gestore del protocollo di memorizzare nella cache i dati dopo il recupero delle risorse.
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
Size()	Restituisce il numero di byte attualmente in uso per archiviare i valori in questa cache.
ToArray<T>()	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
ToString()	Restituisce una rappresentazione di stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo <>una notifica</em> o <em>interrotto</em>. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
IJavaPeerable.Finalized()	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo di tipo controllato dal runtime Android.
JavaCast<TResult>(IJavaObject)	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda.
GetJniTypeName(IJavaPeerable)	Memorizza nella cache le risposte HTTP e HTTPS al file system in modo che possano essere riutilizzate, risparmiando tempo e larghezza di banda.

Si applica a

Condividi tramite