Gérer les données en utilisant un cache client utilisant Ajax

Gérer les données en utilisant un Client CacheLes performances de l'application dépend de la mémoire cache, qui sont implantés sur le client et côté serveur. Si les caches des résultats médiocres, la demande sera mal exécuter. Si les caches sont en vigueur, la demande sera efficace. Dans une large mesure, ce que je viens de dire est évident, mais je tiens à souligner que peu importe comment bien écrit les autres parties de votre code sont, si vous avez une mauvaise stratégie de mise en cache, la demande sera mal remplir. Quatre types de stratégie de mise en cache peuvent être mises en œuvre:

• HTTP validation: Un formulaire de mise en cache, où le client et partager des informations au sujet d'un navigateur Web utilisant un protocole de connexion. Cette forme de mise en cache ne réduit pas le compteur de la conversation, mais elle ne réduit la quantité de données est envoyé à la conversation. Utilisez cette approche si vous avez des données qui change régulièrement et votre connexion réseau entre le client et le serveur est d'une qualité haut débit.

• Client-side »: Un formulaire de mise en cache où seuls les fichiers de cache côté client les informations. En règle générale, vous utilisez cette approche lorsque le serveur ne supporte pas la mise en cache, ou si le voyage aller-retour entre le client et le serveur exige trop de temps.

• Server-side »: Un formulaire de mise en cache où seuls les fichiers de cache côté serveur de l'information. Le client sera constamment interroger le serveur pour que les informations appropriées. Cette forme de mémoire cache sont généralement inefficaces, et elle devrait être utilisée que si la distance physique du réseau entre le client et le serveur est minime (par exemple, le navigateur et le serveur sont sur le même ordinateur).

• Client et côté serveur: Un moyen idéal généralisé de la mise en cache lorsque le serveur et les informations du cache du client. Dans chacun de ces stratégies de mise en cache, vous devez penser à la bande passante disponible, quel type de données que vous avez reçu, et dans quelle mesure le client est en dehors de la serveur. Une inquiétude supplémentaire est le procurations assis entre le client et le serveur qui pourrait mettre en cache les informations.

