Wskazówki dotyczące wydajności

W tym dokumencie opisujemy techniki, które mogą poprawić wydajność Twojej aplikacji. Aby przedstawić niektóre rozwiązania, użyliśmy przykładów z innych interfejsów API lub ogólnych interfejsów API. Jednak te same pojęcia są używane w Google Pay API for Passes.

Kompresja za pomocą gzip

Kompresja gzip pozwala łatwo i wygodnie zmniejszyć przepustowość potrzebną do obsługi żądań. Dekompresja wyników wymaga dodatkowego czasu pracy procesora, jednak w zestawieniu z kosztami związanymi z siecią to rozwiązanie wypada bardzo korzystnie.

Aby odebrać odpowiedź zakodowaną w formacie gzip, ustaw nagłówek Accept-Encoding i dodaj do klienta użytkownika tekst gzip. Oto przykład poprawnych nagłówków HTTP, za pomocą których włączysz kompresję gzip:

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

Praca z częściowymi zasobami

Innym sposobem na poprawę wydajności wywołań interfejsu API jest wysyłanie i odbieranie tylko części danych, które Cię interesują. Dzięki temu aplikacja nie musi przesyłać, analizować i zapisywać niepotrzebnych pól, co pozwala wydajniej wykorzystywać zasoby, w tym sieć, procesor i pamięć.

Istnieją 2 typy żądań częściowych:

Odpowiedź częściowa: w tym żądaniu wybierasz, które pola mają znajdować się w odpowiedzi (użyj parametru żądania fields).
Poprawka: w tym żądaniu aktualizacji wysyłasz tylko te pola, które chcesz zmienić (użyj czasownika HTTP PATCH).

Więcej informacji na temat tworzenia żądań częściowych znajdziesz w sekcjach poniżej.

Odpowiedź częściowa

Po przetworzeniu żądań serwer domyślnie odsyła pełną reprezentację zasobu. Aby uzyskać lepsze wyniki, możesz wysłać do serwera żądanie o odpowiedź częściową, czyli dostarczenie tylko tych pól, których potrzebujesz.

Aby wysłać takie żądanie, użyj parametru żądania fields, określając w nim pola, które chcesz odebrać w odpowiedzi. Tego parametru możesz użyć w każdym żądaniu, które zwraca dane odpowiedzi.

Parametr fields wpływa tylko na dane odpowiedzi. Nie ma wpływu na dane, które chcesz wysłać. Aby zmniejszyć ilość danych wysyłanych po zmianie zasobów, użyj żądania poprawki.

Przykład

Ten przykład przedstawia sposób użycia parametru fields w generycznym (fikcyjnym) interfejsie API „Demo”.

Proste żądanie: to żądanie HTTP GET pomija parametr fields i zwraca pełny zasób.

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

Odpowiedź z pełnym zasobem: pełne dane zasobu obejmują poniższe pola i wiele innych pól pominiętych ze względu na długość odpowiedzi.

{
  "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",
    ...
  },
  ...
  ]
}

Żądanie odpowiedzi częściowej: poniższe żądanie tego samego zasobu używa parametru fields, aby znacząco zmniejszyć ilość zwracanych danych.

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

Odpowiedź częściowa: w odpowiedzi na to żądanie serwer wysyła tylko informacje o rodzaju i uproszczoną tablicę, w której każdy element zawiera tylko tytuł HTML i informacje o długości.

200 OK

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

Odpowiedź jest wysyłana w formie obiektu JSON, który zawiera tylko wybrane pola i obiekty nadrzędne.

Szczegółowe informacje o formatowaniu parametru fields znajdziesz poniżej. Opisaliśmy też szczegółowo zawartość odpowiedzi.

Podsumowanie składni parametru fields

Format wartości parametru żądania fields jest oparty na składni XPath. Podsumowanie obsługiwanej składni znajdziesz poniżej. Więcej przykładów przedstawiliśmy w następnej sekcji.

Użyj listy oddzielonej przecinkami, aby wybrać wiele pól.
Użyj a/b, aby wybrać pole b zagnieżdżone w polu a. Użyj a/b/c, aby wybrać pole c zagnieżdżone w polu b.

