Esto es lo más significativo del código , como construir un jEditorPane pasándole un objeto URL

    public void jButton1_actionPerformed(ActionEvent e) {
     Openurl();//al clikar el botón al abordaje llamo a este método
    }
    void Openurl(){
     
	try{
       
   	    URL laurl = new URL(jTextField1.getText());
        
            JEditorPane1.setPage(laurl);
      
 	    } catch(Exception e){}
     }//fin método openurl

Como obtener nuestra propia IP

Y ya que estamos hablando de URL, todos sabemos que una URL en formato de nombre de dominio

tiene asociada una dirección IPv4 ( dentro de nada ya tendremos las IPv6 , ¿ya funcionan en inet?)

 veamos como obtener nuestra propia IP: (en http://www.wikilearning.com/uso_de_sockets-wkccp-3938-159.htm

 lo he corregido y ampliado)

Usaremos la clase java.net.InetAddress , que a su vez tiene una subclase para IPv4 (Inet4Address) y 

otra para IPv6 (Inet6Address)

java.net.InetAddress direccion = java.net.InetAddress.getLocalHost();
    byte direccionIp[] = direccion.getAddress();

Si la dirección de la máquina en que estamos corriendo el test.class es 192.168.173.101 , entonces:

    direccionIp[0] = -64 // corresponde a 192
    direccionIp[1] = -88 // corresponde a 168
    direccionIp[2] = -93 // corresponde a 173
    direccionIp[3] = 101 // corresponde a 101

public class test {
	
 public static void main(String[] args) throws Exception{
    Integer IP[]={0,0,0,0};
    
	java.net.InetAddress direccion = java.net.InetAddress.getLocalHost();
	byte direccionIp[] = direccion.getAddress();
	
	for (int i=0;i<4;i++) {
		IP[i]=(int)direccionIp[i];

                //Si lo veo en formato byte , me sale -64.-88.-93.101 , luego hay que pasarlo a int

		if (IP[i]<0) IP[i]=IP[i]+256;
		System.out.print(IP[i]+".");
   	}//fin for
    }//fin main
}//fin test

Continuamos con los Sockets

En el link http://www.wikilearning.com/sockets-wkccp-3938-157.htm lo explica bastante bién. Resumiéndolo:

 Sockets = 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. http://www.wikilearning.com/sockets-wkccp-3938-157.htm

Esta seria la definición de cara a un desarrollador , desde el punto de vista del Networking un socket seria : ( definición de Cisco)

Estructura de software que opera como un punto de terminación de comunicaciones dentro de un dispositivo de red

El término da para rato: http://club.idecnet.com/~ccastano/cisco/ccna2_foros.htm

Pero nosotros nos centraremos en la definición: Sockets = 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.

Tipos de Sockets

Desde el link http://www.wikilearning.com/sockets-wkccp-3938-157.htm

El tipo de sockets describe la forma en la que se transfiere información a través de ese socket. Sockets Stream (TCP, Transport Control Protocol) Son un servicio orientado a conexión donde los datos se transfieren sin encuadrarlos en registros o bloques. Si se rompe la conexión entre los procesos, éstos serán informados. Los sockets stream permiten a los procesos comunicarse a través de TCP. Una vez establecidas las conexiones, los datos se pueden leer y escribir a/desde los sockets como un flujo (stream) de bytes. Algunas aplicaciones de servicios TCP son: File Tranfer Protocol, FTP Simple Mail Transfer Protocol, SMTP TELNET, servicio de conexión de terminal remoto El protocolo de comunicaciones con streams es un protocolo orientado a conexión, ya que para establecer una comunicación utilizando el protocolo TCP, hay que establecer en primer lugar una conexión entre un par de sockets. Mientras uno de los sockets atiende peticiones de conexión (servidor), el otro solicita una conexión (cliente). Una vez que los dos sockets estén conectados, se pueden utilizar para transmitir datos en ambas direcciones. ------------------------------------------------------------ Sockets Datagrama (UDP, User Datagram Protocol) 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ó. Los sockets datagrama permiten a los procesos utilizar el protocolo UDP para comunicarse a y desde esos sockets por medio de bloques. UDP es un protocolo no fiable y la entrega de los paquetes no está garantizada. Servicios UDP son: Simple Network Management Protocol, SNMP Trivial File Transfer Protocol, TFTP (versión de FTP sin conexión) Versatile Message Transaction Protocol, VMTP (servicio fiable de entrega punto a punto de datagramas independiente de TCP) El protocolo de comunicaciones con datagramas es un protocolo sin conexión, es decir, cada vez que se envíen datagramas es necesario enviar el descriptor del socket local y la dirección del socket que debe recibir el datagrama. Como se puede ver, hay que enviar datos adicionales cada vez que se realice una comunicación. ------------------------------------------------------------- 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. Los sockets raw proporcionan acceso al Internet Control Message Protocol, ICMP, y se utiliza para comunicarse entre varias entidades IP.

