java.net explicacion practica 2013
Post on 28-Jan-2016
10 Views
Preview:
DESCRIPTION
TRANSCRIPT
Programación de Sockets en JavaJava
¿Qué es un Socket?
• Socket– Combinación de dir. IP y nro. de puerto (RFC 793-TCP)– Dos tipos
• Stream socket (comunicación confiable de streams y de dos vías)
• Datagram socket (de dos vías)
• Par de Sockets– Especifica los 2 puntos finales que identifican univocamente
cada conexión TCP en internet.– 4-tupla: (dir. IP cliente, nro. port cliente, dir. IP server,
nro. port server)
Aplicaciones Client-Server
• Implementación de un protocolo estandar definido en un RFC (FTP, HTTP, SMTP…)
– Respeta las reglas dictadas por el RFC– Usará el número de puerto asociado con el protocolo
• Aplicaciones propietarias client-server.
– Un desarrollador o un equipo crea tanto el programa cliente como el servidor
– Deben tener cuidado en no usar los números de puerto bien conocidos* definidos en los RFCs.
* número de puerto bien conocido : administrados por la IANA (Internet Assigned Numbers Authority)
Programación de Socket con TCP
proceso proceso
Proceso de comunicación con sockets TCP
El desarrollador de la aplicación es capaz de setear algunos parametros TCP, como el buffer máximo y los tamaños de segmento máximo.
controlado por el
desarrollador
controlado por el
desarrollador
controlado por el S.O.
controlado por el S.O.
Sockets TCP para el Server y el Client
• Server– Socket en espera
• Espera algún contacto inicial desde el cliente.
– Socket con conexión establecida• Es creado con el contacto inicial del cliente.• El nuevo socket es dedicado a un cliente en particular.• El nuevo socket es dedicado a un cliente en particular.
• Client– Socket
• Inicia una conexión TCP al servidor. (Three-way handshake)
• Especifica la dirección del proceso servidor: la dir. IP del server y el nro. de puerto del proceso.
Sockets con TCP
Socket Client, Socket Server y el establecimiento de la conexión
Llamadas funcionales a Socket
• socket (): crea un socket
• bind(): enlaza un socket a una dir. IP y un nro. de port
• listen(): esperando pasivamente por conexiones
• connect(): iniciando conexión a otro socket• connect(): iniciando conexión a otro socket
• accept(): acepta la nueva conexión
• write(): escribe datos en el socket
• read(): lee datos del socket
• sendto(): envia un datagrama a otro socket UDP
• recvfrom(): lee un datagrama desde otro socket UDP
• close(): cierra el socket (se termina la conexión)
Programación de Socket usando TCPServicio TCP:Servicio TCP:Servicio TCP:Servicio TCP: transferencia de streams confiableconfiableconfiableconfiable
client server
socket( )bind( )connect( )
socket( )bind( )listen( )
accept( )send( )
recv( )
TCP conn. request
TCP ACK
proceso
TCP (buffers)
socket
Controlado porel desarrolladorde la aplicación
Controlado porel sistema
operativo
proceso
TCP (buffers)
socket
internet
recv( )
close( ) close( )
recv( )send( )
Programación de Socket usando TCP
1. El cliente lee una linea del standard input (inFromUserstream)
2. El cliente lo envía al server vía socket (outToServerstream)
3. El server lee la línea desde el
Input stream:
Secuencia de bytes hacia adentro
Output stream:
Proceso
Cliente
1
3. El server lee la línea desde el socket
4. El server procesa la línea y responde al cliente
5. El cliente lee la respuestadesde el socket (inFromServer stream)
Output stream:
Secuencia de bytes hacia afuera
client TCP socket
2
3 4
5
Interacción client/server: TCP
wait for incoming
create socket,port=x, forincoming request:
welcomeSocket = ServerSocket()
create socket,connect to hostid, port=x
Server (hostid) Client
TCP connection setup
wait for incomingconnection request
connectionSocket =welcomeSocket.accept()
connect to hostid, port=xclientSocket =
Socket()
closeconnectionSocket
read reply fromclientSocket
closeclientSocket
send request usingclientSocketread request from
connectionSocket
write reply toconnectionSocket
connection setup
JAVA TCP Sockets• Package java.net
– java.net.ServerSocket• Implementa un socket servidor.• Espera pedidos de conexión a través de la red.• Realiza operatoria basada en el requerimiento• Constructor y Metodos
– ServerSocket(int port)– Socket accept(): Escucha pedidos de conexión y los acepta. Este – Socket accept(): Escucha pedidos de conexión y los acepta. Este
método “bloquea” al socket hasta que ocurre la conexión
– java.net.Socket• Implementa un socket cliente• Es un extremo en la comunicación entre 2 hosts• Constructor y Métodos
– Socket(String host, int port): Crea un socket y lo conecta al número de port del host especificado
– InputStream getInputStream()– OutputStream getOutputStream()– close()
TCPServer.javaimport java.io.*; import java.net.*; /** TCPServer convierte a mayúscula el msg. que recibe desde el cliente*/
class TCPServer {
public static void main(String argv[]) throws Exception {
String sentenciaCliente; String sentenciaCliente; String sentenciaMayuscula;
ServerSocket socketBienvenida = new ServerSocket(6789);
while(true) {
Socket socketConectado = socketBienvenida.accept();
BufferedReader inFromClient = new BufferedReader(newInputStreamReader(socketConectado.getInputStream()));
TCPServer.java
sentenciaCliente = inFromClient.readLine();
sentenciaMayuscula = sentenciaCliente.toUpperCase() + '\n';
DataOutputStream outToClient = DataOutputStream outToClient = new DataOutputStream(socketConectado.getOutputStream());
outToClient.writeBytes(sentenciaMayuscula);
socketConectado.close();}
} }
TCPClient.javaimport java.io.*; import java.net.*;
class TCPClient { public static void main(String argv[]) throws Exception {
String sentencia; String sentenciaModificada; String sentenciaModificada;
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
sentencia = inFromUser.readLine();
Socket socketCliente = new Socket(“10.1.1.5", 6789);
DataOutputStream outToServer = new DataOutputStream(socketCliente.getOutputStream());
TCPClient.java
outToServer.writeBytes(sentencia + '\n');
BufferedReader inFromServer = new BufferedReader(new
InputStreamReader(socketCliente.getInputStream()));
sentenciaModificada = inFromServer.readLine();sentenciaModificada = inFromServer.readLine();
System.out.println(“DESDE EL SERVIDOR: " + sentenciaModificada);
socketCliente.close();
} }
Socket sobre UDP
• UDP– Servicio sin conexión y no confiable – No hay fase inicial de handshaking– Los datos transmitidos pueden recibirse desordenados y
pueden perderse
• Programación de Socket con UDP– No se necesita un socket creado en espera.– No hay “streams” (flujos) adjuntos a los sockets– El host que envía, crea “paquetes” adjuntando la dir. IP
destino y nro. de port a cada conjunto de bytes– El proceso receptor debe “desempaquetar” el paquete
recibido para obtener los bytes de información del paquete
Interacción client/server: UDPServer (hostid)
create socket,
clientSocket = DatagramSocket()
Client
Create, address (hostid, port=x,
create socket,port=x, forincoming request:
serverSocket = DatagramSocket()
closeclientSocket
read reply fromclientSocket
Create, address (hostid, port=x,send datagram request using clientSocket
read request fromserverSocket
write reply toserverSocketspecifying clienthost address,port number
Ejemplo cliente Java (UDP)
Input: recibe paquetes (TCP recibe “byte
Proceso
Cliente
Output: envía paquetes (TCP envía “byte stream”)
(TCP recibe “byte stream”)
client UDP socket
JAVA UDP Sockets
• Package java.net– java.net.DatagramSocket
• Socket para envío y recepción de “datagramas”
• Constructor y Métodos– DatagramSocket(int port): Construye un socket – DatagramSocket(int port): Construye un socket
UDP y lo enlaza al port especificado en el host local
– void receive(DatagramPacket p)
– void send(DatagramPacket p)
– void close()
UDPClient.javaimport java.io.*; import java.net.*;
class UDPClient { public static void main(String args[]) throws Exception {
BufferedReader inFromUser = new BufferedReader(new InputStreamReader(System.in));
byte[] datosAEnviar = new byte[1024]; byte[] datosARecibir = new byte[1024];
String sentencia = inFromUser.readLine();
datosAEnviar = sentencia.getBytes();
DatagramSocket socketCliente = new DatagramSocket();
InetAddress IPAddress = InetAddress.getByName(“server.com");
UDPClient.java
DatagramPacket paqueteAEnviar = new DatagramPacket(datosAEnviar, datosAEnviar.length,
IPAddress, 9876);
socketCliente.send(paqueteAEnviar);
DatagramPacket paqueteARecibir = new DatagramPacket(datosARecibir, datosARecibir.length);
socketCliente.receive(paqueteARecibir);
String sentenciaModificada = new String(paqueteARecibir.getData());
System.out.println(“DESDE EL SEVIDOR:" + sentenciaModificada);
socketCliente.close();
} }
UDPServer.javaimport java.io.*; import java.net.*;
class UDPServer { public static void main(String args[]) throws Exception {
DatagramSocket socketServidor = new DatagramSocket(9876);
byte[] datosARecibir = new byte[1024]; byte[] datosARecibir = new byte[1024]; byte[] datosAEnviar = new byte[1024];
while(true) {
DatagramPacket paqueteARecibir = new DatagramPacket(datosARecibir, datosARecibir.length);
serverSocket.receive(paqueteARecibir);
String sentencia = new String(paqueteARecibir.getData());
UDPServer.java
InetAddress IPAddress = paqueteARecibir.getAddress();
int port = paqueteARecibir.getPort();
String sentenciaMayuscula = sentencia.toUpperCase();
datosAEnviar = sentenciaMayuscula.getBytes(); datosAEnviar = sentenciaMayuscula.getBytes();
DatagramPacket paqueteAEnviar = new DatagramPacket(datosAEnviar, datosAEnviar.length,
IPAddress, port);
serverSocket.send(paqueteAEnviar);
} }
}
Construyendo un simple Web Server
• Atiende un requerimiento HTTP a la vez
• Acepta y parsea el requerimiento HTTP
• Obtiene el archivo requerido desde el • Obtiene el archivo requerido desde el sistema de archivos del servidor
• Crea un mensaje de respuesta HTTP con el archivo requerido precedido por información en el header
• Envía la respuesta directamente al cliente
WebServer.javaimport java.io.*; import java.net.*;import java.util.*; class WebServer {
public static void main(String argv[]) throws Exception { String requestMessageLine; String fileName;
ServerSocket listenSocket = new ServerSocket(80);Socket connectionSocket = listenSocket.accept();
BufferedReader inFromClient = new BufferedReader(new
InputStreamReader(connectionSocket.getInputStream()));
DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
WebServer.java
requestMessageLine = inFromClient.readLine();
StringTokenizer tokenizedLine = new StringTokenizer(requestMessageLine);
if (tokenizedLine.nextToken().equals("GET")){ fileName = tokenizedLine.nextToken(); fileName = tokenizedLine.nextToken(); if (fileName.startsWith("/") == true )
fileName = fileName.substring(1);
File file = new File(fileName); int numOfBytes = (int) file.length(); FileInputStream inFile = new FileInputStream (fileName); byte[] fileInBytes = new byte[numOfBytes];
inFile.read(fileInBytes);
WebServer.javaoutToClient.writeBytes("HTTP/1.0 200 Document Follows\r\n");
if (fileName.endsWith(".jpg")) outToClient.writeBytes("Content-Type: image/jpeg\r\n");
if (fileName.endsWith(".gif")) outToClient.writeBytes("Content-Type: image/gif\r\n");
outToClient.writeBytes("Content-Length: " + numOfBytes + "\r\n");
outToClient.writeBytes("\r\n"); outToClient.write(fileInBytes, 0, numOfBytes); connectionSocket.close();
} else System.out.println("Bad Request Message");
} }
Server con atención concurrente
• El server debe atender nuevos requerimientos de conexión mientras se procesa el previo requerimiento. Así trabajan en general los server TCP.
• Cuando llega un nuevo requerimiento de conexión al server, éste acepta e invoca un nuevo proceso para interactuar con el nuevo cliente (crea un thread por cada conexión).
Método de la clase Serverpublic void listenSocket(){
try{ server = new ServerSocket(4321); } catch (IOException e) {
System.out.println("Could not listen on port 4321"); System.exit(-1);
} while(true){
Server con atención concurrente
ClientWorker w; try{
connection w = new ClientWorker(server.accept(), textArea);
Thread t = new Thread(w); t.start();
} catch (IOException e) { System.out.println("Accept failed: 4321"); System.exit(-1);
} }
}
class ClientWorker implements Runnable {ClientWorker(Socket client, JTextArea textArea) { this.client = client; this.textArea = textArea; }
public void run() {//Enviar o recibir a través de “client”
} }
Cliente
Programación de Socket: referencias
C-language tutorial (audio/slides):
• “Unix Network Programming” (J. Kurose),http://manic.cs.umass.edu/~amldemo/courseware/intro.html
Java-tutorials:Java-tutorials:
• “All About Sockets” (Sun tutorial), http://docs.oracle.com/javase/tutorial/networking/sockets/index.html
• “Socket Programming in Java: a tutorial,” http://www.javaworld.com/javaworld/jw-12-1996/jw-12-sockets.html
top related