Creación de Servicios Web con Netbeans y Glassfish – JAVA y PHP

INTRODUCCIÓN

Glassfish es el servidor de aplicaciones Web de Sun, como hay que crear un “dominio” dentro del servidor de aplicaciones y esto consume muchos recursos no se utiliza en máquinas convencionales ya que el coste de implementación de un servidor de dominios puede ser demasiado elevado por la carga que supone dicha tarea a pesar de que se puede implementar sobre Apache.

Si instalamos la última versión de Netbeans con Glassfish podemos pasar directamente a la sección de Crear el Modelo de datos al que acceder desde Servicios Web

Podemos configurar nuestro dominio tanto con la consola como dentro de NetBeans, usando la interfaz de usuario. Vamos a ver cómo se hace de las dos formas, primero con la consola:

  1. Descargar Glassfish: aquí e instalar con el comando:
    java -Xmx256m -jar glassfish-installer-v2.1.1-b31g-windows.jar
    y ahora, entrar en el directorio glassfish, establecer las variables de entorno JAVA_HOME a vuestro directorio de instalación JDK y lo mismo para PATH añadiéndole el directorio de glassfish,  entonces ejecutamos el comando:
    lib\ant\bin\ant -f setup.xml
    desde el directorio de glassfish.
  2. Ir a la herramienta de administración por consola del servidor, está en:
    glassfish/bin/asadmin.bat
    ahora vamos a crear un dominio mediante la instrucción (en la consola del server):
    create-domain –user nombre_usuario_admin –adminport numero_puerto nombredominio
    en nuestro caso usaremos el dominio Excalibur con usuario root y el puerto 6666:
    create-domain –user root –adminport 6666 excalibur
    esto debe de tardar un poquito, se habrá creado un directorio para el dominio en glassfish/domains/excalibur,y ahora,  justo después, “levantaremos” el dominio en el servidor con la instrucción:
    start-domain excalibur
  3. Ahora podréis hacer uso de la dirección http://localhost:6666 con los datos de usuario para administrar el server. Podéis pararlo con stop-domain.
    Sólo os diré que en mi máquina,al cargar el servidor y crear el dominio, me empezó a consumir su proceso 30MB de RAM,tras iniciar dicho dominio ya iba por 178MB y subiendo…imaginaos un servidor de decenas o cientos de dominios en memoria…más de 900MB pasa perfectamente…y además, esto en un servidor IBM es normal para un único proceso.

Después de trabajar en lecciones anteriores con NetBeans, ya deberíamos conocer las ventajas de utilizar este IDE …

  1. Arrancar NetBeans, ir a la pestaña de Servicios -> Servidores -> Segundo botón del ratón -> añadir servidor ->
    si os dá un error o no sale ninguna ventana necesitáis actualizar vuestra versión del JDK de Java y reinstalar la última versión de NetBeans que trae una versión de Glassfish 3. Servidores  -> iniciar -> http://localhost:4848/
  2. Para comprobar que el servidor está funcionando vamos a crear un nuevo proyecto de tipo Java web -> Web Application -> compilar y Ejecutar ,en el navegador debe aparecer un “Hola Mundo”

Ahora vamos a aprender cómo se crean servicios web que utilicen complejas estructuras de datos así como colecciones y anotaciones,  reutilizables, desde distintos clientes que realicen las operaciones desde JAVA o PHP. También aprenderemos a definir un fichero WSDL para crear un servicio ,ambas cosas con Netbeans y usaremos JAX-WS para construir los clientes automáticamente, es decir, el cliente del servicio web (programa que lo usa desde la máquina de un usuario que se conecta a los servicios de un servidor) traduciendo los mensajes que se comunican por el protocolo SOAP.

Crear el Modelo de datos para Servicios Web (Web services) con Java en Netbeans

Resumen de lo que vamos a hacer: crear un servicio web para registrar (en nuestro modelo de datos) usuarios, pilotos y naves en la base de datos de la clase que implementa el computador…recordar el proyecto BSGModelo

Gracias a una clase llamada administracion que crea los usuariosse le asocia un piloto y a éste una nave (viper), todo esto queda almacenado en el modelo de datos del computador Nexus que se ejecuta sobre el servidor Excalibur (glassfish) y que lanza excepciones construidas por nosotros al nivel de aplicaciones y servicios web.

