¿Cómo elegir servidor web?

Depende de si vamos a realizar un sistema de aplicaciones web o un servicio web, utilizaremos uno u otro.

Ya vimos las recomendaciones del Curso de Servicios Web de utilizar Glassfish para montar servicios web (WSDL) pero también se puede utilizar PHP y Apache, ya depende del número de usuarios y otros parámetros avanzados.
Este artículo se dirige a los que no saben tanto o para aquellos que deseen recordar o comentar los pros y contras de cada servidor, por qué utilizar un servidor con soporte Python (Django) o Rails (Ruby on Rails) en lugar de Apache con módulos para estas tecnologías, por qué no usar un servidor de Microsoft (ver llamadas al sistema y problemas de permisos en Windows),etc.
Empezaremos por una pequeña presentación y continuaremos con un par de vídeos relacionados.
(más…)

Otras Arquitecturas y metodologías SOA, ejercicios

Para terminar con las Arquitecturas Web vamos a dejar que Pablo García Sánchez nos cuente qué otras hay además de las que hemos visto: Otras Arquitecturas y metodologías SOA

EJERCICIO SIMPLE

  • Realizar un servicio web en Java con las operaciones:
    - String addUser(String user, String pass) que la guarde en una lista (variable de clase) y devuelva un mensaje diciendo que se ha guardado
    - boolean loginUser(String user, String pass) que compruebe que el usuario existe recorriendo la lista
    - (podemos usar dos listas de strings, HashMaps o crear una clase Usuario y guardarla en una List<Usuario>)
    - Testearlo en el navegador
  • Descargar ejercicio simple

EJERCICIO AVANZADO

  • Desarrollar dos servicios web (cada uno con su WSDL separado) utilizando JAX-WS. El primero debe recibir un XML con datos de un usuario <nombre><edad><contraseña><tel> y parsear ese XML con JDOM comprobando si hay  excepciones y guardarlo en una base de datos.
  • El segundo debe recibir un usuario y contraseña y devolver true si existe el usuario en la base de datos.
  • Finalmente crear un proceso BPEL con dos operaciones
    - Crear usuario (que ataque al primer servicio)
    - Hacer Login (que ataque al segundo) y devuelva un mensaje diciendo si los datos son correctos o no
    - Capturar Excepciones

EJERCICIO BPEL AVANZADO: descargar

fin Del Curso amigos

« Volver al Curso de Arquitectura de Servicios Web con Java y PHP

Curso de PHP y servicios Web

Gracias a Pedro A. Castillo Valdivieso disponemos de este Curso de PHP:

Introducción a PHP – Programador PHP – UGR

Los ficheros que necesitáis para seguir el guión están aquí.

Lo interesante, ahora que sabemos como programar servicios web complejos con Java y comunicarlos mediante SOAP es usar la clase que traen las últimas versiones de PHP (desde la 5.x), con un ejemplo sencillo, podemos probar a crear una lista de servicios como los que hay en http://www.service-repository.com/schema/namespaces …

El código sería tan sencillo como lo siguiente:

$wsdl = "http://www.currencyserver.de/webservice/currencyserverwebservice.asmx?WSDL";
echo "Servicios ofertados por <strong>$wsdl</strong>";
$client = new SoapClient($wsdl);
$avail = $client->__getFunctions();
echo '<ul>'; 
foreach($avail as $func) { 
 echo "<li>" . $func . "</li>";
} 
echo '</ul><hr />';
echo highlight_string( file_get_contents(__FILE__));

Que devuelve una lista de las operaciones del servicio especificadas por el WSDL.

Y para terminar ya sabéis que podéis crear vuestros propios servicios web con PHP, un ejemplo sencillo:

//Añadiendo función suma:
$cliente = new SoapClient(
null,
array(
"location"=>"http://localhost/simple/serversimple.php",
"uri"=>""
)
);
$suma = $cliente->suma(2,3);
print("La suma de 2 y 3 es :".$suma);

Código fuente de serversimple.php:

function suma($a,$b){
  return intval($a)+intval($b);
}
$server = new SoapServer(null, array('uri'=>""));//Sin WSDL -> uri es obligatorio
$server->addFunction("suma");
$server->handle();

Ver ejemplo funcionando: aquí

Recordar que hay que generar los ficheros WSDL con Katy u otra herramienta.

« Volver al Curso de Servicios Web

Creación de un paquete de servicios web para un modelo de datos JAVA

Una vez creado nuestro paquete con la aplicación Java para interactuar con los servicios web como hemos visto en la lección anterior, vamos a realizar las tareas que habíamos dicho paso por paso. Es decir, vamos a crear un servicio web con una operación para añadir un usuario con su nombre de usuario, password, un nombre de piloto y una nave con su cantidad de armamento, otro para obtener una lista de usuarios con pilotos y naves y otro para hacer un login con usuario y password, para ello:

CREAR DIRECTORIO DE XML:

  1. Dentro de las propiedades del Proyecto Java Web “Excalibur” en la categoría de Sources  -> Package Folder -> Add Folder -> creamos el directorio “XML” dentro de “src” y de etiqueta (label) ponemos “XML”. Aquí vamos a colocar nuestros ficheros WSDL para ver como se construyen servicios web a partir de estos, pero primero el método sencillo…ahora se puede añadir al esquema de forma gráfica cualquier dato y se formatea por el sistema ,podemos crear un servicio web a partir del fichero…

CREAR SERVICIO WEB

  1. En el paquete “es.ugr.battlegalactica.servicios” -> botón derecho  -> New -> Web services -> Web Service -> “construccionNexus”. Añadir el constructor de la clase y la variable estática Nexus nexus de ésta clase, que se incializa en dicho constructor…

CREAR OPERACIÓN PARA AÑADIR UN USUARIO CON SUS PILOTOS Y SUS NAVES ASOCIADAS

  1. Segundo botón en el código dentro de la clase “construccionNexus” -> “Insert Code…” -> “Add Web Service Operation” -> le llamamos “crearUsuarioConPilotosYnaves”
  2. En return type (tipos devueltos) ponemos java.lang.Long y así, si es -1 ha ocurrido un error y en otro caso es el ID del nuevo usuario
  3. Para los parámetros necesitamos que tenga: un nombre y password de usuario,un nombre de piloto  y un nombre de nave; por lo que empezamos por añadir el primer campo con name: “datos_usuario” , type: Choose -> find type -> buscamos “usuario” y seleccionamos el del modelo de datos de BSGModelo, ahora hacemos lo propio para “datos_piloto” -> Piloto y “datos_nave” -> Viper. Pinchamos en “OK” y se genera el código en Java, sólo hemos de meter los datos correspondientes que nos pasa tan amablemente el servicio web a la base de datos de Nexus ,tal como hacíamos en Prueba.java…
    la función de la operación debe quedar así:

    @WebMethod(operationName = "crearUsuarioConPilotosYnaves")
    public Long crearUsuarioConPilotosYnaves(@WebParam(name = "datos_usuario")
    Usuario datos_usuario, @WebParam(name = "datos_piloto")
    Piloto datos_piloto, @WebParam(name = "datos_nave")
    Viper datos_nave) {
     
    if (nexus.obtenerUsuario(datos_usuario.getUsuario())!=null ){
    //El usuario ya existe, salir!
    return new Long(-1);
    }
     
    //Añadir Viper
    Viper v  = null;
    try { //Buscar viper:
    v = nexus.obtenerViper(datos_nave.getNombre());
    } catch (ViperNoEncontradoException ex){
    //La nave no existe, la añadimos
    v = new Viper(datos_nave.getNombre());
    v.setArmamento(datos_nave.getArmamento());
    } finally {
    //En otro caso, la nave es la misma?
    if (!v.getId().equals(datos_nave.getId())){
    //No es la misma, error
    return new Long(-1);
    }
    }
     
    //Añadir piloto:
    Piloto p = null;
    try {
    p = nexus.obtenerPiloto(datos_piloto.getId());
    } catch (PilotoNoEncontradoException ex){
    //NO Existe el piloto, crearlo
    p = new Piloto(datos_piloto.getNombre(), datos_piloto.getDestreza(),
    v.getId());
    nexus.guardarPiloto(p);
    } finally {
    //El piloto existe, tiene la misma ID?
    if (!p.getId().equals(datos_piloto.getId())){
    return new Long(-1);
    }
    }
    ArrayList<Long> lista_pilotos = new ArrayList<Long>();
    lista_pilotos.add(p.getId());
     
    //Añadir el usuario con los datos almacenados ya en Nexus:
    Usuario u = new Usuario(
    datos_usuario.getUsuario(),
    datos_usuario.getPassword(),
    lista_pilotos );
     
    nexus.guardarUsuario(u);
     
    return u.getId();
    }

    Para probarla primero hacemos click con el segundo botón del ratón en el proyecto Excalibur > Deploy ,esto instalará la aplicación web con la nueva operación compilada, ahora vamos a la lista de servicios web y pulsamos en test Web Service, ya podemos añadir usuarios con un piloto y una nave

