通过 datagramsocket 获取 IOException 接收 datagrampakcet (Java)

Question

我正在尝试使用 dagramsocket 将包从客户端发送到服务器，但在花了几个小时在 Whosebug 和官方文档中查找信息后，我仍然收到 IOException。我有一台服务器，从客户那里收到一个句子，更改句子并打印新句子。知道为什么它不起作用吗？这是代码：

客户：

public class YodafyClienteTCP {

    public static void main(String[] args) {

        byte []buferEnvio;
        byte []buferRecepcion=new byte[256];
        int bytesLeidos=0;

        // Nombre del host donde se ejecuta el servidor:
        String host="localhost";
        // Puerto en el que espera el servidor:
        int port=8989;
        DatagramPacket paquete;
        InetAddress direccion;

        // Socket para la conexión TCP
        DatagramSocket socketServicio;

        try {
            // Creamos un socket que se conecte a "host" y "port":

            socketServicio=new DatagramSocket();
            direccion = InetAddress.getByName(host);

            buferEnvio="Al monte del volcán debes ir sin demora".getBytes();

            paquete = new DatagramPacket(buferEnvio, buferEnvio.length, direccion, port);

            // Enviamos el array por el socket;
            socketServicio.send(paquete);
            System.out.println("Paquete enviado por el cliente.");

        socketServicio.close();

            // Excepciones:
        } catch (UnknownHostException e) {
            System.err.println("Error: Nombre de host no encontrado.");
            e.printStackTrace();
        } catch (IOException e) {
            System.err.println("Error de entrada/salida al abrir el socket.");
            e.printStackTrace();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

Class 换句，由服务器调用

public class ProcesadorYodafy {
    // Referencia a un socket para enviar/recibir las peticiones/respuestas
    private DatagramSocket socketServicio;


    // Para que la respuesta sea siempre diferente, usamos un generador de números aleatorios.
    private Random random;

    // Constructor que tiene como parámetro una referencia al socket abierto en por otra clase
    public ProcesadorYodafy(DatagramSocket socketServicio) {
        this.socketServicio=socketServicio;
        random=new Random();
    }


    // Aquí es donde se realiza el procesamiento realmente:
    void procesa(){

        // Como máximo leeremos un bloque de 1024 bytes. Esto se puede modificar.
        byte [] datosRecibidos=new byte[1024];
        int bytesRecibidos=0;
        DatagramPacket paquete;

        // Array de bytes para enviar la respuesta. Podemos reservar memoria cuando vayamos a enviarla:
        byte [] datosEnviar;


        try {
            // Lee la frase a Yodaficar:
            paquete = new DatagramPacket(datosRecibidos, datosRecibidos.length);
            socketServicio.receive(paquete);

            datosRecibidos = paquete.getData();
            bytesRecibidos = datosRecibidos.length;

            //yodaDo is just a method that changes some characters in the sentence
            String peticion=new String(datosRecibidos,0,bytesRecibidos);
            String respuesta=yodaDo(peticion);
            System.out.println("Here is your new sentence : " + respuesta);         

            socketServicio.close();

        } catch (IOException e) {
            System.err.println("Error al obtener los flujos de entrada/salida.");
        }

    }

服务器：

public class YodafyServidorIterativo {

    public static void main(String[] args) {

        // Puerto de escucha
        int port=8989;
        // array de bytes auxiliar para recibir o enviar datos.
        byte []buffer=new byte[256];
        // Número de bytes leídos
        int bytesLeidos=0;
        //Socket
        DatagramSocket socketServicio;

        try {
            // Abrimos el socket en modo pasivo, escuchando el en puerto indicado por "port"
            socketServicio = new DatagramSocket(port);
                        // Mientras ... siempre!
            do {
                //////////////////////////////////////////////////

                // Creamos un objeto de la clase ProcesadorYodafy, pasándole como
                // argumento el nuevo socket, para que realice el procesamiento
                // Este esquema permite que se puedan usar hebras más fácilmente.
                ProcesadorYodafy procesador=new ProcesadorYodafy(socketServicio);
                procesador.procesa();

            } while (true);

        } catch (IOException e) {
            System.err.println("Error al escuchar en el puerto "+port);
        }

    }

}

Answer 1

首先，这是一个UDP连接，如前所述here。寻找正确的连接，您会更快地找到需要的文档。

其次，无论何时，您的问题可能是由以下原因引起的：

您的一项服务未启动或
您没有设置客户端应用程序的端口，并认为您在本地使用它，可能会导致资源冲突。

尝试设置客户端的端口，并确保在启动客户端之前启动服务器。

Answer 2

已解决。我在 class ProcesadorYodafy 中关闭了数据报套接字，并在服务器中只打开了一次套接字，因此在接下来的循环迭代中，尽管我正在向那里发送包，但数据报套接字已关闭。谢谢大家

通过 datagramsocket 获取 IOException 接收 datagrampakcet (Java)

Getting IOException receiving datagrampakcet through datagramsocket (Java)

java

udp

ioexception