Java Language
Sockets de Java
Buscar..
Introducción
Los sockets son una interfaz de red de bajo nivel que ayuda a crear una conexión entre dos programas, principalmente clientes que pueden estar o no ejecutándose en la misma máquina.
La programación de sockets es uno de los conceptos de redes más utilizados.
Observaciones
Hay dos tipos de tráfico de protocolo de Internet:
1. TCP - Protocolo de control de transmisión 2. UDP - Protocolo de datagramas de usuario
TCP es un protocolo orientado a la conexión.
UDP es un protocolo sin conexión.
TCP es adecuado para aplicaciones que requieren alta confiabilidad, y el tiempo de transmisión es relativamente menos crítico.
UDP es adecuado para aplicaciones que necesitan una transmisión rápida y eficiente, como los juegos. La naturaleza sin estado de UDP también es útil para servidores que responden a pequeñas consultas de un gran número de clientes.
En palabras más simples:
Use TCP cuando no pueda permitirse perder datos y cuando el tiempo para enviar y recibir datos no importe. Use UDP cuando no pueda perder tiempo y cuando la pérdida de datos no importe.
Existe una garantía absoluta de que los datos transferidos permanecen intactos y llegan en el mismo orden en que se enviaron en caso de TCP.
mientras que no hay garantía de que los mensajes o paquetes enviados alcancen en absoluto en UDP.
Un simple servidor TCP con respaldo
Nuestro servidor TCP echo back será un hilo separado. Es simple como es un comienzo. Solo devolverá lo que sea que envíe, pero en mayúscula.
public class CAPECHOServer extends Thread{
// This class implements server sockets. A server socket waits for requests to come
// in over the network only when it is allowed through the local firewall
ServerSocket serverSocket;
public CAPECHOServer(int port, int timeout){
try {
// Create a new Server on specified port.
serverSocket = new ServerSocket(port);
// SoTimeout is basiacally the socket timeout.
// timeout is the time until socket timeout in milliseconds
serverSocket.setSoTimeout(timeout);
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public void run(){
try {
// We want the server to continuously accept connections
while(!Thread.interrupted()){
}
// Close the server once done.
serverSocket.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Ahora a aceptar conexiones. Vamos a actualizar el método de ejecución.
@Override
public void run(){
while(!Thread.interrupted()){
try {
// Log with the port number and machine ip
Logger.getLogger((this.getClass().getName())).log(Level.INFO, "Listening for Clients at {0} on {1}", new Object[]{serverSocket.getLocalPort(), InetAddress.getLocalHost().getHostAddress()});
Socket client = serverSocket.accept(); // Accept client conncetion
// Now get DataInputStream and DataOutputStreams
DataInputStream istream = new DataInputStream(client.getInputStream()); // From client's input stream
DataOutputStream ostream = new DataOutputStream(client.getOutputStream());
// Important Note
/*
The server's input is the client's output
The client's input is the server's output
*/
// Send a welcome message
ostream.writeUTF("Welcome!");
// Close the connection
istream.close();
ostream.close();
client.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
// Close the server once done
try {
serverSocket.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOServer.class.getName()).log(Level.SEVERE, null, ex);
}
}
Ahora, si puede abrir telnet e intentar conectarse, verá un mensaje de bienvenida.
Debe conectarse con el puerto que especificó y la dirección IP.
Deberías ver un resultado similar a este:
Welcome!
Connection to host lost.
Bueno, la conexión se perdió porque la terminamos. A veces tendríamos que programar nuestro propio cliente TCP. En este caso, necesitamos que un cliente solicite información del usuario y la envíe a través de la red para recibir la información en mayúsculas.
Si el servidor envía los datos primero, el cliente debe leer los datos primero.
public class CAPECHOClient extends Thread{
Socket server;
Scanner key; // Scanner for input
public CAPECHOClient(String ip, int port){
try {
server = new Socket(ip, port);
key = new Scanner(System.in);
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public void run(){
DataInputStream istream = null;
DataOutputStream ostream = null;
try {
istream = new DataInputStream(server.getInputStream()); // Familiar lines
ostream = new DataOutputStream(server.getOutputStream());
System.out.println(istream.readUTF()); // Print what the server sends
System.out.print(">");
String tosend = key.nextLine();
ostream.writeUTF(tosend); // Send whatever the user typed to the server
System.out.println(istream.readUTF()); // Finally read what the server sends before exiting.
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
} finally {
try {
istream.close();
ostream.close();
server.close();
} catch (IOException ex) {
Logger.getLogger(CAPECHOClient.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
Ahora actualiza el servidor
ostream.writeUTF("Welcome!");
String inString = istream.readUTF(); // Read what the user sent
String outString = inString.toUpperCase(); // Change it to caps
ostream.writeUTF(outString);
// Close the connection
istream.close();
Y ahora ejecuta el servidor y el cliente, deberías tener una salida similar a esta
Welcome!
>
