Einfache Möglichkeit zum Implementieren von Server Gesendeten Ereignisse in Node.js?

Hab ich sah sich um und es scheint, als ob alle die Wege zur Umsetzung einer SSEs in Node.js durch komplexeren code, aber es scheint, es sollte eine einfachere Möglichkeit zum senden und empfangen von SSEs. Gibt es irgendwelche APIs oder die Module, einfacher geht es?

was über die Verwendung von sockets?
SSE läuft auf HTTP und HTTP läuft über TCP-sockets 🙂 "websockets" wäre passender. Allerdings gibt es ein buch von Bibliotheken, die SSE heute. Ich persönlich erstellten npmjs.com/package/@toverux/expresse, weil ich unzufrieden war, durch die vorhandenen Pakete.

InformationsquelleAutor Jasch1 | 2016-03-27

-10

Sollten Sie in der Lage sein, so etwas zu tun mit Socket.io. Erste, Sie brauchen, um es zu installieren mit npm install socket.io. Von dort aus, in Ihrem code, den Sie haben wollen var io = require(socket.io);

Können Sie sehen, weitere ausführliche Beispiele von Socket.IO

Könnten Sie so etwas wie dieses auf dem server:
```
var express = require('express');
var app = express();
var server = require('http').createServer(app);
var io = require('../..')(server);
var port = process.env.PORT || 3000;

server.listen(port, function () {
  console.log('Server listening at port ' + port);
});

app.use(express.static(__dirname + '/public'));

io.on('connection', function (socket) {
    socket.emit('EVENT_NAME', {data});
});
```
Dass so etwas wie dies auf dem client:
```
<script src="socket_src_file_path_here"></script>
<script>
  var socket = io('http://localhost');
  socket.on('EVENT_NAME', function (data) {
    console.log(data);
    //Do whatever you want with the data on the client
  });
</script>
```
- Danke für die eingehende Antwort mit Beispielen!
- Ich bin absolut gegen diese Vorgehensweise! Ich bin mit der Buchse.IO-für eine lange Zeit jetzt, und ich kann sicher sagen, dass es eine Menge von Schmerzen, die Sie beginnen zu kämpfen, wie die Zeit vergeht. Server-Side-Events sind unidirektional, und die Steckdosen sind bidirektional. Ein Anfrage-Antwort-Typ, und der andere ist lang-Art der Verbindung. Der Unterschied ist riesig, und Sie absolut nicht brauchen-Steckdosen - Sie wird zu tun haben mit Wiederherstellung der Verbindung, spam Schutz, server down geht, vielleicht Clustern. Gehen Sie mit einfachen SSE, die es bereits in Browsern! Siehe andere Antworten dafür!
- Der OP fragte nach SSE, keine WebSockets.
InformationsquelleAutor

Hier ist ein express-server sendet eine Server-Sent Events (SSE) pro Sekunde, die einen Countdown von 10 bis 0:

const express = require('express')

const app = express()
app.use(express.static('public'))

app.get('/countdown', function(req, res) {
  res.writeHead(200, {
    'Content-Type': 'text/event-stream',
    'Cache-Control': 'no-cache',
    'Connection': 'keep-alive'
  })
  countdown(res, 10)
})

function countdown(res, count) {
  res.write("data: " + count + "\n\n")
  if (count)
    setTimeout(() => countdown(res, count-1), 1000)
  else
    res.end()
}

app.listen(3000, () => console.log('SSE app listening on port 3000!'))

Setzen Sie den obigen code in eine Datei (index.js) und führen Sie es: node index

Als Nächstes fügen Sie den folgenden HTML-Code in eine Datei (public/index.html):