Wyjątek: jeśli odpowiedź interfejsu API używa kodu danych i jest zagnieżdżona w obiekcie data, który wygląda jak data: { ... }, nie dodawaj „data” do specyfikacji fields. Dodanie do specyfikacji fields obiektu data, takiego jak data/a/b, powoduje błąd. Użyj tylko specyfikacji fields, takiej jak a/b.
Użyj selektora podrzędnego, aby zażądać zbioru konkretnych podrzędnych pól tablic lub obiektów. W tym celu umieść wyrażenia w nawiasach „( )”.
Przykład: fields=items(id,author/email) zwraca tylko identyfikator elementu i e-mail autora każdego elementu w tablicy. Możesz też podać jedno pole podrzędne, gdzie fields=items(id) jest równoważne z fields=items/id.
Jeśli to konieczne, w wybranych polach używaj symboli wieloznacznych.
Przykład: fields=items/pagemap/* wybiera wszystkie obiekty w elemencie pagemap.

Więcej przykładów zastosowania parametru fields

W poniższych przykładach opisano, jak wartość parametru fields wpływa na odpowiedź.

Uwaga: tak jak każda wartość parametru zapytania, wartość parametru fields musi być zakodowana na potrzeby adresu URL. W przykładach w tym dokumencie kodowanie zostało pominięte, aby ułatwić ich czytanie.

Wskaż pola, które chcesz otrzymać w odpowiedzi, lub wybierz odpowiednie pola.

Wartość parametru żądania fields ma postać listy pól oddzielonej przecinkami. Każde pole jest określane względem elementu głównego odpowiedzi. Oznacza to, że jeśli wykonujesz operację na liście, w odpowiedzi otrzymasz kolekcję, która zwykle zawiera tablicę zasobów. Jeśli wykonujesz operację, która zwraca 1 zasób, pola są określane względem tego zasobu. Jeśli wybrane pole jest tablicą lub jej częścią, serwer zwraca wybraną część wszystkich elementów tablicy.

Oto kilka przykładów na poziomie kolekcji:

Przykłady	Efekt
`items`	Zwraca wszystkie elementy tablicy, łącznie ze wszystkimi polami w każdym elemencie (nie zwraca żadnych innych pól).
`etag,items`	Zwraca zarówno pole `etag`, jak i wszystkie elementy tablicy.
`items/title`	Zwraca tylko pole `title` każdego elementu tablicy. Gdy jest zwracane zagnieżdżone pole, odpowiedź zawiera obiekty nadrzędne. Pola nadrzędne nie zawierają innych pól podrzędnych, o ile nie wybrano ich wprost.
`context/facets/label`	Zwraca tylko pole `label` każdego elementu tablicy `facets`, która jest zagnieżdżona w obiekcie `context`.
`items/pagemap/*/title`	Zwraca tylko pole `title` (jeśli jest obecne) każdego elementu tablicy we wszystkich obiektach podrzędnych obiektu `pagemap`.

Oto kilka przykładów na poziomie zasobu:

Przykłady	Efekt
`title`	Zwraca pole `title` żądanego zasobu.
`author/uri`	Zwraca pole podrzędne `uri` obiektu `author` w żądanym zasobie.
`links/*/href`	Zwraca pole `href` każdego obiektu podrzędnego względem `links`.

Aby żądać tylko fragmentów pól, dokonaj wyborów podrzędnych.

Jeśli żądanie dotyczy określonych pól, serwer zwraca domyślnie całe obiekty lub elementy tablicy. Możesz użyć odpowiedzi, która zawiera tylko pewne pola podrzędne. W tym celu użyj składni wyboru podrzędnego „( )”, jak pokazujemy w tym przykładzie.

Przykład	Efekt
`items(title,author/uri)`	Zwraca tylko wartości `title` i `uri` autora z każdego elementu tablicy.

Obsługa odpowiedzi częściowych

Gdy serwer przetworzy prawidłowe żądanie z parametrem zapytania fields, razem z żądanymi danymi wyśle kod stanu HTTP 200 OK. Jeśli parametr zapytania fields zawiera błąd lub jest nieprawidłowy z innego powodu, serwer zwróci kod stanu HTTP 400 Bad Request i komunikat o błędzie z wyjaśnieniem, na czym polega problem z wybranymi polami (na przykład "Invalid field selection a/b").

Poniżej znajdziesz przykładową odpowiedź częściową, o której była już mowa wcześniej, we wprowadzeniu. Aby określić, które pola zwrócić, żądanie używa parametru fields.

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

Odpowiedź częściowa wygląda tak:

200 OK

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

Uwaga: w interfejsach API, które obsługują parametry zapytania do podziału danych na strony (na przykład maxResults i nextPageToken), te parametry pozwalają zmniejszyć liczbę wyników zapytań do rozmiaru, który ułatwia obsługę. Jeśli ich nie zastosujesz, wzrost wydajności wynikający z odpowiedzi częściowej może nie zostać osiągnięty.

Poprawka (częściowa aktualizacja)

Po zmianie zasobów nie musisz wysyłać niepotrzebnych danych. Aby wysłać tylko zaktualizowane dane pól, które zmieniasz, użyj czasownika HTTP PATCH. Opisana w tym dokumencie semantyka poprawki jest inna (i prostsza) niż w implementacji interfejsu GData częściowej aktualizacji.

Krótki przykład podany poniżej pokazuje, jak dzięki poprawce można zminimalizować ilość wysyłanych danych i zmniejszyć rozmiar aktualizacji.

Przykład

Ten przykład przedstawia proste żądanie poprawki, które aktualizuje tylko nazwę zasobu generycznego (fikcyjnego) interfejsu API „Demo”. Zasób ma też komentarz, zbiór cech, stan i wiele innych pól, ale to żądanie wysyła tylko pole title, ponieważ tylko ono zostało zmienione:

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

{
  "title": "New title"
}

Odpowiedź:

200 OK

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

Serwer zwraca kod stanu 200 OK i pełną reprezentację zaktualizowanego zasobu. Żądanie poprawki dotyczy tylko pola title, dlatego jest to jedyna wartość inna niż we wcześniejszym przykładzie.

Uwaga: jeśli użyjesz parametru fields odpowiedzi częściowej razem z poprawką, możesz jeszcze bardziej zwiększyć wydajność żądań aktualizacji. Żądanie poprawki zmniejsza tylko rozmiar żądania. Odpowiedź częściowa zmniejsza rozmiar odpowiedzi. Aby zmniejszyć ilość danych wysyłanych w obie strony, użyj żądania poprawki z parametrem fields.

Semantyka żądania poprawki

Treść żądania poprawki zawiera tylko pola zasobów, które chcesz zmienić. Jeśli podajesz pole, musisz dodać wszystkie obiekty nadrzędne, tak jak obiekty nadrzędne zwracane w odpowiedzi częściowej. Zmienione dane, które chcesz wysłać, są scalane z danymi obiektu nadrzędnego (jeśli istnieje).

Dodawanie: aby dodać nowe pole, podaj jego nazwę i wartość.
Zmiana: aby zmienić wartość dotychczasowego pola, podaj jego nazwę i ustaw je na nową wartość.
Usuwanie: aby usunąć pole, podaj jego nazwę i ustaw je na null. Przykład: "comment": null. Możesz też usunąć cały obiekt (jeśli jest zmienny), ustawiając go na null. Jeśli używasz biblioteki klienta interfejsu Java API, użyj Data.NULL_STRING. Szczegóły znajdziesz na stronie dotyczącej pustej wartości JSON.

Ważna informacja o tablicach: żądania poprawki z tablicami zastępują dotychczasową tablicę tą podaną przez Ciebie. Nie możesz zmieniać, dodawać ani usuwać elementów tablicy stopniowo.

Używanie poprawki w cyklu odczytu, zmiany i zapisu

Warto najpierw pobrać odpowiedź częściową z danymi, które chcesz zmienić. Jest to szczególnie ważne w przypadku zasobów używających znaczników ETag, ponieważ musisz podać bieżącą wartość ETag w nagłówku HTTP If-Match, aby zaktualizować zasób. Po pobraniu danych możesz zmienić wartości i wysłać zmienioną częściową reprezentację z żądaniem poprawki. Oto przykład, w którym założono, że zasób Demo używa znaczników ETag:

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

Oto odpowiedź częściowa:

200 OK

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

Żądanie poprawki przedstawione poniżej opiera się na tej odpowiedzi. Jak widzisz, użyliśmy też parametru fields, aby ograniczyć ilość danych zwracanych w odpowiedzi poprawki:

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. */
  },
}

