MATERIA:

TECNOLOGÍAS WAN

TEMA:
CLIENTE/SERVIDOR

ALUMNOS:
SOTO URBINA EVA GUADALUPE
RAMIREZ HERRERA FRANCISCO JIOVANNI
PREZA DELGADO RICARDO
FLORES SILVESTRE YOSELIN

DOCENTE:
JIMENEZ ARIZMENDI JUAN CARLOS
 MARCO TEORICO

Los sockets son un mecanismo que nos permite establecer un enlace entre dos programas
que se ejecutan independientes el uno del otro (generalmente un programa cliente y un
programa servidor) Java por medio de la librería java.net nos provee dos clases:

 Socket para implementar la conexión desde el lado del cliente

 ServerSocket que nos permitirá manipular la conexión desde el lado del servidor.

Antes de comenzar a ver código (que es lo que todos queremos) explicaré cómo será el
funcionamiento de nuestra aplicación cliente servidor usando sockets en Java, cabe resaltar
que tanto el cliente como el servidor no necesariamente deben estar implementados en
Java, solo deben conocer sus direcciones IP y el puerto por el cual se comunicarán.

Ilustración 1Petición Cliente/Servidor

Cliente:

Los procesos clientes son más sencillos que los procesos de los servidores, los
primeros no requieren de privilegios de sistemas para funcionar, en cambio los
procesos servidores sí.
 Los usuarios cuando quieren acceder a un servicio de red, ejecutan un software cliente. El
diseño de los servidores debe ser muy cuidadoso, debe incluir código para la manipulación
de:

 autenticación: verificar la identidad del cliente.

 seguridad de datos: para que estos no puedan ser accedidos inapropiadamente.
 privacidad: garantizar que la información privada de un usuario, no sea accedida por
alguien no autorizado.
 protección: asegurar que las aplicaciones no monopolicen los recursos del sistema.
 autorización: verificar si el cliente tiene acceso al servicio proporcionado por el
servidor.

La mayoría de las comunicaciones punto-a-punto en las redes (incluida Internet), están

basadas en el modelo Cliente/Servidor. Desde el punto de vista Internet/Intranet, se tendría:

 Un servidor es un ordenador remoto - en algún lugar de la red - que proporciona

información según petición.
 Un cliente funciona en su ordenador local, se comunica con el servidor remoto, y
pide a éste información.
 El servidor envía la información solicitada.

Un único servidor típicamente sirve a una multitud de clientes, ahorrando a cada uno de
ellos el problema de tener la información instalada y almacenada localmente.