Abrir el proyecto de la lección 2: BSGModelo y haremos lo siguiente:

  1. Ya que todo servicio se construye a partir de un Proyecto Web, vamos a crear un nuevo proyecto web: File -> New Project -> Java Web -> Web Application , nombre: “Excalibur”, para que podamos almacenar datos y confeccionar asociaciones entre el proyecto BSGModelo y el proyecto de Aplicación Web con Servicios llamado “Excalibur” vamos a este proyecto -> segundo botón en “Libraries” -> Add Project -> seleccionar BSGModelo y Add Project JAR files.
  2. Ahora vamos a modificar el proyecto “BSGModelo”, “en es.ugr.battlegalactica.modelos” -> botón derecho -> New -> Java Class -> nombre: “Usuarios”, como tenemos que asociar los vipers y los pilotos, debemos cambiar primero la clase pilotos para meter dentro una lista de vipers, crear en usuarios una lista de pilotos en la clase usuarios y luego añadir una lista de usuarios en nexus. El código ha quedar así:
    Ver modelo de datos

    Descargar BSGModelo_usuarios.

    Para que probemos todos estos cambios, hemos hecho cambios a la función Main de la clase Prueba.java:

     
    // Web 2.0: Arquitectura Orientada a Servicios en Java
    // Primer Modelo: BSGModelo con la clase Prueba
    // @author Juan Belón Pérez
     
     
    package es.ugr.battlegalactica;
     
    import es.ugr.battlegalactica.modelo.Elemento;
    import es.ugr.battlegalactica.modelo.Nexus;
    import es.ugr.battlegalactica.modelo.Piloto;
    import es.ugr.battlegalactica.modelo.Usuario;
    import es.ugr.battlegalactica.modelo.Viper;
    import es.ugr.battlegalactica.modelo.excepciones.NoHayArmamentoException;
    import es.ugr.battlegalactica.modelo.excepciones.PilotoNoEncontradoException;
    import es.ugr.battlegalactica.modelo.excepciones.ViperNoEncontradoException;
    import java.util.ArrayList;
    import java.util.Iterator;
     
    /**
    * Clase con los 3 primeros ejercicios propuestos
    * @author Juan Belón Pérez
    */
    public class Prueba {
    private static ArrayList<Elemento> elementos;
    private static ArrayList<Piloto> pilotos;
    private static ArrayList<Viper> vipers;
    private static Nexus nexus;
     
    // Función principal.
    //Imprime por pantalla un mensaje fijo.
    // @param args la linea de argumentos del programa
     
    public static void main(String[] args) 
    throws NoHayArmamentoException, PilotoNoEncontradoException,
     ViperNoEncontradoException {
    System.out.println("Prueba del modelo de datos BattleStarGallactica");
    //crear dos elementos e imprimir sus identificadores en la consola. 
    //Si todo ha ido bien se deberían escribir los identificadores 1 y 2
    init();
    System.out.println("Prueba de creación de elementos:");
    for (Elemento e: elementos){
    System.out.printf("%d,",e.getId());
    }
    System.out.println("\nPrueba de creación de pilotos:\n");
    for (Piloto p: pilotos){
    System.out.printf("ID:%d,Nombre:%s,Destreza:%d\n",p.getId(),p.getNombre(),
    p.getDestreza());
    }
    System.out.println("\nPrueba de creación de vipers:\n");
    for (int i=0; i<4; i++){ //Disparar 4 veces con todos los vipers:
    for (Viper v: vipers){
    System.out.printf("#%d# Disparando con el viper ID:%d,Nombre:%s," +
    "Armamento:%d\n",(i+1),v.getId(),v.getNombre(),v.getArmamento());
    try {
    v.disparar();
    } catch (NoHayArmamentoException e){
    System.err.println("\n\tError al disparar:"+e.getMessage()+"\n");
    }
    System.out.printf("\tEl nuevo armamento del viper con ID:%d y Nombre: %s"+
    " ahora tiene %d unidad/es\n",
    v.getId(),v.getNombre(),v.getArmamento());
    }
    }
    System.out.println("\nPrueba de creación de Nexus con Pilotos:\n");
    Iterator<Piloto> iter_piloto = nexus.listarPilotos();
    Piloto aux_piloto = null;
    while (iter_piloto.hasNext()){
    aux_piloto = iter_piloto.next();
    System.out.printf("Piloto %s, ID:%d\n", aux_piloto.getNombre(),
    aux_piloto.getId());
    }
    System.out.println("\nPrueba de creación de Nexus con Vipers:\n");
    Iterator<Viper> iter_viper = nexus.listarVipers();
    Viper aux_viper = null;
    while (iter_viper.hasNext()){
    aux_viper = iter_viper.next();
    System.out.printf("Viper %s, ID:%d\n", aux_viper.getNombre(),
    aux_viper.getId());
    }
    if (aux_piloto!=null){
    System.out.println("\nPrueba de búsqueda (el último:" +
    aux_piloto.getId()+") de Pilotos en Nexus:\n" +
    nexus.obtenerPiloto(aux_piloto.getId()).getNombre());
    }
    if (aux_viper!=null){
    System.out.println("\nPrueba de búsqueda de Vipers (el último:"+
    aux_viper.getId()+") en Nexus:\n" +
    nexus.obtenerViper(aux_viper.getId()).getNombre()
    );
    }
     
    System.out.println("\nComprobar que se generan las excepciones "+
    "buscando un Piloto falso:23\n");
    try {
    aux_piloto = nexus.obtenerPiloto(new Long(23));
    } catch (PilotoNoEncontradoException ex){
    System.err.println("\n\t"+ex.getMessage());
    }
    System.out.println("\nComprobar que se generan las excepciones "+
    "buscando un Viper falso:23");
    try {
    aux_viper = nexus.obtenerViper(new Long(23));
    } catch (ViperNoEncontradoException ex){
    System.err.println("\n\t"+ex.getMessage());
    }
     
    try {
    Usuario usuario = nexus.obtenerUsuario("juaxix");
    System.out.println("\nCreación de un usuario ("+
    usuario.getUsuario() + " con piloto: " +
     
    (nexus.obtenerPiloto(
    usuario.getPilotos().get(0)
    ).getNombre()) + " y viper asociado a este piloto: "+
    nexus.obtenerViper(
    nexus.obtenerPiloto(
    (nexus.obtenerUsuario(usuario.getId()).getPilotos().get(0))
    ).getNaves().get(0)
    ).getNombre()
    );
    System.out.flush();
    } catch (PilotoNoEncontradoException ex){
    System.err.println("\n\t"+ex.getMessage());
     } catch (Exception ex){
     System.err.println("\n\tNEXUS LOG:"+ex.getMessage());
     }
    }
     
    // Inicializador de elementos, pilotos, vipers y Nexus (vipers, pilotos y usuarios)
    private static void init(){
    Viper v_aux;
    elementos = new ArrayList<Elemento>();
    pilotos   = new ArrayList<Piloto>();
    vipers    = new ArrayList<Viper>();
    nexus     = new Nexus();
    elementos.add(new Elemento());
    elementos.add(new Elemento());
     
    v_aux = new Viper("Trueno");
    v_aux.setArmamento(4);
    vipers.add(v_aux);
     
    pilotos.add(new Piloto("Migue",120,v_aux.getId()));
    v_aux = new Viper("Rayo");
    v_aux.setArmamento(4);
    vipers.add(v_aux);
    pilotos.add(new Piloto("Sara",110,v_aux.getId()));
     
    //INTRODUCIR DATOS EN NEXUS:
    v_aux = new Viper("Trueno");
    v_aux.setArmamento(4);
    nexus.guardarViper(v_aux);
    Piloto juax = new Piloto("Juax",130,v_aux.getId());
    nexus.guardarPiloto(juax);
     
    v_aux = new Viper("Fuego");
    v_aux.setArmamento(5);
    nexus.guardarViper(v_aux);
    nexus.guardarPiloto(new Piloto("Jesús",130,v_aux.getId()));
    //Creación de un usuario en Nexus:
    ArrayList<Long> lista_pilotos_usuario = new ArrayList<Long>();
    lista_pilotos_usuario .add(juax.getId());
    Usuario usuario = new Usuario("juaxix" //nombre usuario/
    , "juaxix" // password 
    ,lista_pilotos_usuario // lista de ids de pilotos asociados
    );
    nexus.guardarUsuario(usuario);
     
    }
     
    }

    La idea del modelo de datos es parecida a un modelo de cajas:

    La nueva línea que ha de mostrar la ejecución de esta clase (el proyecto BSGModelo) es: 

    “Creación de un usuario (juaxix con piloto: Juax y viper asociado a este piloto: Trueno”

  3. Para usar los servicios, creamos un nuevo paquete, en el proyecto Java Web llamado “Excalibur” ->  “Source Packages” -> botón derecho -> New -> Java Package -> llamado “es.ugr.battlegalactica.servicios”.

Continuar >

< volver al Curso de Arquitectura de Servicios Web con JAVA + XML + PHP

Artículos relacionados:

  1. fernando javier dice:

    esta muy bien mira necesito ayuda
    me dejaron un proyecto
    el cual es mostrar informacion de vacantes de una empresa y que este subida esta informacion en internet. En un sitio web.
    tienen servidor glasfish 3.0.1 y la programacion sera en java netbens 6.8 y para el diseño del sitio web se utilizara dreamweaver cs4.
    mi pregunta crees que en ese servidor yo pueda alojar el sitio y que este funcionando en internet yo pienso que no.
    estaria bien tu opinion gracias.

  2. pablo dice:

    hola. soy estudiante, quiero acceder a una pagina web hosteada en una maquina, desde otra maquina de la misma red, la web esta publicada en glasfish, se puede? como tendria que hacer?
    muchas gracias :)
    pablo

    • Juan Belón dice:

      claro que puedes pero el tema de que sea Glassfish o Apache da un poco igual porque tienes que meterle mano al problema usando conocimientos de redes de ordenadores, en tu configuración de redes deberías crear una interfaz virtual por ejemplo, desde el ordenador que acceda a las dos redes y esa interfaz virtual conectaría mediante un enrutado (comando route) ambas subredes y ya podrías acceder…

Please type the characters of this captcha image in the input box

Por favor escriba los caracteres de la imagen captcha en el cuadro de entrada

footer
jbelon © | sitemap.xml