Serwer w odpowiedzi wysyła kod stanu HTTP 200 OK i częściową reprezentację zaktualizowanego zasobu.

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. */
  }
}

Bezpośrednie tworzenie żądania poprawki

Niektóre żądania poprawki wymagają, aby użyć wcześniej pobranych danych. Jeśli na przykład chcesz dodać element do tablicy bez utraty żadnego z istniejących elementów tablicy, musisz najpierw pobrać istniejące dane. Podobnie, jeśli interfejs API używa znaczników ETag, razem z żądaniem musisz wysłać poprzednią wartość ETag, aby zaktualizować zasób.

Uwaga: aby wymusić zastosowanie poprawki, gdy są używane znaczniki ETag, możesz użyć nagłówka HTTP "If-Match: *". Jeśli to zrobisz, przed zapisem nie trzeba będzie wykonywać odczytu.

Jednak w innych przypadkach możesz utworzyć żądanie poprawki bezpośrednio bez wcześniejszego pobierania istniejących danych. Możesz na przykład łatwo ustawić żądanie, które aktualizuje pole do nowej wartości lub dodaje nowe pole. Oto przykład:

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
  }
}

Jeśli pole komentarza zawiera już wartość, zostanie ona zastąpiona przez nową. W przeciwnym razie zostanie w nim ustawiona nowa wartość. Podobnie, jeśli jest już ustawiona głośność, jej wartość zostanie zastąpiona. W przeciwnym razie zostanie ona utworzona. Pole dokładności zostanie usunięte (jeśli jest ustawione).

