Questa pagina è stata tradotta dall'API Cloud Translation.

Migliorare le prestazioni

Questo documento descrive alcune tecniche che puoi utilizzare per migliorare le prestazioni della tua applicazione. In alcuni casi, vengono utilizzati esempi tratti da altre API o API generiche per illustrare le idee presentate. Tuttavia, gli stessi concetti valgono per l'API Google Drive.

Compressione mediante gzip

Un modo semplice e pratico per ridurre la larghezza di banda necessaria per ogni richiesta consiste nell'attivare la compressione gzip. Sebbene ciò richieda più tempo di CPU per decomprimere i risultati, il compromesso con i costi di rete di solito lo rende molto utile.

Per ricevere una risposta con codifica gzip devi fare due cose: impostare un'intestazione Accept-Encoding e modificare il tuo user agent in modo che contenga la stringa gzip. Ecco un esempio di intestazioni HTTP formattate correttamente per abilitare la compressione gzip:

Accept-Encoding: gzip
User-Agent: my program (gzip)

Lavorare con risorse parziali

Un altro modo per migliorare le prestazioni delle chiamate API consiste nell'inviare e ricevere solo la parte dei dati che ti interessa. Ciò consente all'applicazione di evitare il trasferimento, l'analisi e l'archiviazione dei campi non necessari, in modo da poter utilizzare risorse come rete, CPU e memoria in modo più efficiente.

Esistono due tipi di richieste parziali:

Risposta parziale: una richiesta in cui specifichi i campi da includere nella risposta (utilizza il parametro di richiesta fields).
Patch: una richiesta di aggiornamento in cui vengono inviati solo i campi da modificare (utilizza il verbo HTTP PATCH).

Nelle sezioni che seguono vengono forniti ulteriori dettagli su come inviare richieste parziali.

Risposta parziale

Per impostazione predefinita, il server restituisce la rappresentazione completa di una risorsa dopo l'elaborazione delle richieste. Per migliorare le prestazioni, puoi chiedere al server di inviare solo i campi effettivamente necessari e ottenere invece una risposta parziale.

Per richiedere una risposta parziale, utilizza il parametro di richiesta fields per specificare i campi da restituire. Puoi utilizzare questo parametro con qualsiasi richiesta che restituisce dati di risposta.

Tieni presente che il parametro fields influisce solo sui dati della risposta e non sugli eventuali dati che devi inviare. Per ridurre la quantità di dati inviati durante la modifica delle risorse, utilizza una richiesta patch.

Esempio

L'esempio seguente mostra l'uso del parametro fields con un'API "Demo" generica (fittizia).

Richiesta semplice: questa richiesta HTTP GET omette il parametro fields e restituisce la risorsa completa.

https://www.googleapis.com/demo/v1

Risposta completa della risorsa: i dati completi della risorsa includono i seguenti campi e molti altri che sono stati omessi per brevità.

{
  "kind": "demo",
  ...
  "items": [
  {
    "title": "First title",
    "comment": "First comment.",
    "characteristics": {
      "length": "short",
      "accuracy": "high",
      "followers": ["Jo", "Will"],
    },
    "status": "active",
    ...
  },
  {
    "title": "Second title",
    "comment": "Second comment.",
    "characteristics": {
      "length": "long",
      "accuracy": "medium"
      "followers": [ ],
    },
    "status": "pending",
    ...
  },
  ...
  ]
}

Richiesta di una risposta parziale: la seguente richiesta per la stessa risorsa utilizza il parametro fields per ridurre in modo significativo la quantità di dati restituiti.

https://www.googleapis.com/demo/v1?fields=kind,items(title,characteristics/length)

Risposta parziale: in risposta alla richiesta precedente, il server invia una risposta contenente solo le informazioni sul tipo insieme a un array di elementi essenziali che include solo le informazioni HTML relative al titolo e alla lunghezza in ciascun elemento.

200 OK

