Cenário: os dados de atualização de back -end são empurrados para o cliente (a parte Java usa o servidor Tomcat).
Existem muitas soluções para impulsionar os dados no back -end, como votação, cometa e websocket.
1. A pesquisa é o menor custo de desenvolvimento para o back -end, o que significa processar solicitações de Ajax e retornar os dados da maneira tradicional. Quando eu estava na escola, os projetos de laboratório sempre usavam a pesquisa porque é a mais segura e mais fácil de implementar. No entanto, o desperdício de recursos de comunicação causado pela pesquisa não pode ser ignorado. Independentemente de os dados mudarem ou não, a solicitação será enviada e respondida como de costume, e cada solicitação HTTP terá uma informação de cabeçalho longa.
2. O conceito de cometa é uma conexão longa. Depois que o cliente envia uma solicitação, o back-end mantém a conexão até que a conexão seja interrompida ou o back-end retorna dados e, em seguida, restabelece a conexão, transferindo efetivamente os recursos de comunicação para o servidor, que na verdade consome recursos do servidor.
3. O WebSocket é uma tecnologia de comunicação duplex completa fornecida pelo HTML5. Ele realiza a comunicação entre o cliente e o servidor através de "handshake". Tem um bom desempenho em tempo real e uma cabeça pequena. Os navegadores atualmente suportados são os seguintes:
A situação ideal é usar a combinação de websocket e cometa e usar o método do cometa para rebaixar navegadores como o IE8. Mas, dessa maneira, o back -end precisa implementar duas lógicas para solicitações de processamento, a saber, WebSocket e Comet. Portanto, este artigo adicionou node.js. O motivo para fazer isso é transferir a lógica que lida com o WebSocket (ou cometa) para a parte Node.js, e não "induz problemas" ao back-end, porque em situações reais, não é fácil para os desenvolvedores de front-end promover desenvolvedores de back-end. O Node.js é a camada intermediária para comunicação entre o navegador e a camada lógica de negócios Java, conectando o cliente ao tomcat e se comunicando com o tomcat através do soquete (é soquete, não webSocket, e o back -end precisa implementar a interface do soquete.
No cliente, WebSocket e Comet são implementados através do Socket.io. O Socket.io escolherá o método de implementação apropriado (WebSocket, Long Pull ..) para diferentes versões do navegador ou clientes diferentes. A introdução do soquete.io facilita o manuseio do WebSocket (ou conexão longa). Socket.io
O cliente apresenta soquete.io:
<script src = "static/js/socket.io.js"> </sCript>
Código JavaScript do cliente:
var soket = io.connect ('127.0.0.1:8181'); // Envie dados para o soquete do servidor.emit ('FromWebClient', jSondata); // Receba dados do soquete do servidor.on ('pushtowebclient', function (data) {// do sth.});Código do servidor Node.js:
var http = requer ('http'), app = http.createServer (). Ouça ('8181'), io = requer ('soket.io'). Ouça (app); io.sockets.on ('Connection', function (Socketio) {// Receba dados do Socketio.on ('FromWebClient', function (webclientData) {// do sth.}); // cliente desconectado 'desconectio (' desconect ',; Socketio.emit ('pushtowebclient', jsondata);Estabelecer uma boa conexão entre o cliente e o servidor Node.js é apenas a primeira etapa. O seguinte também requer estabelecer uma conexão entre o servidor Node.js e a camada lógica de negócios Java. No momento, o servidor Node.js serve como cliente para enviar uma solicitação de conexão TCP ao TomCat. Depois que a conexão é bem -sucedida, o Node.js Server e o TomCat estabelecem um canal duplex completo, e é o único. Não importa quantas solicitações do cliente sejam, elas são encaminhadas do servidor Node.js para TomCat; Da mesma forma, os dados pressionados pelo TomCat também são distribuídos a cada cliente através do servidor Node.js.
Há um problema aqui, ou seja, depois que as conexões do WebSocket e as conexões de soquete forem estabelecidas, as duas conexões são bloqueadas. O Tomcat não sabe qual conexão do WebSocket enviou os dados, nem sabe qual cliente enviou os dados. Obviamente, o Node.js pode usar o ID da sessão para enviar ao Tomcat para identificar qual cliente é, mas este artigo usa outro método.
Quando um cliente estabelece uma conexão WebSocket com o Node.js, cada conexão conterá uma instância, chamada Socketio aqui. Cada soquete possui um atributo de identificação para identificar exclusivamente essa conexão, que é chamada Socket_id aqui. Usando Socket_Id, uma tabela de mapeamento é estabelecida no servidor Node.js para armazenar a relação de mapeamento entre cada soquete e soquete_id. Quando o servidor Node.js envia dados para o TomCat, o Socket_Id é trazido com ele e, em seguida, a peça Java realiza uma série de processamento e encapsula os diferentes dados exigidos por cada cliente e o retorna. Os dados retornados devem ter um relacionamento correspondente com Socket_Id. Dessa forma, quando o servidor Node.js recebe os dados enviados pelo Tomcat, ele é distribuído a diferentes clientes por um soquete diferente através da tabela de mapeamento acima mencionada.
Código do servidor Node.js:
var http = require ('http'), net = requer ('net'), app = http.createServer (). Ouça ('8181'), io = requer ('soket.io'). escute (app), noderver = new.socket (); // Conecte -se ao tomcat modeServer.connect (8007, '127.0.0.1', function () {console.log ('conectado');}); // armazenar a instância de conexão Websocket do cliente var asocket = {}; // Crie uma conexão com o cliente io.sockets.on ('conexão', function (Socketio) {// Receba dados do cliente e envie -os para tomcat soockio.on ('fromwebclient', function (webclientData) {// armazenar a tabela de mapping asocks [socketio.id] = Socketio; = Socketio.id; }); // Receba dados do tomcat nodeServer.on ('dados', function (data) {var jSondata = json.parse (data.toString ()); // distribui dados ao cliente para (var i em jsondata.list) {asocket [jsondata.List [i] ['sid']]. jsondata.list [i] .Data);O código acima omite alguma lógica, como os dados recebidos pelo servidor Node.js do TomCat, é dividido em dois tipos, um é os dados pressionados e o outro é os dados que respondem à solicitação. Aqui, os dados pressionados são processados uniformemente.
Ao processar a comunicação, os dados enviados pelo Node.js para o tomcat estão em formato de string, e os dados recebidos do tomcat são um objeto buffer (oito bytes), que precisa ser convertido em string e depois convertido em json e enviado ao cliente.
Este artigo apenas fornece um exemplo simples dessas duas conexões, e muitas coisas precisam ser adicionadas aos negócios específicos. Como o Node.js é introduzido no projeto, o front-end precisa realizar mais coisas, como processamento, cache e até adicionar muita lógica de negócios.