Download Archivos y Flujos (Streams)

PROGRAMACIÓN
ORIENTADA A OBJETOS
Dra. Maricela Bravo
[email protected]
ARCHIVOS Y FLUJOS
Archivos
Los archivos tienen como finalidad guardar
datos de forma permanente.Una vez que
acaba la aplicación los datos almacenados
están disponibles para que otra aplicación
pueda recuperarlos para su consulta o
modificación.
Archivos
La organización de un archivo define la forma en la en
que se estructuran u organizan los datos.
Formas de organización fundamentales:


Secuenciales: los registros se insertan en el archivo
en orden de llagada. Las operaciones básicas
permitidas son: escribir, añadir al final del archivo y
consultar .
Directa o aleatoria: cuando un registro es
directamente accesible mediante la especificación de
un índice.
Flujos (Streams)
Es una abstracción, que representa a un flujo de datos entre
un origen y un destino en Java. Todo proceso de entrada y
salida en Java se hace a través de flujos.
Entre el origen y el destino debe existir un canal , por el que
viajan datos.
Cuando se abre un archivo se establece una conexión entre
el programa y el dispositivo que contiene ese archivo , por el
canal fluirá la secuencia de datos.
Igual ocurre al intentar escribir en un archivo.
Archivos y Flujos (Streams)
Para obtener información de una fuente un
programa abre un stream y lee la información
secuencialmente
Archivos y Flujos (Streams)
De igual forma, un programa puede enviar
información
a un destino externo abriendo un
stream al destino y escribiendo la información
secuencialmente .
Archivos y Flujos (Streams)
No importa el tipo de datos ni de donde proviene ni
a donde se dirige, los algoritmos para la lectura y
escritura de datos son escencialmente los mismos
Abrir el stream
mientra haya información
leer información
cerrar el stream
Abrir el stream
mientra haya información
escribir la información
cerrar el stream
Archivos y Flujos (Streams)
Java posee una colección de clases stream las cuales
soportan estos algoritmos de lectura y escritura
Para utilizar las clases stream el programa deberá
importar el paquete java.io donde se encuentran
todas las clases necesarias para dar entrada/salida a
las aplicaciones.
FileReader, FileWriter
Los streams para archivos se manejan con los
objetos asociados a la clase File(FileReader y
FileWriter) para leer y escribir a un archivo en
asociación con los métodos: read() y write().
Un stream para archivos se puede crear a partir de
Un String con el nombre del archivo
Un objeto tipo File
Un objeto tipo FileDescriptor
Archivos y Flujos
/* El siguiente programa utiliza un objeto FileReader y uno
FileWriter para copiar el contenido de un archivo denominado
cancion.txt a un archivo denominado salida*/
import java.io.*;
public class Copy
{
public static void main(String[] args) throws IOException
{
File inputFile = new File("cancion.txt");
File outputFile = new File("salida");
FileReader in = new FileReader(inputFile);
FileWriter out = new FileWriter(outputFile);
int c;
while ((c = in.read()) != -1)
out.write(c);
in.close();
out.close();
}
}
ENTRADA - SALIDA
Streams
• Un stream representa un flujo de
información:
• procedente de una fuente
(teclado, file, memoria, red,
etc.) o
• dirigida a un destino (pantalla,
file, etc.)
• Los streams comparten una
misma interfaz que hace abstracción
de los detalles específicos de cada
dispositivo de E/S.
• Todas las clases de streams están
en el paquete java.io
13
Clases de Streams
(Streams orientados a byte)
• Los módulos sombreados
representan fuentes de datos.
• Los módulos sin sombrear
representan procesadores.
• Los procesadores se pueden aplicar
a otro procesador o a una fuente.
14
Subclases de InputStream
FileInputStream: lectura de files byte a
byte
 ObjectInputStream: lectura de files con
objetos.
 FilterInputStream:

◦ BufferedInputStream: lectura con buffer, más
eficiente.
◦ DataInputStream: lectura de tipos de datos
primitivos (int, double, etc.).
15
Subclases de OutputStream
FileOutputStream: escritura de files byte a
byte
 ObjectOutputStream: escritura de files
