SocketException es una subclase de IOException , por lo que es una excepción comprobada. Es la excepción más general que señala un problema al intentar abrir o acceder a un socket. La jerarquía de excepción completa de este error es:
java.lang.Object
java.lang.Throwable
java.lang.Exception
java.io.IOException
java.net.SocketException
Como ya sabrá, se recomienda encarecidamente utilizar la clase de excepción de socket más específica que designe el problema con mayor precisión. También vale la pena señalar que SocketException, generalmente viene con un mensaje de error que es muy informativo sobre la situación que causó la excepción.
Implemented Interfaces: Serializable Direct Known Subclasses: BindException, ConnectException, NoRouteToHostException, PortUnreachableException
¿Qué es la programación de sockets?
Es un concepto de programación que utiliza sockets para establecer conexiones y permite que varios programas interactúen entre sí mediante una red. Los sockets proporcionan una interfaz para establecer comunicación mediante la pila de protocolos de red y permiten que los programas compartan mensajes a través de la red. Los sockets son puntos finales en las comunicaciones de red. Un servidor de socket suele ser un servidor de subprocesos múltiples que puede aceptar requests de conexión de socket. Un cliente de socket es un programa/proceso que inicia una solicitud de comunicación de socket.
java.net.SocketException: restablecimiento de la conexión
Esta SocketException ocurre en el lado del servidor cuando el cliente cerró la conexión del socket antes de que la respuesta pudiera devolverse a través del socket. Por ejemplo, cerrando el navegador antes de recuperar la respuesta. El restablecimiento de la conexión simplemente significa que se recibió un TCP RST. El paquete TCP RST es que el lado remoto que le dice que la conexión en la que se envió el paquete TCP anterior no se reconoce, tal vez la conexión se cerró, tal vez el puerto no está abierto y algo como esto. Un paquete de reinicio es simplemente uno sin carga útil y con el bit RST establecido en las banderas del encabezado TCP.
Ahora, a partir de la implementación, está claro que necesitamos dos programas, uno que maneje al cliente y el otro que maneje al servidor. Son los siguientes:
Ejemplo 1: lado del servidor
Java
// Java Program to Illustrate SocketException
// Server Side App
// Importing required classes
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
// Main class
public class SimpleServerApp {
// Main driver method
public static void main(String[] args)
throws InterruptedException
{
new Thread(new SimpleServer()).start();
}
static class SimpleServer implements Runnable {
// run() method for thread
@Override public void run()
{
ServerSocket serverSocket = null;
// Try block to check for exceptions
try {
serverSocket = new ServerSocket(3333);
serverSocket.setSoTimeout(0);
// Till condition holds true
while (true) {
try {
Socket clientSocket
= serverSocket.accept();
// Creating an object of
// BufferedReader class
BufferedReader inputReader
= new BufferedReader(
new InputStreamReader(
clientSocket
.getInputStream()));
System.out.println(
"Client said :"
+ inputReader.readLine());
}
// Handling the exception
catch (SocketTimeoutException e) {
// Print the exception along with
// line number
e.printStackTrace();
}
}
}
// Catch block to handle the exceptions
catch (IOException e1) {
// Display the line where exception occurs
e1.printStackTrace();
}
finally {
try {
if (serverSocket != null) {
serverSocket.close();
}
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Ejemplo 2: del lado del cliente
Java
// Java Program to Illustrate SocketException
// Client Side App
// Importing required classes
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
// Class 1
// Main class
public class SimpleClientApp {
// Main driver method
public static void main(String[] args)
{
// Calling inside main()
new Thread(new SimpleClient()).start();
}
// Class 2
// Helper class
static class SimpleClient implements Runnable {
// run() method for the thread
@Override public void run()
{
// Initially assign null to our socket to be
// used
Socket socket = null;
// Try block to e=check for exceptions
try {
socket = new Socket("localhost", 3333);
// Creating an object of PrintWriter class
PrintWriter outWriter = new PrintWriter(
socket.getOutputStream(), true);
// Display message
System.out.println("Wait");
// making thread to sleep for 1500
// nanoseconds
Thread.sleep(15000);
// Display message
outWriter.println("Hello Mr. Server!");
}
// Catch block to handle the exceptions
// Catch block 1
catch (SocketException e) {
// Display the line number where exception
// occurred using printStackTrace() method
e.printStackTrace();
}
// Catch block 2
catch (InterruptedException e) {
e.printStackTrace();
}
// Catch block 3
catch (UnknownHostException e) {
e.printStackTrace();
}
// Catch block 4
catch (IOException e) {
e.printStackTrace();
}
finally {
try {
// If socket goes NULL
if (socket != null)
// Close the socket
socket.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Producción:
java.net.SocketException: restablecimiento de la conexión
en java.net.SocketInputStream.read(SocketInputStream.java:196)
en java.net.SocketInputStream.read(SocketInputStream.java:122)
en sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:283)
en sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:325)
en sun.nio.cs.StreamDecoder.read(StreamDecoder.java:177)
en java.io.InputStreamReader.read(InputStreamReader.java:184)
en java.io.BufferedReader.fill(BufferedReader.java:154)
en java.io.BufferedReader.readLine(BufferedReader.java:317)
en java.io.BufferedReader.readLine(BufferedReader.java:382)
en com.javacodegeeks.core.lang.NumberFormatExceptionExample.SimpleServerApp$SimpleServer.run(SimpleServerApp.java:36)
en java.lang.Thread.run(Thread.java:744)
Ahora, para deshacerse de java.net.SocketException para obtener el resultado adecuado, se puede percibir como si fuera un cliente y obtuviera este error al conectarse a la aplicación del lado del servidor, luego agregue los siguientes cambios de la siguiente manera:
- Primero, verifique si el servidor se está ejecutando haciendo telnet en el puerto de host en el que se ejecuta el servidor.
- Comprobar si el servidor se reinició
- Compruebe si el servidor se conmutó a un host diferente
- registrar el error
- Informe el problema al equipo del servidor
Nota: En la mayoría de los casos, encontrará que alguno de los servidores no se está ejecutando o se reinicia de forma manual o automática.
Publicación traducida automáticamente
Artículo escrito por praveen13kulkarni y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA