oct
2
2012

Socket UDP | Ejemplo de Cliente a Servidor y Servidor a Servidor

Descarga el contenido del Artículo en PDF Download PDF

En este artículo vemos el código necesario para crear un esquema Cliente-Servidor-Servidor utilizando el protocolo UDP, realizado en Java utilizando varios Sockets.

Cómo ya sabéis UDP no está orientado a conexión, para más información podéis ver este link.
Información general de la Wikipedia:
Socket Wikipedia

Socket UDP

En el ejemplo el cliente va a llamar a un servidor que llamará al otro, como si fuese una cadena. Después el último devolverá la respuesta al anterior y el anterior al cliente inicial.

El funcionamiento sería así:
- El cliente se conecta con el servidor A.
- El servidor A transmite la petición del cliente al servidor B.
- El servidor B envía su respuesta al servidor A.
- El servidor A transfiere la respuesta del servidor A al cliente.

Código del Servidor A:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
 
import java.net.*;
import java.io.*;
public class servidorudp {
   public static void main(String argv[]) {
 
      DatagramSocket socket;
      boolean fin = false;
      //Creamos un objeto de tipo DatagrmaPacket para recibir un paquete del cliente
      DatagramPacket paquete;
      //Creamos paquete de vuelta para el cliente
      DatagramPacket paquete2;
      //Declaramos una variable de tipo string donde guardaremos el mensaje recibido
      //por el lciente
      String mensaje ="";
      //Declaramos una variable string para la cadena que le mandaremos al cliente
      String MensajeSalida ="";
 
      try {
 
    	 //Abrimos un socket en el puerto 6000
    	  //A través de este socket enviaremos paquetes de tipo Datagrama
         socket = new DatagramSocket(6000);
 
         //Nos preparamos para recibir una mensaje de 256 bytes
    	 byte[] mensaje_bytes = new byte[256];
    	 mensaje_bytes = new byte[256];
         //Creamos un contenedor de datagrama, el buffer será el array mensaje_bytes
    	 paquete = new DatagramPacket(mensaje_bytes,256);
 
 
         do {
 
            mensaje_bytes = new byte[256];
 
            //Creamos un contenedor de datagrama, el buffer será el array mensaje_bytes
            paquete = new DatagramPacket(mensaje_bytes,256);
 
            //Esperamos a recibir un paquete
            socket.receive(paquete);
 
           //Convertimos el mensaje recibido en un string
        	mensaje = new String(mensaje_bytes).trim();
 
           //Imprimimos el paquete recibido
           System.out.println(mensaje);  
 
 
           //Condiciones encadenadas para mandar la información
           //dependiendo del dato recibido
           if (mensaje.startsWith("HELLO")) {
 
          	   MensajeSalida = "HELLO";
           }
           else if (mensaje.startsWith("ALL")) {
 
        	   MensajeSalida = "ALL BUR:250;CHE:300; BIG:540; PAT:380; SAL:240; BEV:210; DIE:0; COF:0; DES:300";
           	System.out.println(MensajeSalida);
 
           }
           else if(mensaje.startsWith("BUR"))
           {
        	   MensajeSalida = "BUR 250";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("CHE")) {
        	   MensajeSalida = "CHE 300";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("BIG")) {
        	   MensajeSalida= "BIG 540";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("PAT")) {
        	   MensajeSalida= "PAT 380";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("SAL")) {
        	   MensajeSalida= "SAL 240";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("BEV")) {
        	   MensajeSalida= "SAL 210";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("DIE")) {
        	   MensajeSalida= "DIE 0";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("COF")) {
        	   MensajeSalida= "COF 0";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("DES")) {
        	   MensajeSalida= "DES 300";
           	System.out.println(MensajeSalida);
           }
           else if (mensaje.startsWith("fin")) {
        	   MensajeSalida= "fin";
       	    System.out.println(MensajeSalida);
       	    fin=true;
           }
           else{
        	   MensajeSalida = "ERROR";	
           	   System.out.println(MensajeSalida);
           }
 
 
           //Nº de puerto desde donde se envió  
           int puerto = paquete.getPort();  
           //Dirección de Internet desde donde se envió
           InetAddress address = paquete.getAddress();
           //Preparamos el formato que le vamos a mandar
           byte[] mensaje2_bytes = new byte[256];
           //Guardamos en mensaje2_bytes el mensaje de salida formateado
           mensaje2_bytes = MensajeSalida.getBytes();
           //Generamos el paquete de vuelta, usando los datos  
           // del remitente del paquete original
           paquete2 = new DatagramPacket(mensaje2_bytes,MensajeSalida.length(),address,puerto);
           // Enviamos  
           socket.send(paquete2);
 
         } while (!fin);
      }
      catch (Exception e) {
         System.err.println(e.getMessage());
         System.exit(1);
      }
   }
}

