Visió de conjunt: En la moderna emmagatzematge en memòria cau de desenvolupament d'aplicacions és un dels aspectes més importants a tenir en compte durant el disseny d'aplicacions. L'objectiu més comú d'emmagatzematge en memòria cau és millorar el rendiment. Una memòria cau pot ser definida com una col·lecció d'objectes. Conté els objectes amb estat amb tecles com a identificadors únics. L'emmagatzematge més comú per a qualsevol sistema d'emmagatzematge en memòria cau en la memòria. Però el sistema d'emmagatzematge en memòria cau també pot emmagatzemar articles en disc, base de dades o qualsevol altre emmagatzematge persistent. L'emmagatzematge en memòria cau de Java System (JCS) és un marc d'emmagatzematge en memòria cau distribuït desenvolupat en Java. Millora el rendiment de les aplicacions mitjançant el suport a la gestió de diversos data.JCS memòria cau dinàmiques dóna suport a les memòries cau de memòria i disc. El marc JCS és completament configurable a través de fitxer de propietats i proporciona molta flexibilitat en la gestió de memòria cau.
En aquest article vaig a discutir el marc JCS amb l'exemple de treball.
Introducció: En la majoria de les aplicacions web, dades es recuperen de la base de dades. L'operació de base de dades és costós i consumeix temps. Ara, un dia les aplicacions web són dades porta molt de temps i és la primera resposta als criteris bàsics per al seu èxit. Si l'aplicació web està accedint a la base de dades amb freqüència per a cada sol·licitud a continuació, el seu rendiment serà lenta. Així les aplicacions web estan seguint diferents tècniques de disseny per reduir els temps de latència i ampliar.
JCS és un sistema d'emmagatzematge en memòria cau distribuït compost que treballa en JDK 1.4 i versions superiors. El rendiment de JCS és molt impressionant per a aplicacions de lectura és alt i baix de venda.
A continuació es presenten algunes de les principals característiques del sistema d'emmagatzematge en memòria cau de Java
· Memory management
· Thread pool control
· Extensible framework
· Configurable runtime parameters
· Key based data retrieval
· Distributed composite cache
· Element event handling
JCS - El cau Compost: La base del sistema d'emmagatzematge en memòria cau de Java es basa en la memòria cau de material compost. Hi ha quatre tipus de caixets disponibles per a cada regió. Qualsevol tipus de memòria cau pot ser endollat en la configuració JCS per activar-la. Els següents són els quatre diferents caixets i els seus detalls.
- memòria cau (LRU): Aquest és el mecanisme de memòria cau bàsic àmpliament utilitzat. La memòria cau és extremadament ràpid. Utilitza El menys usat recentment (LRU) algoritme per administrar els objectes emmagatzemats en la memòria. La memòria cau LRU es basa en la seva pròpia implementació LRU Mapa. Aquesta implementació Mapa és molt més ràpid en comparació amb l'aplicació LRUMap o qualsevol altre tipus de Mapa.
- Disk Cache (indexat): El cau de disc s'utilitza per emmagatzemar dades quan el cau de memòria està plena. Quan la indexació es fa servir amb la memòria cau de disc, el rendiment molt més ràpid. procés basat cua s'utilitza per emmagatzemar dades en el disc. El cau de disc és completament configurable. Un grup de subprocessos s'utilitza per gestionar els subprocessos de treball de cua que també fan que el procés sigui més ràpid.
- JDBC memòria cau de disc: Aquest és un altre tipus de memòria cau de disc que és fiable, ràpid i totalment configurable. L'emmagatzematge bàsic és JDBC base de dades compatible. Tant les claus i els valors s'emmagatzemen a la base de dades. Les dades s'emmagatzemen com un BLOB i els elements de dades caducats també s'eliminen periòdicament. grup de subprocessos també es pot utilitzar per gestionar la cua de subprocessos de treball per a un processament més ràpid.
- TCP lateral memòria cau: Aquest és un mecanisme per distribuir les dades en memòria cau en diversos servidors distribuïts. Aquest és també l'emmagatzematge en memòria cau del sistema totalment configurable. També pot utilitzar el mecanisme de detecció UDP per afegir nodes sense molestar tot el sistema. El lateral de la memòria cau TCP estableix connexions amb els servidors de socket d'altres nodes i realitza la gestió d'emmagatzematge. Un servidor és suficient per gestionar múltiples regions.
- Memòria cau remota utilitzant RMI: Aquesta és una altra opció d'emmagatzematge en memòria cau proporcionada per JCS. En aquest mecanisme cada node no està obligat a connectar amb un altre node. El servidor de memòria cau a distància pot utilitzar-se com un punt de connexió i cada node pot connectar amb ella. El servidor de memòria cau remota s'utilitza per mantenir una versió serialitzada de l'objecte. El servidor remot pot agrupar-se amb altres servidors de commutació per error per recuperar.
configuració de la dependència: A la següent secció discutirem una aplicació simple donades JCS. Abans de moure en ella, hem de tenir les següents dependències al CLASSPATH. Si us plau, descarregueu els flascons executables i posar-los al CLASSPATH per generar l'aplicació.
- JCS-1.3.jar
- Commons-logging.jar
- commons-lang-2.4.jar
- jar
Treballar amb JCS: En aquesta secció anem a discutir els diferents components del sistema d'emmagatzematge en memòria cau de Java i els detalls de configuració. Anem a explicar cada component amb l'exemple de treball.
El que segueix és un simple empleat tinença classe de detalls dels empleats. La classe ha d'implementar serialitzada interfície que les seves dades es conservarà. Conté mètodes de captador / definidor per a les dades de lectura i escriptura.
Listing1: Mostrant classe Employee
Empleat classe pública implementa java.io.Serializable{
private String nom;
direcció de private String;
empid private String;
Empleat públic(nom de la cadena, direcció de la cadena, empid cadena) {
this.name = nom;
this.address = Direcció;
this.empid = empid;
}
Public String getName() {
nom de retorn;
}
setName public void(nom de la cadena) {
this.name = nom;
}
Cadena GetAddress pública() {
adreça del remitent;
}
setAddress public void(direcció de la cadena) {
this.address = Direcció;
}
Cadena getEmpid pública() {
tornar empid;
}
setEmpid public void(empid cadena) {
this.empid = empid;
}
}
El següent és el principal EmployeeManager classe que importa paquets JCS per utilitzar les API de marc. Utilitza una regió coneguda com memòria cau 'EmpCache' posar i obtenir dades en / des de la memòria. Les dades s'emmagatzemen a la memòria cau mitjançant l'ús de parells de claus / valor. La recuperació es basa en la clau associada amb cada valor. L'aplicació està mostrant addició / recuperació i l'eliminació dels objectes emmagatzemats en una memòria cau.
LISTING2: Mostrant classe EmployeeManager
org.apache.jcs.JCS importació;
importació org.apache.jcs.access.exception.CacheException;
EmployeeManager classe pública {
memòria cau privada JCS;
EmployeeManager pública()
{
tractar de
{
// Carregar el cau
cache = JCS.getInstance( “empCache” );
// Inicialitzar la memòria cau, Aquí les dades poden ser carregats durant la inicialització
cache.put( “123”, Empleat nou( “efecte”, “Detroit.USA”, “123” ) );
cache.put( “143”, Empleat nou( “Ric”, “Seattle.USA”, “143” ) );
cache.put( “153”, Empleat nou( “Jhon”, “Chicago.USA”, “153” ) );
cache.put( “163”, Empleat nou( “i”, “Houston.USA”, “163” ) );
}
agafar( i CacheException )
{
e.printStackTrace();
}
}
addEmployee public void( emp empleat )
{
tractar de
{
cache.put( emp.getEmpid(), emp );
}
agafar( i CacheException )
{
e.printStackTrace();
}
}
Empleat Públic getEmployee( empid cadena )
{
return ( empleat )cache.get( empid );
}
removeEmployee public void( empid cadena )
{
tractar de
{
Cache.Remove( empid );
}
agafar( i CacheException )
{
e.printStackTrace();
}
}
public static void principal( Cadena[] args )
{
// Creu el gestor d'empleat
EmployeeManager empManager = new EmployeeManager();
// Afegir als empleats amb el gerent de l'empleat
/*empManager.addEmployee(Empleat nou(“nom1”, “Adreça 1”, “empid1”));
empManager.addEmployee(Empleat nou(“nom2”, “Adreça 2”, “empid2”));
empManager.addEmployee(Empleat nou(“Nombre3”, “address3”, “empid3”));*/
// obtenir empleat
Empleat emp = empManager.getEmployee(“123”);
System.out.println( “detalls dels empleats recuperats de la memòria cau: ” + emp.getName()+”-“+emp.getAddress());
// Traieu empleat
empManager.removeEmployee(“123”);
// Després de l'eliminació de l'empleat
System.out.println( “detalls dels empleats després de l'eliminació de la memòria cau: ” + empManager.getEmployee(“123”) );
}
}
El que segueix és l'arxiu de configuració cache.ccf. Es porta a terme tots els paràmetres configurables amb els seus valors. La primera secció és la regió per defecte de la memòria cau que conté els valors per defecte. Si no hi ha regió d'encàrrec està configurat, llavors es faran servir aquests valors per defecte. La segona secció és la definició de la regió memòria cau costum que és empCache aquí. Es defineix els valors dels paràmetres personalitzats. L'última secció és la regió de memòria cau auxiliar que descriu la memòria cau de disc i altres paràmetres relacionats.
Listing3: Mostrant fitxer de configuració
# DEFAULT CACHE REGIÓ
jcs.default = DC
jcs.default.cacheattributes = org.apache.jcs.engine.CompositeCacheAttributes
jcs.default.cacheattributes.MaxObjects = 1000
jcs.default.cacheattributes.MemoryCacheName = org.apache.jcs.engine.memory.lru.LRUMemoryCache
jcs.default.cacheattributes.UseMemoryShrinker = false
jcs.default.cacheattributes.MaxMemoryIdleTimeSeconds = 3600
jcs.default.cacheattributes.ShrinkerIntervalSeconds = 60
jcs.default.elementattributes = org.apache.jcs.engine.ElementAttributes
jcs.default.elementattributes.IsEternal = false
jcs.default.elementattributes.MaxLifeSeconds = 21600
jcs.default.elementattributes.IdleTime = 1800
jcs.default.elementattributes.IsSpool = true
jcs.default.elementattributes.IsRemote = true
jcs.default.elementattributes.IsLateral = true
# Del amagatall per defecte
jcs.region.empCache = DC
jcs.region.empCache.cacheattributes = org.apache.jcs.engine.CompositeCacheAttributes
jcs.region.empCache.cacheattributes.MaxObjects = 1000
jcs.region.empCache.cacheattributes.MemoryCacheName = org.apache.jcs.engine.memory.lru.LRUMemoryCache
jcs.region.empCache.cacheattributes.UseMemoryShrinker = false
jcs.region.empCache.cacheattributes.MaxMemoryIdleTimeSeconds = 3600
jcs.region.empCache.cacheattributes.ShrinkerIntervalSeconds = 60
jcs.region.empCache.cacheattributes.MaxSpoolPerRun = 500
jcs.region.empCache.elementattributes = org.apache.jcs.engine.ElementAttributes
jcs.region.empCache.elementattributes.IsEternal = false
# Memòries cau auxiliar disponible
jcs.auxiliary.DC = org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheFactory
jcs.auxiliary.DC.attributes = org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheAttributes
jcs.auxiliary.DC.attributes.DiskPath = c:/temp
jcs.auxiliary.DC.attributes.MaxPurgatorySize=10000000
jcs.auxiliary.DC.attributes.MaxKeySize=1000000
jcs.auxiliary.DC.attributes.MaxRecycleBinSize=5000
jcs.auxiliary.DC.attributes.OptimizeAtRemoveCount=300000
jcs.auxiliary.DC.attributes.ShutdownSpoolTimeLimit=60
Conclusió: In this article we have discussed about caching concepts and one of the most popular caching framework known as Java Caching System. The article also covered different components of JCS and their implementation. Finalment hem analitzat una mostra d'exemple de treball basat en l'emmagatzematge en memòria cau de Java marc del Sistema. El JCS és molt potent i escrit en llenguatge Java. El mecanisme d'emmagatzematge i el seu disseny interior són molt potents per a aplicacions de baixa implica una gran lectura i. L'aplicació és totalment configurable pel que es pot integrar amb qualsevol nova i existent d'aplicació sense posar molt esforç.
