JCache est une API basée sur Java utilisée pour la mise en cache en mémoire d'objets Java. Cela inclut également la création d'objets, l'invalidation, la mise en file d'attente, l'accès partagé et la cohérence entre les machines virtuelles Java (JVM).
NCache est une solution de mise en cache distribuée très puissante et polyvalente, dotée d'un vaste ensemble de fonctionnalités et d'outils. NCache fournit une implémentation de la spécification JCache (JSR 107). En utilisant cela, vous pouvez profiter des avantages du grand nombre de fonctionnalités et d'outils fournis par NCache.
La création d'une instance JCache est nécessaire pour que vous puissiez effectuer des opérations sur le cache. En Java, la méthode getCache () est considérée comme l'une des méthodes les plus pratiques pour obtenir une instance JCache. L'exemple de code suivant montre comment vous pouvez initialiser un cache à l'aide de cette méthode.
/*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");Une fois que le cache a été initialisé avec succès et que vous avez acquis un handle de cache, vous pouvez effectuer de nombreuses opérations sur le cache comme ajoutant, aller chercher, la mise à jouret suppression données du cache.
L'exemple de code suivant montre comment vous pouvez utiliser l'instance de cache (que vous avez créée dans l'exemple de code ci-dessus) pour effectuer des opérations de base sur le cache.
/*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);Une autre fonctionnalité de JCache est Expiration des données où les données du cache expirent en fonction du temps. JCache prend en charge deux principaux types d'expirations, à savoir Expiration absolue ainsi que Expiration glissante. Dans Expiration absolue, les données du cache expirent après un intervalle de temps fixe. Dans Expiration glissante, les données du cache expirent après un intervalle de temps, mais cet intervalle de temps est réinitialisé à chaque accès à ces données.
Les éléments peuvent être ajoutés et mis à jour dans le cache avec des expirations absolues et glissantes définies. Dans l'exemple de code suivant, les données sont ajoutées au cache avec l'expiration absolue définie.
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);Notifications de niveau de cache sont des événements généraux déclenchés lorsque certains événements enregistrés se produisent. Afin d'obtenir des notifications d'événement(s) de JCache, vous devez implémenter les interfaces liées aux événements pertinents.
Dans l'exemple ci-dessous, on suppose que vous avez implémenté la fabrique de filtres d'événements.
// 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);L'API fournie par NCache vous offre des fonctionnalités et des fonctions plus robustes par rapport à l'API fournie par JCache. Certaines des fonctionnalités qui NCache fournit mais pas JCache sont les suivants :
Afin d'utiliser toutes ces fonctionnalités fournies par le NCache API, vous devez avoir une instance de son cache.
L'exemple de code suivant montre comment vous pouvez utiliser une API JCache pour obtenir une instance de cache de NCache en utilisant la méthode unwrap. Cette instance est ensuite utilisée pour ajouter des données dans le cache avec étiquettes (caractéristique de NCache) activé. Ces balises peuvent être utilisées à la place des clés pour récupérer ultérieurement les données du cache.
...
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);