INFORME DE LABORATORIO 1

SISTEMA DISTRIBUIDOS

Presentado por:
FELIPE SERRANO ZAMORA
COD: 1033685327

Tutor:
CARLOS HERNAN SILVA

SISTEMAS DISTRIBUIDOS
INGENIERIA DE SISTEMAS - ECBTI
UNIVERSIDAD NACIONAL ABIERTA Y A DISTANCIA
BOGOTA DC. – OCTUBRE DE 2013
 INTRODUCCION
Este informe, consiste en la realización de un Socket, para la comprobación de la
conexión del Cliente – Servidor, elaborado mediante el lenguaje de programación
Java. Por eso se puede dar una prueba básica en la conexión del Cliente- Servidor
y su funcionamiento y dar base para la realización de los sistemas distribuidos
basándose en esta práctica.
 OBJETIVOS

General:
 Elaborar una aplicación distribuida cliente – servidor.
Específicos:
 Crear una aplicación socket de cliente – servidor en lenguaje Java.
 Comprobar el funcionamiento de la aplicación.
 PRACTICA DE LABORATORIO Nº 1
1. Marco teórico
Arquitectura cliente-servidor
La arquitectura cliente-servidor es un modelo de aplicación distribuida en el que
las tareas se reparten entre los proveedores de recursos o servicios, llamados
servidores, y los demandantes, llamados clientes. Un cliente realiza peticiones a
otro programa, el servidor, quien le da respuesta. Esta idea también se puede
aplicar a programas que se ejecutan sobre una sola computadora, aunque es más
ventajosa en un sistema operativo multiusuario distribuido a través de una red de
computadoras.
En esta arquitectura la capacidad de proceso está repartida entre los clientes y los
servidores, aunque son más importantes las ventajas de tipo organizativo debidas
a la centralización de la gestión de la información y la separación de
responsabilidades, lo que facilita y clarifica el diseño del sistema.
La separación entre cliente y servidor es una separación de tipo lógico, donde el
servidor no se ejecuta necesariamente sobre una sola máquina ni es
necesariamente un sólo programa. Los tipos específicos de servidores incluyen los
servidores web, los servidores de archivo, los servidores del correo, etc. Mientras
que sus propósitos varían de unos servicios a otros, la arquitectura básica seguirá
siendo la misma.
Una disposición muy común son los sistemas multicapa en los que el servidor se
descompone en diferentes programas que pueden ser ejecutados por diferentes
computadoras aumentando así el grado de distribución del sistema.
La arquitectura cliente-servidor sustituye a la arquitectura monolítica en la que no
hay distribución, tanto a nivel físico como a nivel lógico.
La red cliente-servidor es aquella red de comunicaciones en la que todos los
clientes están conectados a un servidor, en el que se centralizan los diversos
recursos y aplicaciones con que se cuenta; y que los pone a disposición de los
clientes cada vez que estos son solicitados. Esto significa que todas las gestiones
que se realizan se concentran en el servidor, de manera que en él se disponen los
requerimientos provenientes de los clientes que tienen prioridad, los archivos que
son de uso público y los que son de uso restringido, los archivos que son de sólo
lectura y los que, por el contrario, pueden ser modificados, etc. Este tipo de red
puede utilizarse conjuntamente en caso de que se esté utilizando en una red
mixta.