Código del Servidor B:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
//Practica3 Yolanda_Jimenez_Anaya
 
import java.net.*;
import java.io.*;
public class servidor3udp {
 
	public static void main(String argv[]) {
 
 
		if (argv.length != 1) {
	         System.err.println("java servidor3udp ");
	         System.exit(1);}
 
        //CUANDO SE HACE REFERENCIA AL SERVIDOR2, ES A LA CLASE servidorudp.java
		//Declaración de variables
		DatagramSocket socket;
	    DatagramSocket socketCli;
	    DatagramPacket paquet;
	    DatagramPacket paquetServidor;
	    DatagramPacket paquetServidor2;
	    InetAddress address;
	    byte[] mensaje_bytes = new byte[256];
	    byte[] mensajeServidor_bytes = new byte[256];
	    byte[] mensajeServidor2_bytes = new byte[256];
	    byte[] Pedido1_bytes = new byte[256];
	    byte[] Pedido2_bytes = new byte[256];
	    byte[] mensaje3_bytes = new byte[256];
	    String mensaje="HELLO";
	    String mensajeServidor,mensajeServidor2, mensaje3  = "";
	    int iCaloriaPeiddo2,  iCaloriaPeiddo1, longMensaje, pos, port,iTotalCalorias=0;
	    String Pedido2, Pedido1, CaloriaPedido2, CaloriaPedido1 ="";
 
 
	    try {
 
	    	//Creamos un socket para comunicarnos con el servidor 
	 	    socket = new DatagramSocket();
	 	    //Obtenemos la dirección de destino
	        address=InetAddress.getByName(argv[0]);
	        mensaje = "HELLO";
		    mensaje_bytes = mensaje.getBytes();
		    //Creamos el paquete que vamos a enviar
	        paquet = new DatagramPacket(mensaje_bytes,mensaje.length(),address,6000);
	        socket.send(paquet);
 
 
	        //Recibimos el paquete que nos devuelve el servidor2
		    mensajeServidor_bytes = new byte[256];
		    paquetServidor = new DatagramPacket(mensajeServidor_bytes,256);
	        socket.receive(paquetServidor);
 
		    mensajeServidor = new String(mensajeServidor_bytes).trim();
	        System.out.println(mensajeServidor);
	        //Bucle para que el servidor siempre este esperando una entrada
	        socketCli =  new  DatagramSocket(6001);
 
	        do{
 
	        	 mensaje_bytes = new byte[256];
				 paquet = new DatagramPacket(mensaje_bytes,256);
 
				 //Recibimos un paquete del cliente
				 socketCli.receive(paquet);
				 mensaje = new String(mensaje_bytes).trim();
 
				 //Obtenemos la dirección y el puerto del cliente
	       		 address = paquet.getAddress();
			     port = paquet.getPort();
 
 
 
			     if (mensaje.startsWith("HELLO")) {
			    	 //Si se ha recibido la palabra HELLO del cliente, le contestaremos
 
			    	 paquetServidor = new DatagramPacket(mensaje_bytes,mensaje.length(),address,port);
			         socketCli.send(paquetServidor); 
			     }
			     else{
			    	 System.out.println(mensaje);
 
					 //Limpiamos las variables utilizadas.
					 iCaloriaPeiddo2=0;
					 iCaloriaPeiddo1=0;
					 longMensaje=0;
 
					  //Para separar las dos descipciones calcularemos el tamaño de la cadena
					  //y buscaremos un espacio que las separa, después cogeremos la segunda cadena
					  //emepzando por la posición +1, para poder saltar el espacio en blanco
 
					  longMensaje = mensaje.length();
					  pos= mensaje.indexOf(' ');
 
					  if (pos > 0) {
 
						//Si es mayor que cero se han recibido dos palabras  
						//Separamos el contenido enviado para calcular la suma de calorias  
 
						//Obtenemos la descripción de los dos pedidos  
 
						//Segundo pedido  
						Pedido2 = mensaje.substring(pos+1, longMensaje); 
 
					    //Primer pedido
					    Pedido1 = mensaje.substring(0,pos);
 
 
					    //Calculamos las calorias del pedido2
					    Pedido2_bytes = Pedido2.getBytes();
					    paquet = new DatagramPacket(Pedido2_bytes,Pedido2.length(),address,6000);
					    socket.send(paquet);
 
					    mensajeServidor2_bytes = new byte[256];
						paquetServidor2 = new DatagramPacket(mensajeServidor2_bytes,256);
					    socket.receive(paquetServidor2);
						mensajeServidor2 = new String(mensajeServidor2_bytes).trim();
 
 
						//Se calcula el tamaño del resultado del Pedido2
						longMensaje = mensajeServidor2.length();
						pos= mensajeServidor2.indexOf(' ');
 
					    if ((pos < 0) || mensajeServidor2.startsWith("ERROR") || mensajeServidor2.startsWith("ALL")){
					    	//Si se ha recibido del servidor2 la palabra error, o la palabra ALL, las calorias serán 99999
					    	CaloriaPedido2 = "ERROR";
					    	mensajeServidor2 = Pedido2 + " " + "ERROR";
					    	iCaloriaPeiddo2 = 9999;
					    }
					    else{
					       //Separamos las calorias del pedido2
						   CaloriaPedido2 = mensajeServidor2.substring(pos+1, longMensaje);
						   //Valor numérico de las calorias del pedido2
						   iCaloriaPeiddo2 = Integer.parseInt(CaloriaPedido2.trim());
					    }
 
						//Calculamos las calorias del pedido1
					    Pedido1_bytes = Pedido1.getBytes();
					    //Le mandamos al servidor2 el literal del Pedido1
					    paquet = new DatagramPacket(Pedido1_bytes,Pedido1.length(),address,6000);
					    socket.send(paquet);
 
					    mensajeServidor_bytes = new byte[256];
						paquetServidor = new DatagramPacket(mensajeServidor_bytes,256);
					    socket.receive(paquetServidor);
						mensajeServidor = new String(mensajeServidor_bytes).trim();
 
 
						//Se calcula el tamaño del resultado del Pedido2
						longMensaje = mensajeServidor.length();
						pos= mensajeServidor.indexOf(' ');
 
					    if ((pos < 0) || mensajeServidor.startsWith("ERROR") || mensajeServidor.startsWith("ALL")){
					    	//Si se ha recibido del servidor2 la palabra error, o la palabra ALL, las calorias serán 99999
					    	CaloriaPedido1 = "ERROR";
					    	mensajeServidor = Pedido1 + " " + "ERROR";
					    	iCaloriaPeiddo1 = 9999;
					    }
					    else{
					       //Separamos las calorias del pedido1
						   CaloriaPedido1 = mensajeServidor.substring(pos+1, longMensaje);
						   //Valor numérico de las calorias del pedido2
						   iCaloriaPeiddo1 = Integer.parseInt(CaloriaPedido1.trim());
					    }
 
 
						//Calculamos el total de las calorias
						if(iCaloriaPeiddo2 == 9999 || iCaloriaPeiddo1 == 9999){
							//Si uno de los dos pedidos es erroneo el total de calorias será 9999
							iTotalCalorias = 9999;
						}
						else
						  iTotalCalorias = iCaloriaPeiddo1 + iCaloriaPeiddo2;
 
						System.out.println(mensajeServidor);
						System.out.println(mensajeServidor2);
						//Se crea el mensaje final con los dos pedidos y la suma de sus calorias.
						 mensaje3 = Pedido1 + " " + Pedido2 + " " + iCaloriaPeiddo1 + " " + iCaloriaPeiddo2 + " = " + iTotalCalorias;
 
						//Imprimimos en el servidor3 el total
						 System.out.println(mensaje3);
						 mensaje3_bytes = mensaje3.getBytes();
						//Le mandamos al cliente el total de calorias de los dos productos.
						 paquetServidor = new DatagramPacket(mensaje3_bytes,mensaje3.length(),address,port);
				         socketCli.send(paquetServidor);
 
 
					  }
					  else{
						 //Si es menor que 0 solo se habrá recibido una palabra 
						 //Le mandamos al servidor2 la descripción
 
					     //Enviamos al servidor la palabra recibida
						 paquet = new DatagramPacket(mensaje_bytes,mensaje.length(),address,6000);
					     socket.send(paquet);
 
					     mensajeServidor_bytes = new byte[256];
						 paquetServidor = new DatagramPacket(mensajeServidor_bytes,256);
					     socket.receive(paquetServidor);
 
 
						 mensajeServidor = new String(mensajeServidor_bytes).trim();
					     System.out.println(mensajeServidor);
 
 
					     //El resultado se lo mandamos al cliente
					     paquetServidor = new DatagramPacket(mensajeServidor_bytes,mensajeServidor.length(),address,port);
				         socketCli.send(paquetServidor);
 
					  }
			     }
 
	        }while (1>0);
 
	    }
	   catch (Exception e) {
	   System.err.println(e.getMessage());
	   System.exit(1);}
}
}