CREAR OPERACIÓN PARA HACER UN LOGIN CON USUARIO Y PASSWORD

  1. Una vez creado un usuario en la base de datos la función para hacer un login es tan simple como esta:
    @WebMethod(operationName = "hacerLogin")
    public String operation(@WebParam(name = "usuario")
    String nombre_usuario, @WebParam(name ="password") String contrasena) {
    //TODO write your implementation code here:
    Usuario u = nexus.obtenerUsuario(nombre_usuario);
    if (u==null) return "El usuario no existe";
    else if (u.getPassword().equals(contrasena)){
    return "Acceso concedido";
    } else {
    return "Contraseña inválida";
    }
    }

    Recordar que para testear los servicios podemos hacerlo en SOAP UI:

CREAR OPERACIÓN PARA OBTENER UN LISTADO DE USUARIOS

  1. Es simplemente crear un listado a partir de recorrer el array de estos y devolverlo para que lo analice sintácticamente el sistema y devuelva la construcción XML correspondiente:
    public List<Usuario> listadoUsuarios() {
    List<Usuario> listado = null;
    for (Iterator<Usuario> iter = nexus.listarUsuarios(); iter.hasNext(); ){
    listado.add(iter.next());
    }
    return listado;
    }

Buenas prácticas de programación: Los servicios web son un tipo de comunicación, añadir lógica de programación resulta en algo no-generalizable y por lo tanto ,no reutilizable. Resumiento: hay que hacer una conversión de los datos de un modelo de datos en un modelo de datos de un servicio web,i.e.,las clases con su lógica de programación en Java a un modelo del servicio y luego el paso inverso. Entre medias están las páginas web u otros clientes que los utilizan con su propia lógica. Por ello se recomienda diseñar los servicios web lo último, cuando ya tenemos todo lo que necesitamos en cuanto a datos y lógica interna con ellos, separar cada fichero WSDL para cada servicio es recomendable por si necesitamos cambiar algo y nos cuesta menos trabajo.

CREAR CLIENTES PARA CONECTARSE A LOS SERVICIOS WEB

  1. En el proyecto “Excalibur” creamos el paquete “es.ugr.battlegalactica.servicios” y dentro de este -> segundo botón del ratón-> New -> Other -> Web Services -> Web Service Client -> seleccionamos del proyecto “Excalibur” el Servicio Web “construccionNexus” -> OK ; y ahora en package ponemos “es.ugr.battlegalactica.clientes”. Esto debe crearnos todas las clases Java para comunicarse con las operaciones del Servicio Web. Pero para saber que funcionan usamos un JUnit Test , creamos un paquete llamado “es.ugr.battlegalactica.clientes” y dentro un nuevo JUnit Test para clases existentes, elegimos la clase a testear y hacemos como en la primera lección las unidades de prueba.

< Volver al curso de Arquitectura de Servicios Web con JAVA y PHP

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&lt;Elemento&gt; elementos;
    private static ArrayList&lt;Piloto&gt; pilotos;
    private static ArrayList&lt;Viper&gt; 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&lt;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&lt;Piloto&gt; 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&lt;Viper&gt; 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&lt;Elemento&gt;();
    pilotos   = new ArrayList&lt;Piloto&gt;();
    vipers    = new ArrayList&lt;Viper&gt;();
    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&lt;Long&gt; lista_pilotos_usuario = new ArrayList&lt;Long&gt;();
    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

Conceptos básicos: XML + JAVA + JDOM + SOAP + PHP

Hablemos primero un poco acerca de XML Gracias a los protocolos para conectar XML como XML-RPC,SOAP o RSS, XML sobrevivió al desastre de convertirse en un lenguaje que no aportara nada nuevo a lo existente (HTML), y que combinado con WSDL, JAVA y PHP obtenemos las herramientas más utilizadas en la red hoy en día: servicios.

XML es robusto, podemos modificar el fichero fácilmente sin que pierda su significado dramáticamente; podemos construir una estructura para moldear la forma en que se comunican nuestros servicios con los clientes y aplicaciones con diversas reglas, me gustaría que mirárais la documentación sobre XML, XML-RPC,SOAP,RSS,SAX,DOM, JDOM y WSDL que he puesto aquí (de la UGR , y también en un comprido manuales_comunicacion.rar para tenerlo en local) ya que se explican conceptos fundamentales, como el standalone de xml (para decir si la estructura del árbol documento [DOM] se construye sólo con un fichero o por medio de varios, etc.), o lo nuevo de XML que son los namespace para que dentro del nombre de la etiqueta se pueda incrustar un diccionario: <dic:alumno>…</dic:alumno>, etc.; también, indicando donde está mediante <Nombre xmlns=”url_del_diccionario_nombre”>…