Socket
Socket designa un concepto abstracto por el cual dos programas (posiblemente
situados en computadoras distintas) pueden intercambiar cualquier flujo de datos,
generalmente de manera fiable y ordenada.
El término socket es también usado como el nombre de una interfaz de
programación de aplicaciones (API) para la familia de protocolos de Internet
TCP/IP, provista usualmente por el sistema operativo.
Los sockets de Internet constituyen el mecanismo para la entrega de paquetes de
datos provenientes de la tarjeta de red a los procesos o hilos apropiados. Un
socket queda definido por un par de direcciones IP local y remota, un protocolo de
transporte y un par de números de puerto local y remoto.
Sockets en Java
Los sockets son básicamente formas en las que podemos interconectar 2 (o más)
programas mediante el uso de la internet. En java se utilizan para poder crear
conexiones utilizando básicamente una IP/hostname y un puerto para establecer
la conexión. Para aprender podemos utilizarla para conectar 2 programas por
medio de Internet.
¿Cómo funciona?
El modelo más básico de los sockets consta de 2 simples programas, un servidor
y un cliente. Básicamente el programa servidor comienza a “escuchar” en un
puerto determinado (nosotros lo especificamos), y posteriormente el programa que
la hace de “cliente” debe conocer la ip o nombre de dominio/hostname del servidor
y el puerto que está escuchando, al saber esto simplemente solicita establecer
una conexión con el servidor. Es aquí cuando el servidor acepta esa conexión y se
puede decir que estos programas están “conectados”, de este modo pueden
intercambiar información. En el siguiente video muestro un programa servidor con
sockets, explico más o menos el código, en que consiste y hago una prueba en el
cual la conexión es exitosa.

2. Desarrollo de la práctica.
 1) Consultar el código en lenguaje de programación Java para el cliente.
// Cliente que lee y muestra la
información que le envía un enviarDatos( evento.getActionComm
Servidor. and() );
import java.io.*;
import java.net.*; campoIntroducir.setText( "" );
import java.awt.*; }
import java.awt.event.*; }
import javax.swing.*; );

public class Cliente extends

JFrame { contenedor.add( campoIntroducir,
private JTextField BorderLayout.NORTH );
campoIntroducir;
private JTextArea // crear areaPantalla
areaPantalla; areaPantalla = new
private ObjectOutputStream JTextArea();
salida; contenedor.add( new
private ObjectInputStream JScrollPane( areaPantalla ),
entrada; BorderLayout.CENTER );
private String mensaje = "";
private String servidorChat; setSize( 300, 150 );
private Socket cliente; setVisible( true );

// inicializar servidorChat y } // fin del constructor de

configurar GUI Cliente
public Cliente( String host )
{ // conectarse al servidor y
super( "Cliente" ); procesar mensajes del servidor
private void ejecutarCliente()
servidorChat = host; // {
establecer el servidor al que se // conectarse al servidor,
va a conectar este cliente obtener flujos, procesar la
conexión
Container contenedor = try {
getContentPane(); conectarAServidor(); //
Paso 1: crear un socket para
// crear campoIntroducir y realizar la conexión
registrar componente de escucha obtenerFlujos(); //
campoIntroducir = new Paso 2: obtener los flujos de
JTextField(); entrada y salida
procesarConexion(); //
campoIntroducir.setEditable( fals Paso 3: procesar la conexión
e ); }

campoIntroducir.addActionListener // el servidor cerró la

( conexión
new ActionListener() { catch ( EOFException
excepcionEOF ) {
// enviar mensaje al System.err.println( "El
servidor cliente termino la conexión" );
public void }
actionPerformed( ActionEvent
evento ) // procesar los problemas
{ que pueden ocurrir al comunicarse
con el servidor
 catch ( IOException
excepcionES ) {
excepcionES.printStackTrace();
} }
finally {
cerrarConexion(); //
Paso 4: cerrar la conexión
} procesarConexion() throws
} // fin del método
ejecutarCliente
// conectarse al servidor
private void
conectarAServidor() throws
IOException
{ e );
mostrarMensaje( "Intentando
realizar conexión\n" );
// crear Socket para
realizar la conexión con el
servidor
cliente = new
Socket( InetAddress.getByName( se
rvidorChat ), 12345 );
// mostrar la información
de la conexión
mostrarMensaje( "Conectado
a: " +
cliente.getInetAddress().getHostN
ame() );
} ( ClassNotFoundException
// obtener flujos para enviar
y recibir datos
private void obtenerFlujos()
throws IOException
{
// establecer flujo de
salida para los objetos
salida = new
ObjectOutputStream( cliente.getOu
tputStream() );
salida.flush(); // vacíar
búfer de salida para enviar
información de encabezado
// establecer flujo de
entrada para los objetos
entrada = new
ObjectInputStream( cliente.getInp
utStream() );
mostrarMensaje( "\nSe
recibieron los flujos de
E/S\n" );
// procesar la conexión con el
servidor
private void
IOException
{
// habilitar
campoIntroducir para que el
usuario del cliente pueda enviar
mensajes
establecerCampoTextoEditable( tru
do { // procesar mensajes
enviados del servidor
// leer mensaje y
mostrarlo en pantalla
try {
mensaje = ( String )
entrada.readObject();
mostrarMensaje( "\n"
+ mensaje );
}
// atrapar los problemas
que pueden ocurrir al leer del
servidor
catch
excepcionClaseNoEncontrada ) {
mostrarMensaje( "\nSe
recibió un objeto de tipo
desconocido" );
}
} while ( !
mensaje.equals( "SERVIDOR>>>
TERMINAR" ) );
} // fin del método
procesarConexion
// cerrar flujos y socket
private void cerrarConexion()
{
mostrarMensaje( "\nCerrando
conexión" );
establecerCampoTextoEditable( fal
se ); // deshabilitar la GUI se actualice
campoIntroducir apropiadamente

try { public void run() //

salida.close(); actualiza areaPantalla
entrada.close(); {
cliente.close();
} areaPantalla.append( mensajeAMost
catch( IOException rar );
excepcionES ) {
areaPantalla.setCaretPosition(
excepcionES.printStackTrace();
} areaPantalla.getText().length() )
} ;
}
// enviar mensaje al servidor
private void } // fin de la clase
enviarDatos( String mensaje ) interna
{
// enviar objeto al ); // fin de la llamada a
servidor SwingUtilities.invokeLater
try { }

salida.writeObject( "CLIENTE>>> " // método utilitario que es

+ mensaje );
salida.flush();
mostrarMensaje( "\nCLIENTE>>> " +
mensaje );
} establecerCampoTextoEditable( fin
// procesar los problemas
que pueden ocurrir al enviar el
objeto
catch ( IOException
excepcionES ) {
areaPantalla.append( "\nError al
escribir el objeto" );
}
} public void run()
// método utilitario que es
llamado desde otros subprocesos
para manipular a
// areaPantalla en el
subproceso despachador de eventos
private void
mostrarMensaje( final String
mensajeAMostrar )
{ interna
// mostrar mensaje del
subproceso de ejecución de la GUI
SwingUtilities.invokeLater(
new Runnable() { //
clase interna para asegurar que
llamado desde otros subprocesos
para manipular a
// campoIntroducir en el
subproceso despachador de eventos
private void
al boolean editable )
{
// mostrar mensaje del
subproceso de ejecución de la GUI
SwingUtilities.invokeLater(
new Runnable() { //
clase interna para asegurar que
la GUI se actualice
apropiadamente
//
establece la capacidad de
modificar campoIntroducir
{
campoIntroducir.setEditable( edit
able );
}
} // fin de la clase
); // fin de la llamada a
SwingUtilities.invokeLater
}
 public static void
main( String args[] )
{
Cliente aplicacion;

if ( args.length == 0 )
aplicacion = new
Cliente( "127.0.0.1" );
else
aplicacion = new
Cliente( args[ 0 ] );

aplicacion.setDefaultCloseOperati
on( JFrame.EXIT_ON_CLOSE );

aplicacion.ejecutarCliente();
}

} // fin de la clase Cliente

2) Hacer lo mismo con la clase Servidor.
3) // Configurar un servidor 35) {
que reciba una conexión de 36)
un cliente, envíe enviarDatos( evento.getActi
4) // una cadena al cliente y onCommand() );
cierre la conexión. 37)
5) import java.io.*; campoIntroducir.setText( ""
6) import java.net.*; );
7) import java.awt.*; 38) }
8) import java.awt.event.*; 39) }
9) import javax.swing.*; 40) );
10) 41)
11) public class Servidor 42)
extends JFrame { contenedor.add( campoIntrod
12) private JTextField ucir, BorderLayout.NORTH );
campoIntroducir; 43)
13) private JTextArea 44) // crear
areaPantalla; areaPantalla
14) private 45) areaPantalla = new
ObjectOutputStream salida; JTextArea();
15) private 46) contenedor.add( new
ObjectInputStream entrada; JScrollPane( areaPantalla )
16) private ServerSocket ,
servidor; 47)
17) private Socket BorderLayout.CENTER );
conexion; 48)
18) private int contador = 49) setSize( 300, 150 );
1; 50) setVisible( true );
19) 51)
20) // configurar GUI 52) } // fin del
21) public Servidor() constructor de Servidor
22) { 53)
23) super( "Servidor" ); 54) // configurar y
24) ejecutar el servidor
25) Container contenedor 55) public void
= getContentPane(); ejecutarServidor()
26) 56) {
27) // crear 57) // configurar
campoIntroducir y registrar servidor para que reciba
componente de escucha conexiones; procesar las
28) campoIntroducir = conexiones
new JTextField(); 58) try {
29) 59)
campoIntroducir.setEditable 60) // Paso 1: crear
( false ); un objeto ServerSocket.
30) 61) servidor = new
campoIntroducir.addActionLi ServerSocket( 12345, 100 );
stener( 62)
31) new 63) while ( true ) {
ActionListener() { 64)
32) 65) try {
33) // enviar 66)
mensaje al cliente esperarConexion(); // Paso
34) public void 2: esperar una conexión.
actionPerformed( ActionEven 67)
t evento ) obtenerFlujos(); //
 Paso 3: obtener flujos de 96) conexion =