Clase PrincipalChat:
Esta clase implementa la interfaz grafica para poder mostrar los mensajes entrantes y un
JTextField para poder enviarlos. La interfaz contiene un menu para poder salir del
programa.
En el main se puede ver que se espera conexiones de clientes.
1. package servidor;
2.
3. import java.awt.BorderLayout;
4. import java.awt.Color;
5. import java.awt.event.ActionEvent;
6. import java.awt.event.ActionListener;
7. import java.io.IOException;
8. import java.net.InetAddress;
9. import java.net.ServerSocket;
10. import java.net.Socket;
11. import java.util.concurrent.ExecutorService;
12. import java.util.concurrent.Executors;
13. import java.util.logging.Level;
14. import java.util.logging.Logger;
15. import javax.swing.*;
16.
17. /**Clase que se encarga de correr los threads de enviar y recibir texto
18. * y de crear la interfaz grafica.
19. *
20. * @author Rafa
21. */
22. public class PrincipalChat extends JFrame{
23. public JTextField campoTexto; //Para mostrar mensajes de los usuarios
24. public JTextArea areaTexto; //Para ingresar mensaje a enviar
25. private static ServerSocket servidor; //
26. private static Socket conexion; //Socket para conectarse con el cliente
27. private static String ip = "127.0.0.1"; //ip a la cual se conecta
28.
29. public static PrincipalChat main;
30.
31. public PrincipalChat(){
32. super("Servidor"); //Establece titulo al Frame
33.
34. campoTexto = new JTextField(); //crea el campo para texto
35. campoTexto.setEditable(false); //No permite que sea editable el campo de texto
36. add(campoTexto, BorderLayout.NORTH); //Coloca el campo de texto en la parte
superior
37.
38. areaTexto = new JTextArea(); //Crear displayArea
39. areaTexto.setEditable(false);
40. add(new JScrollPane(areaTexto), BorderLayout.CENTER);
41. areaTexto.setBackground(Color.orange); //Pone de color cyan al areaTexto
42. areaTexto.setForeground(Color.BLACK); //pinta azul la letra en el areaTexto
43. campoTexto.setForeground(Color.BLACK); //pinta toja la letra del mensaje a enviar
44.
45.
46. //Crea menu Archivo y submenu Salir, ademas agrega el submenu al menu
47. JMenu menuArchivo = new JMenu("Archivo");
48. JMenuItem salir = new JMenuItem("Salir");
49. menuArchivo.add(salir); //Agrega el submenu Salir al menu menuArchivo
50.
51. JMenuBar barra = new JMenuBar(); //Crea la barra de menus
52. setJMenuBar(barra); //Agrega barra de menus a la aplicacion
53. barra.add(menuArchivo); //agrega menuArchivo a la barra de menus
54.
55. //Accion que se realiza cuando se presiona el submenu Salir
56. salir.addActionListener(new ActionListener() { //clase interna anonima
57. public void actionPerformed(ActionEvent e) {
58. System.exit(0); //Sale de la aplicacion
59. }
60. });
61.
62. setSize(300, 320); //Establecer tamano a ventana
63. setVisible(true); //Pone visible la ventana
64. }
65.
66. //Para mostrar texto en displayArea
67. public void mostrarMensaje(String mensaje) {
68. areaTexto.append(mensaje + "\n");
69. }
70. public void habilitarTexto(boolean editable) {
71. campoTexto.setEditable(editable);
72. }
73.
74. /**
75. * @param args the command line arguments
76. */
77. public static void main(String[] args) {
78. PrincipalChat main = new PrincipalChat(); //Instanciacion de la clase
Principalchat
79. main.setLocationRelativeTo(null); //Centrar el JFrame
80. main.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //habilita cerrar la ventana
81. ExecutorService executor = Executors.newCachedThreadPool(); //Para correr los
threads
82.
83. try {
84. //main.mostrarMensaje("No se encuentra Servidor");
85. servidor = new ServerSocket(11111, 100);
86. main.mostrarMensaje("Esperando Cliente ...");
87.
88. //Bucle infinito para esperar conexiones de los clientes
89. while (true){
90. try {
91. conexion = servidor.accept(); //Permite al servidor aceptar
conexiones
92.
93. //main.mostrarMensaje("Conexion Establecida");
94. main.mostrarMensaje("Conectado a :
" +conexion.getInetAddress().getHostName());
95.
96. main.habilitarTexto(true); //permite escribir texto para enviar
97.
98. //Ejecucion de los threads
99. executor.execute(new Recibe(conexion, main)); //client
100. executor.execute(new Envia(conexion, main));
101. } catch (IOException ex) {
102. Logger.getLogger(PrincipalChat.class.getName()).log(Level.SEVE
RE,null, ex);
103. }
104. }
105. } catch (IOException ex) {
106. Logger.getLogger(PrincipalChat.class.getName()).log(Level.SEVERE, null
, ex);
107. } //Fin del catch
108. finally {
109. }
110. executor.shutdown();
111. }
112. }

Clase ThreadEnvia:
En esta clase establecemos nuestro canal de salida tipo ObjectOutputStream, el cual nos
sirve para escribir el mensaje, enviarlo y mostrarlo en pantalla mediante el metodo
enviarDatos().
Ademas declaramos la variable conexion tipo Socket, la cual se encarga de establecer el
flujo de datos entre cliente y servidor.
package servidor;
1.
2. import java.io.IOException;
3. import java.io.ObjectOutputStream;
4. import java.net.Socket;
5. import java.awt.event.ActionEvent;
6. import java.awt.event.ActionListener;
7. import java.net.SocketException;
8.
9. public class ThreadEnvia implements Runnable {
10. private final PrincipalChat main;
11. private ObjectOutputStream salida;
12. private String mensaje;
13. private Socket conexion;
14.
15. public ThreadEnvia(Socket conexion, final PrincipalChat main){
16. this.conexion = conexion;
17. this.main = main;
18.
19. //Evento que ocurre al escribir en el areaTexto
20. main.campoTexto.addActionListener(new ActionListener() {
21. public void actionPerformed(ActionEvent event) {
22. mensaje = event.getActionCommand();
23. enviarDatos(mensaje); //se envia el mensaje
24. main.campoTexto.setText(""); //borra el texto del enterfield
25. } //Fin metodo actionPerformed
26. }
27. );//Fin llamada a addActionListener
28. }
29.
30. //enviar objeto a cliente
31. private void enviarDatos(String mensaje){
32. try {
33. salida.writeObject("Servidor>>> " + mensaje);
34. salida.flush(); //flush salida a cliente
35. main.mostrarMensaje("Servidor>>> " + mensaje);
36. } //Fin try
37. catch (IOException ioException){
38. main.mostrarMensaje("Error escribiendo Mensaje");
39. } //Fin catch
40.
41. } //Fin methodo enviarDatos
42.
43. //manipula areaPantalla en el hilo despachador de eventos
44. public void mostrarMensaje(String mensaje) {
45. main.areaTexto.append(mensaje);
46. }
47.
48. public void run() {
49. try {
50. salida = new ObjectOutputStream(conexion.getOutputStream());
51. salida.flush();
52. } catch (SocketException ex) {
53. } catch (IOException ioException) {
54. ioException.printStackTrace();
55. } catch (NullPointerException ex) {
56. }
57. }
58.
59. }

1. Clase ThreadRecibe:
En esta clase establecemos nuestro canal de entrada tipo ObjectInputStream, el cual se
encarga de recibir los mensajes enviados por el cliente o servidor.
Aqui se procesa los mensajes recibidos y luego son mostrados en pantalla.
Es importante aclarar que se debe cerrar el canal de entrada de datos y el Socket de
conexion una vez finalizado el flujo de datos.
package servidor;
2.
3. import java.io.EOFException;
4. import java.io.IOException;
5. import java.io.ObjectInputStream;
6. import java.net.Socket;
7. import java.net.SocketException;
8. import java.util.logging.Level;
9. import java.util.logging.Logger;
10.
11. public class ThreadRecibe implements Runnable {
12. private final PrincipalChat main;
13. private String mensaje;
14. private ObjectInputStream entrada;
15. private Socket cliente;
16.
17.
18. //Inicializar chatServer y configurar GUI
19. public ThreadRecibe(Socket cliente, PrincipalChat main){
20. this.cliente = cliente;
21. this.main = main;
22. }
23.
24. public void mostrarMensaje(String mensaje) {
25. main.areaTexto.append(mensaje);
26. }
27.
28. public void run() {
29. try {
30. entrada = new ObjectInputStream(cliente.getInputStream());
31. } catch (IOException ex) {
32. Logger.getLogger(ThreadRecibe.class.getName()).log(Level.SEVERE, null, ex);
33. }
34. do { //procesa los mensajes enviados dsd el servidor
35. try {//leer el mensaje y mostrarlo
36. mensaje = (String) entrada.readObject(); //leer nuevo mensaje
37. main.mostrarMensaje(mensaje);
38. } //fin try
39. catch (SocketException ex) {
40. }
41. catch (EOFException eofException) {
42. main.mostrarMensaje("Fin de la conexion");
43. break;
44. } //fin catch
45. catch (IOException ex) {
46. Logger.getLogger(ThreadRecibe.class.getName()).log(Level.SEVERE, null,
ex);
47. } catch (ClassNotFoundException classNotFoundException) {
48. main.mostrarMensaje("Objeto desconocido");
49. } //fin catch
50.
51. } while (!mensaje.equals("Servidor>>> TERMINATE")); //Ejecuta hasta que el server
escriba TERMINATE
52.
53. try {
54. entrada.close(); //cierra input Stream
55. cliente.close(); //cieraa Socket
56. } //Fin try
57. catch (IOException ioException) {
58. ioException.printStackTrace();
59. } //fin catch
60.
61. main.mostrarMensaje("Fin de la conexion");
62. System.exit(0);
63. }
64. }
 1. En el paquete Cliente encontramos:

Clase PrincipalChat:
Esta clase implementa la interfaz gráfica para poder mostrar los mensajes entrantes y un
JTextField para poder enviarlos. La interfaz contiene un menú para poder salir del
programa.
Esta clase busca servidores para poder conectarse.
package cliente;
2.
3. import java.awt.BorderLayout;
4. import java.awt.Color;
5. import java.awt.event.ActionEvent;
6. import java.awt.event.ActionListener;
7. import java.io.EOFException;
8. import java.io.IOException;
9. import java.net.InetAddress;
10. import java.net.ServerSocket;
11. import java.net.Socket;
12. import java.util.concurrent.ExecutorService;
13. import java.util.concurrent.Executors;
14. import java.util.logging.Level;
15. import java.util.logging.Logger;
16. import javax.swing.*;
17.
18. /**Clase que se encarga de correr los threads de enviar y recibir texto
19. * y de crear la interfaz grafica.
20. *
21. * @author Rafa
22. */
23. public class PrincipalChat extends JFrame{
24. public JTextField campoTexto; //Para mostrar mensajes de los usuarios
25. public JTextArea areaTexto; //Para ingresar mensaje a enviar
26. private static ServerSocket servidor; //
27. private static Socket cliente; //Socket para conectarse con el cliente
28. private static String ip = "127.0.0.1"; //ip a la cual se conecta
29.
30. public static PrincipalChat main;
31.
32. public PrincipalChat(){
33. super("Cliente"); //Establece titulo al Frame
34.
35. campoTexto = new JTextField(); //crea el campo para texto
36. campoTexto.setEditable(false); //No permite que sea editable el campo de texto
37. add(campoTexto, BorderLayout.NORTH); //Coloca el campo de texto en la parte
superior
38.
39.
40. areaTexto = new JTextArea(); //Crear displayArea
41. areaTexto.setEditable(false);
42. add(new JScrollPane(areaTexto), BorderLayout.CENTER);
43. areaTexto.setBackground(Color.orange); //Pone de color cyan al displayArea
44. areaTexto.setForeground(Color.BLACK); //pinta azul la letra en el displayArea
45. campoTexto.setForeground(Color.BLACK); //pinta toja la letra del mensaje a enviar
46.
47.
48. //Crea menu Archivo y submenu Salir, ademas agrega el submenu al menu
49. JMenu menuArchivo = new JMenu("Archivo");
50. JMenuItem salir = new JMenuItem("Salir");
51. menuArchivo.add(salir); //Agrega el submenu Salir al menu menuArchivo
52.
53. JMenuBar barra = new JMenuBar(); //Crea la barra de menus
54. setJMenuBar(barra); //Agrega barra de menus a la aplicacion
55. barra.add(menuArchivo); //agrega menuArchivo a la barra de menus
56.
57. //Accion que se realiza cuando se presiona el submenu Salir
58. salir.addActionListener(new ActionListener() { //clase interna anonima
59. public void actionPerformed(ActionEvent e) {
60. System.exit(0); //Sale de la aplicacion
61. }
62. });
63.
64. setSize(300, 320); //Establecer tamano a ventana
65. setVisible(true); //Pone visible la ventana
66. }
67.
68. //Para mostrar texto en displayArea
69. public void mostrarMensaje(String mensaje) {
70. areaTexto.append(mensaje + "\n");
71. }
72. public void habilitarTexto(boolean editable) {
73. campoTexto.setEditable(editable);
74. }
75.
76. /**
77. * @param args the command line arguments
78. */
79. public static void main(String[] args) {
80. PrincipalChat main = new PrincipalChat(); //Instanciacion de la clase
Principalchat
81. main.setLocationRelativeTo(null); //Centrar el JFrame
82. main.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //habilita cerrar la ventana
83. ExecutorService executor = Executors.newCachedThreadPool(); //Para correr los
threads
84.
85. try {
86. main.mostrarMensaje("Buscando Servidor ...");
87. cliente = new Socket(InetAddress.getByName(ip), 11111); //comunicarme con el
servidor
88. main.mostrarMensaje("Conectado a :" +cliente.getInetAddress().getHostName());
89.
90. main.habilitarTexto(true); //habilita el texto
91.
92. //Ejecucion de los Threads
93. executor.execute(new ThreadRecibe(cliente, main));
94. executor.execute(new ThreadEnvia(cliente, main));
95.
96. } catch (IOException ex) {
97. Logger.getLogger(PrincipalChat.class.getName()).log(Level.SEVERE, null, ex);
98. } //Fin del catch
99. finally {
100. }
101. executor.shutdown();
102. }
103. }

Las clases descritas en el paquete Cliente: ThreadRecibe y ThreadEnvia son

exactamente las mismas que se describieron en el paquete Servidor.

Nuestro proyecto se verá así:

El resultado final se mostrara de la siguiente manera: