JCache es una API basada en Java que se utiliza para el almacenamiento en memoria caché de objetos Java. Esto también incluye la creación de objetos, la invalidación, la puesta en cola, el acceso compartido y la coherencia entre máquinas virtuales Java (JVM).
NCache es una solución de almacenamiento en caché distribuida muy poderosa y versátil que viene con un amplio conjunto de características y herramientas. NCache proporciona una implementación de la especificación JCache (JSR 107). Con esto, puede aprovechar los beneficios de la gran cantidad de funciones y herramientas proporcionadas por NCache.
Se requiere la creación de una instancia de JCache para que pueda realizar cualquier operación en el caché. En Java, el método getCache () se considera uno de los métodos más convenientes para obtener una instancia de JCache. El siguiente ejemplo de código demuestra cómo puede inicializar un caché usando este método.
/*Create an instance of JCache's caching provider to get JCacheManager's instance */
CachingProvider provider = Caching.getCachingProvider();
CacheManager manager = provider.getCacheManager();
/*Get a cache from manager via its string name.*/
javax.cache.Cache jCache = manager.getCache("myreplicatedcache");Una vez que el caché se haya inicializado con éxito y haya adquirido un identificador de caché, puede realizar muchas operaciones en el caché como la adición de, atractivo, actualizacióny eliminando datos de la caché.
El siguiente ejemplo de código demuestra cómo puede usar la instancia de caché (que creó en el ejemplo de código anterior) para realizar operaciones básicas en el caché.
/*Adding data to the cache*/
Product product = fetchProductFromDB();
String key = "Product:" + product.getProductID();
jCache.put(key, product);
/*Update data in the cache*/
product.setUnitsInStock(newValue); // updated units
jCache.replace(key, product);
/*Get data from the cache*/
Object item = jCache.get(key);
/*Remove data from the cache*/
Boolean result = jCache.remove(key);Otra característica de JCache es Caducidad de datos donde los datos de caché caducan en función del tiempo. JCache admite dos tipos principales de vencimientos, a saber Caducidad absoluta y Caducidad móvil. En Caducidad absoluta, los datos dentro de la memoria caché caducan después de un intervalo de tiempo fijo. En la caducidad variable, los datos dentro de la memoria caché caducan después de un intervalo de tiempo, pero este intervalo de tiempo se restablece cada vez que se accede a estos datos.
Los elementos se pueden agregar y actualizar en el caché con vencimientos absolutos y deslizantes definidos. En el siguiente ejemplo de código, los datos se agregan a la memoria caché con la caducidad absoluta definida.
CachingProvider cachingProvider = Caching.getCachingProvider();
CacheManager manager = cachingProvider.getCacheManager();
Customer customer = new Customer();
customer.setAge(22);
String key = "Customer:" + customer.getCustomerID();
//configure the expiration duration
CompleteConfiguration<Object, Object> cacheConfig = new MutableConfiguration().setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ONE_MINUTE));
//create cache with customized configuration settings
javax.cache.Cache jCache = manager.createCache("mypartitionedcache", cacheConfig);
//add item to cache which will expire after 1 minute
jCache.put(key, customer);Notificaciones de nivel de caché son eventos generales que se disparan cuando ocurren ciertos eventos registrados. Para recibir notificaciones de eventos de JCache, debe implementar las interfaces relacionadas con eventos relevantes.
En el siguiente ejemplo, se supone que ha implementado la fábrica de filtros de eventos.
// class that implements the event-listener factory
public class MyCacheEntryListener<K, V>
implements CacheEntryCreatedListener<K, V>, Serializable
{...
for (CacheEntryEvent<? extends K,? extends V> event: events)
{
System.out.println("Received a " + event);
}
...
}
...
//configuring
MyCacheEntryListener<String,String> m_listener = new MyCacheEntryListener<String,String>();
MutableConfiguration<String, String> config = new MutableConfiguration<String, String>();
config.setTypes(String.class, String.class).addCacheEntryListenerConfiguration(
new MutableCacheEntryListenerConfiguration<String, String>
(FactoryBuilder.factoryOf(m_listener),FactoryBuilder.factoryOf(
new MyCacheEntryEventFilter<String, String>()),true,true));
Cache<String, String> jCache = cacheManager.createCache("myreplicatedcache", config);La API proporcionada por NCache le brinda características y funciones más sólidas en comparación con la API proporcionada por JCache. Algunas de las características que NCache proporciona pero JCache no es el siguiente:
Para utilizar todas estas funciones proporcionadas por el NCache API necesita tener una instancia de su caché.
El siguiente ejemplo de código demuestra cómo puede usar una API de JCache para obtener una instancia de caché de NCache utilizando el método de desempaquetado. Esta instancia luego se usa para agregar datos en el caché con etiquetas (característica de NCache) activado. Estas etiquetas se pueden usar en lugar de claves para recuperar datos del caché más adelante.
...
com.alachisoft.ncache.client.Cache cache = null;
cache = (com.alachisoft.ncache.client.Cache) jCache.unwrap(com.alachisoft.ncache.client.Cache.class);
Customer customer = fetchCustomer();
String customerKey = “Customer” + customer.getCustomerID();
// Specify Tags
List<Tag> tags = List.of(new Tag("East Coast Customers"));
CacheItem cacheItem = new CacheItem(customer);
cacheItem.setTags(tags);
cache.add(customerKey, cacheItem);