entrada y salida. servidor.accept(); //
68) permitir al servidor
procesarConexion(); // Paso aceptar la conexión
4: procesar la conexión. 97)
69) } mostrarMensaje( "Conexión "
70) + contador + " recibida de:
71) // procesar " +
excepción EOFException 98)
cuando el cliente cierre la conexion.getInetAddress().g
conexión etHostName() );
72) catch 99) }
( EOFException excepcionEOF 100)
) { 101) // obtener flujos para
73) enviar y recibir datos
System.err.println( "El 102) private void
servidor terminó la obtenerFlujos() throws
conexión" ); IOException
74) } 103) {
75) 104) // establecer flujo
76) finally { de salida para los objetos
77) 105) salida = new
cerrarConexion(); // Paso ObjectOutputStream( conexio
5: cerrar la conexión. n.getOutputStream() );
78) ++contador; 106) salida.flush(); //
79) } vaciar búfer de salida para
80) enviar información de
81) } // fin de encabezado
instrucción while 107)
82) 108) // establecer flujo
83) } // fin del bloque de entrada para los objetos
try 109) entrada = new
84) ObjectInputStream( conexion
85) // procesar .getInputStream() );
problemas con E/S 110)
86) catch ( IOException 111)
excepcionES ) { mostrarMensaje( "\nSe
87) recibieron los flujos de
excepcionES.printStackTrace E/S\n" );
(); 112) }
88) } 113)
89) 114) // procesar la conexión
90) } // fin del método con el cliente
ejecutarServidor 115) private void
91) procesarConexion() throws
92) // esperar que la IOException
conexión llegue, después 116) {
mostrar información de la 117) // enviar mensaje de
conexión conexión exitosa al cliente
93) private void 118) String mensaje =
esperarConexion() throws "Conexión exitosa";
IOException 119) enviarDatos( mensaje
94) { );
95) 120)
mostrarMensaje( "Esperando 121) // habilitar
una conexión\n" ); campoIntroducir para que el
 usuario del servidor pueda 148) salida.close();
