¿Hay una manera de crear un cliente websocket dentro de una aplicación java para comunicarse con un servidor websocket node.js?

Question

Actualmente, estoy trabajando en una aplicación de primavera de java que se ejecuta en un servidor tomcat y quiero crear un cliente WebSocket allí para comunicarse con un servidor websocket node.js que funciona localmente. No puedo encontrar ninguna implementación para el cliente. El cliente tiene que estar dentro de la vista (.jsp file) o en un controlador? El cliente websocket tiene que estar dentro de la aplicación web. Aquí está la implementación del servidor node.js: const WebSocket = require('ws'); const express = require('express') const app = express() const server = require('http').createServer(app); const wss = new WebSocket.Server({ server:server }); wss.on('connection', function connection(ws) { console.log('A new client Connected!'); ws.binaryType = 'arraybuffer'; ws.on('message', function incoming(message) { const array = new Int16Array(message); //console.log(array); console.log(new Date().toLocaleString().replace(',',' ')+    + ' Data received'); ws.send('The server received the message!'); }); }); server.listen(3000, () => console.log(`Lisening on port :3000`))

syntaxsavvy · Accepted Answer

Si utiliza js, debe utilizar WebSocket js obj para implementarlo. Y hay más muestras en línea. Supongo que quieres construir un cliente websocket en Java. Así que puedes refrescar esto para construir cliente. La siguiente es simple demo.

dependencia de los bienes

        
            org.java-websocket
            Java-WebSocket
            1.5.1

websocket client

public class MyWebSocketClient extends WebSocketClient {
    private static final Logger LOGGER = LoggerFactory.getLogger(MyWebSocketClient.class);

    public MyWebSocketClient(URI serverUri) {
        super(serverUri);
    }

    @Override
    public void onOpen(ServerHandshake arg0) {
        // TODO Auto-generated method stub
        LOGGER.info("------ MyWebSocket onOpen ------");
    }

    @Override
    public void onClose(int arg0, String arg1, boolean arg2) {
        // TODO Auto-generated method stub
        LOGGER.info("------ MyWebSocket onClose ------{}",arg1);
    }

    @Override
    public void onError(Exception arg0) {
        // TODO Auto-generated method stub
        LOGGER.info("------ MyWebSocket onError ------{}",arg0);
    }

    @Override
    public void onMessage(String arg0) {
        // TODO Auto-generated method stub
        LOGGER.info("-------- receive data from websocket server： " + arg0 + "--------");
    }
}

definir un frijol para usar


@SpringBootApplication
public class WebSocketApplication {
    public static void main(String[] args){
        SpringApplication.run(WebSocketApplication.class, args);
    }

        @Bean
    public WebSocketClient webSocketClient() {
        try {
            MyWebSocketClient webSocketClient = new MyWebSocketClient(new URI("ws://127.0.0.1:3000/connection"));
            webSocketClient.connect();
            return webSocketClient;
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        return null;
    }
   
}

In a restController to invoke

@RestController
public class WebSocketController {

    @Autowired
    private WebSocketClient webSocketClient;

    @RequestMapping("subscribe")
    public String subscribe() {
        webSocketClient.send("hello sever，i want subscribe data A");
        return "send ok";
    }
}

Respondida el Dec 17, 2020 a las 16:28 - por syntaxsavvy

Gpt · Answer

Para crear un cliente WebSocket en una aplicación Java que se comunique con un servidor WebSocket Node.js, puedes utilizar la librería Java-WebSocket. Aquí te muestro un ejemplo de cómo puedes implementar un cliente WebSocket en Java:

Agrega la dependencia de `Java-WebSocket` en tu proyecto Maven (puedes encontrarla en Maven Repository).

Crea una clase para tu cliente WebSocket en Java:

java
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import java.net.URI;

public class MyWebSocketClient extends WebSocketClient {

    public MyWebSocketClient(URI serverUri) {
        super(serverUri);
    }

    @Override
    public void onOpen(ServerHandshake handshakedata) {
        System.out.println("Connected to server");
    }

    @Override
    public void onMessage(String message) {
        System.out.println("Received message: " + message);
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {
        System.out.println("Connection closed");
    }

    @Override
    public void onError(Exception ex) {
        ex.printStackTrace();
    }
}

En tu controlador Spring, puedes crear una instancia de `MyWebSocketClient` y conectarlo al servidor WebSocket Node.js:

java
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.net.URI;
import java.net.URISyntaxException;

@Controller
public class WebSocketController {

    @GetMapping("/connect-websocket")
    @ResponseBody
    public String connectWebSocket() {
        try {
            MyWebSocketClient client = new MyWebSocketClient(new URI("ws://localhost:3000"));
            client.connect();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }

        return "WebSocket connection established";
    }
}

Para llamar al método desde tu vista `.jsp`, puedes agregar un enlace o un botón que haga la petición a `/connect-websocket`.

Recuerda que es importante manejar las excepciones y manejar los cierres de conexión adecuadamente en tu implementación real. Además, asegúrate de que tu servidor Tomcat tenga acceso a la red donde se encuentra el servidor WebSocket Node.js para establecer la conexión.

Espero que esta información te ayude a implementar un cliente WebSocket en tu aplicación Java para comunicarte con el servidor WebSocket Node.js. ¡Déjame saber si tienes alguna otra pregunta o duda!

Respondida el Dec 18, 2020 a las 16:26 - por Gpt

Gemini · Answer

Sí, puedes crear un cliente WebSocket dentro de una aplicación Java para comunicarte con un servidor WebSocket Node.js. Dónde colocar el cliente WebSocket El cliente WebSocket puede colocarse tanto en la vista (.jsp) como en un controlador. Sin embargo, se recomienda colocarlo en un controlador para una mayor modularidad y mantenibilidad. Implementación en el controlador Puedes utilizar la biblioteca Java WebSocket Client para crear fácilmente un cliente WebSocket en Java. Ejemplo de código para el controlador: java import org.java_websocket.client.WebSocketClient; import org.java_websocket.handshake.ServerHandshake; public class WebSocketClientController { private WebSocketClient webSocketClient; public void connectWebSocket() { webSocketClient = new WebSocketClient(new URI( ws://localhost:3000 )) { @Override public void onOpen(ServerHandshake serverHandshake) { System.out.println( WebSocket connection opened ); } @Override public void onMessage(String message) { System.out.println( Received message:   + message); } @Override public void onClose(int code, String reason, boolean remote) { System.out.println( WebSocket connection closed ); } @Override public void onError(Exception ex) { System.out.println( WebSocket connection error:   + ex.getMessage()); } }; webSocketClient.connect(); } public void sendMessage(String message) { webSocketClient.send(message); } public void closeWebSocket() { webSocketClient.close(); } } Uso en la vista Puedes utilizar JavaScript en tu archivo .jsp para interactuar con el cliente WebSocket creado en el controlador. Ejemplo de código para la vista: javascript var webSocketClient = new WebSocket( ws://localhost:3000 ); webSocketClient.onopen = function() { console.log( WebSocket connection opened ); }; webSocketClient.onmessage = function(event) { console.log( Received message:   + event.data); }; webSocketClient.onclose = function() { console.log( WebSocket connection closed ); }; webSocketClient.onerror = function(error) { console.log( WebSocket connection error:   + error); }; function sendMessage() { var message = document.getElementById( message ).value; webSocketClient.send(message); } function closeWebSocket() { webSocketClient.close(); } Con este enfoque, puedes crear y controlar un cliente WebSocket dentro de tu aplicación Java y comunicarte con tu servidor WebSocket Node.js.

¿Hay una manera de crear un cliente websocket dentro de una aplicación java para comunicarse con un servidor websocket node.js?

3 Respuestas: