Scénario: les données de mise à jour du backend sont poussées au client (la partie Java utilise le serveur Tomcat).
Il existe de nombreuses solutions pour pousser les données dans le backend, telles que le sondage, la comète et WebSocket.
1. Le sondage est le coût de développement le plus bas pour le backend, ce qui signifie traiter les demandes AJAX et le retour des données de la manière traditionnelle. Lorsque j'étais à l'école, les projets de laboratoire ont toujours utilisé des sondages car il est le plus sûr et le plus facile à mettre en œuvre. Cependant, le gaspillage des ressources de communication causés par le sondage ne peut être ignoré. Que les données changent ou non, la demande sera envoyée et répondu comme d'habitude, et chaque demande HTTP aura une longue information d'en-tête.
2. Le concept de comète est une longue connexion. Une fois que le client a envoyé une demande, le backend maintient la connexion jusqu'à ce que la connexion soit chronométrée ou que le backend renvoie les données, puis rétablit la connexion, en transférant efficacement les ressources de communication vers le serveur, qui consomme réellement les ressources du serveur.
3. WebSocket est une technologie de communication complète fournie par HTML5. Il réalise la communication entre le client et le serveur via "Handshake". Il a de bonnes performances en temps réel et une petite tête. Les navigateurs actuellement pris en charge sont les suivants:
La situation idéale consiste à utiliser la combinaison de WebSocket et de comète, et d'utiliser la méthode de la comète pour rétrograder les navigateurs tels que IE8. Mais de cette manière, le backend doit implémenter deux logiques pour le traitement des demandes, à savoir WebSocket et Comet. Par conséquent, cet article a ajouté Node.js. La raison de cela est de transférer la logique qui gère WebSocket (ou comète) dans la partie Node.js, et non "induire des problèmes" au backend, car dans les situations réelles, il n'est pas facile pour les développeurs frontaux de promouvoir les développeurs back-end. Node.js est la couche intermédiaire de communication entre le navigateur et la couche Java Business Logic, la connexion du client à Tomcat et la communication avec Tomcat via Socket (c'est Socket, pas WebSocket, et le backend doit implémenter l'interface de socket.
Sur le client, WebSocket et Comet sont implémentés via socket.io. Socket.io choisira la méthode d'implémentation appropriée (WebSocket, Long Pull ..) pour différentes versions de navigateur ou différents clients. L'introduction de socket.io facilite la gestion de WebSocket (ou de la connexion longue). Socket.io
Le client présente Socket.io:
<script src = "static / js / socket.io.js"> </ script>
Code JavaScript client:
var socket = io.connect ('127.0.0.1:8181'); // Envoi des données au serveur socket.emit ('fromwebclient', jSondata); // reçoit des données de serveur socket.on ('pushtowebclient', function (data) {// do sth.});Code du serveur Node.js:
var http = require ('http'), app = http.createServer (). écouter ('8181'), io = require ('socket.io'). écouter (app); io.sockets.on ('connexion', fonction (sockettio) {// recevoir des données du client sockettio.on ('fromwebclient', function (webClientData) {// Do sth.}); // client déconnecter socketo.on ('déconnecter', function () {console.log ('disconnected du client');}); socketio.emit ('pushtowebclient', jSondata);});L'établissement d'une bonne connexion entre le client et le serveur Node.js n'est que la première étape. Ce qui suit nécessite également l'établissement d'une connexion entre le serveur Node.js et la couche Java Business Logic. À l'heure actuelle, le serveur Node.js sert de client pour envoyer une demande de connexion TCP à Tomcat. Une fois la connexion réussie, le serveur Node.js et Tomcat établissent un canal duplex complet, et c'est le seul. Peu importe le nombre de demandes des clients, ils sont transmis du serveur Node.js à Tomcat; De même, les données poussées par Tomcat sont également distribuées à chaque client via le serveur Node.js.
Il y a un problème ici, c'est-à-dire que les connexions WebSocket et les connexions de socket sont établies, les deux connexions sont bloquées. Tomcat ne sait pas quelle connexion WebSocket a envoyé les données, et il ne sait pas quel client a envoyé les données. Bien sûr, Node.js peut utiliser l'ID de session pour envoyer à Tomcat pour identifier le client qu'il s'agit, mais cet article utilise une autre méthode.
Lorsqu'un client établit une connexion WebSocket avec Node.js, chaque connexion contiendra une instance, qui est appelée socketio ici. Chaque sockettio a un attribut d'ID pour identifier de manière unique cette connexion, qui est appelée socket_id ici. À l'aide de socket_id, une table de mappage est établie sur le serveur Node.js pour stocker la relation de mappage entre chaque sockettio et socket_id. Lorsque le serveur Node.js envoie des données à Tomcat, le socket_id est apporté avec lui, puis la pièce Java effectue une série de traitement, puis résume les différentes données requises par chaque client et les renvoie. Les données renvoyées doivent avoir une relation correspondante avec socket_id. De cette façon, lorsque le serveur Node.js reçoit les données envoyées par Tomcat, elle est distribuée à différents clients par différents socketio via la table de mappage susmentionnée.
Code du serveur Node.js:
var http = require ('http'), net = require ('net'), app = http.createServer (). écouter ('8181'), io = require ('socket.io'). écouter (app), nodeServer = new Net.Socket (); // Connectez-vous à TomCat NodeServer.Connect (8007, '127.0.0.1', fonction () {console.log ('connecté');}); // Stockez l'instance de connexion WebSocket du client var asocket = {}; // Créer une connexion avec le client io.sockets.on ('connexion', fonction (sockettio) {// recevoir des données du client et l'envoyer à tomcat sockettio.on ('fromwebclient', function (webClientData) {// store à la table de mappage asocku socketio.ID; }); // reçoit des données de tomcat nodeserver.on ('data', fonction (data) {var jSondata = JSON.Parse (data.toString ()); // Distribuez des données au client pour (var i dans jsondata.list) {asocket [jSondata.list [i] ['sid'] jsondata.list [i] .data);}});Le code ci-dessus omet une logique, comme les données reçues par le serveur Node.js de Tomcat est divisée en deux types, l'une est les données poussées, et l'autre est les données répondant à la demande. Ici, les données poussées sont uniformément traitées.
Lors du traitement de la communication, les données envoyées par Node.js à Tomcat sont au format String, et les données reçues de Tomcat sont un objet tampon (huit octets), qui doit être converti en chaîne puis converti en JSON et envoyée au client.
Cet article donne juste un exemple simple de ces deux connexions, et beaucoup de choses doivent être ajoutées à l'entreprise spécifique. Étant donné que Node.js est introduit dans le projet, le front-end doit entreprendre plus de choses, comme le traitement, la mise en cache et même l'ajout de beaucoup de logique commerciale.