Header Ads Widget

Ticker

6/recent/ticker-posts

Todo lo que necesita saber sobre la paginación API

 


A medida que aumentan las expectativas de los consumidores, el rendimiento de la API nunca ha sido más importante que en la actualidad. Es una estadística bien conocida que el 53% de los usuarios web abandonarán una página web si tarda más de 3 segundos en cargarse.

Estas expectativas no necesariamente se alinean con los requisitos técnicos de una API. En la era del big data y la analítica, las API se ocupan de mayores cantidades de datos en su backend que nunca. Para mantenerse firmes en la economía digital actual, las API deben optimizarse para lograr la máxima eficiencia . La paginación de API es una estrategia clave para asegurarse de que sus API se ejecuten sin problemas y de manera efectiva.

Pero, ¿qué es la paginación API? ¿Cómo puede la paginación de API ayudar a sus API a funcionar al máximo rendimiento? Te lo contamos, en nuestra guía completa de paginación API.

Todo lo que necesita saber sobre la paginación API

Para asegurarnos de que estamos en la misma página, comencemos por ver qué es la paginación. Luego profundizaremos en la paginación de API con implementaciones de código de ejemplo.

¿Qué es la paginación?

¿Alguna vez ha hecho clic en una galería de imágenes? ¿O leer un extenso tutorial web dividido en varios segmentos? ¿Conoce los números en la parte inferior de la galería o página web?

Eso es paginación.

Sitechecker.pro, un sitio web técnico de SEO, define la paginación como "una numeración ordinal de páginas, que generalmente se encuentra en la parte superior o inferior de las páginas del sitio". La paginación de API simplemente aplica ese principio al ámbito del diseño de API.

Las consultas de API a bases de datos densas podrían devolver millones, si no miles de millones, de resultados. No se sabe qué tipo de drenaje podría poner en su API. Por lo tanto, la paginación ayuda a limitar la cantidad de resultados para ayudar a mantener el tráfico de la red bajo control.

Veamos algunos de los métodos de paginación API más comunes antes de ver ejemplos de codificación.

Paginación compensada

La paginación offset es una de las más sencillas de implementar. Se logra usando ellimitoffset comandos La paginación compensada es popular entre las aplicaciones impulsadas por bases de datos SQL, ya que limitoffsetya están incluidas en la SQL SELECTbiblioteca.

Solicitud de API usando limit y se offsetve así:

GET /items?limit=20&offset=100

La paginación compensada casi no requiere programación. Es también sin estado en el lado del servidor y funciona independientemente de los sort_byparámetros personalizados .

La desventaja de la paginación de compensación es que tropieza cuando se trata de valores de compensación grandes. Si tuviera que establecer un desplazamiento de 1000000, por ejemplo, la API tendría que escanear un millón de entradas de la base de datos y luego descartarlas.

La otra desventaja de la paginación de desplazamiento es que agregar nuevas entradas a la tabla puede causar confusión, lo que se conoce como desplazamiento de página. Considere este escenario:

  1. Comience con la consulta GET /items/?offset=0&limit=15
  2. Agregue 10 elementos nuevos a la base de datos
  3. Realice la misma consulta nuevamente. Esto solo devolverá 5 resultados, ya que agregar 10 elementos a la base de datos movió el desplazamiento hacia atrás en 10. Esto puede causar mucha confusión en el lado del cliente.

Paginación del teclado

La paginación del conjunto de claves utiliza los valores de filtro de la página anterior para determinar el siguiente conjunto de elementos. Luego, esos resultados se indexarán.

Considere este ejemplo:

  1. El cliente solicita los artículos más recientes GET /items?limit=20
  2. Al hacer clic en la página siguiente, la consulta encuentra la fecha mínima de creación de 2019–01–20T00: 00: 00. Luego, se utiliza para crear un filtro de consulta para la página siguiente.GET /items?limit=20&created:lte:2019-01-20T00:00:00
  3. Y así…

Los beneficios de este enfoque es que no requiere una lógica de backend adicional. Solo requiere un limitparámetro de URL. También presenta un orden consistente, incluso cuando se agregan nuevos elementos a la base de datos. También funciona sin problemas con valores de compensación grandes.

