如何使用cURL/NodeJs脚本结合SSE向特定客户端连接/Web会话发送HTTP消息

Hey there! No need to apologize—we all start somewhere, and this is a great question as you dive into SSE and session-based messaging. Let’s break down exactly how to fix your broadcast issue and send targeted alerts to specific client sessions.

Core Idea #

The key problem right now is you’re not tracking which SSE connection belongs to which user session. To fix this, we’ll:

1. Maintain a map that links session IDs to active SSE response streams.
2. When a client connects to your SSE endpoint, store their session ID and corresponding response object in this map.
3. Create a way to look up a session ID in the map and send messages only to that specific connection.

Step-by-Step Implementation #

1. Set Up Session Management (If You Haven’t Already) #

First, make sure Express is handling sessions properly—this is how we’ll identify unique clients. If you’re not using express-session yet, install and configure it:

npm install express-session

Then add it to your Express app:

const express = require('express');
const session = require('express-session');
const app = express();

// Configure session middleware (adjust options for your needs)
app.use(session({
  secret: 'your-strong-secret-key', // Replace with a secure secret in production
  resave: false,
  saveUninitialized: false,
  cookie: { 
    secure: process.env.NODE_ENV === 'production', // Use true for HTTPS
    maxAge: 24 * 60 * 60 * 1000 // Session expires after 1 day
  }
}));

// Parse JSON bodies for API requests
app.use(express.json());

2. Track Active SSE Connections #

Create a Map to store active SSE connections, keyed by session ID. This will let us quickly find the right connection to send messages to.

// Stores session ID -> SSE response object mappings
const activeSSEConnections = new Map();

3. Create the SSE Endpoint #

Update your SSE route to associate each incoming connection with the client’s session ID, and clean up when the connection closes:

app.get('/sse', (req, res) => {
  // Set required SSE headers
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');
  res.setHeader('Connection', 'keep-alive');
  res.setHeader('Access-Control-Allow-Origin', '*'); // Adjust if you need strict CORS

  const sessionId = req.session.id;
  // Save the connection in our map
  activeSSEConnections.set(sessionId, res);
  console.log(`New SSE connection for session: ${sessionId}`);

  // Send a welcome message to confirm the connection
  res.write('data: {"type": "info", "content": "SSE connection established!"}\n\n');

  // Clean up the connection when the client disconnects
  req.on('close', () => {
    activeSSEConnections.delete(sessionId);
    console.log(`SSE connection closed for session: ${sessionId}`);
  });
});

4. Add an API to Send Targeted Messages #

Create an endpoint that lets you manually trigger messages to a specific session ID. You can call this via cURL, Postman, or your admin interface:

app.post('/send-alert-to-session', (req, res) => {
  const { sessionId, alertMessage } = req.body;

  // Find the connection for the target session
  const targetConnection = activeSSEConnections.get(sessionId);

  if (!targetConnection) {
    return res.status(404).json({
      success: false,
      error: `No active SSE connection found for session ID: ${sessionId}`
    });
  }

  try {
    // Send the alert in valid SSE format (data: [content]\n\n)
    targetConnection.write(`data: {"type": "alert", "content": "${alertMessage}"}\n\n`);
    res.json({
      success: true,
      message: `Alert sent to session ${sessionId}`
    });
  } catch (error) {
    // If the connection is dead, remove it from the map and return an error
    activeSSEConnections.delete(sessionId);
    res.status(500).json({
      success: false,
      error: `Failed to send alert: ${error.message}`
    });
  }
});

5. Update Your React Frontend #

Your React app just needs to connect to the /sse endpoint—since it’s same-origin, the session cookie will automatically be sent, so the backend can map it to the right connection. Here’s a simple component example:

import { useEffect, useState } from 'react';

function AlertReceiver() {
  const [alerts, setAlerts] = useState([]);

  useEffect(() => {
    // Initialize SSE connection
    const eventSource = new EventSource('/sse');

    // Handle incoming messages
    eventSource.onmessage = (event) => {
      const message = JSON.parse(event.data);
      if (message.type === 'alert') {
        setAlerts(prev => [...prev, message.content]);
      }
    };

    // Handle errors (e.g., connection drops)
    eventSource.onerror = (error) => {
      console.error('SSE connection error:', error);
      eventSource.close();
    };

    // Clean up on component unmount
    return () => {
      eventSource.close();
    };
  }, []);

  return (
    <div className="alert-container">
      <h2>Your Alerts</h2>
      {alerts.length === 0 ? (
        <p>No alerts yet.</p>
      ) : (
        alerts.map((alert, index) => (
          <div key={index} className="alert alert-danger">
            {alert}
          </div>
        ))
      )}
    </div>
  );
}

export default AlertReceiver;

Key Notes to Avoid Issues #

• Memory Leaks: Always remove connections from the map when the client disconnects (we do this in the req.on('close') handler).
• Session Expiry: If a session expires, the client’s SSE connection will still exist—you might want to add logic to check session validity periodically, or handle errors when sending messages to expired sessions.
• Scalability: If you ever move to a multi-server setup (e.g., load balancers), the in-memory Map won’t work across servers. For that, you’d need a shared store like Redis to track connections globally. But for your personal project, the in-memory map is perfect to start with.
• Error Handling: Wrap message sends in try/catch blocks to handle cases where the connection was closed unexpectedly.

Testing It Out #

1. Start your Express server.
2. Open 5 browser tabs (each will create a unique session).
3. Get one of the session IDs (you can log req.session.id in the /sse endpoint to see them).
4. Send a POST request to /send-alert-to-session with the session ID and your alert message:

curl -X POST -H "Content-Type: application/json" -d '{"sessionId": "YOUR_SESSION_ID", "alertMessage": "This is your targeted alert!"}' http://localhost:3000/send-alert-to-session

Only the tab with that session ID will receive the alert!

内容的提问来源于stack exchange，提问作者Emmanuel Batse