Sabiendo que DTD y un esquema XSD definen de la misma forma la estructura de un XML, estos últimos XSD son los más utilizados hoy en día, porque es realmente sencillo (al menos cuando estuve construyendo zenphp me costó mucho tener reglas DTD válidas para el generador de aplicaciones php a partir de un xml) hacer dichas reglas usando XML, ya que XSD se basa en un DTD ,son los diccionarios predefenidos que se van incrustando como las muñecas rusas.

El protocolo XML funciona normalmente a través del puerto HTTP (80) y dió lugar al XML-RPC, fué más famoso que SOAP porque éste había que introducirlo mediante un conjunto de reglas propias y era pesado de hacer, actualmente existen librerías que crean los envoltorios para enviar mensajes:

XML-RPC

Ver XML-RPC en los manuales

..embebiendo tipos en parámetros y estos en valores dando forma así a las peticiones y las respuestas de los servicios.

SOAP : es ligero, tiene pocas etiquetas y casi no pesan nada, es como la evolución de XML-RPC ,al fin y al cabo, es otro envoltorio para enviar mensajes por HTTP o SMTP , (Facebook lo usa)…

WSDL: además define reglas para un servicio web…mirar la documentación propuesta anteriormente para más información…

Para empezar, veremos como conectar Java con un WSDL y obtener resultados, siguiendo los pasos:

  1. Dispondremos primero de un editor: SOAP UI ,descargar e instalar
  2. Ahora daremos con una lista de servicios de tipo WSDL, por ejemplo los servicios de DaeHosting:

    http://webservices.daehosting.com/services/

    abrimos el servicio de fechas: http://webservices.daehosting.com/services/DatesService.wso y copiamos la dirección URL de la descripción de sus servicios ,que es el fichero WSDL [un XML] que necesitamos: http://webservices.daehosting.com/services/DatesService.wso?WSDL

  3. Abrimos SOAP UI y Vamos al menú: “File -> New soapUI Project” , insertamos la URL copiada del paso anterior en “Initial WSDL/WADL” y se pondrá automáticamente el nombre a “DatesService” pero podemos ponerle el que queramos, pinchamos en “OK” y empezará a cargar los servicios que ofrece dicho WSDL. Estos aparecerán en la pestaña “Navigator” en modo árbol, seleccionamos MonthNames y desplegamos el árbol de modo que hacemos doble click sobre “Request 1″ y aparecerá una ventana con el esquema XML de la petición que se realiza al servidor, las entradas se pueden identificar por el caracter “?”
  4. Vamos a pulsar en la ventana de “Request 1″ con el segundo botón del ratón->”Validate” para validar el documento y veremos que nos aparecen mensajes para que rellenemos los datos pedidos, pero antes debemos conocer qué poner en “iLanguage”, para ello, abrimos del árbol de Servicios “DateServiceSoapBinding” el “Request1″ de “MainLanguages” de forma que al ejecutarlo nos aparecerá como respuesta del servidor una lista con el formato XML del WSDL del servicio con los idiomas que soporta, copiamos el valor para el español: “LANG_SPANISH” y volvemos a la ventana del “Request 1″ de la Operación “MonthNames” donde ahora sí sabemos qué valor hay que poner en el tipo de dato “iLanguage”: LANG_SPANISH.  Los otros dos parámetros :  bAbbreviated y bUse13Months son booleanos, probad vosotros mismos qué diferencias hay entre poner 0 ó 1 :)
    En cualquier caso el resultado de la ejecución correcta del servicio debe de tener una pinta como esta:
  5. Acabamos de presenciar la generación de llamadas a servicios para que devuelvan el nombre de los meses en un idioma deseado, con lo que este servicio, (por ingeniería inversa) sabemos que se trata de un traductor…
  6. Combinando los servicios podemos hacer cosas realmente interesantes…probad a usar la petición de la operación MonthName para obtener el mes de Abril en Alemán por ejemplo

