Événements envoyés par le serveur (SSE) ou WebSockets
Comparez SSE et WebSockets afin de comprendre quand choisir chaque technologie selon les besoins spécifiques du temps réel.
Événements envoyés par le serveur (SSE) ou WebSockets est une leçon WebSockets & Real-Time Systems with Spring gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage WebSockets & Real-Time Systems with Spring, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours WebSockets & Real-Time Systems with Spring comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
Real-Time: Beyond Request-Response
Modern web applications often need instant updates. Think live scores, chat messages, or stock price changes. Traditional HTTP's request-response model isn't always ideal for these scenarios.
We need ways for the server to push data to the client without the client constantly asking for it.
WebSockets: A Quick Refresher
You've learned about WebSockets. They establish a persistent, full-duplex connection between a client and server over a single TCP connection.
- Full-duplex: Both client and server can send and receive messages independently at any time.
- Great for highly interactive applications like chat or multiplayer games.
Introducing Server-Sent Events (SSE)
Server-Sent Events (SSE) offer another way for servers to push data to clients. Unlike WebSockets, SSE is unidirectional.
- The server sends data to the client.
- The client cannot send data back to the server using the same SSE connection.
- It's built on standard HTTP, making it simpler for certain use cases.
SSE Server: Spring Boot Example
Let's see how a Spring Boot server can send events. This controller streams a new message every second to any connected client.
Notice the text/event-stream media type.
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import java.time.Duration;
@RestController
public class SseController {
@GetMapping(path = "/stream-events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<String> streamEvents() {
return Flux.interval(Duration.ofSeconds(1))
.map(sequence -> "data: Event " + sequence + "\n\n");
}
public static void main(String[] args) {
// This is a minimal Spring Boot application setup.
// In a real app, you'd have @SpringBootApplication
// and SpringApplication.run(YourApplication.class, args);
// For this snippet, we just show the controller.
System.out.println("SSE Controller is defined. Run a Spring Boot app to test.");
}
}SSE Client: JavaScript Example
Here's how a simple web page can connect to the SSE stream from our Spring server. The EventSource API handles reconnections automatically!
<!DOCTYPE html>
<html>
<head>
<title>SSE Client</title>
</head>
<body>
<h1>SSE Events</h1>
<div id="events"></div>
<script>
const eventSource = new EventSource('/stream-events');
eventSource.onmessage = function(event) {
const p = document.createElement('p');
p.textContent = event.data;
document.getElementById('events').appendChild(p);
};
eventSource.onerror = function(err) {
console.error("EventSource failed:", err);
eventSource.close();
};
console.log("Connected to SSE stream...");
</script>
</body>
</html>Key Difference: Communication Flow
The core distinction lies in how data flows:
- WebSockets: Offer two-way (full-duplex) communication. Both client and server can initiate sending messages.
- SSE: Provides one-way (unidirectional) communication. The server pushes data to the client; the client cannot push data back using the same connection.
For client-to-server data with SSE, a separate HTTP request (e.g., POST) is needed.
When to Choose WebSockets
Opt for WebSockets when your application requires:
- Real-time interactivity: Both client and server need to send messages frequently.
- Low latency: Interactive games, collaborative editing tools, live video/audio streaming.
- Bidirectional communication: Chat applications where users send and receive messages.
- Binary data exchange: WebSockets handle both text and binary data efficiently.
When to Choose Server-Sent Events (SSE)
SSE is an excellent choice for scenarios where:
- Server-to-client updates are primary: Stock tickers, news feeds, social media updates, system notifications.
- Simplicity is key: SSE uses standard HTTP, making it simpler to implement for one-way data push.
- Automatic reconnection: The
EventSourceAPI handles connection drops and retries automatically. - Browser compatibility: Widely supported, with robust polyfills for older browsers if needed.
Choosing the Right Tool
Consider your application's needs carefully:
- If you only need to push data from server to client, SSE is often simpler and more efficient.
- If you need a true two-way, low-latency, interactive channel, WebSockets are the way to go.
- Don't overcomplicate; start with the simplest solution that meets your requirements.
Quick Check: SSE vs. WebSockets
Which of the following scenarios is best suited for Server-Sent Events (SSE)?
Recap: SSE vs. WebSockets
We explored two powerful technologies for real-time communication:
- WebSockets: Offers full-duplex (two-way) communication, best for highly interactive, bidirectional applications.
- Server-Sent Events (SSE): Provides unidirectional (server-to-client) communication, ideal for dashboards, notifications, and continuous data feeds.
Choosing between them depends on whether your application primarily needs to push data from the server or requires interactive two-way messaging.
Questions Fréquemment Posées
La leçon « Événements envoyés par le serveur (SSE) ou WebSockets » est-elle gratuite ?
Oui — le texte complet de « Événements envoyés par le serveur (SSE) ou WebSockets » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours WebSockets & Real-Time Systems with Spring, passe à CoddyKit PRO. Le cours WebSockets & Real-Time Systems with Spring comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Événements envoyés par le serveur (SSE) ou WebSockets » ?
Comparez SSE et WebSockets afin de comprendre quand choisir chaque technologie selon les besoins spécifiques du temps réel. Tu pratiques WebSockets & Real-Time Systems with Spring avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer WebSockets & Real-Time Systems with Spring ?
Aucune expérience préalable n'est requise. WebSockets & Real-Time Systems with Spring sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Événements envoyés par le serveur (SSE) ou WebSockets » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon WebSockets & Real-Time Systems with Spring ?
Oui. Chaque leçon WebSockets & Real-Time Systems with Spring inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Événements envoyés par le serveur (SSE) ou WebSockets
- Architectures de diffusion de données en temps réel
- Mise en œuvre des notifications utilisateur
- Suivre la présence et l’état en ligne