Comment utiliser Java Websocket pour réaliser un affichage des cotations boursières en temps réel ?

Comment utiliser Java WebSocket pour obtenir un affichage des cotations boursières en temps réel ?

Avec le développement d'Internet, les mises à jour en temps réel des cotations boursières sont devenues de plus en plus importantes. La manière traditionnelle d'afficher les cotations boursières consiste généralement à actualiser constamment la page pour obtenir les données les plus récentes, ce qui n'est pas très efficace et exerce une certaine pression sur le serveur. L'utilisation de la technologie WebSocket peut réaliser efficacement l'affichage des cotations boursières en temps réel et réduire efficacement la pression sur le serveur.

WebSocket est un protocole de communication full-duplex Par rapport au protocole HTTP traditionnel, il peut permettre au serveur de transmettre activement des données au client sans que ce dernier n'envoie de requête. De cette manière, l'envoi fréquent de demandes et de réponses est évité, ce qui permet un affichage en temps réel plus efficace des cotations boursières.

Ce qui suit est un exemple simple d'utilisation de Java WebSocket pour implémenter l'affichage des cotations boursières en temps réel :

1. Tout d'abord, créez une classe de serveur WebSocket pour recevoir les demandes de connexion des clients et les messages push. Ceci peut être réalisé en utilisant la bibliothèque javax.websocket fournie en Java.

import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArraySet;

@ServerEndpoint("/stock")
public class StockWebSocketServer {
    private static final Set<Session> sessions = new CopyOnWriteArraySet<>();

    @OnOpen
    public void onOpen(Session session) {
        sessions.add(session);
        // 在此处可以进行一些初始化操作，比如订阅股票行情数据
    }

    @OnClose
    public void onClose(Session session) {
        sessions.remove(session);
        // 在此处进行资源释放操作，比如取消订阅股票行情数据
    }

    @OnMessage
    public void onMessage(String message, Session session) {
        // 在此处可以处理客户端发送的消息
    }

    @OnError
    public void onError(Throwable throwable) {
        // 在此处处理错误信息
    }

    public static void sendMessage(String message) {
        for (Session session : sessions) {
            try {
                session.getBasicRemote().sendText(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2. Ensuite, vous pouvez créer une source de données boursières simple, mettre à jour les données de cotation boursière à un certain moment et les transmettre au client via le serveur WebSocket.

import java.util.Random;

public class StockSource {
    private static final String[] STOCKS = {"AAPL", "GOOGL", "AMZN", "MSFT"};
    private static final Random RANDOM = new Random();
    
    public static void start() {
        new Thread(() -> {
            while (true) {
                String stock = randomStock();
                double price = randomPrice();
                String message = stock + ": " + price;
                StockWebSocketServer.sendMessage(message);
                sleep(1000);
            }
        }).start();
    }
    
    private static String randomStock() {
        int index = RANDOM.nextInt(STOCKS.length);
        return STOCKS[index];
    }
    
    private static double randomPrice() {
        return RANDOM.nextDouble() * 1000;
    }
    
    private static void sleep(int milliseconds) {
        try {
            Thread.sleep(milliseconds);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3. Enfin, démarrez le serveur WebSocket et la source de données boursières dans le programme principal.

public class Main {
    public static void main(String[] args) {
        StockSource.start();

        WebSocketContainer container = ContainerProvider.getWebSocketContainer();
        try {
            container.connectToServer(StockWebSocketServer.class, new URI("ws://localhost:8080/stock"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Avec l'exemple de code ci-dessus, nous pouvons implémenter un système simple d'affichage des cotations boursières en temps réel. Lorsque le client se connecte au serveur WebSocket, le serveur transmet en permanence les dernières données boursières au client, obtenant ainsi des effets de mise à jour en temps réel. Dans le même temps, cela réduit également la pression sur le serveur et améliore les performances du système et l’expérience utilisateur.

Bien sûr, ce qui précède n'est qu'un exemple simple. Dans les applications réelles, l'optimisation et le traitement correspondants doivent être effectués en fonction de besoins spécifiques, tels que l'ajout de l'authentification des utilisateurs, la conversion du format de données, etc. Dans le même temps, la page frontale doit également écrire le code correspondant pour recevoir les données poussées par le serveur WebSocket et les afficher.

Pour résumer, l'utilisation de la technologie Java WebSocket est un choix très efficace et réalisable lors de la mise en œuvre de l'affichage des cotations boursières en temps réel. Il permet au serveur de transmettre activement les données au client, réduisant ainsi la pression sur le serveur, améliorant les performances du système et améliorant également l'expérience utilisateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!