läkarefirstinc.com

  

Bästa artiklarna:

  
Main / Hur man använder skriv bakom applikationen

Hur man använder skriv bakom applikationen

Som förkortning kommer "databas" att användas för att beskriva vilken datakälla som helst. En CacheStore är en applikationsspecifik adapter som används för att ansluta en cache till en underliggande datakälla. CacheStore-implementeringen får åtkomst till datakällan med hjälp av en datatillgångsmekanism, till exempel Hibernate, Toplink Essentials, JPA, applikationsspecifika JDBC-samtal, en annan applikation, mainframe, en annan cache och så vidare.

CacheStore förstår hur man bygger ett Java-objekt med hjälp av data som hämtas från datakällan, kartlägger och skriver ett objekt till datakällan och raderar ett objekt från datakällan. Både datakällans anslutningsstrategi och datakällan-till-applikations-objekt-mappningsinformationen är specifik för datakällschemat, applikationsklasslayouten och driftsmiljön. Därför måste denna mappningsinformation tillhandahållas av applikationsutvecklaren i form av en CacheStore-implementering.

Se "Skapa en CacheStore-implementering" för mer information. När ett program frågar cachen om en post, till exempel nyckeln X och X inte redan finns i cachen, kommer delegering automatiskt att delegeras till CacheStore och be den att ladda X från den underliggande datakällan. Om X finns i datakällan kommer CacheStore att ladda det, återställa det till koherens, sedan kommer koherens att placera det i cachen för framtida användning och slutligen returnera X till applikationskoden som begärde det.

Detta kallas läs-cachning. Uppdatera-framåt-cache-funktionalitet kan ytterligare förbättra läsprestandan genom att minska upplevd latens. Se "Uppfriskning-framåt-cachning" för mer information. Figur 9-1 Läs igenom cachning. Sammanhållning kan hantera uppdateringar av datakällan på två distinkta sätt, det första är genomskrivning.

I det här fallet, när applikationen uppdaterar en bit data i cachen, det vill säga, samtal sätts ... Detta förbättrar inte skrivprestanda alls, eftersom du fortfarande har att göra med skrivningens latens till datakällan. Förbättring av skrivprestanda är syftet med funktionen Skriv-bakom cache. Se "Skriv bakom cachning" för mer information. Figur 9-2 Genomskrivningscaching. I Scribe-Behind-scenariot skrivs modifierade cacheposter asynkront till datakällan efter en konfigurerbar fördröjning, antingen efter 10 sekunder, 20 minuter, en dag eller till och med en vecka eller längre.

För skriv-bak-cachning bibehåller koherens en efterbliven kö med de data som måste uppdateras i datakällan. När applikationen uppdaterar X i cachen läggs X till i efterhandskön om den inte redan finns där. annars ersätts den och efter den angivna fördröjningsfördröjningen kommer Coherence att ringa CacheStore för att uppdatera den underliggande datakällan med det senaste tillståndet X.

Observera att efterblivningsfördröjningen är relativt den första av en serie modifieringar - med andra ord kommer data i datakällan aldrig att ligga bakom cachen med mer än efterskrivningsfördröjningen. Resultatet är en "läs en gång och skriv med ett konfigurerbart intervall", vilket är mycket mindre ofta scenario. Det finns fyra huvudfördelar med denna typ av arkitektur :.

Applikationen förbättras i prestanda, eftersom användaren inte behöver vänta på att data ska skrivas till den underliggande datakällan. Uppgifterna skrivs senare och av en annan exekveringstråd.

Applikationen upplever drastiskt minskad databasbelastning: Eftersom mängden både läs- och skrivoperationer minskar, så är databasbelastningen också. Avläsningarna minskas genom cachning, som med alla andra cachningsmetoder. Skrivningarna, som vanligtvis är mycket dyrare operationer, reduceras ofta eftersom flera ändringar av samma objekt inom efterskrivningsintervallet "samlas" och bara skrivs en gång till den underliggande datakällan "skriv-koalescerande".

Dessutom kan skriv till flera cacheposter kombineras till en enda databastransaktion "skrivkombination" med hjälp av CacheStore. Applikationen är något isolerad från databasfel: Om data som applikationen använder finns i koherenscachen kan applikationen fortsätta utan att databasen är uppe. Detta är lätt att uppnå när du använder Coherence Partitioned Cache, som delar hela cachen över alla deltagande klusternoder med lokal lagring aktiverad, vilket möjliggör enorma cacheminnen.