{
  "kind": "demo",
  "items": [{
    "title": "First title",
    "characteristics": {
      "length": "short"
    }
  }, {
    "title": "Second title",
    "characteristics": {
      "length": "long"
    }
  },
  ...
  ]
}

Tieni presente che la risposta è un oggetto JSON che include solo i campi selezionati e i relativi oggetti padre che contengono.

Di seguito vengono illustrati i dettagli su come formattare il parametro fields, seguiti da ulteriori dettagli su cosa viene restituito esattamente nella risposta.

Riepilogo della sintassi dei parametri dei campi

Il formato del valore del parametro di richiesta fields è generico e si basa sulla sintassi XPath. La sintassi supportata è riepilogata di seguito e ulteriori esempi sono forniti nella sezione seguente.

Utilizza un elenco separato da virgole per selezionare più campi.
Utilizza a/b per selezionare un campo b nidificato all'interno del campo a; utilizza a/b/c per selezionare un campo c nidificato all'interno di b.

Eccezione:per le risposte dell'API che utilizzano wrapper "dati", in cui la risposta è nidificata all'interno di un oggetto data simile a data: { ... }, non includere "data" nella specifica fields. L'inclusione dell'oggetto dati con una specifica dei campi come data/a/b causa un errore. Utilizza invece una specifica fields come a/b.
Utilizza un sottoselettore per richiedere un insieme di sottocampi specifici di matrici o oggetti inserendo espressioni tra parentesi "( )".
Ad esempio: fields=items(id,author/email) restituisce solo l'ID elemento e l'indirizzo email dell'autore per ciascun elemento nell'array items. Puoi anche specificare un singolo campo secondario, dove fields=items(id) equivale a fields=items/id.
Se necessario, utilizza caratteri jolly nella selezione dei campi.
Ad esempio: fields=items/pagemap/* seleziona tutti gli oggetti in una mappa di pagina.

Altri esempi di utilizzo del parametro dei campi

Gli esempi riportati di seguito includono le descrizioni di come il valore del parametro fields influisce sulla risposta.

Nota: come per tutti i valori dei parametri di query, il valore del parametro fields deve essere codificato come URL. Per una migliore leggibilità, gli esempi in questo documento omettono la codifica.

Identifica i campi che vuoi che vengano restituiti o effettua delle selezioni di campi.

Il valore del parametro di richiesta fields è un elenco di campi separati da virgole e ogni campo viene specificato in base alla radice della risposta. Di conseguenza, se esegui un'operazione list, la risposta è una raccolta e generalmente include un array di risorse. Se stai eseguendo un'operazione che restituisce una singola risorsa, i campi vengono specificati in relazione a quella risorsa. Se il campo selezionato è (o fa parte di) un array, il server restituisce la parte selezionata di tutti gli elementi dell'array.

Ecco alcuni esempi a livello di raccolta:

Esempi	Effetto
`items`	Restituisce tutti gli elementi nell'array di elementi, inclusi tutti i campi di ogni elemento, ma nessun altro campo.
`etag,items`	Restituisce sia il campo `etag` sia tutti gli elementi nell'array di elementi.
`items/title`	Restituisce solo il campo `title` per tutti gli elementi nell'array di elementi. Ogni volta che viene restituito un campo nidificato, la risposta include gli oggetti padre che contengono. I campi principali non includono altri campi secondari, a meno che non vengano selezionati esplicitamente.
`context/facets/label`	Restituisce solo il campo `label` per tutti i membri dell'array `facets`, che a sua volta è nidificato sotto l'oggetto `context`.
`items/pagemap/*/title`	Per ogni elemento nell'array items, restituisce solo il campo `title` (se presente) di tutti gli oggetti secondari di `pagemap`.

Ecco alcuni esempi a livello di risorsa:

Esempi	Effetto
`title`	Restituisce il campo `title` della risorsa richiesta.
`author/uri`	Restituisce il sottocampo `uri` dell'oggetto `author` nella risorsa richiesta.
`links/*/href`	Restituisce il campo `href` di tutti gli oggetti secondari di `links`.

Richiedi solo parti di campi specifici utilizzando le selezioni secondarie.

Per impostazione predefinita, se la tua richiesta specifica campi specifici, il server restituisce gli oggetti o gli elementi array nella loro interezza. Puoi specificare una risposta che includa solo alcuni sottocampi. A tale scopo, utilizza la sintassi di sottoselezione "( )", come nell'esempio riportato di seguito.

Esempio	Effetto
`items(title,author/uri)`	Restituisce solo i valori di `title` e `uri` dell'autore per ciascun elemento nell'array di elementi.

Gestione delle risposte parziali

Dopo che un server ha elaborato una richiesta valida che include il parametro di ricerca fields, invia un codice di stato HTTP 200 OK insieme ai dati richiesti. Se il parametro di query fields presenta un errore o non è valido, il server restituisce un codice di stato HTTP 400 Bad Request e un messaggio di errore che indica all'utente qual era il problema nella selezione dei campi (ad esempio, "Invalid field selection a/b").

Ecco l'esempio di risposta parziale mostrato nella sezione introduttiva riportata sopra. La richiesta utilizza il parametro fields per specificare quali campi restituire.

https://www.googleapis.com/demo/v1?fields=kind,items(title,characteristics/length)

La risposta parziale sarà simile alla seguente:

200 OK

{
  "kind": "demo",
  "items": [{
    "title": "First title",
    "characteristics": {
      "length": "short"
    }
  }, {
    "title": "Second title",
    "characteristics": {
      "length": "long"
    }
  },
  ...
  ]
}

Nota:per le API che supportano i parametri di query per l'impaginazione dei dati (ad esempio maxResults e nextPageToken), utilizzali per ridurre i risultati di ogni query a una dimensione gestibile. In caso contrario, i possibili miglioramenti delle prestazioni con una risposta parziale potrebbero non essere realizzati.

Patch (aggiornamento parziale)

Inoltre, puoi evitare di inviare dati non necessari quando modifichi le risorse. Per inviare dati aggiornati solo per i campi specifici che stai modificando, utilizza il verbo HTTP PATCH. La semantica delle patch descritta in questo documento è diversa (e più semplice) rispetto alla precedente implementazione GData dell'aggiornamento parziale.

Il breve esempio riportato di seguito mostra come l'utilizzo della patch riduce al minimo i dati da inviare per effettuare un piccolo aggiornamento.

Esempio

Questo esempio mostra una semplice richiesta di patch per aggiornare solo il titolo di una risorsa API "Demo" generica (fittizia). La risorsa contiene anche un commento, un insieme di caratteristiche, uno stato e molti altri campi, ma questa richiesta invia solo il campo title, dato che questo è l'unico campo che viene modificato:

PATCH https://www.googleapis.com/demo/v1/324
Authorization: Bearer your_auth_token
Content-Type: application/json

{
  "title": "New title"
}

Risposta:

200 OK

{
  "title": "New title",
  "comment": "First comment.",
  "characteristics": {
    "length": "short",
    "accuracy": "high",
    "followers": ["Jo", "Will"],
  },
  "status": "active",
  ...
}

Il server restituisce un codice di stato 200 OK insieme alla rappresentazione completa della risorsa aggiornata. Poiché nella richiesta di patch era incluso solo il campo title, questo è l'unico valore diverso da prima.

Nota: se usi il parametro risposta parziale fields in combinazione con la patch, puoi aumentare ulteriormente l'efficienza delle tue richieste di aggiornamento. Una richiesta di patch riduce solo la dimensione della richiesta. Una risposta parziale riduce la dimensione della risposta. Quindi, per ridurre la quantità di dati inviati in entrambe le direzioni, utilizza una richiesta di patch con il parametro fields.

Semantica di una richiesta di patch

Il corpo della richiesta di patch include solo i campi delle risorse che vuoi modificare. Quando specifichi un campo, devi includere tutti gli oggetti principali che contengono, proprio come gli oggetti principali che includono vengono restituiti con una risposta parziale. I dati modificati che invii vengono uniti ai dati relativi all'oggetto padre, se esistente.

Aggiungi:per aggiungere un campo che non esiste già, specifica il nuovo campo e il relativo valore.
Modifica: per modificare il valore di un campo esistente, specifica il campo e impostalo sul nuovo valore.
Elimina:per eliminare un campo, specifica il campo e impostalo su null. Ad esempio: "comment": null. Puoi anche eliminare un intero oggetto (se è modificabile) impostandolo su null. Se utilizzi la libreria client dell'API Java, utilizza Data.NULL_STRING. Per i dettagli, consulta JSON null.

Nota sugli array:le richieste di patch che contengono array sostituiscono l'array esistente con quello fornito da te. Non puoi modificare, aggiungere o eliminare elementi in un array in modo frammentario.

Utilizzo di patch in un ciclo di lettura, modifica e scrittura

Può essere utile iniziare recuperando una risposta parziale con i dati che vuoi modificare. Ciò è particolarmente importante per le risorse che utilizzano ETag, poiché devi fornire il valore ETag attuale nell'intestazione HTTP If-Match per aggiornare correttamente la risorsa. Dopo aver ottenuto i dati, puoi modificare i valori da cambiare e inviare la rappresentazione parziale modificata con una richiesta di patch. Ecco un esempio in cui si presuppone che la risorsa demo utilizzi gli ETag:

GET https://www.googleapis.com/demo/v1/324?fields=etag,title,comment,characteristics
Authorization: Bearer your_auth_token

Questa è la risposta parziale:

200 OK

{
  "etag": "ETagString"
  "title": "New title"
  "comment": "First comment.",
  "characteristics": {
    "length": "short",
    "level": "5",
    "followers": ["Jo", "Will"],
  }
}

La seguente richiesta di patch si basa su questa risposta. Come mostrato di seguito, utilizza anche il parametro fields per limitare i dati restituiti nella risposta della patch:

PATCH https://www.googleapis.com/demo/v1/324?fields=etag,title,comment,characteristics
Authorization: Bearer your_auth_token
Content-Type: application/json
If-Match: "ETagString"

{
  "etag": "ETagString"
  "title": "",                  /* Clear the value of the title by setting it to the empty string. */
  "comment": null,              /* Delete the comment by replacing its value with null. */
  "characteristics": {
    "length": "short",
    "level": "10",              /* Modify the level value. */
    "followers": ["Jo", "Liz"], /* Replace the followers array to delete Will and add Liz. */
    "accuracy": "high"          /* Add a new characteristic. */
  },
}

