Aplicación de iOS para Abades con gestión de datos en Google App Engine

Jueves, 8 de septiembre de 2011 | 6 comentarios

Detalles de la aplicación para iOS

¿Para qué sirve?

• Proporciona información de los establecimientos del Grupo Abades
• Muestra las últimas noticias, promociones, eventos y tweets de las redes de la empresa
• Se pueden conseguir puntos de Abades, con un número de puntos suficiente, el usuario puede canjear estos por regalos que cada establecimiento pone a disposición de clientes que los frecuentan.

Funcionalidades de la aplicación

1.- Información de los establecimientos de la empresa:

El proceso de funcionamiento de la aplicación del Grupo Abades es el siguiente: hay una caché de días en los que la base de datos no se actualiza a menos que el usuario lo requiera. La primera vez que se arranca este número de días y otros parámetros de configuración se ponen a 0, por lo que si entramos en el listado de establecimientos de un tipo: áreas de servicio, hoteles o restaurantes, se descargará de Google App Engine, los datos que se han guardado en el modelo de datos del servidor por los empleados de la empresa en formato XML y se insertarán en la base de datos local en alrededor de un minuto. A partir del momento en que se almacenan estos datos hay 6 dias en los que no se vuelven a actualizar al ser datos de un tipo distinto a las promociones/eventos, noticias o ficheros,  se mantienen actualizados con otra frecuencia distinta.  En el caso de ser una imagen, la primera vez que se descarga se guarda en una caché (* nota programadores: de ASIDownloadCache), que hemos visto en los cursos de programación de este blog, entonces se almacenarán durante el número de días configurado, 31 por defecto, ya que son más estables y no deberían cambiar a menudo. Veréis que hay mucha info que aparece en la aplicación que es replicada en la web, sin embargo hay secciones como los puntos de sitios de interés que es más completa en esta aplicación de iOS. Las subsecciones de esta funcionalidad son las  siguientes:

2.- Promociones y eventos:

los empleados de la empresa, a través de la herramienta web de administración de promociones, colocan en abades.com y sus otras webs una lista de promociones, esta lista es accesible por medio de un fichero XML,tal como en la funcionalidad anterior se almacena una caché temporal de estas que permite visualizar una lista con títulos, centros y una imagen asociada, al pinchar sobre cualquiera de ellas entraríamos en la presentación de la imagen de la promoción ampliada, un texto descriptivo de la misma así como la información de contacto: teléfono, web, mail, etc. Su fecha y el centro de emplazamiento de la promoción o el evento.
     

3.- Mi cuenta en Abades:

4.- Mapa:

    

5.- Noticias y tweets:

            

6.- Sección de regalos:

 

Aplicación para iPhone: Carta Astral

Sábado, 13 de agosto de 2011 | 7 comentarios

Esta aplicación surgió como un proyecto personal a partir de la necesidad de crear cartas astrales.

El reto comenzó con la forma en que se han realizar los cálculos de una carta astral. Por suerte, hay un software escrito en C, de los alemanes Dieter Koch and Alois Treindl y Astrodienst Zurich llamado SWISSEPH, conecté por consola ssh con mi servidor, utilicé wget con la última versión ( 1.76 ) y tras el make probé Swetest que a partir de una serie de argumentos de entrada muestra por pantalla un “ephemeris”, el resultado de leer una base de datos de posiciones de planetas, asteroides, estrellas, etc. y devolver las posiciones para cada una de las casas de dicha fecha y hora en el lugar especificado por longitud y latitud.Este programa además lanza una serie de datos para generar gráficas como “spreadsheets”.
Veamos un vídeo de demostración:

Usando estos datos y un pequeño script:

//Analizar sintácticamente la fecha,hora,longitud y latitud
exec ("swetest -edir../src/ -b$utdatenow -ut$utnow -p0123456789
-eswe -house$longitud,$latitud, -fPlj -g, -head", $salida);
 foreach ($salida as $key => $linea)
      {
        $row = explode(',',$linea);
        $pl_name[$key] = $row[0];
        $longitude[$key] = $row[1];
        $house_pos[$key] = $row[3];
      };

Donde cada línea de salida de swetest se divide en arrays $row, con los elementos:0 = planeta,1 = longitud,2 = posición de casa, planetas en 0 – 9, cúspides en 10 – 21. Los nombres de los componentes,empiezan por 0 = Sol, que es la estrella del sistema solar,junto con la Luna=1 y Mercurio = 2 hasta Plutón = 9, los símbolos serían del 1 = Aries hasta 12 = Piscis. Para asociar la longitud y latitud al signo se hace una regla de 30 que limita la longitud y la combina con la casa asociada que devuelve el programa, de esta forma, podemos generar una imagen con instrucciones de dibujado geométrico (círculos, líneas, símbolos como texto)…Podéis ver un ejemplo aquí.

Para generar textos más completos he utilizado webs que los devuelven gratuitamente a partir de los datos, como grupovenus.
Finalmente, con un script en Python dentro de Google App Engine se crean todas las consultas en segundo plano, se construye el XML con HTML+CSS embebido, imágenes, etc. y se guardan, previo análisis sintáctico mediante la clase NSXMLParser en la base de datos SQlite asociada al Modelo de Datos, tal como vimos en los cursos.

Las animaciones de la app: las transiciones están hechas en OpenGL (HMGLTransition) y con las clases CAAnimation. El menú giratorio es una extensión de la clase UIGestureRecognizer ( KTOneFingerRotationGestureRecognizer ) modificada adaptando cada sección a un ángulo con una animación UIView…

Para la base de datos, primero se genera el modelo de datos, luego se compila y ejecuta la aplicación para que el mismo SDK cree el fichero SQlite así, tenemos la base sobre la que insertar los datos, una vez hemos rellenado todas las tablas, copiamos el fichero sqlite al proyecto y con un código como este:

NSString *storePath = [[self applicationDocumentsDirectory]
stringByAppendingPathComponent:
 @"Carta_Astral.sqlite"];
 
// Set up the store.
// For the sake of illustration, provide a pre-populated default store.
 
NSFileManager *fileManager = [NSFileManager defaultManager];
// If the expected store doesn’t exist, copy the default store.
if (![fileManager fileExistsAtPath:storePath]) {
NSString *defaultStorePath = [[NSBundle mainBundle]
pathForResource:@"Carta_Astral" ofType:@"sqlite"];
if (defaultStorePath) {
[fileManager copyItemAtPath:defaultStorePath
toPath:storePath error:NULL];
}
}

la primera vez que se ejecuta la aplicación, se copia al directorio de Documentos y ahí es donde se graban los datos del usuario, hago especial énfasis en que los tipos de datos complejos como Arrays de imágenes, textos y nombres se guardan en un tipo de dato del Modelo de Datos de Cocoa llamado Transformable.

En la sección de manuales hay tres tipos de manuales, los vídeos de youtube que se cargan sobre un objeto WebView, los textos con imagen que se cargan sobre una vista a mano y los pdf’s que se descargan a una caché con ASIHttp DownloadCache…Para paginar todos los documentos, libros, vídeos he usado una clase que crea un número infinito (gracias Andreas Katzian) de ScrollViews y los guarda en una caché de vistas para no tener que ir generándolos cada vez que se cambia de página, de forma que sólo se consulta una vez a la base de datos, se guarda una caché de tuplas y luego una caché de vistas con sus correspondientes botones, etc., así es mucho más eficiente y sencillo.
Para compartir textos e imágenes se utilizó ShareKit.

Veréis que las barras de navegación y las barras botones (tab) tienen una textura de fondo, esto se hace sobrecargando la clase correspondiente, en concreto el método de dibujado, para hacer que pinte una imagen por debajo y luego el resto del contenido.

Puedes probar a comprar la aplicación desde su sección en la web: Carta Astral para iPhone.

Aplicaciones web multiplataforma con XSL y XML: un reto SEO

Jueves, 24 de marzo de 2011 | sin comentarios

Gracias al uso de XSL vamos a transformar un XML para lo que nos convenga.

Lo primero, la utilidad, una aplicación en PHP o Java o cualquier otro lenguaje, como por ejemplo un juego o un TPV, una tienda, un portal…, cualquier tipo de aplicación puede compartir datos como hemos visto en los cursos y talleres de servicios web, pero podemos avanzar un poco más: si comprendemos el uso de una plantilla XSLT que transforme un fichero XML, siendo este la salida de nuestra aplicación, en un fichero XHTML que el navegador interpreta, sea en un móvil, un ordenador de escritorio o cualquier otro formato que necesitemos…entonces, las posibilidades son ilimitadas.

Para nosotros como webmasters, programadores, diseñadores…, un XSLT es un fichero que sirve para dar formato HTML a un fichero XML.
http://es.wikipedia.org/wiki/Extensible_Stylesheet_Language_Transformations
¿Cómo?
En español, si abres un fichero .XML con el navegador, éste lee la cabecera buscando de qué manera interpretarlo, aquí entra en juego el esquema XSLT, donde la T es de template, o sea, plantilla, en nuestro caso, una plantilla XHTML.
Bueno, vamos a los ejemplos, éste en concreto es de la W3C:
http://www.w3schools.com/xml/simplexsl.xml
como ves, es una dirección .XML que interpreta el navegador, incluso el IE6 :-).
Esto lo hace gracias a que en la cabecera aparece:

<?xml-stylesheet type=”text/xsl” href=”simple.xsl” ?>
entonces, usa la hoja de estilos o plantilla para dar formato que está en la misma dirección pero con distinta extensión:
http://www.w3schools.com/xml/simple.xsl
como ves, este fichero se basa en un esquema de TRANSFORMACIÓN

, lo que quiere decir que va a tomar el contenido del fichero inicial .XML y usando las reglas del XSL va a convertir las etiquetas con nombres comunes, en el ejemplo, son elementos del desayuno, ej.) “<breakfast_menu>” , en divisiones del tipo:
——-
<div style=”..”>
<span>
<!–etc.–>
</span>
</div>
——-
En concreto, esta regla es :
________________________________
<xsl:for-each select=”breakfast_menu/food”>
[CODIGO XHTML]
</xsl:for-each>
________________________________
para extraer los valores de un elemento de un nodo xml, se utiliza <xsl:value-of select=”RUTA/NOMBRE_NODO”/>
que es lo que se utiliza en el ejemplo para el precio, nodo <price> (que está dentro de <food>, que está dentro del menú <breakfast_menu>, que es la raíz o root del documento).
Para mostrar el valor de un atributo, por ejemplo,si a cada nodo <price> le añadimos la moneda:
<price currency=”dollar”>8.50</price>
en la plantilla xslt ,el valor se sacaría, así:
<xsl:value-of select=”price/@currency”/>
ya que estamos dentro de un bucle (o loop) que recorre todos los elementos del tipo
breakfast_menu/food
es decir, todos los <food>, dentro tienen un <price> y sacamos el atributo currency con la @.

La lista completa de referencias de XSL con templates está en:
http://www.w3schools.com/XSL/xsl_w3celementref.asp

Este es un ejemplo sencillo porque no incluye ningún DTD o definición de datos (en lenguaje XTiger), este se suele utilizar para hacer las cosas bien como ingenieros, …este DTD es un fichero que está por debajo del XML y es el que determina cómo se debe construir el árbol DOM completo, es decir, si no se siguen las reglas del DTD base, el fichero XML no es válido. Pero esto ya es pa nota jeje…hace unos años escribí un generador de código php+xhtml+jscript+css en php-gtk que creaba el esqueleto de una web en función a un xml ,el vídeo está aquí:

Resumiendo, podemos tener una aplicación que genere el mismo código XML para todas las plataformas pero cambiando sólo el esquema XSLT le diremos a la aplicación final que interpreta dicho XML cómo ha de hacerlo. Para el caso de móviles utilizaremos su lenguaje propio, al igual que si fuera una aplicación externa que necesitamos conectar/adaptar con nuestra aplicación, pudiendo usar servicios web como ya vimos en otros tutoriales si necesitamos algo más avanzado.

Para editar XSLT tienes editores a patadas :] ( Amaya )

Más tutoriales:

• Tutorial: Cómo crear páginas web con XML y XSLT
• Conceptos básicos: XML,XSL,XSD,etc.
• Referencias para XSLT
• Una aproximación a MySQL con XML

y más cosas habrá por ahi…

¿Quién está usando XML y XSLT hoy en día?: Blizzard lo utilizó en su primera versión de su web de Starcraft 2 ( XML , XSL -en este caso usan un script PHP que define el idioma y lo coloca en el atributo lang que se interpreta en la plantilla XSL- ), supongo que mantenía una base de datos interna en la empresa y quería reutilizarla por lo que le dió una salida xml y creó un esquema xslt bastante chulo, no me extrañaría que fuera la misma aplicación que usaran para gestionar el trabajo de los empleados… Otras empresas lo utilizan, Microsoft para su Office, OpenOffice también,…las universidades quieren pasar todo a XML, en Sun, digo, Oracle, todo se quiere hacer en función a XML para poder traspasar todas las fronteras y si no pueden usar un xslt para transformar de un lado a otro con facilidad.

Las ventajas de usar XML como código fuente es que podremos ocultar un poco mejor el XHTML final de posibles plagios e intentos de ataque, la información mostrada es muy fácil de leer, esto es bueno para la web semántica (web 3.0!), bueno para el posicionamiento (SEO),claro, de hecho Google anunció que una página en XML y XSLT iría a la cabeza antes que otra en XHTML, las arañas, webbots ,spiders, como queráis llamarlas, graban mejor información en XML y hacen las transformaciones a XHTML…además es un buen reto construir una web en XML,

¿O no?

Aplicación web de anuncios con mapas de Google Maps

Jueves, 20 de enero de 2011 | 8 comentarios

Hace unos años estuve realizando pruebas con aplicaciones web simbióticas usando mapas de Google Maps, finalmente algunos clientes me pidieron productos basados en dichas pruebas, en el vídeo mostrado a continuación se muestra una de ellas, del dominio inmorusticas.com, está en fase muy beta aunque las críticas son bien recibidas, como siempre…, pero se puede dislumbrar lo fácil que es construir sin un equipo de diseño, sólo con mi trabajo como programador un sitio web como los que actualmente están “dando caña” en internet.

Está optimizado para SEO  (posicionamiento) aunque siempre se puede mejorar, por ejemplo, las direcciones amigables google se pueden optimizar más aún.

Los puntos fuertes de una aplicación de este tipo,son

• la mayor parte hecha en AJAX con Php y MySQL
• tiene un generador interno de formularios basado en plantillas
• se pueden añadir categorías, subcategorías
• inmuebles con una interminable lista de campos a rellenar, entre los que cuentan: la posición en el mapa con coordenadas de latitud y longitud, imágenes que aparecen animadas, datos de varios tipos como requisitos de la información de la propiedad
• varias formas de indexar los elementos: filtros a medida, por provincia, categoría, subcategoría, precio,etc.
• una administración interna para dar de alta/modificar/eliminar/aceptar las fichas en cada categoría así como los servicios e información del sitio web.
• sindicación de contenidos por RSS: compartir los anuncios para con otros servicios web con XML

y seguramente me dejo algo más pero es sólo para dar una idea de lo que se puede hacer, básicamente todos los sitios de anuncios utilizan este tipo de estructura y arquitectura de la información, además de los mapas de Google Maps, claro.

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

Lunes, 1 de marzo de 2010 | sin comentarios

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

Lunes, 1 de marzo de 2010 | sin comentarios

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í:
   

   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