Linjär skalbarhet: För att ett program ska hantera fler samtidiga användare behöver du bara öka antalet noder i klustret. effekten på databasen när det gäller belastning kan avstämmas genom att öka avskrivningsintervallet. Figur 9-3 Skriv bakom cachning. Medan det är möjligt att aktivera caching med bakomliggande cache är det helt enkelt en fråga om att justera en konfigurationsinställning, och se till att efterskrivning fungerar som förväntat är mer involverad. Specifikt måste applikationsdesign ta itu med flera designproblem i förväg.

Den mest direkta konsekvensen av efterbliven caching är att databasuppdateringar sker utanför cachetransaktionen; dvs cache-transaktionen kommer i de flesta fall att slutföras innan databastransaktionerna börjar.

Detta innebär att databastransaktionerna aldrig får misslyckas; om detta inte kan garanteras måste återbetalningar tillgodoses. Eftersom eftersläpning kan ombeställa databasuppdateringar, måste begränsningar för referensintegritet tillåta uppdateringar utan ordning. Konceptuellt innebär detta att använda databasen som ISAM-stil lagring primärnyckelbaserad åtkomst med garanti för motstridiga uppdateringar. Om andra applikationer delar databasen introducerar detta en ny utmaning - det finns inget sätt att garantera att en efterskriven transaktion inte kommer i konflikt med en extern uppdatering.

Detta innebär att bakomliggande konflikter måste hanteras heuristiskt eller eskaleras för manuell justering av en mänsklig operatör. Som en tumregel är det idealt att kartlägga varje uppdatering av cacheposter till en logisk databastransaktion, eftersom detta garanterar de enklaste databastransaktionerna.

Eftersom efterskott effektivt gör cache-systemet till registreringssystemet tills efterskrivningskön har skrivits till disk, måste affärsbestämmelser tillåta klusterhållbart snarare än diskbeständigt lagring av data och transaktioner.

Medan naturen i asynkron kö och belastningsgenomsnitt minimerade den direkta effekten av detta, kan det för vissa arbetsbelastningar vara problematiskt. Bästa praxis för berörda applikationer var att använda com. Från och med koherens 3. Om möjligt bör applikationer upphäva användningen av VersionedBackingMap om den endast användes för sitt skrivköbeteende. I scenariot Uppdatera-framåt tillåter koherens en utvecklare att konfigurera en cache för att automatiskt och asynkront ladda om uppdateringen av alla nyligen cache-poster från cache-laddaren innan den löper ut.

Resultatet är att efter att en post som ofta har öppnats har kommit in i cachen kommer applikationen inte att känna effekten av en läsning mot en potentiellt långsam cachelager när posten laddas om på grund av utgången.

Den asynkrona uppdateringen utlöses endast när ett objekt som är tillräckligt nära utgångstiden nås - om objektet nås efter utgångstiden kommer Coherence att utföra en synkron läsning från cacheminnet för att uppdatera dess värde. Uppdateringstiden uttrycks som en procentandel av postens utgångstid. Antag till exempel att utgångstiden för poster i cachen är inställd på 60 sekunder och uppdateringsfaktorn är inställd på 0.

Om det cachade objektet nås efter 60 sekunder kommer Coherence att utföra en synkron läsning från cacheminnet för att uppdatera dess värde. Men om en begäran utförs för en post som är mer än 30 men mindre än 60 sekunder gammal returneras det aktuella värdet i cachen och koherens schemalägger en asynkron omladdning från cacheminnet.

Uppdatering är särskilt användbart om objekt nås av ett stort antal användare. Värdena förblir fräscha i cacheminnet och den latens som kan orsakas av överdrivna omladdningar från cacheminnet undviks.

XML-kodfragmentet i exempel 9-1 konfigurerar en uppdateringsfaktor på 0. Detta innebär att om en post nås inom tio sekunder efter utgångstiden kommer den att planeras för en asynkron omladdning från cacheminnet.

Det finns två vanliga tillvägagångssätt för cache-åt sidan mönster i en grupperad miljö. En handlar om att leta efter en cachemiss, sedan fråga efter databasen, fylla i cacheminnet och fortsätta bearbetningen av applikationen. Detta kan resultera i flera databasbesök om olika applikationstrådar bearbetar samtidigt. Alternativt kan applikationer utföra dubbelkontrollerad låsning som fungerar eftersom kontrollen är atomär med avseende på cacheposten.

Detta resulterar emellertid i en betydande mängd omkostnader vid en cachemiss eller en databasuppdatering av ett klustrat lås, ytterligare läsning och klustrad upplåsning - upp till ytterligare 10 nätverkshopp eller 6-8 ms på en typisk gigabit Ethernet-anslutning, plus ytterligare bearbetning av overhead och en ökning av "låsetid" för en cachepost.