enviar mensajes 149) entrada.close();
122) 150) conexion.close();
establecerCampoTextoEditabl 151) }
e( true ); 152) catch( IOException
123) excepcionES ) {
124) do { // procesar los 153)
mensajes enviados por el excepcionES.printStackTrace
cliente ();
125) 154) }
126) // leer el 155) }
mensaje y mostrarlo en 156)
pantalla 157) // enviar mensaje al
127) try { cliente
128) mensaje = 158) private void
( String ) enviarDatos( String mensaje
entrada.readObject(); )
129) 159) {
mostrarMensaje( "\n" + 160) // enviar objeto al
mensaje ); cliente
130) } 161) try {
131) 162)
132) // atrapar salida.writeObject( "SERVID
problemas que pueden OR>>> " + mensaje );
ocurrir al tratar de leer 163) salida.flush();
del cliente 164)
133) catch mostrarMensaje( "\nSERVIDOR
( ClassNotFoundException >>> " + mensaje );
excepcionClaseNoEncontrada 165) }
) { 166)
134) 167) // procesar
mostrarMensaje( "\nSe problemas que pueden
recibió un tipo de objeto ocurrir al enviar el objeto
desconocido" ); 168) catch ( IOException
135) } excepcionES ) {
136) 169)
137) } while ( ! areaPantalla.append( "\nErr
mensaje.equals( "CLIENTE>>> or al escribir objeto" );
TERMINAR" ) ); 170) }
138) 171) }
139) } // fin del método 172)
procesarConexion 173) // método utilitario
140) que es llamado desde otros
141) // cerrar flujos y subprocesos para manipular
socket a
142) private void 174) // areaPantalla en el
cerrarConexion() subproceso despachador de
143) { eventos
144) 175) private void
mostrarMensaje( "\nFinaliza mostrarMensaje( final
ndo la conexión\n" ); String mensajeAMostrar )
145) 176) {
establecerCampoTextoEditabl 177) // mostrar mensaje
e( false ); // deshabilitar del subproceso de ejecución
campoIntroducir despachador de eventos
146) 178)
147) try { SwingUtilities.invokeLater(
179) new Runnable() { 204) }
// clase interna para 205)
asegurar que la GUI se 206) } // fin de la
actualice apropiadamente clase interna
180) 207)
181) public void 208) ); // fin de la
run() // actualiza llamada a
areaPantalla SwingUtilities.invokeLater
182) { 209) }
183) 210)
areaPantalla.append( mensaj 211) public static void
eAMostrar ); main( String args[] )
184) 212) {
areaPantalla.setCaretPositi 213) Servidor aplicacion
on( = new Servidor();
185) 214)
areaPantalla.getText().leng aplicacion.setDefaultCloseO
th() ); peration( JFrame.EXIT_ON_CL
186) } OSE );
187) 215)
188) } // fin de la aplicacion.ejecutarServidor
clase interna ();
189) 216) }
190) ); // fin de la 217)
llamada a 218) } // fin de la clase
SwingUtilities.invokeLater Servidor
191) }
192)
193) // método utilitario
que es llamado desde otros
subprocesos para manipular
a
194) // campoIntroducir en
el subproceso despachador
de eventos
195) private void
establecerCampoTextoEditabl
e( final boolean editable )
196) {
197) // mostrar mensaje
del subproceso de ejecución
despachador de eventos
198)
SwingUtilities.invokeLater(
199) new Runnable() {
// clase interna para
asegurar que la GUI se
actualice apropiadamente
200)
201) public void
run() // establece la
capacidad de modificar a
campoIntroducir
202) {
203)
campoIntroducir.setEditable
( editable );
3) Reutilizar ambas clases y aplicarlos mediante el programa NetBeans
import java.io.*; new ActionListener() {
import java.net.*;
import java.awt.*; public void
actionPerformed( ActionEvent evento
import java.awt.event.*; )
import javax.swing.*; {

public class Cliente extends JFrame enviarDatos( evento.getActionComman

{ d() );

private JTextField
Campo_Introduccion; Campo_Introduccion.setText( "" );

private JTextArea Area_Pantalla; }

private ObjectOutputStream }
Salida; );
private ObjectInputStream
Entrada;
private String Mensaje = ""; contenedor.add( Campo_Introduccion,
private String Servidor_Chat; BorderLayout.NORTH );

private Socket Cliente;