Il server risponde con un codice di stato HTTP 200 OK e con la rappresentazione parziale della risorsa aggiornata:

200 OK

{
  "etag": "newETagString"
  "title": "",                 /* Title is cleared; deleted comment field is missing. */
  "characteristics": {
    "length": "short",
    "level": "10",             /* Value is updated.*/
    "followers": ["Jo" "Liz"], /* New follower Liz is present; deleted Will is missing. */
    "accuracy": "high"         /* New characteristic is present. */
  }
}

Creazione diretta di una richiesta di patch

Per alcune richieste di patch, devi basarle sui dati recuperati in precedenza. Ad esempio, se vuoi aggiungere un elemento a un array e non vuoi perdere nessuno degli elementi esistenti, devi prima recuperare i dati esistenti. Allo stesso modo, se un'API utilizza ETag, devi inviare il valore ETag precedente con la tua richiesta per aggiornare correttamente la risorsa.

Nota:puoi utilizzare un'intestazione HTTP "If-Match: *" per forzare il passaggio di una patch quando sono in uso gli ETag. In questo caso, non sarà necessario eseguire la lettura prima della scrittura.

Per altre situazioni, tuttavia, è possibile costruire la richiesta di patch direttamente, senza prima recuperare i dati esistenti. Ad esempio, puoi configurare facilmente una richiesta di patch che aggiorni un campo con un nuovo valore o aggiunga un nuovo campo. Ecco un esempio:

PATCH https://www.googleapis.com/demo/v1/324?fields=comment,characteristics
Authorization: Bearer your_auth_token
Content-Type: application/json

{
  "comment": "A new comment",
  "characteristics": {
    "volume": "loud",
    "accuracy": null
  }
}

Con questa richiesta, se il campo di commento ha un valore esistente, il nuovo valore lo sovrascrive; in caso contrario viene impostato sul nuovo valore. Allo stesso modo, se era presente una caratteristica del volume, il relativo valore viene sovrascritto; in caso contrario, viene creato. Il campo relativo all'accuratezza, se impostato, viene rimosso.

Gestione della risposta a una patch

Dopo aver elaborato una richiesta di patch valida, l'API restituisce un codice di risposta HTTP 200 OK insieme alla rappresentazione completa della risorsa modificata. Se l'API utilizza gli ETag, il server aggiorna i valori ETag quando elabora una richiesta di patch, proprio come avviene con PUT.

La richiesta di patch restituisce l'intera rappresentazione della risorsa, a meno che non utilizzi il parametro fields per ridurre la quantità di dati restituiti.

Se una richiesta di patch dà come risultato un nuovo stato della risorsa non valido sintatticamente o semanticamente, il server restituisce un codice di stato HTTP 400 Bad Request o 422 Unprocessable Entity e lo stato della risorsa rimane invariato. Ad esempio, se tenti di eliminare il valore di un campo obbligatorio, il server restituisce un errore.