con objetos.
 FilterOutputStream:

◦ BufferedOutputStream: escritura con buffer,
más eficiente.
◦ DataOutputStream: escritura de tipos de
datos primitivos (int, double, etc.).
16
Clases de Streams
(Streams orientados a caracter)


Soportan UNICODE (16 bits para un char).
Módulos sombreados son fuentes, y sin sombrear son
procesadores.
17
Subclases de Reader

InputStreamReader: convierte un stream
de bytes en un stream de chars.
◦ FileReader: se asocia a files de chars para
leerlos.

BufferedReader: proporciona entrada de
caracteres a través de un buffer (más
eficiencia).
18
Subclases de Writer

OutputStreamWriter: convierte un
stream de bytes en un stream de chars.
◦ FileWriter: se asocia a files de chars para
modificarlos.
BufferedWriter: proporciona salida de
caracteres a través de un buffer (más
eficiencia).
 PrintWriter: métodos print() y println()
para distintos tipos de datos.

19
Otras Clases de java.io
File: permite realizar operaciones
habituales con files y directorios.
 RandomAccessFile: permite acceder al nésimo registro de un file sin pasar por los
anteriores.
 StreamTokenizer: permite “trocear” un
stream en tokens.

20
Típicos Usos de los Streams
(lectura por líneas)
public static void main(String[] args) throws IOException {
// 1a. Se lee un file línea a línea
BufferedReader in = new BufferedReader( new
FileReader("IOStreamDemo.java"));
String s, s2 = new String();
while((s = in.readLine())!= null)
s2 += s + "\n";
in.close();
// 1b. Se lee una línea por teclado
BufferedReader stdin = new BufferedReader( new
InputStreamReader(System.in));
System.out.print("Enter a line:");
System.out.println(stdin.readLine());
}
21
Parsing de tipos básicos
String linea;
int a;
BufferedReader stdin = new BufferedReader( new
InputStreamReader(System.in));
System.out.print("Enter a line:");
linea = stdin.readLine();
a = Integer.parseInt(linea);
System.out.println(a);

