Service Worker durch Vorabladen der Navigation beschleunigen

Mit dem Vorabladen der Navigation können Sie die Startzeit des Service Workers umgehen, indem Sie Anfragen parallel senden.

Jake Archibald
Jake Archibald

Browser Support

  • Chrome: 59.
  • Edge: 18.
  • Firefox: 99.
  • Safari: 15.4.

Source

Zusammenfassung

Das Problem

Wenn Sie eine Website aufrufen, die einen Service Worker zum Verarbeiten von Abrufereignissen verwendet, fordert der Browser den Service Worker auf, eine Antwort zu senden. Dazu wird der Service Worker gestartet (falls er nicht bereits ausgeführt wird) und das Abrufereignis wird gesendet.

Die Bootzeit hängt vom Gerät und den Bedingungen ab. Normalerweise liegt sie bei etwa 50 ms. Auf Mobilgeräten sind es eher 250 ms. In extremen Fällen (langsame Geräte, CPU-Überlastung) kann sie über 500 ms betragen. Da der Service Worker jedoch zwischen Ereignissen für eine vom Browser festgelegte Zeit aktiv bleibt, tritt diese Verzögerung nur gelegentlich auf, z. B. wenn der Nutzer von einem neuen Tab oder einer anderen Website zu Ihrer Website wechselt.

Die Startzeit ist kein Problem, wenn Sie aus dem Cache antworten, da der Vorteil, das Netzwerk zu überspringen, größer ist als die Startverzögerung. Wenn Sie jedoch über das Netzwerk antworten…

SW-Bootmodus
Navigationsanfrage

Die Netzwerkanfrage wird durch das Starten des Service Workers verzögert.

Wir reduzieren die Startzeit weiter, indem wir Code-Caching in V8 verwenden, Service Worker ohne Fetch-Ereignis überspringen, Service Worker spekulativ starten und andere Optimierungen vornehmen. Die Bootzeit ist jedoch immer größer als null.

Facebook hat uns auf die Auswirkungen dieses Problems aufmerksam gemacht und um eine Möglichkeit gebeten, Navigationsanfragen parallel auszuführen:

SW-Bootmodus
Navigationsanfrage

Navigation Preload zur Rettung

Mit dem Vorabladen der Navigation können Sie festlegen, dass die Netzwerkanfrage gestartet wird, während der Service Worker hochfährt, wenn der Nutzer eine GET-Navigationsanfrage stellt.

Die Startverzögerung ist zwar immer noch vorhanden, blockiert aber nicht die Netzwerkanfrage, sodass der Nutzer schneller Inhalte erhält.

Hier ist ein Video, in dem der Service Worker mithilfe einer while-Schleife absichtlich um 500 ms verzögert gestartet wird:

Hier ist die Demo. Damit Sie die Vorteile des Vorabladens von Navigationen nutzen können, benötigen Sie einen Browser, der diese Funktion unterstützt.

Vorabladen der Navigation aktivieren

addEventListener('activate',> event = {
  event.waitUntil(async function() {
    // Feature-detect
    if (self.registration.navigationPreload) {
      // Enable navigation preloads!
      await self.registration.navigationPreload.enable();
    }
  }());
});

Sie können navigationPreload.enable() jederzeit aufrufen oder mit navigationPreload.disable() deaktivieren. Da das fetch-Ereignis jedoch darauf zugreifen muss, ist es am besten, es im activate-Ereignis des Service Workers zu aktivieren und zu deaktivieren.

Vorab geladene Antwort verwenden

Der Browser führt jetzt Preloads für Navigationen durch, aber Sie müssen die Antwort trotzdem verwenden:

addEventListener('fetch',> event = {
  event.respondWith(async function() {
    // Respond from the cache if we can
    const cachedResponse = await caches.match(event.request);
    if (cachedResponse) return cachedResponse;

    // Else, use the preloaded response, if it's there
    const response = await event.preloadResponse;
    if (response) return response;

    // Else try the network.
    return fetch(event.request);
  }());
});

