JCache: Inicializar caché
Después de conectar exitosamente NCache en su aplicación JCache, se requiere una instancia de caché para realizar operaciones de caché. Las aplicaciones Java también pueden interactuar con NCache utilizando el proveedor de API JCache empaquetado como parte de NCache. El proveedor de API de JCache proporciona un método conveniente para inicializar la instancia de caché.
Requisitos previos para las operaciones CRUD de JCache
- Para usar JCache con NCache Professional, Reemplace la
ncache-client
ncache-professional-client
en su pom.xml.
<dependency>
<groupId>com.alachisoft.ncache</groupId>
<artifactId>ncache-client</artifactId>
<version>x.x.x</version>
</dependency>
- Incluya los siguientes paquetes y sus bibliotecas en su aplicación desde el NCache directorio de instalación.
import javax.cache.CacheManager
import javax.cache.Caching;
import javax.cache.spi.CachingProvider;
Asegúrese de que los datos estén serializados o registrados con el NCache formato de serialización.
Asegúrese de que el caché se esté ejecutando.
Inicializar caché
El siguiente método para obtener una instancia de caché en Java es utilizar el getCache
método del JCache CacheManager proporcionado por NCache. Puede obtener una instancia de un caché previamente configurado usando su nombre (identificador único) como argumento para el getCache
método.
//Create an instance of JCache's caching provider to get JCacheManager's instance by NCache.
CachingProvider provider = Caching.getCachingProvider();
CacheManager manager = provider.getCacheManager();
//Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
Obtención NCache Instancia de caché de API
NCacheLa API proporciona funciones de almacenamiento en caché comparativamente avanzadas que incluyen Cerraduras, Grupos, Mensajería de publicación/suscripción, Etiquetasy similar a SQL capacidades de consulta, que pueden ser cruciales para escenarios complejos, distribuidos y de alta carga. Para acceder a todos NCachefunciones a través de JCache, puede utilizar el unwrap
método proporcionado por NCache. Este método le permite obtener una instancia real de NCache, que luego se puede utilizar para acceder y utilizar todos los NCachecapacidades de.
Este ejemplo crea una instancia del proveedor de almacenamiento en caché JCache que obtiene una instancia de JCache Manager y luego desencapsula el NCache instancia de él y obtiene un caché del administrador a través de su nombre.
//Create an instance of JCache's caching provider to get JCacheManager's instance by NCache.
CachingProvider provider = Caching.getCachingProvider();
CacheManager manager = provider.getCacheManager();
//Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
// Unwrapping NCache's cache instance from JCache's cache instance.
com.alachisoft.ncache.client.Cache cache = (com.alachisoft.ncache.client.Cache) jCache.unwrap(com.alachisoft.ncache.client.Cache.class);
Inicialice múltiples cachés en una sola aplicación
Para inicializar múltiples cachés en una sola aplicación, es necesario que los cachés estén previamente configurados y en ejecución.
//Create an instance of JCache's caching provider to get JCacheManager's instance by NCache.
CachingProvider provider = Caching.getCachingProvider();
CacheManager manager = provider.getCacheManager();
//Get a cache from manager via its string name.
javax.cache.Cache demoCache = manager.getCache("demoCache");
javax.cache.Cache productCache = manager.getCache("productCache");
Agregar/Actualizar datos en caché
Después de una inicialización exitosa y de obtener un identificador de caché, puede realizar una put
operación. Es una operación básica proporcionada por JCache y se puede utilizar para agregar/actualizar datos al caché mediante múltiples llamadas API.
Adición de objetos a la memoria caché
En el siguiente ejemplo, se crea un objeto de una clase personalizada y se agrega al caché. Este elemento tiene todas las propiedades proporcionadas en el código siguiente y se agrega al caché usando el put
método.
// Ensure that Cache is already initialized and the item exists.
Product product = new Product();
product.setProductID(1001);
product.setProductName("Chai");
String key = "Product:" + product.getProductID();
// Add data in cache with the values
jCache.put(key, product);
Actualizar datos en caché
En el siguiente ejemplo, un objeto de una clase personalizada se actualiza en la memoria caché. El replace
El método sobrescribe el valor ya existente del objeto.
Product product = new Product();
product.setProductID(1001);
product.setProductName("Chai");
product.setUnitsInStock(5); // updated units.
String key = "Product:" + product.getProductID();
// Replace the item in the cache with updated item.
jCache.replace(key, product);
Agregar y actualizar elementos masivos en caché
Puede agregar y actualizar una colección completa de elementos en el caché usando el putAll
método. Este método devuelve un HashMap de todas las claves que no se agregaron junto con la excepción.
Product product1 = new Product("1001", "Chai");
String key1 = "Product:" + product1.getProductID();
Product product2 = new Product("1002", "Coffee");
String key2 = "Product:" + product2.getProductID();
// Data to add in cache
HashMap dataMap = new HashMap();
dataMap.put(key1, product1);
dataMap.put(key2, product2);
// Get instance of JCacheManager
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
// Add/Update all keys in the cache
jCache.putAll(dataMap);
Recuperar de caché
Usos de JCache get
Método para recuperar una entrada específica del caché a través de la clave.
Recuperar un solo elemento del caché
En el siguiente ejemplo, utilizamos el valor predeterminado get
método para recuperar un objeto preexistente, "Producto: 1001". Este elemento ya existe en la caché. El get
El método devuelve un objeto que debe convertirse en consecuencia. Si no existe una clave coincidente en el caché, se null
se devuelve el valor.
// Get instance of JCacheManager.
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
// Key to get
String key = "Product:1001";
//Get specified item
Product product = (Product) jCache.get(key);
if (product != null) {
// business logic
}
Recuperar datos masivos de caché
Para recuperar una colección del caché, utilice el getAll
método. Este método devuelve una colección de elementos como HashMap.
// Get instance of JCacheManager.
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
HashSet keysToGet = new HashSet();
keysToGet.add("Product:1001");
keysToGet.add("Product:1002");
Map productsMap = jCache.getAll(keysToGet);
if (!productsMap.isEmpty())
{
for (Iterator iter = productsMap.values().iterator(); iter.hasNext();)
{
Product product = (Product) iter.next();
//utilize product object accordingly.
}
}
Quitar datos de la caché
JCache proporciona remove
Método para eliminar la asignación de una clave existente del caché.
Uso del método de eliminación
El método remove en la API JCache elimina la asignación asociada con una clave especificada del caché, si existe. El método devuelve verdadero (si el caché contiene la clave y la eliminación fue exitosa) o falso (si no hay ninguna asignación para la clave). El siguiente ejemplo elimina las asignaciones de claves para Producto clase.
// Get instance of JCacheManager.
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
// Key to remove.
String key = "Product:1001";
// False is returned if key does not exist in cache.
boolean result = jCache.remove(key);
if (result != true) {
//Deleted.
}
else {
//Failed.
}
Eliminar datos masivos
El siguiente fragmento de código elimina los elementos de forma masiva del caché a través del removeAll
método. El código obtiene una instancia de JCache Manager, obtiene el caché requerido del administrador y define las claves contra las cuales se eliminarán los datos.
// Get instance of JCacheManager
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
// Keys to remove
HashSet set = new HashSet();
set.add("Product:1001");
set.add("Product:1002");
// Removing all keys
jCache.removeAll(set);
Borrar la caché
Para borrar el caché por completo (en segundo plano), debe llamar al clear
método.
// Get instance of JCacheManager.
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
// Clear the Cache.
jCache.clear();
Vea también
Notificaciones de eventos en caché
Almacenamiento en caché de hibernación
NCache Módulo de sesión de Java