Código del Cliente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
import java.net.*;
import java.io.*;
 
public class clienteudp {
   public static void main(String argv[]) {
 
	   if (argv.length == 0) {
         System.err.println("java clienteudp servidor");
         System.exit(1);
      }
 
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 
      DatagramSocket socket;
      InetAddress address;
      byte[] mensaje_bytes = new byte[256];
      byte[] MensajeServidor_bytes = new byte[256];
      String mensaje="";
      String mensajeServidor="";
      //Paquete para enviar al servidor
      DatagramPacket paquete;
      //Creamos el objeto paquete2 de tipo DaragramPacket para recibir del servidor
      DatagramPacket paquete2;
      mensaje_bytes=mensaje.getBytes();
 
      try {
 
    	  //Creamos el socket
    	  socket = new DatagramSocket();
 
         // Leemos el primer parámetro, donde debe ir la dirección  
         // IP del servidor 
         address=InetAddress.getByName(argv[0]);
 
         mensaje = "HELLO";
         mensaje_bytes = mensaje.getBytes();
         //Creamos paquete
         paquete = new DatagramPacket(mensaje_bytes,mensaje.length(),address,6001);
         //Mandamos el paquete
 
         socket.send(paquete);
 
         //El mensaje recibido vendrá en bytes
         MensajeServidor_bytes = new byte[256];
         //Esperamos a recibir un paquete
         paquete2 = new DatagramPacket(MensajeServidor_bytes,256);
         socket.receive(paquete2);
         //Convertimos el mensaje recibido en un string
 		 mensajeServidor = new String(MensajeServidor_bytes).trim();
 		 //Imprimimos el paquete recibido
 		 System.out.println(mensajeServidor);  
 
         do {
 
        	//Lee los caracteres introducidos por pantalla 
            mensaje = in.readLine();
            mensaje_bytes = mensaje.getBytes();
 
            //Creamos paquete
            paquete = new DatagramPacket(mensaje_bytes,mensaje.length(),address,6001);
 
            //Mandamos el paquete
            socket.send(paquete);
 
 
            //El mensaje recibido vendrá en bytes
            MensajeServidor_bytes = new byte[256];
 
            //Esperamos a recibir un paquete
            paquete2 = new DatagramPacket(MensajeServidor_bytes,256);
            socket.receive(paquete2);
 
            //Convertimos el mensaje recibido en un string
    		mensajeServidor = new String(MensajeServidor_bytes).trim();
 
    		//Imprimimos el paquete recibido
    		System.out.println(mensajeServidor);  
 
 
         } while (!mensaje.startsWith("fin"));
      }
      catch (Exception e) {
         System.err.println(e.getMessage());
         System.exit(1);
      }
   }
}
Click on any of these buttons to help us to maintain this website.      
CJO

Artículos relacionados

Related Posts

Acerca del Autor:

Leave a comment


siete − 1 =

ndslite

Ayudas!

Recientes

  • Sizet Experience: Una herramienta muy útil sobre todo cuando usamos muchos plugins. El tema que mencionas del hosting...
  • Anika La Rubia: Estos son básicos y lo más utilizados, pero la lista es realmente extensa como he visto en bloogie.es...
  • robert: Hola, sera que podrías poner el código html, Saludos
  • luis: como seria el codigo,si cuando yo ingrese las coordenadas me muestre un punto en el mapa
  • Olga: Muchas gracias por tu comentario!