Genom att använda inbyggd caching låses posten endast för de två nätverkshopparna medan data kopieras till reservservern för feletolerans. Dessutom underhålls lås lokalt på partitionens ägare.

Dessutom hanteras applikationskoden helt på cacheservern, vilket innebär att endast en kontrollerad delmängd av noder kommer direkt åt databasen vilket resulterar i mer förutsägbar belastning och säkerhet.

Dessutom kopplar detta bort cache-klienter från databaslogik. Uppfriskning framåt erbjuder minskad latens jämfört med genomläsning, men bara om cachen exakt kan förutsäga vilka cacheobjekt som sannolikt kommer att behövas i framtiden. Med fullständig noggrannhet i dessa förutsägelser kommer uppdatering framåt att erbjuda minskad latens och ingen extra kostnad.

Ju högre graden av felberäkning är, desto större blir effekten på genomströmningen eftersom fler onödiga förfrågningar kommer att skickas till databasen - vilket till och med kan ha en negativ inverkan på latens om databasen börjar hamna efter på begäran.

Om kraven för efterbliven cachning kan uppfyllas kan efterblivna caching leverera betydligt högre genomströmning och minskad latens jämfört med genomskrivningscaching. Dessutom minskar cachning med bakomliggande belastningen på databasen färre skrivningar och på cacheservern minskade deserialisering av cachevärdet.

Alla CacheStore-operationer ska utformas så att de är idempotenta, det vill säga repeterbara utan oönskade biverkningar. För genomskrivnings- och efterblivna cachemöjligheter tillåter detta koherens att ge låg kostnadstolerans för partiella uppdateringar genom att försöka om databasdelen av en cacheuppdatering under failover-bearbetning.

För efterbliven caching tillåter idempotency också Coherence att kombinera flera cache-uppdateringar till en enda CacheStore-anrop utan att påverka dataintegriteten. Tillämpningar som har ett krav på cache-inskrivning men som måste undvika skrivkombination till exempel av granskningsskäl bör skapa en "versionerad" cache-nyckel, till exempel genom att kombinera den naturliga primära nyckeln med ett sekvens-id.

Sammanhållning stöder inte tvåfas CacheStore-operationer över flera CacheStore-instanser. Med andra ord, om två cacheposter uppdateras, vilket utlöser samtal till CacheStore-moduler som sitter på separata cacheservrar, är det möjligt för en databasuppdatering att lyckas och för den andra att misslyckas.

I det här fallet kan det vara att föredra att använda en cache-bort-arkitektur som uppdaterar cache och databas som två separata komponenter i en enda transaktion med applikationsserverns transaktionshanterare. I många fall är det möjligt att utforma databasschemat för att förhindra logiska åtagandefel men uppenbarligen inte serverfel.

Undantagscachning undviker detta problem eftersom "putter" inte påverkas av databasbeteende och de bakomliggande problemen har tagits upp tidigare i designprocessen. Denna begränsning kommer att tas upp i en kommande release av koherens.

Cachefrågor fungerar bara på data som är lagrade i cachen och kommer inte att utlösa CacheStore för att ladda eventuella saknade eller potentiellt saknade data. Därför bör applikationer som frågar CacheStore-backade cachar säkerställa att all nödvändig data som krävs för frågorna har förinstallerats. För effektivitet bör de flesta bulkbelastningsoperationer göras vid start av applikationen genom att strömma dataset direkt från databasen till cachebatchning av datablock i cachen med hjälp av NamedCache.

Lastarprocessen måste använda ett "Kontrollerbart Cachestore" -mönster för att inaktivera cirkulära uppdateringar tillbaka till databasen.

CacheStore kan styras med hjälp av en anropstjänst som skickar agenter över klustret för att modifiera en lokal flagga i varje JVM eller genom att ställa in värdet i en replikerad cache en annan cachetjänst och läsa den i varje CacheStore-metodanrop minimal kostnad jämfört med den typiska databasåtgärd.

CacheStore-implementeringar är pluggbara, och beroende på cachens användning av datakällan måste du implementera ett av två gränssnitt :. CacheLoader för skrivskyddade cachar. Dessa gränssnitt finns i com. CacheLoader-gränssnittet har två huvudsakliga metoder: För att ansluta en CacheStore-modul, ange CacheStore-implementeringsklassnamnet inom det distribuerade schemat, backing-map-schemat, cachestore-schemat eller läs-skriv-backing-map-schema, cache-konfiguration element.

Läs-skriv-backing-map-schemat konfigurerar en com. Denna bakgrundskarta består av två viktiga element:

(с) 2019 physiciansfirstinc.com