Notazione alternativa quando il verbo HTTP PATCH non è supportato

Se il firewall non consente le richieste HTTP PATCH, esegui una richiesta POST HTTP e imposta l'intestazione di override su PATCH, come mostrato di seguito:

POST https://www.googleapis.com/...
X-HTTP-Method-Override: PATCH
...

Differenza tra patch e aggiornamento

In pratica, quando invii i dati per una richiesta di aggiornamento che utilizza il verbo HTTP PUT, devi inviare solo i campi obbligatori o facoltativi; se invii valori per i campi impostati dal server, questi vengono ignorati. Sebbene questo approccio possa sembrare un altro modo per eseguire un aggiornamento parziale, questo approccio presenta alcune limitazioni. Con gli aggiornamenti che utilizzano il verbo HTTP PUT, la richiesta non va a buon fine se non fornisci i parametri obbligatori e cancella i dati impostati in precedenza se non fornisci parametri facoltativi.

Per questo motivo è molto più sicuro usare la patch. I dati vengono forniti solo per i campi da modificare; i campi omessi non vengono cancellati. L'unica eccezione a questa regola si verifica con gli elementi o gli array ripetuti: se li ometti tutti, rimangono invariati; se fornisci uno di questi elementi, l'intero insieme viene sostituito con quello fornito da te.

Richieste batch

Questo documento mostra come raggruppare le chiamate API per ridurre il numero di connessioni HTTP che il client deve effettuare.

Questo documento riguarda nello specifico l'esecuzione di una richiesta batch tramite l'invio di una richiesta HTTP. Se invece utilizzi una libreria client di Google per effettuare una richiesta batch, consulta la documentazione della libreria client.

Panoramica

Ogni connessione HTTP che il tuo client genera comporta un certo overhead. L'API Google Drive supporta i batch, per consentire al tuo client di inserire diverse chiamate API in un'unica richiesta HTTP.

Esempi di situazioni in cui può essere utile creare gruppi:

Recupero dei metadati per un numero elevato di file.
Aggiornamento collettivo di metadati o proprietà.
Modificare le autorizzazioni per un numero elevato di file, ad esempio aggiungere un nuovo utente o gruppo.
Sincronizzazione dei dati del client locale per la prima volta o dopo un periodo di inattività prolungato.

