NCache è un caching distribuito in memoria per .NET. Ma supporta anche Java grazie al suo client nativo al 100% e alle integrazioni di terze parti. Facciamo un rapido tour attraverso il NCache client Java e due delle sue integrazioni di terze parti per le applicazioni Java.
Operazione di memorizzazione nella cache di base con client Java
Dopo l'installazione 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 } |
Con il client Java, abbiamo più operazioni di memorizzazione nella cache. Oltre all'aggiunta e al recupero di un singolo elemento, abbiamo operazioni in blocco per aggiungere, recuperare, aggiornare ed eliminare elementi; e un'API asincrona. Per ulteriori dettagli su operazioni di memorizzazione nella cache più avanzate, controllare Operazioni CRUD: una panoramica. Possiamo trovare esempi Java anche in quella guida.
Inoltre, all'interno delle nostre applicazioni Java, possiamo utilizzare il file Funzionalità di query SQL e strategie di indicizzazione per recuperare ed eliminare le voci memorizzate nella cache utilizzando una sintassi simile a SQL.
Con queste operazioni di memorizzazione nella cache, scriviamo il nostro meccanismo di memorizzazione nella cache all'interno delle nostre applicazioni Java. Ma con NCache, possiamo sfruttare la sua integrazione di terze parti esistente. Diamo un'occhiata a due di loro.
NCache come cache di secondo livello di ibernazione
Hibernate è uno strumento di mappatura relazionale degli oggetti per Java. Probabilmente non ha bisogno di troppe presentazioni visto che è uno strumento molto diffuso nel mondo Java.
Per evitare un numero eccessivo di roundtrip a un database, Hibernate utilizza diversi meccanismi di memorizzazione nella cache: cache di primo e secondo livello. E Hibernate esegue il fallback tra di loro durante il recupero di oggetti dal database.
La cache di primo livello è una cache per sessione. È il primo controllo della cache di Hibernate durante il caricamento degli oggetti. A differenza della cache di primo livello, la cache di secondo livello è facoltativa. Ed è disponibile per tutte le sessioni.
Hibernate non fornisce alcuna implementazione per la cache di secondo livello. Dobbiamo invece fare affidamento su fornitori di cache di terze parti. NCache funziona come una cache di secondo livello.
Possiamo fare NCache lavorare come provider di cache di secondo livello di Hibernate attraverso i file di configurazione senza modificare il nostro codice di produzione.
La cache di secondo livello è disabilitata per impostazione predefinita. Per abilitarlo e utilizzare NCache come cache di secondo livello, dobbiamo configurarlo nel file di configurazione di Hibernate. Ad esempio, questo è un hibernate.cfg.xml
file,
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 come fornitore di secondo livello
NCacheHibernate.xml
.
Hibernate utilizza le regioni per raggruppare gli oggetti sotto un nome. Con NCache, possiamo avere istanze di cache separate per regione o una singola istanza di cache per più regioni. Anche noi possiamo configurare ogni regione con diversi NCache funzionalità di memorizzazione nella cache. Specifichiamo anche tutte queste configurazioni all'interno del file 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> |
Per maggiori dettagli sul NCacheHibernate.xml
archiviare, controllare Configura oggetti e regioni memorizzabili nella cache.
Anche se abilitiamo la memorizzazione nella cache di secondo livello, Hibernate non memorizza nella cache gli oggetti per impostazione predefinita. Dobbiamo contrassegnare i nostri oggetti come memorizzabili nella cache tramite annotazioni o file di mappatura. Ad esempio, annotiamo a 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; } } |
Ecco come possiamo usare NCache come cache Hibernate di secondo livello. Inoltre, possiamo usare NCache per memorizzare nella cache i risultati della query. Possiamo migliorare le prestazioni complessive delle nostre applicazioni memorizzando nella cache il risultato di query grandi, complesse e frequenti. Per imparare a usare NCache per il caching delle query con Hibernate, controlla Usa la memorizzazione nella cache delle query. Abbiamo bisogno di piccoli cambiamenti nel nostro file di configurazione di Hibernate e nelle nostre query da memorizzare nella cache.
NCache Integrazione primaverile
NCache si integra anche con il framework Spring. Il framework Spring è un framework applicativo e un'inversione del contenitore di controllo per la piattaforma Java. Possiamo collegarci NCache nel modulo di memorizzazione nella cache di Spring, rendendolo scalabile e distribuito.
Quando usiamo NCache con Spring, scarichiamo il nostro database riducendo il numero di viaggi del database per servire i dati, offrendoci prestazioni migliori.
Per iniziare a utilizzare NCache con Spring, dobbiamo annotare la nostra classe di configurazione. Come questo,
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; } } |
Invece di usare le annotazioni, possiamo anche usare un file XML. Tuttavia, è meglio usare le annotazioni poiché possiamo trovare errori di tipo in fase di compilazione.
Dopo aver modificato la configurazione di Spring tramite annotazioni o un file XML, è necessario configurare le cache effettive. Dentro il ncache-spring.xml
file, definiamo le nostre istanze di cache con le loro proprietà come la scadenza e la politica di sfratto. Per esempio,
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> |
Dopo aver configurato la nostra applicazione Spring e aver abilitato la memorizzazione nella cache, il passaggio successivo consiste nell'annotare i metodi che vogliamo memorizzare nella cache. Ad esempio, per memorizzare nella cache un servizio che chiamiamo da un controller API o altri servizi nella nostra applicazione, possiamo scrivere,
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"; } } |
Con tutti questi passaggi, siamo pronti per l'uso NCache con la Primavera.
Per ulteriori dettagli sulla configurazione NCache con Spring, controlla Configurazione delle applicazioni per l'utilizzo NCache come provider di memorizzazione nella cache di primavera.
Conclusione
Ecco come possiamo usare il NCache Client Java per supportare le operazioni di memorizzazione nella cache di base. Possiamo integrarci NCache con Hibernate e Spring Framework con solo modifiche di configurazione e codifica minori.
Oltre a Hibernate e Spring, NCache supporta anche l'API JCache. Possiamo usare NCache nella nostra applicazione JCache e utilizzare la stessa API JCache con una soluzione distribuita. Per imparare a integrare NCache con JCache, visita Guida JCache.
E per le applicazioni ibride con i lati back-end Java e .NET, NCache supporta i tipi di dati portabili. Possiamo usare NCache per condividere i dati tra le applicazioni backend Java e .NET. Ad esempio, con i tipi di dati portatili, possiamo implementare a Archiviazione JSON con NCache condivisione dei dati tra due applicazioni .NET e Java.
Se desideri beneficiare di una soluzione di memorizzazione nella cache distribuita, scalabile e performante nelle tue applicazioni Java, dai NCache un tentativo.