Obsługa odpowiedzi na poprawkę

Po przetworzeniu prawidłowego żądania poprawki interfejs API zwraca kod stanu HTTP 200 OK i pełną reprezentację zmienionego zasobu. Jeśli interfejs API używa znaczników ETag, serwer aktualizuje wartości ETag po przetworzeniu żądania poprawki, tak jak w przypadku PUT.

Żądanie poprawki zwraca reprezentację całego zasobu, o ile nie użyto parametru fields, aby zmniejszyć ilość zwracanych danych.

Jeśli żądanie poprawki powoduje ustawienie nowego stanu żądania, który jest składniowo lub semantycznie nieprawidłowy, serwer zwraca kod stanu HTTP 400 Bad Request lub 422 Unprocessable Entity, a stan zasobu pozostaje bez zmian. Jeśli na przykład spróbujesz usunąć wartość pola wymaganego, serwer zwróci błąd.

Inny zapis w sytuacji, gdy czasownik HTTP PATCH nie jest obsługiwany

Jeśli zapora sieciowa nie zezwala na żądania HTTP PATCH, wykonaj żądanie HTTP POST i ustaw nagłówek zastąpienia na PATCH, jak pokazujemy poniżej:

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

Różnica między poprawką a aktualizacją

Kiedy wysyłasz dane żądania aktualizacji, które używa czasownika HTTP PUT, musisz wysłać tylko pola wymagane lub opcjonalne. Jeśli wyślesz wartości pól ustawionych przez serwer, zostaną one zignorowane. Może to wyglądać jak inna metoda wykonania częściowej aktualizacji, jednak ma to swoje ograniczenia. W przypadku aktualizacji, które używają czasownika HTTP PUT, żądanie nie uda się, jeśli nie podasz wymaganych parametrów, oraz wyczyści wcześniej ustawione dane, jeśli nie podasz parametrów opcjonalnych.

Z tego względu dużo bezpieczniejsze jest użycie poprawki. Podajesz tylko dane pól, które chcesz zmienić. Pominięte pola nie są opróżniane. Jedynym wyjątkiem od tej reguły są powtarzające się elementy lub tablice. Jeśli pominiesz je wszystkie, pozostaną bez zmian. Jeśli podasz którekolwiek z nich, cały zbiór zostanie zastąpiony zbiorem, który podasz.

Zalecany limit częstotliwości żądań

Możemy ograniczyć dopuszczalną częstotliwość wywołań naszego interfejsu API. Zalecamy, aby częstotliwość żądań nie przekraczała 20 na sekundę.

Żądania wsadowe do Google Pay for Passes

Interfejs Google Pay for Passes API obsługuje wsadowe wywołania interfejsu API, aby zmniejszyć liczbę połączeń, które musi nawiązać klient, zgodnie z opisem w sekcji Szczegóły żądań wsadowych.

Poniżej znajdziesz przykładowy kod tworzenia żądań wsadowych za pomocą bibliotek Google Pay for Passes:

Uwaga: wymaga to biblioteki Java com.google.api-client w wersji 1.23 lub nowszej albo google/apiclient biblioteki PHP w wersji 2.4.

Java

//Set up client batch
Walletobjects client = new Walletobjects.Builder(httpTransport, jsonFactory, credentials)
        .setApplicationName(config.getApplicationName())
        .build();