Area_Pantalla = new
JTextArea();
public Cliente( String host )
contenedor.add( new
{ JScrollPane( Area_Pantalla ),
super( "Cliente" ); BorderLayout.CENTER );

Servidor_Chat = host; setSize( 300, 150 );

setVisible( true );
Container contenedor =
getContentPane();
}

Campo_Introduccion = new
JTextField(); private void ejecutarCliente()
{
Campo_Introduccion.setEditable( fal
se );
try {
Campo_Introduccion.addActionListene conectarAServidor();
r(
 obtenerFlujos();
Cliente.getInetAddress().getHostNam
procesarConexion(); e() );
} }

catch ( EOFException private void obtenerFlujos()

excepcionEOF ) { throws IOException
{
System.err.println( "Conexión del
cliente terminada" );
} Salida = new
ObjectOutputStream( Cliente.getOutp
utStream() );
catch ( IOException Salida.flush();
excepcionES ) {

excepcionES.printStackTrace(); Entrada = new

ObjectInputStream( Cliente.getInput
} Stream() );

finally { mostrarMensaje( "\nSFlujos de

cerrarConexion(); E/S recibidas\n" );

} }

} private void procesarConexion()

throws IOException
{
private void conectarAServidor()
throws IOException establecerCampoTextoEditable(
true );
{
mostrarMensaje( "Intentando
realizar conexión con el do {
servidor\n" );

try {
Cliente = new Mensaje = ( String )
Socket( InetAddress.getByName( Serv Entrada.readObject();
idor_Chat ), 12345 );
mostrarMensaje( "\n" +
Mensaje );
mostrarMensaje( "Conectado a: }
" +
 catch
( ClassNotFoundException Salida.writeObject( "CLIENTE>>> " +
excepcionClaseNoEncontrada ) { mensaje );
mostrarMensaje( "\nSe Salida.flush();
recibió un objeto de caracter
desconocido" );
mostrarMensaje( "\nCLIENTE>>> " +
} mensaje );
}
} while ( !
Mensaje.equals( "SERVIDOR>>>
TERMINAR" ) ); catch ( IOException
excepcionES ) {

} Area_Pantalla.append( "\nError al
escribir el objeto" );
}
private void cerrarConexion()
}
{
mostrarMensaje( "\nCerrar la
conexión con el servidor..." ); private void
mostrarMensaje( final String
establecerCampoTextoEditable( mensajeAMostrar )
false );
{
try {
Salida.close();
SwingUtilities.invokeLater(
Entrada.close();
new Runnable() {
Cliente.close();
}
public void run()
catch( IOException
excepcionES ) { {

excepcionES.printStackTrace(); Area_Pantalla.append( mensajeAMostr

ar );
}
} Area_Pantalla.setCaretPosition(

private void enviarDatos( String Area_Pantalla.getText().length() );

mensaje ) }
{

}
try { );
 } );
}
private void
establecerCampoTextoEditable( final
boolean editable ) public static void main( String
args[] )
{
{
Cliente aplicacion;
SwingUtilities.invokeLater(
new Runnable() {
if ( args.length == 0 )
aplicacion = new
public void run() Cliente( "127.0.0.1" );
{ else
aplicacion = new
Campo_Introduccion.setEditable( edi Cliente( args[ 0 ] );
table );
}
aplicacion.setDefaultCloseOperation
( JFrame.EXIT_ON_CLOSE );
}
aplicacion.ejecutarCliente();
}

import java.io.*; private ObjectInputStream

Entrada;
import java.net.*;
private ServerSocket Servidor;
import java.awt.*;
private Socket Conexion;
import java.awt.event.*;
private int Contador = 1;
import javax.swing.*;

public Servidor()
public class Servidor extends
JFrame { {
private JTextField super( "Servidor" );
Campo_Introduccion;
private JTextArea Area_Pantalla;
Container contenedor =
private ObjectOutputStream getContentPane();
Salida;
 Campo_Introduccion = new {
JTextField();

Campo_Introduccion.setEditable( fal try {

se );

Servidor = new
Campo_Introduccion.addActionListene ServerSocket( 12345, 100 );
r(
new ActionListener() {
while ( true ) {

public void
actionPerformed( ActionEvent evento try {
)
esperarConexion();
{
obtenerFlujos();

enviarDatos( evento.getActionComman procesarConexion();

d() ); }

Campo_Introduccion.setText( "" );
catch ( EOFException
} excepcionEOF ) {
}
); System.err.println( "Conexion con
el servidor terminada" );
}

contenedor.add( Campo_Introduccion,
BorderLayout.NORTH ); finally {
cerrarConexion();
Area_Pantalla = new ++Contador;
JTextArea();
}
contenedor.add( new
JScrollPane( Area_Pantalla ),
BorderLayout.CENTER ); }

setSize( 300, 150 ); }

setVisible( true );

} catch ( IOException
excepcionES ) {

public void ejecutarServidor()

excepcionES.printStackTrace();
String mensaje = "¡Conexión
} exitosa!";
enviarDatos( mensaje );
}
establecerCampoTextoEditable(
true );
private void esperarConexion()
throws IOException
{ do {
mostrarMensaje( "Esperar la
conexión con le cliente...\n" );
try {
Conexion = Servidor.accept();
mensaje = ( String )
mostrarMensaje( "Conexión del Entrada.readObject();
cliente" + Contador + " recibida
desde: " + mostrarMensaje( "\n" +
mensaje );
}
Conexion.getInetAddress().getHostNa
me() );
} catch
( ClassNotFoundException
excepcionClaseNoEncontrada ) {
private void obtenerFlujos()
throws IOException mostrarMensaje( "\nSe
recibió un objeto de caracter
{ desconocido" );
}
Salida = new
ObjectOutputStream( Conexion.getOut
} while ( !
putStream() );
mensaje.equals( "CLIENTE>>>
Salida.flush(); TERMINAR" ) );
Entrada = new
ObjectInputStream( Conexion.getInpu
}
tStream() );

private void cerrarConexion()

mostrarMensaje( "\nFlujos de
E/S recibidas\n" ); {
} mostrarMensaje( "\n¡Conexión
finalizada!\n" );
establecerCampoTextoEditable(
private void procesarConexion()
throws IOException false );

{
 try { new Runnable() { // clase
interna para asegurar que la GUI se
Salida.close(); actualice apropiadamente
Entrada.close();
Conexion.close(); public void run() //
} actualiza areaPantalla

catch( IOException {
excepcionES ) {
Area_Pantalla.append( mensajeAMostr
excepcionES.printStackTrace(); ar );

}
Area_Pantalla.setCaretPosition(
}
Area_Pantalla.getText().length() );
private void enviarDatos( String }
mensaje )
{
}
try {

Salida.writeObject( "SERVIDOR>>> " );

+ mensaje ); }
Salida.flush();

mostrarMensaje( "\nSERVIDOR>>> " +

mensaje ); private void
establecerCampoTextoEditable( final
} boolean editable )
{
catch ( IOException
excepcionES ) {
SwingUtilities.invokeLater(
Area_Pantalla.append( "\n¡Error al new Runnable() {
escribir mensaje!" );
}
public void run()
}
{

private void Campo_Introduccion.setEditable( edi

mostrarMensaje( final String table );
mensajeAMostrar )
}
{
SwingUtilities.invokeLater(
 } Servidor aplicacion = new
Servidor();

); aplicacion.setDefaultCloseOperation
} ( JFrame.EXIT_ON_CLOSE );

aplicacion.ejecutarServidor();
public static void main( String
args[] ) }

{
}
4) Comprobar su conexión y funcionamiento.
Así quedo funcionado el socket, y probar la conexión del cliente –servidor y su uso
básico que pueda determinar la manera de funcionar mediante dicha aplicación.
 CONCLUSIONES
 La práctica de laboratorio de exitosa.
 El funcionamiento de la aplicación del Socket es un éxito.
 La conexión de dicha aplicación se funciona con base en su funcionamiento.
 BIBLIOGRAFIA
 es.wikipedia.org
 http://codigoprogramacion.com/cursos/java/103-sockets-en-java-con-cliente-y-
servidor.html