Implémentation d'une requête unique cache clientUn cache effective et efficace devrait pas changer le modèle de programmation du client. Par conséquent, un cache côté client est le mieux mis en œuvre en modifiant la classe asynchrone. Alors à chaque fois un peu de code utilise asynchrone, le cache est vérifié et de voir si la réponse est déjà disponibles. Si la réponse est disponible, puis le code reçoit la réponse immédiatement. L'exemple suivant a des crochets pour faire usage d'une cache.

 Source: / client / scripts / jaxson / Common.js fonction Asynchronous_call (request) (var instance = this; if (! this.settings) (throw new Error ( "Paramètres n'est pas défini");) if (this.xmlhttp.readyState! = 4 & & this.xmlhttp.readyState! = 0) (throw new Error ( "demande Actuellement actif ne peut pas continuer");) this.xmlhttp.open (request.action, request.url, c'est vrai, this.settings.username, cette . settings.password); globals.info ( "demande d'ouverture" + request.url); if (Request.Headers) (for (defHeader dans Request.Headers) (this.xmlhttp.setRequestHeader (defHeader, Request.Headers [defHeader] );)) if (this.settings.headers) (for (defHeader dans this.settings.headers) (this.xmlhttp.setRequestHeader (defHeader, this.settings.headers [defHeader]);)) = this.settings.url request.url; if (this.cache.processAndBreakBeforeRequest (this.xmlhttp, this.settings demande,) == true) ( globals.info ( «les données récupérées depuis le cache de la demande» + instance.settings.url); return; )this.xmlhttp.onreadystatechange = function () (if (instance.xmlhttp.readyState == 4) (globals.info ( "Les données reçues pour la demande" + instance.settings.url); if (instance.cache.processAndBreakAfterRequest (instance.xmlhttp, instance.settings demande,) == true) ( return; )try (instance.settings.onComplete (instance.xmlhttp);) catch (e) (globals.errorHandler (e);))) try (this.xmlhttp.send (request.data);) catch (e) (globals. errorHandler (e);))

Le code asynchrone est très similaire à ce qui était présenté dans l'article 4. Les nouvelles pièces sont en gras. Accrocher un cache en mode asynchrone est simple: vous devez capturer la demande avant qu'il ne soit envoyé, puis capturez la réponse quand il arrive. Asynchrone ne met pas en oeuvre un cache, car il ya plusieurs façons de coder une cache. La meilleure stratégie, et celle choisie par asynchrone, est de déléguer les appels à une autre méthode. Dans le cas de la capture d'une demande, la méthode this.cache.processAndBreakBeforeRequest est appelée. L'objet XMLHttpRequest, la requête et les paramètres de l'instance asynchrones sont passés à la méthode. Si la méthode retourne vrai, Asynchronous_call puis retourne immédiatement. Le retour immédiat indique généralement que les données sont dans le cache, mais elle peut aussi être utilisé pour arrêter une requête.

Dans le cas de la capture d'une réponse, dans l'application de onreadystatechange est une demande à la méthode instance.cache.processAndBreakAfterRequest. Trois paramètres sont passés à la méthode: une instance de XMLHttpRequest, demande, et les paramètres. Sur la base de ces trois paramètres, le cache peut stocker les données des réponses puissent être récupérés à une date ultérieure. Si processAndBreakAfterRequest la méthode retourne true, alors les données de réponse n'est pas envoyée à la méthode onComplete. De manière générale, vous ne feriez pas cela, mais elle est nécessaire si vous mettez en oeuvre un cache HTTP validation.

Le type de cache que vous voulez mettre en œuvre dépend de vos besoins. Il peut être soit un cache côté client ou d'un cache de validation HTTP. Dans le cadre de l'application Stock Ticker, un seul cache demande du client est créé. Le cache de requête unique client en cache à chaque demande une fois et ne jamais faire une demande de seconde physique HTTP. C'est parfait pour le cas de l'exemple de téléscripteur boursier, car les données historiques ticker ne change jamais. Si les données devaient changer, vous aurez besoin d'avoir un moyen d'indiquer des données périmées. Dans un tel cas, la validation d'un cache HTTP serait plus approprié. Le code suivant est la mise en œuvre d'un seul cache demande du client.

 Source: / client / scripts / jaxson / var Common.js CacheController = (_cache: nouveaux paramètres Array ()) function CachedProcessAndBreakBeforeRequest (request, settings) (if (request.action == "GET") (var obj = CacheController._cache [ . url]; if (obj! = null) (var fakeXMLHttp = (status: 200, statusText: obj.StatusText, responseText: obj.ResponseText, responseXML: obj.ResponseXML) try (settings.onComplete (fakeXMLHttp);) catch ( e) (globals.errorHandler (e); return false) return true;)) return false;) function CachedProcessAndBreakAfterRequest (XMLHTTP, demande, réglages) (if (xmlhttp.status == 200 & & request.action == "GET") (CacheController._cache [settings.url] = (Statut: xmlhttp.status, StatusText: xmlhttp.statusText, responseText: xmlhttp.responseText, responseXML: xmlhttp.responseXML);) return false;)

Le client demande unique cache côté ne fonctionne que lorsque les protocoles HTTP GET est appelée, ce qui est totalement logique, mais ne soulèvent la question de savoir si un POST, DELETE ou de vente pourront être mis en cache. La réponse est, oui ils peuvent, si le cache est intelligents. Par exemple, si vous étiez à mettre en cache un PUT, puis quand la même URL est appelé en utilisant GET, vous n'avez pas besoin d'interroger le serveur. Cette stratégie peut vous causer des ennuis si il ya une chance que les utilisateurs multiples seront l'exécution d'un PUT. Mais il ya une optimisation que vous pouvez spin off un fil JavaScript et d'interroger le statut des données envoyées par le mis en utilisant HTTP validation. Il est important de réaliser que vous pouvez régler le cache en fonction de vos préférences. Vous pouvez même régler le cache de sorte qu'il peut URL précontrainte lorsque certaines URL ont été demandés.

Le client demande unique cache côté n'est pas si intelligent et renvoie un objet si elle existe dans le cache, sinon, il interroge le serveur HTTP. La fonction est appelée avant CachedProcessAndBreakBeforeRequest asynchrone fait une demande physique. Lorsque la fonction est appelée, l'existence de l'URL est testé dans l'objet CacheController._cache. Si l'URL n'existe pas, alors FALSE est retourné, indiquant que l'URL doit être exécuté. Si l'URL existe, alors un objet mis en cache n'existe. L'existence d'un objet mis en cache signifie qu'il n'est pas nécessaire d'appeler le serveur, et la méthode onComplete le code peut être appelé directement. Le seul problème avec l'objet mis en cache est qu'il n'y a aucune disponible XMLHttpRequest.

La solution à ce problème est de créer une instance de faux XMLHttpRequest. Utilisation de JavaScript, il est facile de créer un objet fantaisie. Lorsque la situation devient plus délicate, c'est que les méthodes n'ont pas été définies, elles ne sont donc pas disponibles. Les en-têtes ne sont pas disponibles parce qu'ils n'ont pas été stockés dans l'objet quand l'objet en cache a été créé. Encore une fois, le fait que les en-têtes ne sont pas stockées dans le cache souligne qu'il s'agit d'une implémentation simple de XMLHttpRequest. La variable fakeXMLHttp représente l'objet XMLHttpRequest et faux est utilisée pour appeler la méthode settings.onComplete du code. Parce settings.onComplete est appelée, le cache renvoie une valeur fausse, ce qui indique que asynchrone ne doit pas faire une requête HTTP.

L'autre partie du code est la fonction de cache CacheProcessAndBreakAfterRequest, qui est utilisé pour ajouter une entrée objet mis en cache. L'ajout de l'objet pour mettre en cache est limitée à un code de statut HTTP de 200 et un serveur HTTP GET. Si l'objet est ajouté à la cache, puis l'objet XMLHttpRequest de propriété, statut, statusText, responseText, et responseXML sont enregistrées. Si vous voulez créer une implémentation complète de l'objet XMLHttpRequest faux et enregistrer les en-têtes HTTP, vous devez mettre ce code dans la fonction CacheProcessAndBreakAfterRequest. Comme alternative, vous pourriez être tenté d'enregistrer une référence à l'instance XMLHttpRequest. Le problème est que le cache n'est pas dans le contrôle de l'instance de XMLHttpRequest, donc en enregistrant une référence, vous ne sauvegardez pas les données, comme l'instance asynchrone pouvait réutiliser l'instance XMLHttpRequest pour une autre demande. Par conséquent, chaque fois que la mise en œuvre de votre cache, vous devez copier les informations qui doivent être enregistrés dans le cache.

Implémentation d'une validation du client HTTP CacheLa mise en œuvre du cache est simple en ce que une fois qu'une demande a été exécutée et enregistrée, elle ne sera jamais exécutée à nouveau. Pour les URL où les données ne change jamais, c'est acceptable. Toutefois, il existe des URL où les données sont modifiées, comme c'est le cas avec un ticker stocks en temps réel, et le cache de requête unique client est totalement inacceptable. Dans ces situations, le cache de requête unique client doit être étendue pour utiliser HTTP validation.

Expiration de la mise en cache HTTP est une mauvaise idée (en général) Lorsque vous utilisez HTTP validation, vous laissez l'infrastructure Internet de gérer le cache. Il existe deux modèles: HTTP HTTP d'expiration et de validation. Lors de l'utilisation HTTP d'expiration, Vous dites que le contenu est valide pour une certaine période de temps. La période de temps pendant lequel les données sont valides dépend de ce que les en-têtes HTTP dire. Il n'est généralement pas une bonne idée d'utiliser le modèle d'expiration HTTP; plutôt, il est préférable d'utiliser HTTP validation et écrire du code pour aider à l'infrastructure Internet à faire son travail. Pour comprendre pourquoi le modèle d'expiration HTTP est problématique, envisager le scénario suivant. Supposons que vous exécutez AWeb site qui héberge de nouvelles RSS. Pour réduire le trafic répétitifs sur le site Web, vous permettez la mise en cache HTTP et attribuer une date d'expiration de 30 minutes. (La date d'expiration est une valeur arbitraire utilisée à des fins d'illustration.) Cela signifie que lorsque le navigateur télécharge des contenus, la prochaine version du contenu sera disponible dans 30 minutes. Indiquant une période d'attente de 30 minutes est une mauvaise idée dans que 30 minutes, nouvelles peuvent changer radicalement.

Un client qui a téléchargé une partie du contenu est alors limitée à l'extraction de nouvelles en 30 cycles minute. Bien sûr, le client ne pouvait ignorer ou vider la mémoire cache, ce qui entraîne le téléchargement de la dernière information. Si le client se vide toujours le cache, le client aura toujours obtenir les dernières nouvelles, mais à un coût du téléchargement de contenu qui mai ne pas avoir changé. Le coût des ressources ne devrait surprendre personne, car toujours obtenir le dernier contenu en utilisant des moyens sans mise en cache que ce soit. Scripts tels que les servlets Java / JSP ou des pages ASP.NET utilisent souvent cette stratégie, et l'administrateur de la gestion du site Web se demande pourquoi il ya des problèmes de performance.

un article présenté par Sonja Lande

Disclaimer:Notre site n'est pas responsable du contenu de cet article. Webarticles est une ressource d'information gratuite.
Important: Cet article «Gérer les données en utilisant un client cache en utilisant Ajax" a été traduit par un logiciel automatique. Nous nous sentons désolés pour les fautes d'orthographe que mai ont eu lieu. Nous vous remercions de votre compréhension.