event.preloadResponse ist ein Promise, das mit einer Antwort aufgelöst wird, wenn:

  • Das Vorabladen der Navigation ist aktiviert.
  • Die Anfrage ist eine GET-Anfrage.
  • Die Anfrage ist eine Navigationsanfrage, die von Browsern beim Laden von Seiten, einschließlich iFrames, generiert wird.

Andernfalls ist event.preloadResponse weiterhin vorhanden, wird aber mit undefined aufgelöst.

Wenn Ihre Seite Daten aus dem Netzwerk benötigt, ist es am schnellsten, sie im Service Worker anzufordern und eine einzelne gestreamte Antwort zu erstellen, die Teile aus dem Cache und Teile aus dem Netzwerk enthält.

Angenommen, wir möchten einen Artikel anzeigen:

addEventListener('fetch',> event = {
  const url = new URL(event.request.url);
  const includeURL = new URL(url);
  includeURL.pathname += 'include';

  if (isArticleURL(url)) {
    event.respondWith(async function() {
      // We're going to build a single request from multiple parts.
      const parts = [
        // The top of the page.
        caches.match('/article-top.include'),
        // The primary content
        fetch(includeURL)
          // A fallback if the network >fails.
          .catch(() = caches.match('/article-offline.include')),
        // The bottom of the page
        caches.match('/article-bottom.include')
      ];

      // Merge them all together.
      const {done, response} = await mergeResponses(parts);

      // Wait until the stream is complete.
      event.waitUntil(done);

      // Return the merged response.
      return response;
    }());
  }
});

Im obigen Beispiel ist mergeResponses eine kleine Funktion, die die Streams der einzelnen Anfragen zusammenführt. Das bedeutet, dass wir den im Cache gespeicherten Header anzeigen können, während die Netzwerkinhalte gestreamt werden.

Das geht schneller als das „Anwendungsshell“-Modell, da die Netzwerkanfrage zusammen mit der Seitenanfrage erfolgt und der Inhalt ohne größere Hacks gestreamt werden kann.

Die Anfrage für includeURL wird jedoch durch die Startzeit des ServiceWorkers verzögert. Auch das können wir mit dem Vorabladen der Navigation beheben. In diesem Fall möchten wir aber nicht die gesamte Seite vorab laden, sondern nur einen Include.

Dazu wird mit jeder Preload-Anfrage ein Header gesendet:

Service-Worker-Navigation-Preload: true

Der Server kann damit für Anfragen zum Vorabladen der Navigation andere Inhalte senden als für eine reguläre Navigationsanfrage. Denken Sie daran, einen Vary: Service-Worker-Navigation-Preload-Header hinzuzufügen, damit Caches wissen, dass sich Ihre Antworten unterscheiden.

Jetzt können wir die Preload-Anfrage verwenden:

// Try to use the preload
const networkContent = Promise.resolve(event.preloadResponse)
  // Else do a normal fetch
  .then(r => r || fetch(includeURL))
  // A fallback if the network fails.
  .catch(() => caches.match('/article-offline.include'));

const parts = [
  caches.match('/article-top.include'),
  networkContent,
  caches.match('/article-bottom')
];

Kopfzeile ändern

Standardmäßig ist der Wert des Headers Service-Worker-Navigation-Preload auf true festgelegt. Sie können ihn jedoch beliebig ändern:

navigator.serviceWorker.ready.then(registration => {
  return registration.navigationPreload.setHeaderValue(newValue);
}).then(() => {
  console.log('Done!';);
});

Sie können ihn beispielsweise auf die ID des letzten Beitrags festlegen, den Sie lokal im Cache gespeichert haben, damit der Server nur neuere Daten zurückgibt.

Status abrufen

Sie können den Status des Vorabladens der Navigation mit getState abrufen:

navigator.serviceWorker.ready.then(registration => {
  return registration.navigationPreload.getState();
}).then(state => {
  console.log(state.enabled); // boolean
  console.log(state.headerValue); // string
});

Vielen Dank an Matt Falkenhagen und Tsuyoshi Horo für ihre Arbeit an dieser Funktion und ihre Hilfe bei diesem Artikel. Und ein großes Dankeschön an alle, die an der Standardisierung beteiligt waren.