In ogni caso, invece di inviare ogni chiamata separatamente, puoi raggrupparle in un'unica richiesta HTTP. Tutte le richieste interne devono essere indirizzate alla stessa API di Google.

Puoi effettuare un massimo di 100 chiamate in una singola richiesta batch. Se devi effettuare un numero maggiore di chiamate, utilizza più richieste batch.

Nota: il sistema batch dell'API Google Drive utilizza la stessa sintassi del sistema di elaborazione batch OData, ma la semantica è diversa.

Nota: le richieste batch con più di 100 chiamate potrebbero causare un errore.

Nota: esiste un limite di 8000 caratteri per la lunghezza dell'URL per ogni richiesta interna.

Nota: attualmente Google Drive non supporta le operazioni batch per i contenuti multimediali, né per il caricamento né per il download.

Dettagli batch

Una richiesta batch è composta da più chiamate API combinate in un'unica richiesta HTTP, che può essere inviata al batchPath specificato nel documento di rilevamento API. Il percorso predefinito è /batch/api_name/api_version. In questa sezione viene descritta in dettaglio la sintassi batch; in seguito troverai un esempio.

Nota: un insieme di richieste n raggruppate insieme viene conteggiato come richiesta n, non come richiesta singola. La richiesta batch viene suddivisa in un insieme di richieste prima dell'elaborazione.

Formato di una richiesta batch

Una richiesta batch è una singola richiesta HTTP standard contenente più chiamate API di Google Drive, che utilizzano il tipo di contenuti multipart/mixed. All'interno della richiesta HTTP principale, ciascuna delle parti contiene una richiesta HTTP nidificata.

Ogni parte inizia con la propria intestazione HTTP Content-Type: application/http. Può anche avere un'intestazione Content-ID facoltativa. Tuttavia, le intestazioni delle parti servono solo a contrassegnare l'inizio della parte e sono separate dalla richiesta nidificata. Una volta che il server ha annullato il wrapping della richiesta batch in richieste separate, le intestazioni delle parti vengono ignorate.

Il corpo di ogni parte è a sua volta una richiesta HTTP completa, con il proprio verbo, URL, intestazioni e corpo. La richiesta HTTP deve contenere solo la parte del percorso dell'URL; gli URL completi non sono consentiti nelle richieste batch.

Le intestazioni HTTP per la richiesta batch esterna, ad eccezione delle intestazioni Content- come Content-Type, si applicano a ogni richiesta del batch. Se specifichi una determinata intestazione HTTP sia nella richiesta esterna che in una singola chiamata, il valore dell'intestazione della singola chiamata sostituisce il valore dell'intestazione della richiesta batch esterna. Le intestazioni di una singola chiamata si applicano solo a quella chiamata.

Ad esempio, se fornisci un'intestazione Autorizzazione per una chiamata specifica, questa intestazione si applica solo a quella chiamata. Se fornisci un'intestazione Authorization per la richiesta esterna, questa si applica a tutte le singole chiamate, a meno che non la sostituisca con le intestazioni Authorization proprie.

Quando il server riceve la richiesta in batch, applica i parametri di query e le intestazioni della richiesta esterna (a seconda dei casi) a ciascuna parte, quindi tratta ogni parte come se fosse una richiesta HTTP separata.

Risposta a una richiesta batch

La risposta del server è una singola risposta HTTP standard con un tipo di contenuto multipart/mixed; ogni parte è la risposta a una delle richieste della richiesta in batch, nello stesso ordine delle richieste.

Come le parti della richiesta, ogni parte della risposta contiene una risposta HTTP completa, inclusi un codice di stato, intestazioni e corpo. E, come per le parti della richiesta, ogni parte della risposta è preceduta da un'intestazione Content-Type che segna l'inizio della parte.

