Oorsig: In die moderne program ontwikkeling kas is een van die belangrikste aspekte tydens toediening ontwerp in ag geneem word. Die mees algemene doel van die kas is om prestasie te verbeter. 'N kas kan gedefinieer word as 'n versameling voorwerpe. Dit bevat Stateful voorwerpe met sleutels as unieke identifiseerders. Die mees algemene stoor vir enige kas stelsel is ter nagedagtenis. Maar kas stelsel kan ook items in skyf stoor, databasis of enige ander aanhoudende stoor. Die Java Caching System (JCS) is 'n verspreide kas raamwerk ontwikkel in Java. Dit verbeter die aansoek prestasie deur die verskaffing van ondersteuning aan verskeie dinamiese kas data.JCS bestuur ondersteun in die geheue en skyf caches. Die JCS raamwerk is heeltemal instel deur eienskappe lêer en bied baie buigsaamheid in die kas bestuur.
In hierdie artikel sal ek die JCS raamwerk met werkende voorbeeld bespreek.
Inleiding: In die meeste van die web-programme, data word op die databasis beskikbaar. Die databasis werking is duur en tydrowend. Nou 'n dag die web programme is data intensiewe en eerste reaksie tyd is die basiese kriteria vir die sukses. As die web-program gereeld toegang tot databasis vir elke versoek dan sal sy prestasie stadig. So het die web-programme volg verskillende ontwerp tegnieke vir die vermindering van latency tye en skaal.
JCS is 'n saamgestelde versprei caching stelsel wat werk op JDK 1.4 en bo-weergawes. Die prestasie van JCS is baie indrukwekkend vir 'n lae sit en 'n hoë Lees aansoeke.
Hier volg 'n paar van die belangrikste eienskappe van Java Caching System
· Memory management
· Thread pool control
· Extensible framework
· Configurable runtime parameters
· Key based data retrieval
· Distributed composite cache
· Element event handling
JCS - Die Saamgestelde Cache: Die fondament van Java Caching stelsel is gebaseer op saamgestelde kas. Daar is vier tipes caches beskikbaar vir elke streek. Enige tipe kas kan ingeprop in die JCS opset om dit aktief te maak. Hier volg die vier verskillende caches en hul besonderhede.
- Kasgeheue (LRU): Dit is die mees gebruikte basiese kas meganisme. Die geheue kas is baie vinnig. Dit maak gebruik van die minste Onlangs gebruikte (LRU) algoritme om die voorwerpe in die geheue gestoor te bestuur. Die LRU geheue kas is gebaseer op sy eie LRU Map implementering. Dit Map implementering is baie vinniger in vergelyking met LRUMap implementering of enige ander tipe Kaart.
- Disk Cache (geïndekseer): Die skyf cache word gebruik om data te stoor wanneer die geheue kas is vol. Wanneer kruip gebruik met die skyf kas, die prestasie baie vinniger. Tou gebaseer proses word gebruik om data te stoor op die skyf. Die skyf kas is heeltemal konfigureerbare. 'N draad swembad gebruik word om te bestuur die tou werker drade wat ook die proses vinniger te maak.
- JDBC Disk Cache: Dit is 'n ander soort skyf kas wat betroubaar, vinnig en ten volle instel. Die basiese stoor is JDBC versoenbaar databasis. Beide die sleutels en waardes word gestoor in die databasis. Die data gestoor word as 'n blob en die verval data-elemente word ook van tyd tot tyd verwyder. Draad swembad kan ook gebruik word om te bestuur tou werker drade vir vinniger verwerking.
- TCP Laterale Cache: Dit is 'n meganisme om die kas data op verskeie versprei bedieners versprei. Dit is ook heeltemal konfigureerbare kas stelsel. Dit kan ook gebruik UDP ontdekking meganisme om knope te voeg sonder om die hele stelsel te versteur. Die TCP Laterale Cache vestig verbinding met socket bedieners op ander nodes en voer die stoor bestuur. Een bediener is voldoende om verskeie streke te bestuur.
- Remote Cache met behulp van RMI: Dit is nog 'n kas opsie wat deur JCS. In hierdie meganisme is elke node nie nodig om met ander node. Die afgeleë kas bediener kan gebruik word as 'n aansluitingspunt en elke knoop kan konnekteer met dit. Die afgeleë kas bediener gebruik word om 'n serialized weergawe van jou voorwerp te hou. Die afgeleë bediener kan gegroepeer met ander bedieners te fail herstel.
afhanklikheid opset: In die volgende artikel sal ons 'n eenvoudige program met behulp van JCS bespreek. Voordat hulle in dit, Ons moet die volgende afhanklikes in die classpath het. Laai asseblief die uitvoerbare pype en sit dit in die classpath om die aansoek te bou.
- JCS-1.3.jar
- Commons-logging.jar
- Commons-lang-2.4.jar
- jar
Werk met JCS: In hierdie afdeling sal ons verskillende komponente van Java Caching System en die opset besonderhede bespreek. Ons sal elke komponent met werkende voorbeeld verduidelik.
Hier volg 'n eenvoudige werknemer klas hou werknemer besonderhede. Die klas moet implementeer serialiseerbaar koppelvlak as die data sal volgehou. Dit bevat lucky / setter metodes vir lees en skryf data.
Listing1: Resultate Werknemer klas
openbare klas Employee implemente java.io.Serializable{
private naam String;
private String adres;
private String empid;
openbare Werknemer(string naam, string adres, string empid) {
this.name = naam;
this.address = posadres;
this.empid = empid;
}
openbare String getName() {
terugkeer naam;
}
public void setName(string naam) {
this.name = naam;
}
openbare String getAddress() {
terugkeer adres;
}
public void setAddress(string adres) {
this.address = posadres;
}
public String getEmpid() {
terugkeer empid;
}
public void setEmpid(string empid) {
this.empid = empid;
}
}
Volgende is die belangrikste EmployeeManager klas wat JCS pakkette voer om die raamwerk API te gebruik. Dit maak gebruik van 'n kas streek bekend as 'EmpCache' om data in / sit en kry uit die geheue. Die data gestoor word in die kasgeheue deur die gebruik van sleutel / waarde paar. Die herwinning is gebaseer op die sleutel wat verband hou met elke waarde. Die aansoek toon Daarbenewens / herwinning en verwydering van voorwerpe gestoor in 'n kas.
Listing2: Resultate EmployeeManager klas
invoer org.apache.jcs.JCS;
invoer org.apache.jcs.access.exception.CacheException;
openbare klas EmployeeManager {
private JCS kas;
openbare EmployeeManager()
{
probeer
{
// Laai die kas
kas = JCS.getInstance( “empCache” );
// Inisialiseer die kas, Hier data kan tydens inisialisering gelaai
cache.put( “123”, nuwe werknemer( “Nick”, “Detroit.USA”, “123” ) );
cache.put( “143”, nuwe werknemer( “Ric”, “Seattle.USA”, “143” ) );
cache.put( “153”, nuwe werknemer( “Jhon”, “Chicago.USA”, “153” ) );
cache.put( “163”, nuwe werknemer( “en”, “Houston.USA”, “163” ) );
}
vang( e CacheException )
{
e.printStackTrace();
}
}
public void addEmployee( werknemer OBP )
{
probeer
{
cache.put( emp.getEmpid(), OBP );
}
vang( e CacheException )
{
e.printStackTrace();
}
}
public Employee getEmployee( string empid )
{
return ( werknemer )cache.get( EmpID );
}
public void removeEmployee( string empid )
{
probeer
{
cache.remove( EmpID );
}
vang( e CacheException )
{
e.printStackTrace();
}
}
openbare statiese nietig hoof( String[] argumente )
{
// Skep die werknemer bestuurder
EmployeeManager empManager = nuwe EmployeeManager();
// werknemers dra by tot die werknemer bestuurder
/*empManager.addEmployee(nuwe werknemer(“NAME1”, “Adres 1”, “empid1”));
empManager.addEmployee(nuwe werknemer(“NAME2”, “adres 2”, “empid2”));
empManager.addEmployee(nuwe werknemer(“NAME3”, “address3”, “empid3”));*/
// kry werknemer
Employee emp = empManager.getEmployee(“123”);
System.out.println( “Werknemer besonderhede opgespoor van die kas: ” + emp.getName()+”-“+emp.getAddress());
// verwyder werknemer
empManager.removeEmployee(“123”);
// Na verwydering van werknemer
System.out.println( “Werknemer besonderhede na die verwydering van die kas: ” + empManager.getEmployee(“123”) );
}
}
Na aanleiding van die konfigurasielêer cache.ccf. Dit hou al die konfigureerbare parameters met hul waardes. Die eerste gedeelte is die standaard kas streek wat die standaard waardes hou. Indien geen persoonlike streek dan is ingestel dié verstek waardes gebruik gaan word. Die tweede afdeling word die definisie van die persoonlike kas streek wat empCache hier. Dit omskryf die persoonlike parameterwaardes. Die laaste gedeelte is die hulpwerkwoord CACHE streek wat die skyf kas en ander verwante parameters beskryf.
Listing3: Resultate konfigurasielêer
# DEFAULT CACHE STREEK
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 = vals
jcs.default.cacheattributes.MaxMemoryIdleTimeSeconds = 3600
jcs.default.cacheattributes.ShrinkerIntervalSeconds = 60
jcs.default.elementattributes = org.apache.jcs.engine.ElementAttributes
jcs.default.elementattributes.IsEternal = vals
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
# Pre-gedefinieerde CACHE GEBIEDE
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 = vals
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 = vals
# BESKIKBAAR ONDERSTEUNENDE caches
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
Gevolgtrekking: In hierdie artikel het ons gepraat oor caching konsepte en een van die mees gewilde kas raamwerk bekend as Java Caching System. Die artikel bedek ook verskillende komponente van JCS en die implementering daarvan. Ten slotte het ons 'n voorbeeld werkende voorbeeld bespreek gebaseer op Java Caching System raamwerk. Die JCS is baie sterk en geskryf in Java taal. Die stoor meganisme en sy interne ontwerp is baie sterk vir 'n hoë Lees en lae sit aansoeke. Die implementering is heeltemal konfigureerbare sodat dit kan geïntegreer word met enige nuwe en bestaande aansoek sonder om veel moeite.