Si quereis saber las diferencias_entre_sockets_stream_y_datagrama pues ya sabeis ,vais al link. Pero me quedo con esta idea:

"UDP es menos complejo y tiene una menor sobrecarga sobre la conexión; esto hace que sea el indicado en la implementación

de aplicaciones cliente/servidor en sistemas distribuidos montados sobre redes de área local."

"TCP parece más indicado para la implementación de servicios de red como un control remoto (rlogin, telnet)

 y transmisión de ficheros (ftp); que necesitan transmitir datos de longitud indefinida"

Modelo de comunicaciones con Java (http://www.wikilearning.com/modelo_de_comunicaciones_con_java-wkccp-3938-161.htm)

El modelo de sockets más simple es: El servidor establece un puerto y espera durante un cierto tiempo (timeout segundos), a que el cliente establezca la conexión. Cuando el cliente solicite una conexión, el servidor abrirá la conexión socket con el método accept(). El cliente establece una conexión con la máquina host a través del puerto que se designe en puerto# El cliente y el servidor se comunican con manejadores InputStream y OutputStream Hay una cuestión al respecto de los sockets, que viene impuesta por la implementación del sistema de seguridad de Java. Actualmente, los applets sólo pueden establecer conexiones con el nodo desde el cual se transfirió su código. Esto está implementado en el JDK y en el intérprete de Java de Netscape. Esto reduce en gran manera la flexibilidad de las fuentes de datos disponibles para los applets. El problema si se permite que un applet se conecte a cualquier máquina de la red, es que entonces se podrían utilizar los applets para inundar la red desde un ordenador con un cliente Netscape del que no se sospecha y sin ninguna posibilidad de rastreo.

Apertura de un Socket desde un cliente a un servidor

java.net.Socket socketcliente;

socketcliente = new java.net.Socket("hostServidor",puerto);

//donde hostServidor es de la clase InetAddress (ip) o String (el nombre de dominio o netbios del servidor)

// y puerto es un int entre 0 y 2^16-1 = 65535, pero teniendo en cuenta que desde 0 a 1023 suelen estar reservados y según tu usuario

// deberás tener privilegios de administrador o root

Apertura de un Socket desde un servidor para dar un servicio.(http://www.wikilearning.com/apertura_de_sockets-wkccp-3938-162.htm)

.

Si estamos programando un servidor, la forma de apertura del socket es la que muestra el siguiente ejemplo: ServerSocket miServicio; try { miServicio = new ServerSocket( numeroPuerto ); } catch( IOException e ) { System.out.println( e ); } A la hora de la implementación de un servidor también necesitamos crear un objeto socket desde el ServerSocket para que esté atento a las conexiones que le puedan realizar clientes potenciales y poder aceptar esas conexiones: Socket socketServicio = null; try { socketServicio = miServicio.accept(); } catch( IOException e ) { System.out.println( e ); }

Aconsejo terminar de leerse este excelente tutorial http://www.wikilearning.com/tutorial_de_java-wkc-3938.htm al

menos en lo referente a los sockets.

Y luego aconsejo irse al tutorial  http://www.programacion.com/tutorial/red/12/

Servidor de chat por consola y cliente con interfaz gráfico

 De la página www.monografias.com vamos a ver un servidor de chat en modo consola y un cliente de chat con interfaz gráfico.

Le he añadido comentarios que no tenia y resaltado lo esencial

El servidor : Se lanzaria el servidor con el único parámetro del puerto donde va a escuchar. Por ejemplo en el puerto 4321:

 > java ChatServer 4321

------------- ChatServer.java ----------------

import java.net.*;
import java.io.*;
import java.util.*;

public class  ChatServer  {
  public ChatServer (int port) throws IOException {
    ServerSocket server = new ServerSocket (port);

    //mientras el servidor este en ejecución estará escuchando en el socket client
    while (true) {

      //escuchando en el socket client, si no se conecta nadie se queda en estado block o de espera
      Socket client = server.accept ();

      //Si se conecta un cliente al port , se saca un mensaje por consola de aceptado y la IP del cliente
      System.out.println ("Aceptado desde: " + client.getInetAddress ());

      //ChatHandler , esta clase se define más abajo , seria el manejador y se construye su objeto c

      //tomando como argumento el Socket client, cada vez que se conecte un cliente ,

      // se lanzará un Nuevo ChatHandler...
      ChatHandler c = new ChatHandler (client);

      //lanzamos el objeto c de la clase ChatHandler = manejador del servidor , 1 por cada cliente conectado
      c.start ();
    }
  }
  public static void main (String args[]) throws IOException {
    if (args.length != 1) throw new RuntimeException ("Syntax: ChatServer ");

    //lanzamos el programa pasando el argumento , que es el puerto pasado de string a Integer
    new ChatServer (Integer.parseInt (args[0]));
  }
} 

------------------ ChatHandler.java -----------------------------------

import java.net.*;
import java.io.*;
import java.util.*;
public class  ChatHandler  extends Thread { //hereda de Thread --> va a ver procesos hijo o hilos o instancias
  protected Socket s;                       //en este caso la misma clase ChatHandler va a ser instanciada
  protected DataInputStream i;              //cada vez que se establezca una conexion con el servidor
  protected DataOutputStream o;
  public ChatHandler (Socket s) throws IOException {

    //el socket s pasado como parametro se asigna al s de la clase
    this.s = s;

    //DataInputStream i <--> in= entrada de datos , captura el flujo de datos de entrada de el socket s
    i = new DataInputStream (new BufferedInputStream (s.getInputStream ()));

    //DataOutputStream o <--> out = salida de datos , captura el flujo de datos de salida de el socket s
    o = new DataOutputStream (new BufferedOutputStream (s.getOutputStream ()));
  }

  // El manejador como un Vector y static ( compartido )
  protected static Vector handlers = new Vector ();

  // método run
  public void run () {
    String name = s.getInetAddress ().toString ();
    try {
      broadcast (name + " Se ha conectado.");
      handlers.addElement (this);
      while (true) {
        String msg = i.readUTF ();
        broadcast (name + " - " + msg);
      }
    } catch (IOException ex) {
      ex.printStackTrace ();
    } finally {
      handlers.removeElement (this);
      broadcast (name + " has left.");
      try {
        s.close ();
      } catch (IOException ex) {
        ex.printStackTrace();
      }
    }
  }

  //método broadcast ( nota: broadcast significa multidifusión, en una red de clase c como 192.168.173.0/24

  // la dirección de broadcast seria 192.168.173.255 , cualquier paquete ethernet dirigido

  // a esa dirección de broadcast , está obligado a escucharlo todo dispositivo de red

  // en este caso, simplemente , cuando se envia un mensaje por un cliente se envía a todas las conexiones

  // o clientes que tenga el servidor de chat
  protected static void broadcast (String message) {

    //sincroniza los Vector handlers
    synchronized (handlers) {

      // Interface Enumeration , es un interface contenido en java.util
      Enumeration e = handlers.elements ();

      //Mientras haya elementos en el interface e , que contiene los elementos del vector handlers
      while (e.hasMoreElements ()) {

        //c se le asigna el siguiente elemento de el interface e (que contiene los elementos de el vector handlers)

        // con el casting de rigor --> (ChatHandler)

        //es decir que mientras e tenga elementos se va a crear una instancia de ChatHandler
        ChatHandler c = (ChatHandler) e.nextElement ();

        try {

          // sincroniza el objeto o de c, que es un DataOutputstream ... del socket s establecido con el cliente
          synchronized (c.o) {

            //escribe message en el DataOutputStream o flujo de salida de la instancia c de ChatHandler

            // método writeUTF = Writes a string to the underlying output stream using

            // modified UTF-8 encoding in a machine-independent manner. 
            c.o.writeUTF (message);
          }

          //hace que fluya el rio de datos, liberando el buffer ... down to the river ... :) "Bruce Springteen"
          c.o.flush ();
        } catch (IOException ex) {

          //en caso de excepción ALTO! a ese proceso hijo de ChatHandler
          c.stop ();
        }
      }
    }
  }
}

-------------------------ChatClient.java-------------------------------

/**
* ChatClient.java  1.00 98/10/05 Humberto MartÌnez Barber·
*
* Basado en ChatApplet de Merlin Hughes
*/
import java.net.*;
import java.io.*;
import java.awt.*;

//Hereda de la clase Frame e implementa el interface Runnable

//The Runnable interface should be implemented by any class whose

// instances are intended to be executed by a thread.

// The class must define a method of no arguments called run. 
public class   ChatClient  extends Frame implements Runnable {
  protected DataInputStream i;
  protected DataOutputStream o;
  protected TextArea output;
  protected TextField input;
  protected Thread listener;

//El constructor se implementa con un titulo, un canal de entrada y otro de salida

//ojo no confundir i y o con this.i y this.o
  public ChatClient (String title, InputStream i, OutputStream o) {
    super (title);//la llamada a la superclase es lo 1º que se debe hacer en un constructor
    this.i = new DataInputStream (new BufferedInputStream (i));
    this.o = new DataOutputStream (new BufferedOutputStream (o));
    setLayout (new BorderLayout ());
    add ("Center", output = new TextArea ());
    output.setEditable (false);
    add ("South", input = new TextField ());
    pack ();
    show ();// está deprecated , habria que usar setVisible(true)
    input.requestFocus ();//Obtiene el foco
    listener = new Thread (this);//Crea una instancia o hijo o hilo de la propia clase
    listener.start ();//la lanza
  }
  public void run () {
    try {
      while (true) {
        String line = i.readUTF ();
        output.appendText (line + "\n");
      }
    } catch (IOException ex) {
      ex.printStackTrace ();
    } finally {
      listener = null;
      input.hide ();
      validate ();
      try {
        o.close ();
      } catch (IOException ex) {
        ex.printStackTrace ();
      }
    }
  }
  public boolean handleEvent (Event e) {
    if ((e.target == input) && (e.id == Event.ACTION_EVENT)) {
      try {
        o.writeUTF ((String) e.arg);
            o.flush (); 
      } catch (IOException ex) {
        ex.printStackTrace();
        listener.stop ();
      }
      input.setText ("");
      return true;
    } else if ((e.target == this) && (e.id == Event.WINDOW_DESTROY)) {
      if (listener != null)
        listener.stop ();
      hide ();
      return true;
    }
    return super.handleEvent (e);
  }//el cliente se define con 2 argumentos desde consola el que define un socket el host servidor y el puerto

   // > java ChatClient pc101 4321
  public static void main (String args[]) throws IOException {
    if (args.length != 2)
      throw new RuntimeException ("Syntax: ChatClient ");
    Socket s = new Socket (args[0], Integer.parseInt (args[1]));
    new ChatClient ("Chat " + args[0] + ":" + args[1],
                    s.getInputStream (), s.getOutputStream ());
  }
}