NCache ist ein verteiltes In-Memory-Caching für .NET. Aber es unterstützt auch Java dank seines 100% nativen Clients und Integrationen von Drittanbietern. Lassen Sie uns einen kurzen Rundgang durch die machen NCache Java-Client und zwei seiner Drittanbieter-Integrationen für Java-Anwendungen.
Grundlegender Caching-Vorgang mit dem Java-Client
Nach der Installation 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 } |
Mit dem Java-Client haben wir mehr Caching-Operationen. Abgesehen vom Hinzufügen und Abrufen eines einzelnen Elements haben wir Massenoperationen zum Hinzufügen, Abrufen, Aktualisieren und Löschen von Elementen; und eine asynchrone API. Weitere Einzelheiten zu fortgeschritteneren Caching-Vorgängen finden Sie unter CRUD-Operationen: Ein Überblick. In diesem Handbuch finden wir auch Java-Beispiele.
Außerdem können wir in unseren Java-Anwendungen die verwenden SQL-Abfragefunktionalität und Indizierungsstrategien um zwischengespeicherte Einträge mit einer SQL-ähnlichen Syntax abzurufen und zu löschen.
Mit diesen Caching-Operationen schreiben wir unseren eigenen Caching-Mechanismus in unsere Java-Anwendungen. Aber mit NCache, können wir die vorhandene Integration von Drittanbietern nutzen. Werfen wir einen Blick auf zwei davon.
NCache als Hibernate Second-Level Cache
Hibernate ist ein objektrelationales Mapping-Tool für Java. Wahrscheinlich braucht es nicht allzu viel Einführung, da es ein weit verbreitetes Werkzeug in der Java-Welt ist.
Um übermäßige Roundtrips zu einer Datenbank zu vermeiden, verwendet Hibernate verschiedene Caching-Mechanismen: First- und Second-Level-Caches. Und Hibernate-Fallbacks zwischen ihnen, wenn Objekte aus der Datenbank abgerufen werden.
Der First-Level-Cache ist ein Cache pro Sitzung. Dies ist der erste Cache, den Hibernate beim Laden von Objekten überprüft. Im Gegensatz zum First-Level-Cache ist der Second-Level-Cache optional. Und es ist für alle Sitzungen verfügbar.
Hibernate stellt keine Implementierungen für den Second-Level-Cache bereit. Wir müssen uns stattdessen auf Drittanbieter-Caching-Anbieter verlassen. NCache funktioniert wie ein Second-Level-Cache.
Wir können machen NCache über Konfigurationsdateien als Hibernate-Second-Level-Cache-Anbieter arbeiten, ohne unseren Produktionscode zu ändern.
Der Second-Level-Cache ist standardmäßig deaktiviert. Um es zu aktivieren und zu verwenden NCache Als Second-Level-Cache müssen wir ihn in der Hibernate-Konfigurationsdatei konfigurieren. Das ist zum Beispiel ein hibernate.cfg.xml
Datei,
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 als Second-Level-Provider
NCacheHibernate.xml
.
Hibernate verwendet Regionen, um Objekte unter einem Namen zu gruppieren. Mit NCache, können wir separate Cache-Instanzen pro Region oder eine einzelne Cache-Instanz für mehrere Regionen haben. Sogar wir können jede Region mit unterschiedlichen konfigurieren NCache Caching-Funktionen. Wir spezifizieren alle diese Konfigurationen auch innerhalb der 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> |
Für weitere Informationen über die NCacheHibernate.xml
Dateiprüfung Cachefähige Objekte und Regionen konfigurieren.
Obwohl wir das Second-Level-Caching aktivieren, speichert Hibernate standardmäßig keine Objekte im Cache. Wir müssen unsere Objekte entweder durch Anmerkungen oder Mapping-Dateien als cachebar markieren. Kommentieren wir zum Beispiel a Product
Klasse,
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; } } |
So können wir verwenden NCache als Hibernate-Cache der zweiten Ebene. Auch können wir verwenden NCache um Abfrageergebnisse zwischenzuspeichern. Wir können die Gesamtleistung unserer Anwendungen verbessern, indem wir das Ergebnis großer, komplexer und häufiger Abfragen zwischenspeichern. Um zu lernen, wie man es benutzt NCache für Abfrage-Caching mit Hibernate, check Verwenden Sie das Abfrage-Caching. Wir brauchen kleine Änderungen in unserer Hibernate-Konfigurationsdatei und in unseren zwischenzuspeichernden Abfragen.
NCache Frühlingsintegration
NCache lässt sich auch in das Spring-Framework integrieren. Das Spring-Framework ist ein Anwendungsframework und Inversion-of-Control-Container für die Java-Plattform. Wir können stecken NCache in das Spring-Caching-Modul, wodurch es skalierbar und verteilt wird.
Wenn wir es benutzen NCache Mit Spring entlasten wir unsere Datenbank, indem wir die Anzahl der Datenbankfahrten zum Bereitstellen von Daten reduzieren, wodurch wir eine bessere Leistung erzielen.
Um mit der Verwendung zu beginnen NCache Bei Spring müssen wir unsere Konfigurationsklasse kommentieren. So was,
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; } } |
Anstelle von Annotationen können wir auch eine XML-Datei verwenden. Wir sind jedoch besser dran, Anmerkungen zu verwenden, da wir Tippfehler zur Kompilierzeit finden können.
Nachdem wir die Spring-Konfiguration entweder über Anmerkungen oder eine XML-Datei geändert haben, müssen wir die eigentlichen Caches konfigurieren. Im Inneren des ncache-spring.xml
-Datei definieren wir unsere Cache-Instanzen mit ihren Eigenschaften wie Ablauf und Entfernungsrichtlinie. Zum Beispiel,
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> |
Nachdem Sie unsere Spring-Anwendung konfiguriert und das Caching aktiviert haben, besteht der nächste Schritt darin, die Methoden zu kommentieren, die wir zwischenspeichern möchten. Um beispielsweise einen Dienst zwischenzuspeichern, den wir von einem API-Controller oder anderen Diensten in unserer Anwendung aufrufen, können wir Folgendes schreiben:
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"; } } |
Mit all diesen Schritten sind wir einsatzbereit NCache mit Frühling.
Weitere Einzelheiten zur Konfiguration NCache mit Frühling, überprüfen Konfigurieren von Anwendungen für die Verwendung NCache als Spring-Caching-Anbieter.
Zusammenfassung
So können wir die verwenden NCache Java-Client zur Unterstützung grundlegender Caching-Operationen. Wir können integrieren NCache mit Hibernate und Spring Framework mit nur Konfigurations- und geringfügigen Codierungsänderungen.
Abgesehen von Hibernate und Spring, NCache unterstützt auch die JCache-API. Wir können benutzen NCache in unserer JCache-Anwendung und verwenden dieselbe JCache-API mit einer verteilten Lösung. Integrieren lernen NCache mit JCache, besuchen JCache-Leitfaden.
Und für hybride Anwendungen mit Java- und .NET-Backend-Seiten, NCache unterstützt portable Datentypen. Wir können benutzen NCache um Daten zwischen den Java- und .NET-Backend-Anwendungen auszutauschen. Mit Portable Data Types können wir zum Beispiel a implementieren JSON-Speicher mit NCache gemeinsame Nutzung von Daten zwischen zwei .NET- und Java-Anwendungen.
Wenn Sie von einer verteilten, skalierbaren und performanten Caching-Lösung in Ihren Java-Anwendungen profitieren möchten, geben Sie NCache ein Versuch.