ObjectInputStream & ObjectOutputStream
Las clases ObjectInputStream y ObjectOutputStream nos permiten enviar objetos a través de sockets TCP.
ObjectOutputStream outObjeto = new
ObjectOutputStream(socket.getOutoutStream());
ObjectInputStream inObjeto = new
ObjectInputStream(socket.getInputStream());
Utilizaremos
los métodos readObject() para leer el
objeto del stream y writeObject() para
escribir el objeto al stream.
Para que un
programa java pueda convertir un objeto en un montón de bytes y pueda luego
recuperarlo, el objeto necesita ser Serializable.
Al poder convertir el objeto a bytes, ese objeto se puede enviar a través de
red, guardarlo en un fichero, y después reconstruirlo al otro lado de la red,
leerlo del fichero…
Para que un
objeto sea serializable basta con que implemente la interfaz Serialzable. Como la interfaz Serializable no tiene métodos,
es muy sencillo implementarla, basta con un implements
Serializable y nada más.
Si dentro
de la clase hay atributos que son otras clases, éstos a su vez también deben
ser Serializables. Con los tipos de java (String, Integer, etc.) no hay
problema porque lo son. Si ponemos como atributo nuestras propias clases, éstas
a su vez deben implementar Serializable.
Ejemplo
En el
siguiente ejemplo vamos a ver como el programa servidor crea un objeto Persona,
dándole valores y se lo envía al programa cliente, el programa cliente realiza
los cambios oportunos en el objeto y se lo devuelve modificado al servidor.
ARCHIVO SERVIDOROBJETO.JAVA
import java.io.*;
import java.net.*;
public class ServidorObjeto {
public static void main(String[] arg) throws IOException,
ClassNotFoundException {
int numeroPuerto = 6000;// Puerto
ServerSocket servidor = new ServerSocket(numeroPuerto);
System.out.println("Esperando
al cliente.....");
Socket cliente = servidor.accept();
// Se prepara
un flujo de salida para objetos
ObjectOutputStream
outObjeto = new
ObjectOutputStream( cliente.getOutputStream());
// Se prepara
un objeto y se envía
Persona per = new Persona("Juan", 20);
outObjeto.writeObject(per);
//enviando
objeto
System.out.println("Envio:
" + per.getNombre() +"*"+ per.getEdad());
// Se obtiene
un stream para leer objetos
ObjectInputStream
inObjeto = new
ObjectInputStream( cliente.getInputStream());
Persona dato = (Persona) inObjeto.readObject();
System.out.println("Recibo:
" + dato.getNombre() + "*" + dato.getEdad());
// CERRAR
STREAMS Y SOCKETS
outObjeto.close();
inObjeto.close();
cliente.close();
servidor.close();
}// Fin de
main
}// Fin de ServidorObjeto
ARCHIVO CLIENTEOBJETO.JAVA
import java.io.*;
import java.net.*;
public class ClienteObjeto {
public static void main(String[] arg) throws IOException,
ClassNotFoundException {
String Host = "localhost";
int Puerto = 6000;//puerto
remoto
System.out.println("PROGRAMA
CLIENTE INICIADO....");
Socket cliente = new Socket(Host, Puerto);
//Flujo
de entrada para objetos
ObjectInputStream
perEnt = new
ObjectInputStream(cliente.getInputStream());
//Se recibe
un objeto
Persona dato = (Persona) perEnt.readObject();
//recibo
objeto
System.out.println("Recibo:
" + dato.getNombre() + "*" + dato.getEdad());
//Modifico
el objeto
dato.setNombre("Juan
Ramos");
dato.setEdad(22);
//FLUJO DE salida
para objetos
ObjectOutputStream
perSal = new
ObjectOutputStream( cliente.getOutputStream());
// Se envía
el objeto
perSal.writeObject(dato);
System.out.println("Envio:
" + dato.getNombre() + "*" + dato.getEdad());
// CERRAR
STREAMS Y SOCKETS
perEnt.close();
perSal.close();
cliente.close();
}// Fin de
main
}// Fin de ClienteObjeto
ARCHIVO PERSONA.JAVA
import java.io.Serializable;
@SuppressWarnings("serial")
public class Persona implements Serializable {
String nombre;
int edad;
public Persona(String nombre, int edad) {
super();
this.nombre = nombre;
this.edad = edad;
}
public Persona() { super(); }
public String
getNombre() { return nombre; }
public void
setNombre(String nombre) { this.nombre = nombre; }
public int getEdad() { return edad; }
public void setEdad(int edad) {this.edad = edad; }
}// Fin de Persona
Utilizaremos las clases ByteArrayOutputStream y ByteARrayInputStream. Se necesita convertir el objeto a un array de bytes.
Persona persona = new Persona("Maria", 22);
// Convertimos objeto a bytes
ByteArrayOutputStream bs = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bs);
// Escribir objeto a bytes
out.writeObject(persona);
// Cerrar stream
out.close();
// Objeto en bytes
byte[] bytes = bs.toByteArray();
Para
convertir los bytes recibidos por el datagrama en un objeto Persona escribimos:
// Recibo datagrama
byte[] recibidos = new byte[1024];
DatagramPacket paqRecibido = new
DatagramPacket(recibidos, recibidos.length);
socket.receive(paqRecibido); // recibo el datagrama
// Convertirmos bytes a objetos
ByteArrayInputStream bais = new ByteArrayInputStream(recibidos);
ObjectInputStream in = new ObjectInputStream(bais);
// Obtengo objeto
Persona persona = (Persona)in.readObject();
in.close(); // Cerrar stream
0 comentarios:
Publicar un comentario