También están disponibles: parseDouble(), parseLong()
22
Típicos Usos de los Streams
(escritura por líneas)
// throws IOException
String []s = {“hola“, “que”, “tal”};
// Se inicializa s
PrintWriter out1 = new PrintWriter( new
BufferedWriter( new
FileWriter("IODemo.out")));
int lineCount = 1;
for (int i=0; i<s.length(); i++)
out1.println(lineCount++ + ": " + s[i]);
out1.close();
23
Típicos Usos de los Streams
(escritura de tipos básicos)
// throws IOException
DataOutputStream out2 = new
DataOutputStream(new
BufferedOutputStream(new
FileOutputStream("Data.txt")));
out2.writeDouble(3.14159);
out2.writeBytes("That was pi\n“);
out2.writeChars( "That was pi\n“);
out2.writeDouble(1.41413);
out2.writeUTF("Square root of 2");
out2.close();
24
Típicos Usos de los Streams
(lectura de tipos básicos)
// throws IOException
DataInputStream in5 = new DataInputStream( new
BufferedInputStream( new
FileInputStream("Data.txt")));
System.out.println(in5.readDouble());
System.out.println(in5.readLine()); // deprecated
System.out.println(in5.readDouble());
System.out.println(in5.readUTF());
25
Típicos Usos de los Streams
(files de acceso aleatorio)
// throws IOException
// acceso de lectura/escritura
RandomAccessFile rf = new RandomAccessFile("rtest.dat", "rw");
for(int i = 0; i < 10; i++)
rf.writeDouble(i*1.00);
rf.close();
rf = new RandomAccessFile("rtest.dat", "rw");
rf.seek(5*8); // salta 5 doubles (8 bytes cada uno)
rf.writeDouble(47.00); // modifica el sexto double
rf.close();
// acceso de sólo lectura
rf = new RandomAccessFile("rtest.dat", "r");
for(int i = 0; i < 10; i++)
System.out.println( "Value " + i + ": " + rf.readDouble());
rf.close();
26
Típicos Usos de los Streams
(Object Stream)

Java permite guardar objetos en archivos, pero esos objetos
deben implementar la interfaz Serializable:
public class MySerializableClass implements Serializable { ... }

Ejemplo:
// throws IOException
FileOutputStream out = new FileOutputStream("theTime.dat");
ObjectOutputStream s = new ObjectOutputStream(out);
s.writeObject("Today");
s.writeObject(new Date(1,1,2006));
s.close();
// throws IOException y ClassNotFoundException
FileInputStream in = new FileInputStream("theTime.dat");
ObjectInputStream s = new ObjectInputStream(in);
String today = (String)s.readObject();
Date date = (Date)s.readObject();
s.close();
27
MANEJO DE ERRORES
Manejo de Errores
La captura de errores inadecuados ha sido siempre
un problema en el software.
Un programa lanza una excepción en el punto en que
primero se detecta un error.
Cuando una aplicación termina anormalmente pudo
deberse a :archivos que se abrieron y no se cerraron,
conexiones de redes que no se cerraron, datos que
no se escribieron en disco.
Una aplicación bien diseñada e implementada no
debe permitir que esto suceda.
Manejo de Errores
Mecanismo de manejo de excepciones en JAVA
try
catch
throw
throws
finally
Cómo hacerlo ?
1. El programador intentará (try) una operación para
anticipar errores.
2. Cuando una rutina encuentra un error, se lanza (throw)
una excepción.
3. Por último, alguien interesado en una condición de
error lo capturará (catch).
Manejo de Errores
Objeto de excepción
Código de Usuario
Qué hacer con
los errores
Código de Biblioteca
Detecta errores
¿Qué es un Servidor Web?

Un servidor Web o demonio HTTP es un
programa que controla el flujo de datos
entrantes y salientes de una computadora
conectada a Intranet e Internet.

Un servidor Web es un programa de aplicación
que atiende las solicitudes HTTP realizadas por
los navegadores.

Escucha peticiones en el número de puerto 80,
normalmente.

Los programas de aplicación más difundidos
para montar un servidor Web son:
◦
Apache Tomcat
◦
Internet Information Server
32
Elementos de un Servidor Web

Un servidor Web es la
combinación de:
◦
Una plataforma de
hardware
◦
Un sistema operativo
◦
Software del servidor
◦
Y contenidos (HTML,
gráficas, video, audio)
Contenidos
Servidor HTTP
S.O.
Hardware
Contenidos:
•HTML
•Gráficas
•Audio
•Video
•Otros
33
Ejemplo
Internet – Infraestructura TCP/IP
Sitio Web
Privado
Sitio Web
Público
Servidor HTTP
Firewall
Servidor HTTP
S.O. Red
S.O. Red
Hardware
Hardware
Intranet
TCP/IP
Computadora
Computadora
Computadora
Browser
Browser
Browser
O.S. Red
O.S. Red
O.S. Red
Hardware
Hardware
Hardware
34
Protocolo HTTP

Es un protocolo de petición/respuesta sin estado
cuya operación básica es la siguiente :
GET/document.html http/1.1
http/1.1 200 OK
Content-Type:text/html
<HTML>…</HTML>
Navegador Web
Servidor Web
35
Sockets
Pila de protocolos TCP/IP

Capa de Aplicación
◦ Aplicaciones estándar
 HTTP
 FTP
 Telnet
◦ Aplicaciones de usuario

Capa de Transporte
◦ TCP
◦ UDP
◦ Interfaces de programación:
 Sockets

Capa de Red

Capa de Enlace
◦ IP
◦ Drivers de dispositivos
37

TCP/IP Stack
Application
(http, ftp, telnet,…)
Transport
(TCP, UDP,..)
Network
(IP,..)
Link
(device driver,..)
Pila de protocolos TCP/IP



TCP (Transport Control
Protocol)
Es un protocolo orientado a
conexión que proporciona un
flujo de datos confiable entre
dos computadoras.
Ejemplo de aplicaciones:
◦ HTTP
◦ FTP
◦ Telnet
38

TCP/IP Stack
Application
(http, ftp, telnet,…)
Transport
(TCP, UDP,..)
Network
(IP,..)
Link
(device driver,..)
Pila de protocolos TCP/IP



UDP (User Datagram
Protocol)
Es un protocolo que envía
paquetes de datos
independientes, llamados
datagramas, de una
computadora a otra, sin
garantizar su llegada.
Ejemplo de aplicaciones:
◦ Clock server
◦ Ping
39

TCP/IP Stack
Application
(http, ftp, telnet,…)
Transport
(TCP, UDP,..)
Network
(IP,..)
Link
(device driver,..)
¿Qué son los puertos?

TCP y UDP utilizan
puertos para enviar datos
entrantes a un proceso
particular que se esté
ejecutando en la
computadora.
server
P
o
r
t
app
app
app
app
port
port
port
port
TCP
Client
TCP or UDP
Packet
40
Data
port# data
¿Qué son los puertos?

Los puertos son representados por valores enteros
positivos de 16 bits.

Algunos puertos están reservados para soportar servicios
preestablecidos:

◦ FTP
21/TCP
◦ Telnet
23/TCP
◦ SMTP
25/TCP
◦ HTTP
80/TCP
Los procesos o servicios de usuarios generalmente usan
números de puertos >= 1024.
41
Sockets


Los sockets proporcionan una interfaz para la
programación de redes en la capa de transporte.
Las comunicaciones de redes utilizando Sockets es muy
similar al manejo de I/O en archivos.
◦ De hecho, el manejo de sockets es tratado como el manejo de
archivos.
◦ Los streams utilizados en operaciones de I/O de archivos también
son aplicables a I/O basado en sockets.

La comunicación basada en Sockets es independiente del
lenguaje de programación.
◦ Esto es, que un programa de socket escrito en Java también se
puede comunicar con un programa escrito en Java o con un
programa de socket no escrito en Java.
42
Comunicación entre Sockets

Un servidor (programa) corre en una computadora
específica y tiene un socket que se asocia con un puerto
específico. El servidor se mantiene en espera escuchando
al socket para cuando un cliente realiza una petición de
conexión.
43
port
server
Connection request
Client
Comunicación entre Sockets
Si todo sale bien, el servidor acepta la conexión. Después de la
aceptación, el servidor obtiene un nuevo socket asociado a un puerto
diferente. Necesita un nuevo socket (consecuentemente un número
de puerto diferente), de tal forma que puede continuar escuchando al
socket original para solicitudes de conexión mientras que atiende al
cliente conectado.
port
44
port
server
port

Connection
Client
Clases de Java para crear Sockets

Un socket es un endpoint de un enlace de comunicación
bi-direccional entre dos programas ejecutándose en la red.

Un socket se asocia a un número de puerto de tal forma
que la capa de TCP puede identificar la aplicación a la cual
están destinados los datos.

El paquete de Java .net proporciona dos clases:
◦ Socket – para implementar un cliente
◦ ServerSocket – para implementar un servidor.
45
Java Sockets
Server
ServerSocket(1234)
Flujo de salida/escritura
Client
Flujo de entrada/lectura
Socket(“128.250.25.158”, 1234)
46
Puede
ser un dominio como “mandroo.cs.mu.oz.au”
Sockets
47
Programación de Sockets usando TCP
TCP service: transferencia confiable de flujos de bytes
client
socket( )
bind( )
connect( )
send( )
socket( )
bind( )
listen( )
server
TCP conn. request
TCP ACK
accept( )
recv( )
recv( )
close( )
controlled by
application
developer
controlled by
operating
system
48
process
socket
TCP with
buffers,
variables
send( )
close( )
Internet
process
socket
TCP with
buffers,
variables
Client/server socket interaction: TCP
Server (running on hostid)
Client
create socket,
port=x, for
incoming request:
welcomeSocket =
ServerSocket()
TCP
connection setup
wait for incoming
connection request
connectionSocket =
welcomeSocket.accept()
read request from
connectionSocket
write reply to
connectionSocket
close
connectionSocket
49
create socket,
connect to hostid, port=x
clientSocket =
Socket()
send request using
clientSocket
read reply from
clientSocket
close
clientSocket
Ejemplo de un Server
1. Crear el Server Socket:
ServerSocket server;
DataOutputStream os;
DataInputStream is;
server = new ServerSocket( PORT );
2. Espera solicitudes de clientes:
Socket client = server.accept();
3. Crea flujos de I/O para comunicarse con el cliente
is = new DataInputStream( client.getInputStream() );
os = new DataOutputStream( client.getOutputStream() );
4. Realiza comunicación con un cliente
Receive from client: String line = is.readLine();
Send to client: os.writeBytes("Hello\n");
5. Cierra el socket:
50
client.close();
Ejemplo de un Cliente
1. Crear un objeto de Socket:
client = new Socket( server, port_id );
2. Crea flujos de I/O para comunicarse con el servidor.
is = new DataInputStream(client.getInputStream() );
os = new DataOutputStream( client.getOutputStream() );
3. Realiza I/O o comunicación con el server:
◦ Receive data from the server:
String line = is.readLine();
◦ Send data to the server:
os.writeBytes("Hello\n");
4. Cierra el socket cuando termina:
client.close();
51
Un Server Simple
import java.net.*;
import java.io.*;
public class SimpleServer
{
public static void main(String args[]) throws IOException
{
// Registrar el servicio en el puerto 1234
ServerSocket s = new ServerSocket(1245);
//Espera y acepta conexiones
Socket s1 = s.accept();
//Obtiene un flujo de comunicación asociado con el socket
OutputStream s1out = s1.getOutputStream();
DataOutputStream dos = new DataOutputStream (s1out);
//Envia un mensaje
dos.writeUTF("Hola que tal");
//Cierra la conexión, pero no el socket del servidor
dos.close();
s1out.close();
}
52}
s1.close();
Un Cliente Simple
import java.net.*;
import java.io.*;
public class SimpleClient
{
public static void main(String args[]) throws IOException
{
//Abrir una conexión al server en el puerto 1234
Socket s1 = new Socket("localhost",1245);
//Obtener un manejador de flujo de entrada del socket y leer la entrada
InputStream s1In = s1.getInputStream();
DataInputStream dis = new DataInputStream(s1In);
String st = new String (dis.readUTF());
System.out.println(st);
//Cerrar la conexion
dis.close();
s1In.close();
}
53
}
s1.close();
Ejecución

Ejecutar Server en el localhost
◦

Ejecutar el Client en cualquier máquina:
◦

java SimpleServer
java SimpleClient
Hola que tal
Si se ejecuta el cliente cuando el server no está escuchando:
◦ java SimpleClient
Exception in thread "main" java.net.ConnectException: Connection refused
at java.net.PlainSocketImpl.socketConnect(Native Method)
at java.net.PlainSocketImpl.doConnect(PlainSocketImpl.java:320)
at java.net.PlainSocketImpl.connectToAddress(PlainSocketImpl.java:133)
at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:120)
at java.net.Socket.<init>(Socket.java:273)
at java.net.Socket.<init>(Socket.java:100)
at SimpleClient.main(SimpleClient.java:6)
54
Servidor de ECO
import java.io.*;
import java.net.*;
public class ServidordeEco {
public static void main(String[] args)
{
try
{
ServerSocket s = new ServerSocket(8189);
Socket entrante = s.accept();
try
{
InputStream se = entrante.getInputStream();
DataInputStream in = new DataInputStream(se);
OutputStream so = entrante.getOutputStream();
PrintWriter out = new PrintWriter(so,true);
55
Servidor de ECO
out.println("Escriba ADIOS para salir");
boolean terminado = false;
while(!terminado)
{
String linea = in.readLine();
out.println("Eco: " + linea );
if (linea.trim().equals("ADIOS"))
terminado = true;
}
}
finally
{
}
}
}
entrante.close();
}
catch(IOException e)
{
e.printStackTrace();
}
56
Servidor Web

Maneja solamente una petición HTTP

Acepta y parsea la petición HTTP

Obtiene el archivo requerido del sistema de archivos del
servidor

Crea un mensaje de respuesta HTTP, el cual consiste del
archivo precedido por líneas de cabecera.

Envía la respuesta directamente al cliente.
57
import java.io.*;
import java.net.*;
import java.util.*;
public class WebServer
{
public static void main(String[] args)
{
String requestMessageLine;
String fileName;
try
{
ServerSocket listenSocket = new ServerSocket(8000);
Socket connectionSocket = listenSocket.accept();
BufferedReader inFromClient = new BufferedReader(
new InputStreamReader(connectionSocket.getInputStream()));
DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
requestMessageLine = inFromClient.readLine();
StringTokenizer tokenizedLine = new StringTokenizer(requestMessageLine);
if (tokenizedLine.nextToken().equals("get"))
{
fileName = tokenizedLine.nextToken();
if (fileName.startsWith("/") == true )
fileName = fileName.substring(1);
58
File file = new File(fileName);
int numOfBytes = (int) file.length();
FileInputStream inFile = new FileInputStream
(fileName);
byte[] fileInBytes = new byte[numOfBytes];
inFile.read(fileInBytes);
outToClient.writeBytes("HTTP/1.1 200 Document
Follows\r\n");
if (fileName.endsWith(".jpg"))
outToClient.writeBytes("Content-Type:
image/jpeg\r\n");
59
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");
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
60
/* ChatServer.java */
import java.net.ServerSocket;
import java.net.Socket;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
class ChatServer {
private static int port = 1001; /* port the server listens on */
public static void main (String[] args) throws IOException {
ServerSocket server = null;
try {
server = new ServerSocket(port); /* start listening on the port */
} catch (IOException e) {
System.err.println("Could not listen on port: " + port);
System.err.println(e); System.exit(1); }
Socket client = null;
try {
client = server.accept();
} catch (IOException e) {
System.err.println("Accept failed.");
System.err.println(e); System.exit(1); } /* obtain an input stream
to the client */ BufferedReader in = new BufferedReader(new
InputStreamReader( client.getInputStream()));
String msg;
/* loop reading lines from the client and display them */
while ((msg = in.readLine()) != null) {
System.out.println("Client says: " + msg); } } }
/* ChatClient.java */
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException; class ChatClient { private
static int port = 1001; /* port to connect to */ private static String
host = "localhost"; /* host to connect to */ public static void main
(String[] args) throws IOException { Socket server; PrintWriter out =
null; try { /* try to open a socket to the server at the given host:port
*/ server = new Socket(host, port); /* obtain an output stream to the
server */ out = new PrintWriter(server.getOutputStream(), true); }
catch (UnknownHostException e) { System.err.println(e);
System.exit(1); } BufferedReader stdIn = new BufferedReader( new
InputStreamReader(System.in)); String msg; /* loop reading lines
from stdin and output what was read * to the server */ while ((msg =
stdIn.readLine()) != null) { out.println(msg); } } }
Programación de Sockets con UDP

UDP
◦ No es orientado a conexión y el servicio no es confiable.
◦ No existe una fase inicial de handshaking.
◦ Los datos transmitidos pueden recibirse fuera de orden.

Programación de Sockets con UDP
◦ No necesita que se asocien streams al socket.
◦ El host que envía crea paquetes adjuntando la dirección IP destino
y el número de puerto en cada lote de bytes.
◦ El proceso que recibe debe reorganizar el paquete para obtener
los bytes de información del paquete.
64
Interacción Cliente/Servidor con sockets UDP
Servidor
(corriendo en el hostid)
Crear un socket,
puerto=x, para
solicitudes de entrada:
serverSocket =
DatagramSocket()
Lee solicitud de
serverSocket
Escribe respuesta
serverSocket
especificando la
dirección del
cliente y el puerto
65
Cliente
Crear socket,
clientSocket =
DatagramSocket()
Crear dirección (hostid, port=x,
Enviar datagrama de solicitud
utilizando clientSocket
Lee respuesta de
clientSocket
cierra
clientSocket
JAVA UDP Sockets

Paquete java.net
◦ java.net.DatagramSocket
 Un socket para enviar y recibir paquetes de
datagramas.
 Constructores y métodos
 DatagramSocket(int port): Construye un socket de
datagrama y lo asocia con un puerto espefífico en la
máquina local.
 void receive( DatagramPacket p): Recibe paquetes.
 void send( DatagramPacket p): Envía paquetes.
 void close()
66
UDPClient.java
import java.io.*;
import java.net.*;
class UDPClient {
public static void main(String args[]) throws Exception
{
BufferedReader inFromUser =
new BufferedReader(new InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress = InetAddress.getByName("hostname");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = inFromUser.readLine();
sendData = sentence.getBytes();
67
UDPClient.java
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, IPAddress, 9876);
clientSocket.send(sendPacket);
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
clientSocket.receive(receivePacket);
String modifiedSentence =
new String(receivePacket.getData());
System.out.println("FROM SERVER:" + modifiedSentence);
clientSocket.close();
}
}
68
UDPServer.java
import java.io.*;
import java.net.*;
class UDPServer {
public static void main(String args[]) throws Exception
{
DatagramSocket serverSocket = new
DatagramSocket(9876);
byte[] receiveData = new byte[1024];
byte[] sendData = new byte[1024];
while(true)
{
DatagramPacket receivePacket =
new DatagramPacket(receiveData, receiveData.length);
serverSocket.receive(receivePacket);
String sentence = new String(receivePacket.getData());
69
UDPServer.java
InetAddress IPAddress = receivePacket.getAddress();
int port = receivePacket.getPort();
String capitalizedSentence = sentence.toUpperCase();
sendData = capitalizedSentence.getBytes();
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, IPAddress, port);
serverSocket.send(sendPacket);
}
}
}
70
Socket Exceptions
try {
Socket client = new Socket(host, port);
handleConnection(client);
}
catch(UnknownHostException uhe) {
System.out.println("Unknown host: " + host);
uhe.printStackTrace();
}
catch(IOException ioe) {
System.out.println("IOException: " + ioe);
ioe.printStackTrace();
}
71
Servidor en un Ciclo: Siempre en Ejecución
import java.net.*;
import java.io.*;
public class SimpleServerLoop
{
public static void main(String args[]) throws IOException
{
ServerSocket s = new ServerSocket(1234);
while(true)
{
Socket s1=s.accept();
OutputStream s1out = s1.getOutputStream();
DataOutputStream dos = new DataOutputStream (s1out);
dos.writeUTF("Hola");
dos.close();
s1out.close();
s1.close();
}
}
}
72
Multithreaded Server: Para servir a múltiples
clientes concurrentemente
Server Process
Client 1 Process
Server
Threads

Client 2 Process
73
Internet
Servidor de Eco con Hilos
import java.io.*;
import java.net.*;
import java.util.*;
public class servidorEcoconHilos
{
public static void main(String[] args) {
try {
int i = 1;
ServerSocket s = new ServerSocket(8189);
while(true)
{
Socket entrante = s.accept();
System.out.println(“generando hilo “ + i);
Runnable r = new ManejadorHilos(entrante, i);
Thread t = new Thread(r);
t.start();
i++;
}
}
74
catch(IOException e) {
e.printStackTrace();
}
}
}
//Clase para el manejo de hilos
Class ManejadorHilos implements Runnable
{
public ManejadorHilos(Socket i, int c)
{
entrante = i;
contador = c;
}
public void run()
{
try {
try {
InputStream secuenciaEntrada = entrante.getInputStream();
OutputStream secuenciaSalida = entrante.getOutputStream();
Scanner in = new Scanner(secuenciaEntrada);
PrintWriter out = new PrintWriter(secuenciaSalida, true);
out.println(“Escriba ADIOS para salir”);
75
//Reproducir la entrada del cliente
boolean terminado = false;
while(!terminado && in.hasNextLine()) {
String linea = in.readLine();
out.println("Eco: " + linea );
if (linea.trim().equals("ADIOS"))
terminado = true;
}
}
finally
{
entrante.close();
}
Catch(IOException e)
{
e.printStackTrace();
}
}//End del run
private Socket entrante;
private int contador;
}
76