<html>
<head>
  <script>
  if (!!window.EventSource) {
    var source = new EventSource('/countdown')

    source.addEventListener('message', function(e) {
      document.getElementById('data').innerHTML = e.data
    }, false)

    source.addEventListener('open', function(e) {
      document.getElementById('state').innerHTML = "Connected"
    }, false)

    source.addEventListener('error', function(e) {
      const id_state = document.getElementById('state')
      if (e.eventPhase == EventSource.CLOSED)
        source.close()
      if (e.target.readyState == EventSource.CLOSED) {
        id_state.innerHTML = "Disconnected"
      }
      else if (e.target.readyState == EventSource.CONNECTING) {
        id_state.innerHTML = "Connecting..."
      }
    }, false)
  } else {
    console.log("Your browser doesn't support SSE")
  }
  </script>
</head>
<body>
  <h1>SSE: <span id="state"></span></h1>
  <h3>Data: <span id="data"></span></h3>
</body>
</html>

Öffnen Sie In Ihrem browser localhost:3000 und beobachten Sie die SSE-countdown.

Ich würde sagen, diese Antwort ist der einfachste Weg, zu "Implementieren von Server Gesendeten Ereignisse in Node.js"

InformationsquelleAutor Brent Washburne

10

Server gesendeten Ereignisse sind ziemlich einfach. Werfen Sie einen Blick auf meine zwei teilige blog-post über genau das.
1. http://bayn.es/real-time-web-applications-with-server-sent-events-pt-1/
2. http://bayn.es/real-time-web-apps-with-server-sent-events-pt-2/
- Obwohl es ein wenig kompliziert, ich mag die Idee der Verwendung von Redis. Es ist einfach zu installieren und sehr, sehr mächtig und robuste Lösung. Es wird entfernen Sie die Notwendigkeit, die Entwicklung der Kanäle und alle, die mit seiner internen Funktionen. Es lohnt sich, investieren Zeit lernen. Gutes Beispiel!
InformationsquelleAutor baynezy
3

Fand ich die SSE-Implementierung in node.js.

Github-link: https://github.com/einaros/sse.js

NPM-Modul:https://www.npmjs.com/package/sse

Wird obige link hilft Sie ?

InformationsquelleAutor Gurucharan M K

**client.js**

var eventSource = new EventSource("/route/events");
eventSource.addEventListner("ping", function(e){log(e.data)});

//if no events specified
eventSource.addEventListner("message", function(e){log(e.data)});

**server.js**

http.createServer((req, res)=>{

    if(req.url.indexOf("/route/events")>=){

      res.setHeader('Connection', 'keep-alive');

      res.setHeader("Cache-Control", "no-cache");

      res.setHeader("Content-Type", "text/event-stream");

      let event = "event: ping";

      let id = `id: ${Date.now()}`;

      let data = {
         message:`hello @${new Date().toString()}`
      }

      data = "data: "+JSON.stringify(data);

      res.end(`${event}\n${id}\n${data}\n\n`);
   }
}).listen(PORT)

InformationsquelleAutor Manish Kumar

Ich bin das hinzufügen einer einfachen Implementierung der SSE hier. Es ist nur eine Node.js Datei.

Können Sie einen Blick auf das Ergebnis hier: https://glossy-ox.glitch.me/

const http = require('http');
const port = process.env.PORT || 3000;

const server = http.createServer((req, res) => {
  //Server-sent events endpoint
  if (req.url === '/events') {
    res.writeHead(200, {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive',
    });

    const refreshRate = 1000; //in milliseconds
    const id = Date.now();
    const data = `Hello World ${id}`;
    const message =
      `retry: ${refreshRate}\nid:${id}\ndata: ${data}\n\n`;
    res.end(message);
    return;
  }

  //Client side
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.end(`
    <!DOCTYPE html>
    <html lang="en" dir="ltr">
      <head>
        <meta charset="utf-8">
        <title>SSE</title>
      </head>
      <body>
        <pre id="log"></pre>
      </body>
      <script>
        var eventSource = new EventSource('/events');
        eventSource.onmessage = function(event) {
          document.getElementById('log').innerHTML += event.data + '<br>';
        };
      </script>
    </html>
  `);
});

server.listen(port);

server.on('error', (err) => {
  console.log(err);
  process.exit(1);
});

server.on('listening', () => {
  console.log(`Listening on port ${port}`);
});

InformationsquelleAutor codeKonami

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.