Cache Data with Spring Cache and Couchbase as Backing Store

En esta entrada del blog, descubriremos cómo almacenar datos en caché fácilmente utilizando Caché de primavera y Couchbase como gerente de una tienda de respaldo.

Índice

Introducción
En Caché Abstracción
Implementación de Couchbase
En couchbase-spring-cache y ponerlo en práctica
Conclusión

Introducción

Hubo mucho trabajo relacionado con Primavera ¡últimamente! Hemos estado ocupados trabajando en el Spring Data Couchbase conector para actualizarlo a la generación 2.x del SDK de Java, lo que conlleva una serie de nuevas funciones y mejoras (pero hablaremos de ello más adelante)...

En el camino, nos dimos cuenta de que hay algunas clases en el proyecto que no están realmente relacionadas directamente con Datos de primavera y, como tal, no ha tenido que ceñirse a su ciclo formal de lanzamientos "Release Train": el caché paquete.

Así que empezamos un nuevo y sencillo proyecto de ejemplo de Spring Boot Cache para alojar el 2.x generación del Caché Couchbase Spring aplicación en github (couchbaselabs/couchbase-spring-cache).

Veamos cómo se puede aprovechar para introducir fácilmente el almacenamiento en caché respaldado por Couchbase en un proyecto Spring.

En `Caché` Abstracción

Spring Framework viene con una abstracción ligera de un Caché que los desarrolladores pueden utilizar automáticamente anotando métodos en sus clases (por ejemplo, en una clase @Repositorio estereotipo).

Para hacer uso de los mecanismos de caché de arranque de Spring, basta con anotar los métodos con un puñado de anotaciones relacionadas con la caché:

@Cacheable dejará que se ejecute la primera invocación del método anotado con un conjunto determinado de parámetros de entrada, pero el resultado se almacenará en caché y las invocaciones posteriores (con el mismo conjunto) se servirán de forma transparente desde la caché.
@CachePut siempre invocará el método y almacenará en caché su resultado (a diferencia de @Cacheable no optimiza el flujo de invocación).
@CacheEvict calculará una clave de caché a partir de los parámetros del método anotado y la eliminará de la caché cuando se ejecute el método (por ejemplo, porque invocar este método hace que una entrada sea obsoleta).
@Caching permite reagrupar comportamientos de la anotación anterior en una sola.
@CacheConfig nos permite tener parámetros de caché comunes establecidos en toda una clase.

Implementación de Couchbase

El framework establece el mecanismo abstracto, pero debe elegirse una implementación de respaldo real. Spring viene con algunas de ellas (en memoria Mapa, EhCache, Gemfire...), pero es absolutamente posible definir otras personalizadas, simplemente implantando un Caché y un Gestor de caché y hacerlo visible en el contexto de Spring.

Ese es el objetivo de couchbase-spring-cache.

Cada caché tiene un nombre, y cada valor en la caché tiene una clave de caché. La implementación de Couchbase traducirá eso en una clave de documento que refleje ese...

