Orokorra: moderno aplikazioak garatzeko katxeak horretan alderdi garrantzitsuenetako bat aplikazio diseinu garaian aintzat hartu beharreko da. katxeak helburua ohikoena da errendimendua hobetzeko. Cachea beharreko objektuen bilduma bat bezala definitu daiteke. gakoak identifikadore bakar gisa stateful objektuak biltzen ditu. Bat katxeak sistema biltegiratze Ohikoena memorian da. Baina katxeak sistema ere gorde daiteke diskoan elementu, datu-basea edo beste edozein biltegiratze iraunkorrak. Java Caching Sistema (JCS) Java garatu banatzen katxeak esparru bat. Aplikazio errendimendua dinamikoa hainbat cached data.JCS kudeatzeko laguntza eskainiz memoria eta disko cacheak ere onartzen hobetzen du. JCS esparru propietate fitxategia bidez guztiz konfiguragarria da eta malgutasuna asko eskaintzen cache kudeaketan.
Artikulu honetan JCS lanean adibidez esparru hitz egingo dut.
Sarrera: Web aplikazio gehienetan, Datu da datu-basetik berreskuratu. database eragiketa garestia da eta denbora kontsumitzen. Orain, egun bat web aplikazioen datuak erantzuteko denbora intentsiboa eta lehen bere arrakastaren oinarrizko irizpideak da. web aplikazioa da maiz, datu-basera bada eskaera bakoitzerako ondoren, bere performance motela izango da. Beraz, web aplikazioen diseinu teknika desberdinak dira ondorengo latentzia aldiz murrizteko eta eskalatzeko ireki.
JCS composite banatzen katxeak sistema bat JDK lan egiten da 1.4 eta goiko bertsioak. JCS errendimendua oso altua jarri eta irakurrita handiko aplikazio ikusgarria da.
Honako hauek dira Java Caching Sistema horren ezaugarri nagusietako batzuk
· Memory management
· Thread pool control
· Extensible framework
· Configurable runtime parameters
· Key based data retrieval
· Distributed composite cache
· Element event handling
JCS - Composite cachea: Java Caching System fundazioa cache composite oinarrituta dago. Badira lau caches mota eskualdez eskuragarri. cache mota edozein izango du JCS konfigurazioa da aktiboa egiteko entxufatuta dezake. Hurrengo lau caches ezberdinak eta bere datuak dira.
- Memoria Cache (LRU): Hau erabiliena oinarrizko katxeak mekanismoa da. memoria cachea oso azkarra da. Erabiltzen Gutxienez Duela gutxi erabilita (LRU) Algoritmo memorian gordetako objektuak kudeatzeko. The LRU memoria cache bere LRU Map ezartzeko egin oinarrituta dago. Mapa ezartzeko hau askoz azkarragoa da aldean LRUMap ezartzeko edo Map of beste motatako.
- Disk Cache (Indexatua): Diskoaren cachea datuak gordetzeko erabiltzen denean memoria cache bete da. Noiz indexatzeko diska cache batera erabiltzen da, errendimendua askoz azkarrago. Queue oinarritutako prozesu diskoan datuak gordetzeko erabiltzen. diska cache guztiz konfiguragarria da. haria igerilekua A ilaran hari langileak horrek ere prozesua azkarrago kudeatzeko erabiltzen da.
- JDBC Disko Cache: Hau zein da fidagarria diska cache mota bat da, azkar eta guztiz konfiguragarria. oinarrizko biltegia JDBC datu-basean bateragarri da. Biak gakoak eta balioak dira datu-basean gordetzen. Datuak BLOB gisa gordetzen da eta iraungitako datuak elementu ere aldizka kendu dira. Thread igerilekua ilaran hari langileak kudeatzeko prozesatzeko azkarrago egiteko ere erabil daiteke.
- TCP Alboko Cache: Hau mekanismo bat anitz banatu zerbitzarietan datu cached banatu da. Hau da, era guztiz konfiguragarria katxeak sistema. ere erabili ahal izango da, UDP aurkikuntza mekanismo nodoak gehitzeko sistema osoa aldatu gabe. The TCP Alboko Cache socket beste nodo zerbitzari batera konexioak ezartzen eta biltegiratze kudeaketa burutzen. zerbitzari bat nahikoa da anitz eskualde kudeatzeko.
- Urruneko Cache RMI erabiliz: Hau beste katxeak aukera JCS emandako da. Mekanismo honetan nodo bakoitzean ez da beharrezkoa beste nodo batera konektatu. Urruneko cache zerbitzari konexio puntu gisa erabili ahal izango dira, eta nodo bakoitzak berarekin konektatu ahal. Urruneko cache zerbitzari zure objektu bertsio Serieko bat gordetzeko erabiltzen da. Urruneko zerbitzaria den beste zerbitzari failover berreskuratzeko bil daitezke.
Dependentzia konfigurazioa: Hurrengo atalean aplikazio sinple bat JCS erabiliz hitz egingo dugu. higitzea aurretik, Hurrengo Classpath batean mendekotasunak izan behar dugu. Mesedez deskargatu poteak exekutagarria eta jartzea Classpath aplikazioen eraikitzeko.
- JCS-1.3.jar
- commons-logging.jar
- commons-lang-2.4.jar
- jar
JCS lan egitea: Atal honetan Java Caching System osagaiak eta konfigurazio xehetasunak azaltzen dira,. lanean adibidez osagai bakoitza azalduko ditugu.
Jarraitzen sinple bat da Langilearen Klase holding langile xehetasunak. Klase ezartzeko behar Serializable interface bere datu gisa iraun egingo. getter / setter irakurtzeko eta idazteko datuak metodoak dauka.
Listing1: Langilearen class erakustea
Klase publiko Langilearen inplementatzen java.io.Serializable{
String pribatuaren izen;
String pribatua helbidea;
String pribatua empid;
Langilearen publikoa(Kate izena, String helbidea, String empid) {
this.name = name;
this.address = helbidea;
this.empid = empid;
}
publiko String getName() {
bueltan name;
}
void setName publikoa(Kate izena) {
this.name = name;
}
publiko String getAddress() {
bueltan helbidea;
}
void setAddress publikoa(String helbidea) {
this.address = helbidea;
}
publiko String getEmpid() {
itzuli empid;
}
void setEmpid publikoa(String empid) {
this.empid = empid;
}
}
Jarraian nagusia EmployeeManager Klase inportatuko JCS paketeak esparru APIak erabiltzeko. bezala ezagutzen cache eskualde bat erabiltzen da, 'EmpCache' jarri eta data / sartu oroimenetik. Datuak cache memorian gordetzen den gako / balio bikotea erabiliz. berreskuratze The balio bakoitzari lotutako giltza oinarrituta dago. Aplikazioa Horrez / berreskuratze eta kentzea cache batean gordetako objektuak erakusten.
Listing2: EmployeeManager class erakustea
import org.apache.jcs.JCS;
import org.apache.jcs.access.exception.CacheException;
Klase publiko EmployeeManager {
pribatua JCS cache;
EmployeeManager publikoa()
{
saiatu
{
// Kargatu cachea
cache = JCS.getInstance( “empCache” );
// Hasieratu cachea, Hemen datuak abiarazi bitartean kargatu ahal
cache.put( “123”, Langilearen berria( “Nick”, “Detroit.USA”, “123” ) );
cache.put( “143”, Langilearen berria( “Ric”, “Seattle.USA”, “143” ) );
cache.put( “153”, Langilearen berria( “Jhon”, “Chicago.USA”, “153” ) );
cache.put( “163”, Langilearen berria( “eta”, “Houston.USA”, “163” ) );
}
harrapatzeko( e CacheException )
{
e.printStackTrace();
}
}
void addEmployee publikoa( Langilearen EMP )
{
saiatu
{
cache.put( emp.getEmpid(), EMP );
}
harrapatzeko( e CacheException )
{
e.printStackTrace();
}
}
Publikoa Langilearen getEmployee( String empid )
{
return ( Langilearen )cache.get( EmpID );
}
void removeEmployee publikoa( String empid )
{
saiatu
{
cache.remove( EmpID );
}
harrapatzeko( e CacheException )
{
e.printStackTrace();
}
}
public static void main( Katea[] argumentuak )
{
// Sortu langile kudeatzailea
EmployeeManager empManager = EmployeeManager berria();
// langile Gehitu langile kudeatzailea
/*empManager.addEmployee(Langilearen berria(“Name1”, “Helbidea 1”, “empid1”));
empManager.addEmployee(Langilearen berria(“izena2”, “address2”, “empid2”));
empManager.addEmployee(Langilearen berria(“NAME3”, “address3”, “empid3”));*/
// Talde langilea
Langilearen EMP = empManager.getEmployee(“123”);
System.out.println( “Langilearen xehetasun cache eskuratuko: ” + emp.getName()+”-“+emp.getAddress());
// Kendu langilea
empManager.removeEmployee(“123”);
// langile kentzea ondoren
System.out.println( “Langilearen cache-tik kentzea ondoren xehetasunak: ” + empManager.getEmployee(“123”) );
}
}
Jarraitzen konfigurazio fitxategia da cache.ccf. euren balioekin konfiguragarria parametro guztiak egiten ditu. Lehenengo atalean, lehenetsi cache eskualde horrek balio lehenetsiak antolatzen da. no eskualdean pertsonalizatua konfiguratuta badago orduan balio lehenetsiak hauek erabiliko dira. Bigarren atalean pertsonalizatuan cache eskualde hau da definitzeko empCache here. pertsonalizatuan parametroaren balioak definitzen da. azken atala AUXILIARY CACHE eskualde horrek diska cache eta erlazionatutako beste parametro deskribatzen da.
Listing3: konfigurazio fitxategia erakustea
# DEFAULT CACHE REGION
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
# Aurrez erabakitako CACHE REGIONS
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
# AVAILABLE AUXILIARY cacheak
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
Ondorioa: Artikulu honetan katxeak kontzeptuak buruz eztabaidatu dugu eta Java Caching System bezala ezagutzen ezagunena katxeak esparru bat. Era berean estalita JCS eta horiek ezartzeko osagaiak. Azkenik lagin bat lanean adibidez eztabaidatu dugu oinarritutako Java Caching System-esparrua. JCS oso indartsua eta Java hizkuntzan idatzitako da. The biltegiratze mekanismo eta bere barne-diseinua oso irakurrita handiko eta put txikiko aplikazio indartsua dira. ezartzeko guztiz konfiguragarria da, beraz, edozein aplikazio berrien eta lehendik dela integratu ahal esfortzu handirik jarri gabe.