BatchRequest batch = client.batch();

//Pre insert class
Services.VerticalType verticalType = Services.VerticalType.OFFER;
String classUid = String.format("%s_CLASS_%s", verticalType.toString(), UUID.randomUUID().toString());
String classId = String.format("%s.%s" , config.getIssuerId(), classUid);
OfferClass theClass = rsc.makeOfferClassResource(classId);
client.offerclass().insert(theClass).execute();

// Batch 10 object inserts
for (int i = 0; i < 10; ++i){

    // your objectUid should be a hash based off of pass metadata, for the demo we will use pass-type_object_uniqueid
    String objectUid = String.format("%s_OBJECT_%s", verticalType.toString(), UUID.randomUUID().toString());

    // check Reference API for format of "id", for example offer:(https://developers.google.com/pay/passes/reference/v1/offerobject/insert).
    // Must be alphanumeric characters, ".", "_", or "-".
    String objectId = String.format("%s.%s", config.getIssuerId(), objectUid);
    OfferObject anObject = rsc.makeOfferObjectResource((classId), objectId);
    client.offerobject().insert(anObject).queue(batch, new JsonBatchCallback(){

        @Override
        public void onSuccess(OfferObject t, HttpHeaders responseHeaders) throws IOException {
            System.out.println("Success!");

        }

        @Override
        public void onFailure(GoogleJsonError e, HttpHeaders responseHeaders) throws IOException {
            System.out.println("Error Message:" + e.getMessage());

        }
    });
}
//Execute batch
batch.execute();

Python

# Generating Credentials for auth request
credentials = service_account.Credentials.from_service_account_file(
    config.SERVICE_ACCOUNT_FILE,
        scopes = config.SCOPES)
authed_session = AuthorizedSession(credentials)
# Pre insert class
classUid = 'OFFER' + '_CLASS_'+ str(uuid.uuid4())
config.offer_class['id'] = '%s.%s' % (config.ISSUER_ID,classUid)
response = authed_session.post('https://www.googleapis.com/walletobjects/v1/offerClass?strict=true', json=config.offer_class)
# Build a batch of 10 object insert requests
data = ''
for i in range(9):
  objectUid = 'OFFER' + '_OBJECT_'+ str(uuid.uuid4())
  objectId = '%s.%s' % (config.ISSUER_ID,objectUid)
  data += '--batch_mybatch\n'
  data += 'Content-Type: application/json\n\n'
  data += 'POST /walletobjects/v1/offerObject/\n\n'
  config.offer_object['id'] = objectId
  data += json.dumps(config.offer_object) + '\n\n'
data += '--batch_mybatch--'
# execute batch
response = authed_session.post('https://walletobjects.googleapis.com/batch', data=data, headers={'Content-Type': 'multipart/mixed; boundary=batch_mybatch'})
print('Response:')
print(response.content.decode('UTF-8'))

PHP

// Create an Google_Client which facilitates REST call
$client = new Google_Client();
// do OAuth2.0 via service account file.
// See https://developers.google.com/api-client-library/php/auth/service-accounts#authorizingrequests
putenv('GOOGLE_APPLICATION_CREDENTIALS=' . SERVICE_ACCOUNT_FILE); // for Google_Client() initialization for server-to-server
$client->useApplicationDefaultCredentials();
// Set application name.
$client->setApplicationName(APPLICATION_NAME);
// Set Api scopes.
$client->setScopes(array(SCOPES));
// Pre insert class
$vertical= "OFFER";
$service = new Google_Service_Walletobjects($client);
$classUid = $vertical."_CLASS_".uniqid('', true);
$classId = sprintf("%s.%s" , ISSUER_ID, $classUid);
$offerClass = ResourceDefinitions::makeOfferClassResource($classId);
$response = $service->offerclass->insert($offerClass);
//Initialize service
$service = new Google_Service_Walletobjects($client);
$service->getClient()->setUseBatch(true);
//Get batch
$batch = $service->createBatch();
// Batch 10 object inserts
for($i=0; $i<=10; $i++){
   $vertical= "OFFER";
   $objectUid= $vertical."_OBJECT_".uniqid('', true)
   $objectId = sprintf("%s.%s", ISSUER_ID, $objectUid);
   $offerObject = ResourceDefinitions::makeOfferObjectResource($classId, $objectId);
   $batch->add($service->offerobject->insert($offerObject));
}
// Execute batch
$results = $batch->execute();
var_export($results);