Documente Academic
Documente Profesional
Documente Cultură
SOCKETS
• El paquete java.net
Java ofrece un conjunto de clases que permiten utilizar los URLs (Uniform
Resource Locators). Un URL es una dirección electrónica que permite
encontrar una información en Internet especificando:
El nombre del protocolo que permitirá leer la información. Por ejemplo HTTP.
5.1 Fundamentos
Los sockets son puntos finales de enlaces de comunicaciones entre procesos. Los
procesos los tratan como descriptores de ficheros, de forma que se pueden
intercambiar datos con otros procesos transmitiendo y recibiendo a través de
sockets.
Son un servicio de transporte sin conexión. Son más eficientes que TCP, pero no
está garantizada la fiabilidad. Los datos se envían y reciben en paquetes, cuya
entrega no está garantizada. Los paquetes pueden ser duplicados, perdidos o
llegar en un orden diferente al que se envió.
Sockets Raw
Son sockets que dan acceso directo a la capa de software de red subyacente o a
protocolos de más bajo nivel. Se utilizan sobre todo para la depuración del código
de los protocolos.
En UDP, cada vez que se envía un datagrama, hay que enviar también el
descriptor del socket local y la dirección del socket que va a recibir el datagrama,
luego éstos son más grandes que los TCP. Como el protocolo TCP está orientado
a conexión, tenemos que establecer esta conexión entre los dos sockets antes de
nada, lo que implica un cierto tiempo empleado en el establecimiento de la
conexión, que no existe en UDP.
B. Ejemplo de uso
Para comprender el funcionamiento de los sockets no hay nada mejor que estudiar
un ejemplo. El que a continuación se presenta establece un pequeño diálogo entre
un programa servidor y sus clientes, que intercambiarán cadenas de información.
a.) Programa Cliente
El programa cliente se conecta a un servidor indicando el nombre de la máquina y
el número puerto (tipo de servicio que solicita) en el que el servidor está instalado.
Una vez conectado, lee una cadena del servidor y la escribe en la pantalla:
import java.io.*;
import java.net.*;
class Cliente {
public Cliente( ) {
try{
System.out.println( flujo.readUTF() );
skCliente.close();
System.out.println( e.getMessage() );
new Cliente();
Debe observarse que se realiza una gestión de excepción para capturar los
posibles fallos tanto de los flujos de datos como del socket.
import java.net.* ;
class Servidor {
try {
skCliente.close();
} catch( Exception e ) {
System.out.println( e.getMessage() );
new Servidor();
Utiliza un objeto de la clase ServerSocket (skServidor), que sirve para esperar las
conexiones en un puerto determinado (PUERTO), y un objeto de la clase Socket
(skCliente) que sirve para gestionar una conexión con cada cliente.
Método CrearServidor.-
En este método vamos a crear un servidor sencillo que va atender los datos de un
navegador tal como Internet Explorer. Este servidor va a servir por la dirección
127.0.0.1 que es la de localhost, y por el puerto 80. Estas dos condiciones se
especifican al crear el ServerSocket (Ojo con la dirección especificada ya que
tiene que existir en la máquina).
Una vez creado el ServerSocket se crea un bucle infinito en el cual el método
accept espera hasta recibir una conexión. Este método al aceptar la conexión
devuelve un Socket que es con el que vamos a realizar la conexión al cliente. Al
igual que el método anterior obtenemos un DataInputStream con getInputStream
del cual vamos a leer los datos desde el cliente.
Los datos recibidos diferirán según el navegador utilizado pero serán parecidos a
los que se envían en el ejemplo de CrearCliente. Para conectar con el navegador
una vez ejecutado el ejemplo tenemos que introducir en él
“http://127.0.0.1:80/hola.html” y recibiremos de vuelta el contenido del String
respuesta. Como el navegador encuentra en la página html la referencia a una
imagen gif, realizará una segunda petición pidiendo dicha imagen.
import java.net.*;
import java.io.*;
import java.util.*;
public class Comunicacion
{
public void CrearCliente()
{
Socket conexion=null;
DataInputStream entrada=null;
DataOutputStream salida=null;
String cad="";
byte datosBytes[]=new byte[256];
while (true)
{
++cliente;
Socket conex=conexion.accept();
entrada=new DataInputStream(conex.getInputStream());
System.out.println("Cliente num "+Integer.toString(cliente));
InetAddress direc=conex.getInetAddress();
System.out.println ("Dirección de llamada"+direc.getHostAddress());
cad="";
leido=entrada.read(bytedata);
if (leido>0)
cad=new String(bytedata,0,(leido-1));
//Sacamos lo que hemos recibido desde el cliente
System.out.println("Recibido desde cliente");
System.out.println(cad);
salida=new DataOutputStream(conex.getOutputStream());
body+="<html>\n";
body+="<body>\n";
body+="<h1>Hola que tal!</h1>\n";
body+="<image src='barra.gif'>\n";
body+="</body>\n";
body+="</html>\n";
if (cad.indexOf("barra.gif")>=0)
{
respuesta="HTTP/1.0 200 OK\n";
respuesta+="Date: Mon, 5 Nov 2001 23:59:59GMT\n";
respuesta+="Content-Type: image/gif\n";
respuesta+="Content-Length: 112\n\n";
//Hay que añadir la imagen
//Escribimos la respuesta al cliente
salida.write(respuesta.getBytes());
salida.flush();
try
{
FileInputStream imagen=new FileInputStream("barra.gif");
while((leido=imagen.read(bytedata,0,256))!=-1)
salida.write(bytedata,0,leido);
//Cerramos el Socket
conex.close();
}
}
catch (IOException e)
{
System.out.println(e.toString());
System.out.println("Error al conectar");
}
}
public static void main(String[] args)
{
Comunicacion Comuc =new Comunicacion();
Comuc.CrearServidor();
//Comuc.CrearCliente();
//Comuc.pruebaURL();
What Is a Socket?
Normally, a server runs on a specific computer and has a socket that is bound to a
specific port number. The server just waits, listening to the socket for a client to
make a connection request.
On the client-side: The client knows the hostname of the machine on which the
server is running and the port number to which the server is connected. To make a
connection request, the client tries to rendezvous with the server on the server's
machine and port.
If everything goes well, the server accepts the connection. Upon acceptance, the
server gets a new socket bound to a different port. It needs a new socket (and
consequently a different port number) so that it can continue to listen to the original
socket for connection requests while tending to the needs of the connected client.
The client and server can now communicate by writing to or reading from their
sockets.
The java.net package in the Java platform provides a class, Socket, that implements
one side of a two-way connection between your Java program and another
program on the network. The Socket class sits on top of a platform-dependent
implementation, hiding the details of any particular system from your Java
program. By using the java.net.Socket class instead of relying on native code, your
Java programs can communicate over the network in a platform-independent
fashion.
Additionally, java.net includes the ServerSocket class, which implements a socket that
servers can use to listen for and accept connections to clients. This lesson shows
you how to use the Socket and ServerSocket classes.
If you are trying to connect to the Web, the URL class and related classes
(URLConnection, URLEncoder) are probably more appropriate than the socket classes.
In fact, URLs are a relatively high-level connection to the Web and use sockets as
part of the underlying implementation. See Working with URLs for information
about connecting to the Web via URLs.
URL´S:
http://ima.udg.es/Docencia/02-03/3105100333/index.html
http://www.tlm.unavarra.es/~daniel/docencia/labtel/guion.pdf
http://weblidi.info.unlp.edu.ar/catedras/concurrente/teorias.html