Buscar paginación

La paginación de búsqueda es el siguiente paso más allá de la paginación del conjunto de claves. Al agregar las consultas after_idbefore_id, puede eliminar las restricciones de los filtros y la clasificación. Los identificadores únicos son más estables y estáticos que los campos de cardinalidad inferior, como las enumeraciones estatales o los nombres de categorías.

El único inconveniente de buscar la paginación es que puede resultar complicado crear órdenes de clasificación personalizadas.

Considere este ejemplo:

  1. El cliente solicita una lista de los elementos más recientes GET items?limit=20
  2. El cliente solicita una lista de los siguientes 20 elementos, utilizando los resultados de la primera consulta GET /items?limit=20&after_id=20
  3. El cliente solicita la página siguiente / de desplazamiento, utilizando la entrada final de la segunda página como punto de partida GET /items?limit=20&after_id=40

La paginación de búsqueda se puede consolidar en una WHEREcláusula. Por ejemplo:

SELECT
* FROM Items WHERE Id > 20 LIMIT 20

Esto está bien si está clasificando pedidos por Id. ¿Qué sucede cuando desea filtrar por dirección de correo electrónico, por ejemplo? El backend tendría que buscar en la base de datos esa dirección de correo electrónico y luego traducirla en un Id. Luego, se debe realizar una segunda consulta utilizando el Id como WHEREvalor.

Ejemplo:

Query 1

SELECT
	Email = AFTER_EMAIL
FROM
	Items
WHERE
	ID = 20

Luego…

Query 2
SELECT * FROM Items WHERE Email >=[AFTER_EMAIL]
LIMIT 20

Beneficios de la paginación de búsqueda:

  • Desacopla la lógica del filtro de la lógica de paginación
  • Ordenamiento consistente, incluso cuando se agregan nuevos elementos a la base de datos. Ordena bien los elementos agregados más nuevos.
  • Funciona sin problemas, incluso con grandes compensaciones.

Desventajas de la paginación de búsqueda:

  • Más exigentes con los recursos de backend que utilizan la paginación de conjuntos de claves o offset
  • Cuando se eliminan elementos de la base de datos, es start_idposible que ya no sea una identificación válida.

Cómo implementar la paginación de API en su propio diseño de API

Hemos aprendido mucho sobre cómo funciona la paginación API y por qué es importante. Concluyamos con un ejemplo del mundo real para ayudarlo a trabajar la paginación en su propio diseño de API.

Vamos a trabajar con una API REST, ya que son muy comunes. Debería poder traducir estas prácticas a otros lenguajes y entornos de programación con bastante facilidad. Para este ejemplo, usaremos el navegador HAL , que es un navegador API que hace que la vinculación sea fácil e intuitiva. En caso de que no esté familiarizado con HAL , significa lenguaje de aplicación de hipertexto. Agregar HAL a su API lo hará explorable y visible. También permite que su API sea servida y consumida usando bibliotecas de código abierto disponibles para la mayoría de lenguajes de programación.

Una vez que haya configurado HAL y HAL Browser, comencemos con algo de código.

{
    "_links": {
        "self": {
            "href": "http://example.org/api/user?page=3"
        },
        "first": {
            "href": "http://example.org/api/user"
        },
        "prev": {
            "href": "http://example.org/api/user?page=2"
        },
        "next": {
            "href": "http://example.org/api/user?page=4"
        },
        "last": {
            "href": "http://example.org/api/user?page=133"
        }
    }
    "count": 3,
    "total": 498,
    "_embedded": {
        "users": [
            {
                "_links": {
                    "self": {
                        "href": "http://example.org/api/user/mwop"
                    }
                },
                "id": "mwop",
                "name": "Matthew Weier O'Phinney"
            },
            {
                "_links": {
                    "self": {
                        "href": "http://example.org/api/user/mac_nibblet"
                    }
                },
                "id": "mac_nibblet",
                "name": "Antoine Hedgecock"
            },
            {
                "_links": {
                    "self": {
                        "href": "http://example.org/api/user/spiffyjr"
                    }
                },
                "id": "spiffyjr",
                "name": "Kyle Spraggs"
            }
        ]
    }
}