Ahora que sabemos como comunicar servicios con esquemas XML veamos como utilizar Java para implementar una aplicación que haga lo que nuestro querido SOAP UI hace tan fácilmente en una serie de sencillos pasos:

  1. Descargar, descomprimir y abrir el proyecto para NetBeans: Ejemplos XML para Java: aquí.
  2. Debe aparecer un problema de referencias al cargar el proyecto, para solucionarlo descargar las librerías aquí y en las propiedades del proyecto -> Librerías -> pestaña de Compilar -> quitáis las referencias rotas y añadir los ficheros JAR (que hay que descomprimir de  librerias.rar). Entonces deben desaparecer todos los errores de compilación en NetBeans…(BuildAll…)
  3. Ahora expandimos el paquete “EscribirXML.SOAP” y abrimos el fichero ClienteSOAP.java, donde vamos a reemplazar “localhost” de la línea 17 por nuestro servidor WSDL con soporte para acciones SOAP,en este caso es RFC, para mostrar que sirve para RPC también el mismo código:

    http://www.ebi.ac.uk/Tools/webservices/wsdl/WSDbfetch.wsdl

    si el tipo de Operación es SOAP en lugar de RPC, la acción SOAP la podemos leer en el editor SOAP UI en las propiedades de la Operación seleccionada

  4. Mirando el código comprender que se realiza una conexión al servidor y se envía por el método POST una petición HTTP con los parámetros establecidos (acción SOAP si se define) y se escribe en el búfer con wout.write() nuestro esquema XML, por lo tanto copiamos el WSDL del SOAP UI de la petición “Request 1″ para la Operación “getSupportedDBs” (reemplazando los valores de las interrogantes como antes si es que los hay)…
  5. Para probar el ejemplo compilamos y tras hacer click con el segundo botón del ratón sobre ClienteSOAP.java  pulsamos en “Run” (Ejecutar) o bien editamos las opciones del proyecto -> run -> Main class -> “EscribirXML.SOAP.ClienteSOAP”, sin argumentos en este caso…
    El código ha de quedar así:

    package EscribirXML.SOAP;
    import java.net.*;
    import java.io.*;
     
    /**
    *
    * @author
    */
    public class ClienteSOAP {
     
    public final static String DEFAULT_SERVER
    = "http://www.ebi.ac.uk/Tools/webservices/wsdl/WSDbfetch.wsdl";
    // = "http://www.schemaweb.info/webservices/soap/SchemaWebSoap.asmx?WSDL";
    /* public final static String SOAP_ACTION
    = "http://www.schemaweb.info/webservices/methods/GetObjects";*/
     
    public static void main(String[] args) {
    String server = DEFAULT_SERVER;
    try {
    URL u = new URL(server);
    URLConnection uc = u.openConnection();
    HttpURLConnection connection = (HttpURLConnection) uc;
     
    connection.setDoOutput(true);
    connection.setDoInput(true);
    connection.setRequestMethod("POST");
    //connection.setRequestProperty("SOAPAction", SOAP_ACTION);
     
    OutputStream out = connection.getOutputStream();
    Writer wout = new OutputStreamWriter(out);
     
    wout.write(
    "<soapenv:Envelope xmlns:xsi=\""+
    "http://www.w3.org/2001/XMLSchema-instance\" "+
    "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" "+
    "xmlns:soapenv=\"http://schemas.xmlsoap.org/soap/envelope/\" "+
    "xmlns:wsd=\"http://wsdbfetch.ws.jdbfetch.ebi.ac.uk\">"+
    "<soapenv:Header/>"+
    "<soapenv:Body>"+
    "<wsd:getSupportedDBs soapenv:encodingStyle=\""+
    "http://schemas.xmlsoap.org/soap/encoding/\"/>"+
    "</soapenv:Body>"+
    "</soapenv:Envelope>");
    wout.flush();
     
    wout.close();
     
    InputStream in = connection.getInputStream();
    int c;
    System.err.println( "\n\nCONTESTACION\n\n");
    while ((c = in.read()) != -1) System.out.write(c);
    in.close();
     
    }
    catch (IOException e) {
    System.err.println("HA DADO UNA EXCEPCION");
    System.err.println(e);
    }
     
    } // end main
     
    }
  6. La salida debe ser algo como:

Por último vamos a probar un ejemplo del análisis sintáctico de un fichero XML a través del uso de un ParserDOM, abriendo el paquete DOM.Parsear y dentro el fichero “ParserDOM.java” sólo hemos de pasarle la ruta por línea de comandos del fichero y observar los resultados… (ver ejemplos con SAX del mismo proyecto de NetBeans proporcionado)…

El Modelo Objeto Documento de Java además de servir de analizador sintáctico con el método parse(), proporciona interfaces para manejar ficheros como árboles de datos, se obtiene con parsed.getDocument(), si no existen excepciones se trata, en otro caso es que el documento no ha pasado la validación, encontraremos información de prefijo, etc. dentro del árbol…

« Volver al curso de Arquitectura de Servicios en Java+PHP

footer
jbelon © | sitemap.xml