NCache est une mise en cache distribuée en mémoire pour .NET. Mais il prend également en charge Java grâce à son client 100% natif et ses intégrations tierces. Faisons un tour rapide à travers le NCache Client Java et deux de ses intégrations tierces pour les applications Java.
Opération de mise en cache de base avec le client Java
Après l'installation de NCache,
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
try { // After having NCache up and running... // Connect to cache String cacheName = "demoCache"; Cache cache = CacheManager.getCache(cacheName); // Cache a product Product product = buildOrRetrieveProductToCache(); String key = "Product:" + product.getProductID(); cache.add(key, product); // Later in another part of our code... // Retrieve cached product Product foundProduct = cache.get(key, Product.class); if (foundProduct != null) { // Do something with the cached product here } else { // No product was found } } catch (OperationFailedException ex) { // Handle NCache-specific exceptions, like connection failures, here } catch (Exception ex) { // Handle generic exceptions, like IllegalArgumentException, here } |
Avec le client Java, nous avons plus d'opérations de mise en cache. Outre l'ajout et la récupération d'un seul élément, nous avons des opérations en masse pour ajouter, récupérer, mettre à jour et supprimer des éléments ; et une API asynchrone. Pour plus de détails sur les opérations de mise en cache plus avancées, consultez Opérations CRUD : un aperçu. Nous pouvons également trouver des exemples Java dans ce guide.
Aussi, à l'intérieur de nos applications Java, nous pouvons utiliser le Fonctionnalité d'interrogation SQL et stratégies d'indexation pour récupérer et supprimer les entrées mises en cache à l'aide d'une syntaxe de type SQL.
Avec ces opérations de mise en cache, nous écrivons notre propre mécanisme de mise en cache dans nos applications Java. Mais avec NCache, nous pouvons profiter de son intégration tierce existante. Jetons un coup d'œil à deux d'entre eux.
NCache en tant que cache de second niveau Hibernate
Hibernate est un outil de mappage objet-relationnel pour Java. Probablement, il n'a pas besoin de trop d'introduction puisqu'il s'agit d'un outil répandu dans le monde Java.
Pour éviter les allers-retours excessifs vers une base de données, Hibernate utilise différents mécanismes de mise en cache : les caches de premier et de second niveau. Et Hibernate se replie entre eux lors de la récupération d'objets de la base de données.
Le cache de premier niveau est un cache par session. C'est le premier cache qu'Hibernate vérifie lors du chargement d'objets. Contrairement au cache de premier niveau, le cache de second niveau est facultatif. Et il est disponible pour toutes les sessions.
Hibernate ne fournit aucune implémentation pour le cache de second niveau. Nous devons plutôt compter sur des fournisseurs de mise en cache tiers. NCache fonctionne comme un cache de second niveau.
Nous pouvons faire NCache travailler en tant que fournisseur de cache de second niveau Hibernate via des fichiers de configuration sans modifier notre code de production.
Le cache de second niveau est désactivé par défaut. Pour l'activer et utiliser NCache en tant que cache de second niveau, nous devons le configurer dans le fichier de configuration Hibernate. Par exemple, il s'agit d'un hibernate.cfg.xml
fichier,
1 2 3 4 5 6 7 8 9 10 11 |
<hibernate-configuration> <session-factory> <!-- It enables Hibernate second-level cache --><!-- It enables Hibernate second-level cache --> <property name="hibernate.cache.use_second_level_cache">true</property> <!-- It configures NCache as a second-level cache provider, for Hibernate 3.6 and above ---> <property name="hibernate.cache.region.factory_class">JCacheRegionFactory</property> <!-- It's NCache applicaton identifier --> <property name="ncache.application_id">myapp</property><!-- It configures NCache as a second-level cache provider, for Hibernate 3.6 and above ---> JCacheRegionFactory </session-factory> </hibernate-configuration> |
NCache en tant que prestataire de second niveau
NCacheHibernate.xml
.
Hibernate utilise des régions pour regrouper des objets sous un nom. Avec NCache, nous pouvons avoir des instances de cache distinctes par région ou une seule instance de cache pour plusieurs régions. Même nous pouvons configurer chaque région avec différents NCache fonctionnalités de mise en cache. Nous spécifions également toutes ces configurations à l'intérieur du NCacheHibernate.xml
1 2 3 4 5 6 7 8 |
<configuration> <application-config application-id="myapp" enable-cache-exception="true" default-region-name="DefaultRegion" key-case-sensitivity="false"> <cache-regions> <region name="MyCustomRegion" cache-name="myPartitionedcache" priority="default" expiration-type="sliding" expiration-period="8"/> <region name="DefaultRegion" cache-name="demoCache" priority="default" expiration-type="none" expiration-period="0" /> </cache-regions> </application-config> </configuration> |
Pour plus de détails au sujet de la NCacheHibernate.xml
contrôle de fichier Configurer les objets et les régions pouvant être mis en cache.
Même si nous activons la mise en cache de second niveau, Hibernate ne met pas les objets en cache par défaut. Nous devons marquer nos objets comme pouvant être mis en cache via des annotations ou des fichiers de mappage. Par exemple, annotons un Product
classe,
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
@Entity @Table(name = "Products") @Cacheable @Cache(usage = CacheConcurrencyStrategy.READ_WRITE) public class Product { @Id @GeneratedValue @Column(name = "ProductID") private int ProductID; @Column(name = "Name") private String Name; public Product() {} public int getProductID() { return ProductID; } public void setProductID(int productID) { this.ProductID = productID; } public String getName() { return Name; } public void setName(String name) { this.Name = name; } } |
C'est ainsi que nous pouvons utiliser NCache en tant que cache Hibernate de second niveau. Aussi, nous pouvons utiliser NCache pour mettre en cache les résultats de la requête. Nous pouvons améliorer les performances globales de nos applications en mettant en cache le résultat de requêtes volumineuses, complexes et fréquentes. Pour apprendre à utiliser NCache pour la mise en cache des requêtes avec Hibernate, cochez Utiliser la mise en cache des requêtes. Nous avons besoin de petites modifications dans notre fichier de configuration Hibernate et dans nos requêtes à mettre en cache.
NCache Intégration de printemps
NCache s'intègre également au framework Spring. Le framework Spring est un framework d'application et un conteneur d'inversion de contrôle pour la plate-forme Java. On peut brancher NCache dans le module de mise en cache Spring, ce qui le rend évolutif et distribué.
Lorsque nous utilisons NCache avec Spring, nous déchargeons notre base de données en réduisant le nombre de déplacements de la base de données pour servir les données, ce qui nous donne de meilleures performances.
Pour commencer à utiliser NCache avec Spring, nous devons annoter notre classe de configuration. Comme ça,
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
@Configuration @EnableCaching public class CachingConfiguration { @Bean public CacheManager cacheManager() { SpringConfigurationManager springConfigurationManager = new SpringConfigurationManager(); URL resource = getClass().getClassLoader().getResource("ncache-spring.xml"); springConfigurationManager.setConfigFile(resource.getPath()); NCacheCacheManager cacheManager = new NCacheCacheManager(); cacheManager.setSpringConfigurationManager(springConfigurationManager); return cacheManager; } } |
Au lieu d'utiliser des annotations, nous pouvons également utiliser un fichier XML. Cependant, nous ferions mieux d'utiliser des annotations car nous pouvons trouver des erreurs de type au moment de la compilation.
Après avoir modifié la configuration de Spring via des annotations ou un fichier XML, nous devons configurer les caches réels. À l'intérieur de ncache-spring.xml
fichier, nous définissons nos instances de cache avec leurs propriétés telles que la politique d'expiration et d'éviction. Par exemple,
1 2 3 4 5 6 |
<application-config default-cache-name="default"> <caches> <cache name="ProductsCache" ncache-instance="demoCache" priority="normal" expiration-type="absolute" expiration-period="10"/> </caches> </application-config> |
Après avoir configuré notre application Spring et activé la mise en cache, l'étape suivante consiste à annoter les méthodes que nous voulons mettre en cache. Par exemple, pour mettre en cache un service que nous appelons depuis un contrôleur d'API ou d'autres services de notre application, nous pouvons écrire,
1 2 3 4 5 6 7 8 9 10 11 12 |
@Service public class ProductService { @Cacheable("ProductsCache") public String getProductNameByCode(String code) { return retrieveProductNameFromDatastore(code); } private String retrieveProductNameFromDatastore(String code) { // Image a query to retrieve a product name from a database return "Any name"; } } |
Avec toutes ces étapes, nous sommes prêts à utiliser NCache avec le printemps.
Pour plus de détails sur la configuration NCache avec Spring, vérifiez Configuration des applications à utiliser NCache en tant que fournisseur de mise en cache Spring.
Conclusion
C'est ainsi que nous pouvons utiliser le NCache Client Java pour prendre en charge les opérations de mise en cache de base. Nous pouvons intégrer NCache avec Hibernate et Spring Framework avec uniquement des modifications de configuration et de codage mineures.
Outre Hibernate et Spring, NCache prend également en charge l'API JCache. On peut utiliser NCache dans notre application JCache et utiliser la même API JCache avec une solution distribuée. Pour apprendre à intégrer NCache avec JCache, visitez Guide JCache.
Et pour les applications hybrides avec les côtés backend Java et .NET, NCache prend en charge les types de données portables. On peut utiliser NCache pour partager des données entre les applications backend Java et .NET. Par exemple, avec les types de données portables, nous pouvons implémenter un Stockage JSON avec NCache partage de données entre deux applications .NET et Java.
Si vous souhaitez bénéficier d'une solution de mise en cache distribuée, évolutive et performante dans vos applications Java, donnez NCache un essai.