Como puede ver, los enlaces son muy útiles para crear paginación en una API REST.

Tome nota también de las variables. No son accidentales. Las etiquetas como selffirstnext, y last, son ampliamente utilizados por los desarrolladores de la API. Es probable que su API sea coherente con muchas otras API si utiliza estas variables.

Puede utilizar muchos enfoques diferentes para crear paginación en REST. Las consultas resultan ser las más fáciles de implementar y coherentes, por lo que vamos a seguir con ese enfoque.

Creemos un escenario de ejemplo. Vamos a crear una API llamada programmers.featuredy luego enumerar 5 programadores destacados a la vez utilizando la paginación de API.

 166 lines  features/api/programmer.feature
  # we will do 5 per page
  Scenario: Paginate through the collection of programmers
    Given the following programmers exist:
      | nickname    |
      | Programmer1 |
      | Programmer2 |
      | Programmer3 |
      | Programmer4 |
      | Programmer5 |
      | Programmer6 |
      | Programmer7 |
      | Programmer8 |
      | Programmer9 |
      | Programmer10 |
      | Programmer11 |
      | Programmer12 |

Después de realizar la primera solicitud GET, buscará los resultados del NEXTenlace y lo usará para devolver la siguiente página de resultados.

166 lines features/api/programmer.feature
Scenario: Paginate through the collection of programmers Given the following programmers exist: When I request "GET /api/programmers" And I follow the "next" link

Para este ejemplo, usará la biblioteca HATEOAS. El código lo sabe, por lo que sabe a tener en cuenta _linksnexthrefya utilizar los de la siguiente petición GET.

Siguiendo estos criterios, sabrá que Programmer7estaría contenido en la página 2 de resultados. No encontrarás Programmer2ni Programmer11Estos estarían en la página 1 y en la página 3 de los resultados, respectivamente. Intente buscar una entrada del Programador de una línea en particular.

php vendor/bin/behat features/api.programmer.feature:96

Sin embargo, esto no funciona, ya que el código no puede encontrar el nextenlace porque aún no se han agregado.

Agregar enlaces de paginación usando HATEOAS

HATEOAS menciona agregar enlaces de paginación específicamente en su documentación. Para crear esto, creará un recurso llamado PaginatedReprisentationCreemos eso usando ProgrammerController.

ssrc/KnpU/CodeBattle/Controller/Api/ProgrammerController.php

 public function listAction()
    {
        $programmers = $this->getProgrammerRepository()->findAll();
        $collection = new CollectionRepresentation(
            $programmers,
            'programmers',
            'programmers'
        );
    }

Ahora hagamos eso escalable creando la siguiente instancia de PaginatedRepresentationusing $paginated.

use Hateoas\Representation\PaginatedRepresentation;
public function listAction() { $collection = new CollectionRepresentation( $programmers, 'programmers', 'programmers' ); $paginated = new PaginatedRepresentation( ); }

Normalmente, usarías una biblioteca para crear paginación. Como solo estamos creando una maqueta, estamos codificando algunas de las variables por el bien del argumento. Configuraremos la página para que permanezca siempre en 1 y el límite en 5. Esto también le permite calcular el número total de páginas. En este ejemplo, tenemos 12 programadores, divididos entre 5 y luego redondeados usando la función ceil.