Se una determinata parte della richiesta aveva un'intestazione Content-ID, la parte corrispondente della risposta avrà un'intestazione Content-ID corrispondente, con il valore originale preceduto dalla stringa response-, come mostrato nell'esempio seguente.

Nota: il server può effettuare le chiamate in qualsiasi ordine. Non considerare che vengano eseguite nell'ordine in cui li hai specificati. Se vuoi assicurarti che si verifichino due chiamate in un determinato ordine, non puoi inviarle in un'unica richiesta; invia la prima da sola, quindi attendi la risposta alla prima prima di inviare la seconda.

Esempio

L'esempio seguente mostra l'utilizzo della creazione in batch con l'API Google Drive.

Esempio di richiesta batch

POST https://www.googleapis.com/batch/drive/v3 Accept-Encoding: gzip User-Agent: Google-HTTP-Java-Client/1.20.0 (gzip) Content-Type: multipart/mixed; boundary=END_OF_PART Content-Length: 963

--END_OF_PART Content-Length: 337 Content-Type: application/http content-id: 1 content-transfer-encoding: binary

POST https://www.googleapis.com/drive/v3/files/fileId/permissions?fields=id Authorization: Bearer authorization_token Content-Length: 70 Content-Type: application/json; charset=UTF-8

{ "emailAddress":"example@appsrocks.com", "role":"writer", "type":"user" } --END_OF_PART Content-Length: 353 Content-Type: application/http content-id: 2 content-transfer-encoding: binary

POST https://www.googleapis.com/drive/v3/files/fileId/permissions?fields=id&sendNotificationEmail=false Authorization: Bearer authorization_token Content-Length: 58 Content-Type: application/json; charset=UTF-8

{ "domain":"appsrocks.com", "role":"reader", "type":"domain" } --END_OF_PART--

Esempio di risposta batch

Questa è la risposta alla richiesta di esempio nella sezione precedente.

HTTP/1.1 200 OK Alt-Svc: quic=":443"; p="1"; ma=604800 Server: GSE Alternate-Protocol: 443:quic,p=1 X-Frame-Options: SAMEORIGIN Content-Encoding: gzip X-XSS-Protection: 1; mode=block Content-Type: multipart/mixed; boundary=batch_6VIxXCQbJoQ_AATxy_GgFUk Transfer-Encoding: chunked X-Content-Type-Options: nosniff Date: Fri, 13 Nov 2015 19:28:59 GMT Cache-Control: private, max-age=0 Vary: X-Origin Vary: Origin Expires: Fri, 13 Nov 2015 19:28:59 GMT

--batch_6VIxXCQbJoQ_AATxy_GgFUk Content-Type: application/http Content-ID: response-1

HTTP/1.1 200 OK Content-Type: application/json; charset=UTF-8 Date: Fri, 13 Nov 2015 19:28:59 GMT Expires: Fri, 13 Nov 2015 19:28:59 GMT Cache-Control: private, max-age=0 Content-Length: 35

{ "id": "12218244892818058021i" }

--batch_6VIxXCQbJoQ_AATxy_GgFUk Content-Type: application/http Content-ID: response-2

HTTP/1.1 200 OK Content-Type: application/json; charset=UTF-8 Date: Fri, 13 Nov 2015 19:28:59 GMT Expires: Fri, 13 Nov 2015 19:28:59 GMT Cache-Control: private, max-age=0 Content-Length: 35

{ "id": "04109509152946699072k" }

--batch_6VIxXCQbJoQ_AATxy_GgFUk--

Restituisci campi specifici della richiesta

Per impostazione predefinita, il server restituisce un insieme predefinito di campi di risorse specifici per il metodo utilizzato. Ad esempio, il metodo files.list potrebbe restituire solo id, name e mimeType. Questi campi potrebbero non corrispondere esattamente ai campi che ti servono. Se devi restituire altri campi, consulta Restituire campi specifici per un file.