NCache Actúa como un proveedor distribuido de JCache, lo que permite que las aplicaciones Java utilicen caché compatible con JSR 107 para eliminar cuellos de botella en la base de datos y escalar horizontalmente. JCache es una API basada en Java que se utiliza para el almacenamiento en caché de objetos Java en memoria. Esto también incluye la creación de objetos, la invalidación, el spooling, el acceso compartido y la consistencia entre las 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 alto rendimiento de la especificación JSR 107, lo que garantiza la compatibilidad total con aplicaciones Java que requieren almacenamiento en caché distribuido con una latencia inferior a un milisegundo. Al aprovechar esta implementación, puede integrar NCacheLas funciones de nivel empresarial de 's en su entorno compatible con JCache sin fricción arquitectónica.
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ón, y 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:
Algunas de las características que NCache proporciona pero JCache no es el siguiente:
| Elemento | JCache estándar (JSR 107) | NCache Proveedor de JCache |
|---|---|---|
| Buscar | Basado únicamente en clave | Consultas SQL y LINQ |
| Etiquetas de datos | No se admite | Con soporte a través de unwrap |
| Persistencia | Básico | Lectura continua/escritura continua |
| Descamación | Limitado por JVM | Clúster escalable linealmente |
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 tags (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);© Copyright Alachisoft 2002 - Todos los derechos reservados. NCache es una marca registrada de Diyatech Corp.