Implementar el almacenamiento en caché en Android usando operadores RxJava

El caché en su teléfono Android es una colección de pequeños fragmentos de información que sus aplicaciones y navegador web utilizan para mejorar la eficiencia. RxOperator es esencialmente una función que especifica lo observable, así como también cómo y cuándo debe emitir el flujo de datos. En RxJava, hay cientos de operadores para elegir. La mayoría de los operadores actúan sobre un Observable y devuelven otro Observable. Esto le permite aplicar estos operadores en una string, uno tras otro. Cada operador en la string altera el Observable que es el resultado de la actividad del operador anterior.

Primero, debemos comprender por qué el almacenamiento en caché es beneficioso. El almacenamiento en caché es extremadamente beneficioso en los siguientes escenarios:

• Reducción del uso de datos: al almacenar en caché las respuestas de la red, podemos reducir las llamadas de la red.
• Rápido y rápido: obtenga los datos lo más rápido posible

Geek se preguntó acerca de las fuentes de datos

Suponga que tiene algunos datos que desea obtener de la red. Podría simplemente conectarse a la red cada vez que necesite los datos, pero almacenarlos en un disco y en la memoria sería mucho más eficiente.

El siguiente paso lógico es guardar las fuentes a medida que llegan. ¡Nunca notará ningún ahorro si no almacena los resultados de las consultas de red en el disco o las requests de disco en caché en la memoria!

Tipos de almacenamiento en caché

Se puede clasificar en dos tipos

• Memoria caché
• caché de disco

Memoria Caché: Almacena datos en la memoria de la aplicación. Los datos se expulsan si se finaliza la aplicación. Solo aplicable dentro de la misma sesión de aplicación. Debido a que los datos están en la memoria, el caché de memoria es el caché más rápido para acceder a ellos.
Caché de disco: esta función almacena datos en el disco. Los datos se conservan incluso si se termina el programa. Incluso después de reiniciar la aplicación, sigue siendo útil. Como se trata de una operación de E/S, es más lenta que la memoria caché.

Cuando el usuario inicia el programa por primera vez, no habrá datos en la memoria ni datos en la memoria caché del disco. Como resultado, la aplicación deberá realizar una llamada de red para recuperar los datos. Recuperará datos de la red, los almacenará en un disco, los retendrá en la memoria caché y luego devolverá los datos.

Si el usuario vuelve a la misma pantalla durante la misma sesión, los datos se recuperarán de la memoria caché con relativa rapidez. Si el usuario sale y reinicia el programa, obtendrá los datos de la memoria caché del disco, los guardará en la memoria caché y devolverá los datos. Debido a que todos los datos tienen validez, el caché solo devolverá los datos si son válidos en el momento de la recuperación.

Ahora entendemos cómo funciona el almacenamiento en caché, antes de eso, DataSource administrará tres fuentes de datos de la siguiente manera :

1. Memoria
2. Disco
3. La red

Ejemplo 1: un modelo de datos

class GFG {
    
    //Declaring a string
    public String gfg;
}

Ejemplo 2: fuente de datos de memoria 

// Main class
// gfgDataSource
class GFG {

  // Member variables of this class
  private Data gfgData;

  // Method 1
  public Observable<Data> getData() {

    // Making an observable
    return Observable.create(emitter -> {

      if (gfgData != null) {

        // Emitting the data
        emitter.onNext(gfgData);
      }

      emitter.onComplete();
    });
  }

// Method 2
  void cacheInMemory(Data gfgData) {

    // This keyword refers to current object itself
    this.gfgData = gfgData.clone();

    // Cloning the data for cache
    this.gfgData.source = "Spandan Saxena";
  }
}

Ejemplo 3: una fuente de datos de disco

// Main class
// gfgDiskData
class GFG {

  // Member variables of this class
  private Data gfgData;

  // Method 1
  public Observable<Data> getData() {
    return Observable.create(shooter -> {

      if (gfgData != null) {

        // Shooting the data to the disk source for usage.
        shooter.onNext(gfgData);
      }

      shooter.onComplete();
    });
  }

  // Method 2
  // Main driver method
  public void saveToDisk(Data gfgData) {

    // Saving the shooted data
    this.gfgData = gfgData.clone();
    this.gfgData.source = "Spandan Saxena";
  }
}

Implementación:

Ejemplo

// Main class
// gfgDataSpace
class GFG {

    // Member variables of this class

    // A memory data source
    private final MemoryDataSource gfgmemoryData;
    // A disk data source
    private final DiskDataSource gfgDiskData;
    // A network data source
    private final NetworkDataSource gfgNetwork;

    // All these are used as needed.

    // Method 1
    public DataSource(MemoryDataSource gfgmemoryData,
                      DiskDataSource gfgDiskData,
                      NetworkDataSource gfgNetwork)
    {

        // Pushing the reference
        // This keyword refers to current object itself
        this.gfgmemoryData = gfgmemoryData;
        this.gfgDiskData = gfgDiskData;
        this.gfgNetwork = gfgNetwork;
    }

    // Method 2
    public Observable<Data> getDataFromMemory()
    {

        // Getting the data from Mem
        // using the cache
        return gfgmemoryData.getData();
    }

    // Method 3
    public Observable<Data> getDataFromDisk()
    {

        // Getting the data from Disk
        return gfgDiskData.getData().doOnNext(
            data -> gfgmemoryData.cacheInMemory(data));
    }

    // Method 4
    public Observable<Data> getDataFromNetwork()
    {

        // No prior cache available, using network
        // slow way.
        return gfgNetwork.getData().doOnNext(data -> {
            gfgDiskData.saveToDisk(data);
            gfgmemoryData.cacheInMemory(data);
        });
    }
}

En este caso, utilizamos el operador Concat para mantener el orden de los observables, que primero se verifica en la memoria, luego en el disco y finalmente en la red. Como resultado, el operador de Concat nos ayudará a mantener el pedido. Este operador asegura que si recibimos los datos de la memoria, no permite que los otros observables (disco, red) hagan nada y que si recibimos los datos del disco, no deja que el observable de la red haga nada. Como resultado, no hay trabajo duplicado. Aquí es donde entra en juego el operador firstElement.

Conclusión: 

Esto es todo sobre los operadores RxJava, espero que este artículo aclare el tema y cualquier confusión. Usando los operadores RxJava, podemos crear almacenamiento en caché en aplicaciones de Android.