public function listAction()
{ $limit = 5; $page = 1; $numberOfPages = (int) ceil(count($programmers) / $limit); $paginated = new PaginatedRepresentation( $collection, 'api_programmers_list', array(), $page, $limit, $numberOfPages ); return $response;

Ahora que hemos creado el recurso $ paginated podemos pasarlo al createAPIResource.

public function listAction()
{ $paginated = new PaginatedRepresentation( $collection, 'api_programmers_list', array(), $page, $limit, $numberOfPages ); $response = $this->createApiResponse($paginated, 200, 'json'); return $response; }

Ahora intente la prueba nuevamente.

php vendor/bin/behat features/api.programmer.feature:96

Esto todavía devuelve un error, pero estamos llegando a alguna parte. Detecta Programmer7pero Programmer2Programmer11todavía están presentes, ya que todos los programadores todavía están incluidos en la lista.

Ahora convierta estos en paginación real . Dado que pagelimitse están utilizando como parámetros de consulta, sigamos usándolos. Cuando necesite solicitar información, simplemente agregará un REQUEST $requestargumento al controlador.

   public function listAction(Request $request)
    {
    }

Ahora también agregará parámetros de consulta a la lista. Puede agregar $request->query->get('page')y el segundo argumento es el valor predeterminado si no se PAGEenvía por algún motivo. Esto también se LIMITaplica. Esto puede ser configurado por el usuario final, pero vamos a establecer 5 por defecto.

public function listAction(Request $request)
{ $limit = $request->query->get('limit', 5); $page = $request->query->get('page', 1); }

La mayoría de las consultas de paginación de API utilizarán alguna combinación de límites y compensaciones para reducir los resultados de la búsqueda. Dado que este ejemplo solo tiene 12 entradas, solo devolveremos todas las entradas y usaremos matrices PHP para entregar los resultados deseados.

Si tuviera que implementar esto en una API real, podría usar una biblioteca como Pagerfanta , que facilita la paginación y presenta adaptadores para motores de búsqueda.

Para este ejemplo, seguiremos usando la lógica manual y luego usaremos el comando array_slicepara subdividir los resultados.

   public function listAction(Request $request)
    {
        $limit = $request->query->get('limit', 5);
        $page = $request->query->get('page', 1);
        // my manual, silly pagination logic. Use a real library
        $offset = ($page - 1) * $limit;
        $numberOfPages = (int) ceil(count($programmers) / $limit);
        $collection = new CollectionRepresentation(
            // my manual, silly pagination logic. Use a real library
            array_slice($programmers, $offset, $limit),
        );
    }

Esto devuelve todos los resultados y luego devuelve los resultados deseados usando la array_slicefunción. Continúe e intente la prueba nuevamente:

php vendor/bin/behat features/api.programmer.feature:96

¡Éxito! Debería tener una API paginada que funcione en este punto.

Paginación de API: resumen y mejores prácticas

A medida que las API continúan involucrándose más y desarrollándose, la paginación de API solo se volverá más esencial. Como hemos mostrado, algunas API pueden devolver millones de resultados de búsqueda, si no más. Esto puede ralentizar el tiempo de respuesta de una llamada a la API a un rastreo.

Para resumir, hemos analizado qué es la paginación de API, así como algunos de los métodos de implementación más comunes. Estos incluyen la paginación de desplazamiento, la paginación de conjuntos de claves y la paginación de búsqueda. También discutimos algunos de los méritos y deficiencias de cada enfoque para ayudarlo a decidir cuál es el mejor para sus diseños de API.

La paginación compensada es la más fácil de implementar. Sin embargo, la paginación de compensación tiene sus limitaciones, como las limitaciones de los valores de compensación grandes y las inexactitudes que provienen de la deriva de la página. La paginación del conjunto de claves es un poco más sólida, pero también está estrechamente vinculada a los resultados de la página. La paginación de búsqueda es aún más sólida, ya que devuelve un orden coherente incluso cuando se agregan nuevos elementos a la tabla. Sin embargo, la búsqueda de paginación puede ser más complicada de implementar para el backend. También puede descartarse cuando se eliminan elementos de la base de datos.

La paginación de la API es esencial si se trata de una gran cantidad de datos y puntos finales. La paginación implica automáticamente agregar orden al resultado de la consulta. El ID de objeto es el resultado predeterminado, pero los resultados también se pueden ordenar de otras formas.

Finalmente, concluimos con algunos ejemplos de código para darle algunas ideas prácticas sobre cómo escribir su propio código de paginación API.

La paginación de API es un tema muy amplio. Hay mucho que decir al respecto. Puede obtener más información al respecto leyendo este artículo en profundidad de Moesif o este de Dzone .

Publicar un comentario

0 Comentarios