este es un Caché documento relacionado (por defecto utilizando el prefijo "caché:“)
se refiere a un determinado Caché (añadiendo el NOMBRE_DE_LA_CACHE al prefijo anterior)
almacena un valor de caché concreto en CACHE_KEY (así que en general "cache:CACHE_NAME:CACHE_KEY“).

Por ahora los valores deben ser Serializable y se almacenan como SerializableDocument del 2.x Java SDK, pero en el futuro podrían ofrecerse alternativas de transcodificación, por ejemplo JSON/JsonDocument…

En `couchbase-spring-cache` y ponerlo en práctica

Nota:

En el momento de escribir estas líneas, el proyecto se encuentra en 1.0-SNAPSHOT por lo que no está disponible en Maven Central todavía. Tendrás que compilar manualmente el jar y añadirlo a tu repositorio local de Maven.

Descargar y construir el `couchbase-spring-cache` proyecto

Comienza clonando el proyecto desde github:

git clone https://github.com/couchbaselabs/couchbase-spring-cache.git
cd couchbase-spring-cache

1 2	git clonar https://github.com/couchbaselabs/couchbase-spring-cache.git cd couchbase-primavera-caché

A continuación, compílelo e instálelo localmente utilizando Maven:

mvn clean install

1	mvn limpiar instale

Debería ver un mensaje de éxito indicando la versión creada y dónde se instaló:

[INFO] Installing /path/to/couchbase-spring-cache/target/couchbase-spring-cache-<span style="background-color: yellow">1.0-SNAPSHOT.jar</span>

to <span style="background-color: orange">/path/to/.m2/repository/</span><span style="background-color: lightgrey">com/couchbase/client/couchbase-spring-cache/1.0-SNAPSHOT/couchbase-spring-cache-1.0-SNAPSHOT.jar</span>

[INFO] Installing /path/to/couchbase-spring-cache/pom.xml

to /path/to/.m2/repository/com/couchbase/client/couchbase-spring-cache/1.0-SNAPSHOT/couchbase-spring-cache-1.0-SNAPSHOT.pom

[INFO] ------------------------------------------------------------------------

[INFO] BUILD SUCCESS

[INFO] ------------------------------------------------------------------------

[INFO] Instalación de /ruta/a/couchbase-primavera-caché/objetivo/couchbase-primavera-caché-1.0-SNAPSHOT.tarro

a /ruta/a/.m2/repositorio/com/couchbase/cliente/couchbase-primavera-caché/1.0-SNAPSHOT/couchbase-primavera-caché-1.0-SNAPSHOT.tarro

[INFO] Instalación de /ruta/a/couchbase-primavera-caché/pom.xml

a /ruta/a/.m2/repositorio/com/couchbase/cliente/couchbase-primavera-caché/1.0-SNAPSHOT/couchbase-primavera-caché-1.0-SNAPSHOT.pom

[INFO] ------------------------------------------------------------------------

[INFO] CONSTRUIR ÉXITO

[INFO] ------------------------------------------------------------------------

Iniciar un proyecto tutorial

Construiremos un proyecto de ejemplo de Spring Cache utilizando Maven y Spring Boot como base.
Comience por crear la siguiente estructura de directorios para el proyecto en un directorio raíz de su elección (utilizaremos cbcache aquí):

 cbcache
    └── src
        └── main
            └── java
                └── com
                    └── couchbase
                        └── demo

cbcache

└── src

└── principal

└── java

└── com

└── couchbase

└── demo

Por ejemplo, utilice el siguiente comando:

mkdir -p cbcache/src/main/java/com/couchbase/demo/
cd cbcache

1 2	mkdir -p cbcache/src/principal/java/com/couchbase/demo/ cd cbcache

A continuación, inicie el POM en la raíz de cbcache en pom.xml con el siguiente contenido:

<!--?xml version="1.0" encoding="UTF-8"?-->

    4.0.0

    com.couchbase.demo
    cbcache
    0.1.0

    
        org.springframework.boot
        spring-boot-starter-parent
        1.3.0.RELEASE
    

    
        1.8
    

    
        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework
            spring-context
        
        <!--the couchbase cache artifact we built earlier-->
        
            com.couchbase.client
            couchbase-spring-cache
            1.0-SNAPSHOT
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin

4.0.0

com.couchbase.demo

cbcache

0.1.0

org.springframework.arranque

primavera-arranque-arranque-padre

1.3.0.RELEASE

1.8

org.springframework.arranque

primavera-arranque-arranque

org.springframework

primavera-contexto

com.couchbase.cliente

couchbase-primavera-caché

1.0-SNAPSHOT

org.springframework.arranque

primavera-arranque-maven-plugin

Añadir entidad de gestión de libros y repositorio

Utilizaremos el ejemplo de un Reserve (tal y como se encuentra en el repositorio "COMENZAR - Almacenamiento de datos en caché con Spring"guía oficial de Spring.io).

Crear el Reserve clase de entidad en src/main/java/com/couchbase/demo/Libro.java:

import java.io.Serializable;

public class Book implements Serializable {

    private static final long serialVersionUID = -7674163614777124381L;

    private String isbn;
    private String title;

    public Book(String isbn, String title) {
        this.isbn = isbn;
        this.title = title;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        return "Book{" + "isbn='" + isbn + ''' + ", title='" + title + ''' + '}';
    }
}

importar java.io.Serializable;

público clase Reserve implementa Serializable {

privado estático final largo serialVersionUID = -7674163614777124381L;

privado Cadena isbn;

privado Cadena título;

público Reserve(Cadena isbn, Cadena título) {

este.isbn = isbn;

este.título = título;

}

público Cadena getIsbn() {

devolver isbn;

}

público void setIsbn(Cadena isbn) {

este.isbn = isbn;

}

público Cadena getTitle() {

devolver título;

}

público void setTitle(Cadena título) {

este.título = título;

}

@Anular

público Cadena toString() {

devolver "Libro{" + "isbn=" + isbn + ''' + ", title='" + título + ''' + '}';

}

Tenga en cuenta la Reserve clase es SerializableEsto es importante por ahora para el almacenamiento de Couchbase.

Crear una interfaz de repositorio simple y una implementación ingenua que simule un retraso:

en src/main/java/com/couchbase/demo/BookRepository.java:

package com.couchbase.demo;

public interface BookRepository {

    Book getByIsbn(String isbn);

}

paquete com.couchbase.demo;

público interfaz BookRepository {

Reserve getByIsbn(Cadena isbn);

}

en src/main/java/com/couchbase/demo/SimpleBookRepository.java:

package com.couchbase.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.stereotype.Component;

@Component
public class SimpleBookRepository implements BookRepository {

    private static final Logger log = LoggerFactory.getLogger(SimpleBookRepository.class);

    @Override
    public Book getByIsbn(String isbn) {
        simulateSlowService();
        Book result = new Book(isbn, "Some book");
        log.info("Actual fetch of " + isbn);
        return result;
    }

    // Don't do this at home
    private void simulateSlowService() {
        try {
            long time = 5000L;
            Thread.sleep(time);
        } catch (InterruptedException e) {
            throw new IllegalStateException(e);
        }
    }

}

paquete com.couchbase.demo;

importar org.slf4j.Registrador;

importar org.slf4j.LoggerFactory;

importar org.springframework.estereotipo.Componente;

@Componente

público clase SimpleBookRepository implementa BookRepository {

privado estático final Registrador registro = LoggerFactory.getLogger(SimpleBookRepository.clase);

@Anular

público Reserve getByIsbn(Cadena isbn) {

simulateSlowService();

Reserve resultado = nuevo Reserve(isbn, "Algún libro");

registro.información("Actual fetch of" + isbn);

devolver resultado;

}

// No hagas esto en casa

privado void simulateSlowService() {

pruebe {

largo tiempo = 5000L;

Hilo.dormir(tiempo);

} captura (InterruptedException e) {

tirar nuevo IllegalStateException(e);

}

Principal `Spring Boot` Aplicación

Por último, cree una Aplicación que utilice el repositorio en src/main/java/com/couchbase/demo/Application.java:

package com.couchbase.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;

@SpringBootApplication
public class Application {

    private static final Logger log = LoggerFactory.getLogger(Application.class);

    @Component
    static class Runner implements CommandLineRunner {
        @Autowired
        private BookRepository bookRepository;

        @Override
        public void run(String... args) throws Exception {
            long start;
            log.info(".... Fetching books");
            fetchAndLog("isbn-1234");
            fetchAndLog("isbn-1234");
            fetchAndLog("isbn-1234");
            fetchAndLog("isbn-8888");
            fetchAndLog("isbn-8888");
        }

        private void fetchAndLog(String isbn) {
            long start = System.currentTimeMillis();
            Book book = bookRepository.getByIsbn(isbn);
            long time = System.currentTimeMillis() - start;
            log.info(isbn + " --&gt; " + book + " in " + time + "ms");
        }
    }

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

paquete com.couchbase.demo;

importar org.slf4j.Registrador;

importar org.slf4j.LoggerFactory;

importar org.springframework.judías.fábrica.anotación.Autowired;

importar org.springframework.arranque.CommandLineRunner;

importar org.springframework.arranque.SpringApplication;

importar org.springframework.arranque.autoconfigure.SpringBootApplication;

importar org.springframework.estereotipo.Componente;

@SpringBootApplication

público clase Aplicación {

privado estático final Registrador registro = LoggerFactory.getLogger(Aplicación.clase);

@Componente

estático clase Corredor implementa CommandLineRunner {

@Autowired

privado BookRepository repositorio de libros;

@Anular

público void ejecute(Cadena... args) lanza Excepción {

largo iniciar;

registro.información(".... Búsqueda de libros");

fetchAndLog("isbn-1234");

fetchAndLog("isbn-8888");

}

privado void fetchAndLog(Cadena isbn) {

largo iniciar = Sistema.currentTimeMillis();

Reserve Libro = repositorio de libros.getByIsbn(isbn);

largo tiempo = Sistema.currentTimeMillis() - iniciar;

registro.información(isbn + " --> " + Libro + " en " + tiempo + "ms");

}

público estático void principal(Cadena[] args) {

SpringApplication.ejecute(Aplicación.clase, args);

}

Si ejecuta la función Aplicación's principal en su IDE (o si invoca "mvn spring-boot:ejecutar" desde la línea de comandos), observará que todas las llamadas son, en efecto, bastante lentas:

[...] .... Fetching books
[...] Actual fetch of isbn-1234
[...] isbn-1234 --&gt; Book{isbn='isbn-1234', title='Some book'} in 5001ms
[...] Actual fetch of isbn-1234
[...] isbn-1234 --&gt; Book{isbn='isbn-1234', title='Some book'} in 5004ms
[...] Actual fetch of isbn-1234
[...] isbn-1234 --&gt; Book{isbn='isbn-1234', title='Some book'} in 5004ms
[...] Actual fetch of isbn-8888
[...] isbn-8888 --&gt; Book{isbn='isbn-8888', title='Some book'} in 5003ms
[...] Actual fetch of isbn-8888
[...] isbn-8888 --&gt; Book{isbn='isbn-8888', title='Some book'} in 5003ms

[...] .... Buscar en libros

[...] Actual buscar de isbn-1234

[...] isbn-1234 --> Reserve{isbn=isbn-1234, título='Menudo libro'} en 5001ms

[...] Actual buscar de isbn-1234

[...] isbn-1234 --> Reserve{isbn=isbn-1234, título='Menudo libro'} en 5004ms

[...] Actual buscar de isbn-1234

[...] isbn-1234 --> Reserve{isbn=isbn-1234, título='Menudo libro'} en 5004ms

[...] Actual buscar de isbn-8888

[...] isbn-8888 --> Reserve{isbn=isbn-8888, título='Menudo libro'} en 5003ms

[...] Actual buscar de isbn-8888

[...] isbn-8888 --> Reserve{isbn=isbn-8888, título='Menudo libro'} en 5003ms

Añadir capacidades de almacenamiento en caché de Spring Boot

Para activar el almacenamiento en caché, debe seguir algunos pasos: en primer lugar, debe ofrecer a Spring un archivo Gestor de caché @Bean…

Dado que vamos a utilizar el CouchbaseCacheManager (por supuesto), necesitaremos conectarnos a un Grupo y utilizar un Cubo (la unidad de almacenamiento donde couchbase almacenará los documentos de la caché).
Así que el CouchbaseCacheManager necesita una correspondencia entre Caché y los correspondientes Cubo a utilizar, pasado como Mapa.

En src/main/java/com/couchbase/demo/Application.javaañade las siguientes declaraciones de bean:

  public static final String BOOK_CACHE = "books";

  @Bean(destroyMethod = "disconnect")
  public Cluster cluster() {
      //this connects to a Couchbase instance running on localhost
      return CouchbaseCluster.create();
  }

  @Bean(destroyMethod = "close")
  public Bucket bucket() {
      //this will be the bucket where every cache-related data will be stored
      //note that the bucket "default" must exist
      return cluster().openBucket("default", "");
  }

  @Bean
  public CacheManager cacheManager() {
      Map&lt;String, Bucket&gt; mapping = new HashMap&lt;String, Bucket&gt;();
      //we'll make this cache manager recognize a single cache named "books"
      mapping.put(BOOK_CACHE, bucket());
      return new CouchbaseCacheManager(mapping);
  }

público estático final Cadena BOOK_CACHE = "libros";

@Judía(destroyMethod = "desconectar")

público Grupo grupo() {

//esto conecta con una instancia de Couchbase que se ejecuta en localhost

devolver CouchbaseCluster.crear();

}

@Judía(destroyMethod = "cerrar")

público Cubo cubo() {

//este será el cubo donde se almacenarán todos los datos relacionados con la caché

//note that the bucket "default" must exist

devolver grupo().openBucket("por defecto", "");

}

@Judía

público Gestor de caché cacheManager() {

Mapa<Cadena, Cubo> cartografía = nuevo HashMap<Cadena, Cubo>();

//haremos que este gestor de caché reconozca una única caché llamada "libros"

cartografía.poner(BOOK_CACHE, cubo());

devolver nuevo CouchbaseCacheManager(cartografía);

}

A continuación, desea activar el escaneo de anotaciones relacionadas con la caché y el proxy asociado colocando la etiqueta @HabilitarCaché en el Aplicación clase.

Activar caché en `SimpleBookRepository`

Veamos cómo activar el almacenamiento en caché real en nuestro SimpleBookRepository y compruebe cómo se comporta la aplicación después de eso.

Para hacer getByIsbn automáticamente en caché en la primera invocación y servir las invocaciones posteriores con datos de la caché, simplemente anótelo así:

    @Override
    @Cacheable(Application.BOOK_CACHE) //using the name of the cache we declared earlier
    public Book getByIsbn(String isbn) {
        simulateSlowService();
        Book result = new Book(isbn, "Some book");
        log.info("Actual fetch of " + isbn);
        return result;
    }

@Anular

@Almacenable en caché(Aplicación.BOOK_CACHE) //utilizando el nombre de la caché que declaramos anteriormente

público Reserve getByIsbn(Cadena isbn) {

simulateSlowService();

Reserve resultado = nuevo Reserve(isbn, "Algún libro");

registro.información("Actual fetch of" + isbn);

devolver resultado;

}

Vamos a ejecutar la aplicación de nuevo y ver cómo se comporta ahora:

[...] .... Fetching books
[...] Actual fetch of isbn-1234
[...] isbn-1234 --&gt; Book{isbn='isbn-1234', title='Some book'} in 5022ms
[...] isbn-1234 --&gt; Book{isbn='isbn-1234', title='Some book'} in 3ms
[...] isbn-1234 --&gt; Book{isbn='isbn-1234', title='Some book'} in 1ms
[...] Actual fetch of isbn-8888
[...] isbn-8888 --&gt; Book{isbn='isbn-8888', title='Some book'} in 5007ms
[...] isbn-8888 --&gt; Book{isbn='isbn-8888', title='Some book'} in 1ms

[...] .... Buscar en libros

[...] Actual buscar de isbn-1234

[...] isbn-1234 --> Reserve{isbn=isbn-1234, título='Menudo libro'} en 5022ms

[...] isbn-1234 --> Reserve{isbn=isbn-1234, título='Menudo libro'} en 3ms

[...] isbn-1234 --> Reserve{isbn=isbn-1234, título='Menudo libro'} en 1ms

[...] Actual buscar de isbn-8888

[...] isbn-8888 --> Reserve{isbn=isbn-8888, título='Menudo libro'} en 5007ms

[...] isbn-8888 --> Reserve{isbn=isbn-8888, título='Menudo libro'} en 1ms

¡Vaya! Esto es mucho mejor para las invocaciones más allá de la primera, parece que efectivamente se almacena en caché :-)

Ver los datos en Couchbase

Echemos un vistazo rápido a la consola web para verificar que estos magníficos tiempos pueden atribuirse a Couchbase:

abra una nueva pestaña en su navegador y navegue hasta http://localhost:8091.
conectarse a la consola web.
ir a la Cubos de datos y haga clic en Documentos para el cubo que haya elegido utilizar ("por defecto").

Lo que ve en esta pantalla (enlace rápido para los perezosos) debería ser similar a esto:

Podemos ver que ambos libros se almacenaron en caché en couchbase, utilizando el método cache:CACHE_NAME:CACHE_KEY para los ID de los documentos.

Conclusión

Couchbase le facilita el almacenamiento en caché.

Hay mucho más que Caché de primavera puede hacer por usted (por ejemplo, elegir cómo crear la clave de caché, caché condicional, desalojo de caché, etc...), y hay especificidades de couchbase-spring-cache (por ejemplo, para la limpieza de la caché puede elegir entre utilizar una vista que sólo eliminará el documento relevante o, si su cubo está dedicado a una única caché, utilizar la función descarga mecanismo...).

Espero que este tutorial introductorio te haya abierto el apetito sobre la facilidad de uso de la memoria caché con Caché de primavera y Couchbase!

Los próximos pasos serán probablemente introducir formatos de almacenamiento alternativos (como JSON) y ofrecer el artefacto en Maven Central o en un repositorio Maven similar de acceso público (Bintray ¿alguien?)...

Esté atento a las próximas noticias relacionadas con la primavera.

Mientras tanto, feliz codificación :)

Simon Basle, Ingeniero de Software, Pivotal

Comparte este artículo

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Copia de seguridad de Spring Cache con Couchbase

Introducción

En `Caché` Abstracción

Implementación de Couchbase

En `couchbase-spring-cache` y ponerlo en práctica

Descargar y construir el `couchbase-spring-cache` proyecto

Iniciar un proyecto tutorial

Añadir entidad de gestión de libros y repositorio

Principal `Spring Boot` Aplicación

Añadir capacidades de almacenamiento en caché de Spring Boot

Activar caché en `SimpleBookRepository`

Ver los datos en Couchbase

Conclusión

Recibe actualizaciones del blog de Couchbase en tu bandeja de entrada

Autor

Publicado por Simon Basle, Ingeniero de Software, Pivotal

Deja un comentario Cancelar respuesta

¿Listo para empezar con Couchbase Capella?

Empezar a construir

Utilizar Capella gratis

Póngase en contacto

Platform

Self-Managed

Services

Capabilities

Why Couchbase?

Migrate to Capella

By Use Case

By Industry

By Application Need

Popular Docs

By Developer Role

Quickstart

Resource Center

About

Partnerships

Our Services

Partners: Register a Deal

Ready to register a deal with Couchbase?

Marriott

Copia de seguridad de Spring Cache con Couchbase

Introducción

En Caché Abstracción

Implementación de Couchbase

En couchbase-spring-cache y ponerlo en práctica

Descargar y construir el couchbase-spring-cache proyecto

Iniciar un proyecto tutorial

Añadir entidad de gestión de libros y repositorio

Principal Spring Boot Aplicación

Añadir capacidades de almacenamiento en caché de Spring Boot

Activar caché en SimpleBookRepository

Ver los datos en Couchbase

Conclusión

Recibe actualizaciones del blog de Couchbase en tu bandeja de entrada

Autor

Publicado por Simon Basle, Ingeniero de Software, Pivotal

Deja un comentario Cancelar respuesta

¿Listo para empezar con Couchbase Capella?

Empezar a construir

Utilizar Capella gratis

Póngase en contacto

En `Caché` Abstracción

En `couchbase-spring-cache` y ponerlo en práctica

Descargar y construir el `couchbase-spring-cache` proyecto

Principal `Spring Boot` Aplicación

Activar caché en `SimpleBookRepository`