Arranque de primavera – EhCaching

EhCache es un caché de código abierto y basado en Java. Se utiliza para aumentar el rendimiento. Su versión actual es la 3. EhCache proporciona la implementación del administrador de caché JSR-107. Las características de EhCache se dan a continuación:

• Es rápido, ligero, flexible y escalable.
• Nos permite realizar Serializable y Object
• También ofrece políticas de desalojo de caché como LRU, LFU, FIFO,

Los niveles de almacenamiento de EhCaching son los siguientes:

• Almacén en montón: la memoria de montón de Java se utiliza para almacenar entradas de caché.
• Almacén fuera del montón: Almacena entradas de caché en la memoria primaria (RAM).
• Disk Store: utiliza un disco para almacenar entradas de caché.
• Almacén agrupado: el servidor remoto se utiliza para almacenar entradas de caché.

Patrones de uso de EhCache:

Los patrones de acceso utilizados por EhCache se dan a continuación:

• Caché aparte: se puede usar para leer y actualizar operaciones de datos hacia y desde el almacén de datos.
• Cache-as-SoR (sistema de registro): este patrón delega las actividades de lectura y escritura de SOR en el caché para que el código de la aplicación quede absuelto de esta responsabilidad.
• Lectura completa: este patrón copia el patrón de caché aparte mientras lee datos del caché.
• Escritura simultánea: este patrón copia el patrón de caché aparte mientras escribe datos en el caché.
• Write-behind: es una estrategia de almacenamiento en caché en la que la capa de caché se conecta a la base de datos de respaldo.

Puntos para recordar al usar EhCaching:

1. Necesitamos agregar las siguientes dependencias en pom.xml.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.6.1</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
    <version>2.6.1</version></dependency>
<dependency>
    <groupId>javax.cache</groupId>
    <artifactId>cache-api</artifactId>
    <version>1.1.1</version>
</dependency>
<dependency>
    <groupId>org.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>3.8.1</version>
</dependency>

2. A continuación, debemos abrir el archivo application.properties y configurar EhCache utilizando la siguiente propiedad.

# configuring ehcache.xml  
spring.cache.jcache.config=classpath:ehcache.xml 

3. La anotación @EnableCaching activa un posprocesador que inspecciona cada bean Spring en busca de métodos de anotaciones de almacenamiento en caché que sean públicos. Si se encuentra una anotación de este tipo, se creará automáticamente un proxy para interceptar la llamada al método y, por lo tanto, manejar el comportamiento de almacenamiento en caché en consecuencia. Podemos usar la anotación @EnableCaching para habilitar EhCaching de la siguiente manera:

@Configuration
// used for enabling  caching
@EnableCaching
public class CacheConfig {
}

4.Esta anotación a nivel de método le permite a Spring Boot saber que el valor devuelto por el método anotado se puede almacenar en caché. Siempre que se llame a un método marcado con este @Cacheable, se aplicará el comportamiento de almacenamiento en caché. En particular, Spring Boot verificará si el método ya se invocó para los argumentos dados. Esto implica buscar una clave que se genera utilizando los parámetros del método de forma predeterminada. Si no se encuentra ningún valor en la memoria caché relacionado con el método para la clave calculada, el método de destino se ejecutará normalmente. De lo contrario, el valor almacenado en caché se devolverá inmediatamente. @Cacheable viene con muchos parámetros, pero la manera fácil de usarlo es anotar un método con la anotación y parametrizarlo con el nombre del caché donde se almacenarán los resultados.

5. Necesitamos crear un archivo hcache.xml que contenga la información relacionada con el caché, como el nombre del caché, el número del elemento en la memoria y el tiempo de vida de los datos en el caché, etc.

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:noNamespaceSchemaLocation="ehcache.xsd" updateCheck="true"
    monitoring="autodetect" dynamicConfig="true">
    <diskStore path="D:\\cache" />
  
    <cache name="cache1" 
        maxEntriesLocalHeap="10000"
        maxEntriesLocalDisk="1000" 
        eternal="false" 
        diskSpoolBufferSizeMB="20"
        timeToIdleSeconds="300" timeToLiveSeconds="600"
        memoryStoreEvictionPolicy="LFU" 
        transactionalMode="off">
        <persistence strategy="localTempSwap" />
    </cache>
  
</ehcache>

Proyecto de ejemplo

Un ejemplo de Spring Boot EhCaching es el siguiente.

Clase principal:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.ComponentScan;
  
@SpringBootApplication
@ComponentScan("com.codippa")
public class CachingApplication {
  public static void main(String[] args) {
    SpringApplication.run(CachingApplication.class, args);
  }
}

Publicar clase:

public class Post {
  
    private Integer postId;
  
    private String title;
  
    public Post(Integer postId, String title)
    {
        this.postId = postId;
        this.title = title;
    }
  
    public Integer getPostId() { return postId; }
  
    public void setPostId(Integer postId)
    {
        this.postId = postId;
    }
  
    public String getTitle() { return title; }
  
    public void setTitle(String title)
    {
        this.title = title;
    }
}

Clase de controlador:

Esta clase mapea la URL con el método apropiado.

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.beans.factory.annotation.Autowired;
  
@Controller
public class PostController {
  @Autowired
  PostService service; 
    
  @GetMapping("/posts/{id}")
  public @ResponseBody Post findById(@PathVariable("id") Integer postId) {
    return service.findById(postId);
  }
    
  @PostMapping("/updatepost")
  public void updatePost(Post post) {
    service.updatePost(post);
  }
    
  @DeleteMapping("/posts/{id}")
  public void deleteById(@PathVariable("id") Integer postId) {
     service.deleteById(postId);
  }
    
}

Clase de servicio:

Las dos anotaciones de almacenamiento en caché utilizadas en el código se explican a continuación:

• @CachePut : los objetos almacenados en caché son copias de los objetos originales dentro de la base de datos y deben ser idénticos a ellos. Cuando el objeto original cambia, el objeto en caché debe actualizarse. Esto se hace usando la anotación @CachePut y se aplica sobre el método que realiza la operación de actualización.
• @CacheEvict : esta anotación se usa para indicar una operación remota de los datos del caché y se aplica al método que elimina un objeto de la base de datos.

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
  
@Service
public class PostService {
   @Cacheable("posts")
   public Post findById(Integer postId) { 
      System.out.println("Fetching Post"); 
      return new Post(postId, "Demo post"); 
   } 
     
   @CachePut("posts")
   public void updatePost(Post post) {
      // update post
   }
   @CacheEvict("posts")
   public void deleteById(Integer postId) { 
     // delete post
   }
}

Para probar que el almacenamiento en caché funciona, debemos presionar la URL, http://localhost:8080/posts/1, y mirar la consola. Debería imprimir la siguiente salida:

Producción:

Fetching Post