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

Jueves, 25 de febrero de 2010 | 3 comentarios home title

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:

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:

Dispondremos primero de un editor: SOAP UI ,descargar e instalar
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
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 “?”
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:
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…
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:

Descargar, descomprimir y abrir el proyecto para NetBeans: Ejemplos XML para Java: aquí.
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…)
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
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)…

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
 
}

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

Componente de Firefox para diseñadores y maquetadores Web: Pixel Perfect

Miércoles, 24 de febrero de 2010 | sin comentarios home title

Estos son algunos de los diseños en XHTML+CSS que existen actualmente en la red y que se basan en el correcto posicionamiento del arte gráfico usando un esquema de divisiones o cajas que enmarcan el resultado final…

Supongo que muchas veces os preguntaréis cómo diseñan estos genios sus páginas web, (mirad estos 35 excelentes diseños de webs e-commerce) no nos hace falta Flash realmente, sino que usando XHTML y CSS se pueden crear maravillas, ya lo estáis viendo.

Sin embargo, la tediosa tarea de colocar cada imagen en su sitio dentro de una división, cada fondo en el renglón adecuado y el pixel colocado en el milímetro ideal…es una tarea de titanes!, pero para eso amigos tenemos la herramienta Pixel Perfect…para colocar perfectamente los gráficos dentro de nuestra estructura y a mano :)

Y para muestra, un vídeo:

Para instalar esta extensión de Firefox sólo hay que pinchar aquí. (Debes tener Firebug instalado)

Para usarlo: Vamos a nuestra web, pulsamos F12 o sobre el icono de Pixel Perfect

y añadimos una capa con “Add overlay” que será la imagen que necesitamos colocar mediante valores CSS.

Por ejemplo:

Ahora podemos colocar la imagen que hemos añadido gráficamente, para obtener el HTML+CSS correspondiente a esta colocación pinchamos en la pestaña “HTML” y buscamos el objeto añadido dinámicamente o bien pulsamos en “Inspeccionar” y luego en la capa con la imagen superpuesta de modo que podemos copiar fácilmente el código creado por el generador de la extensión.

Felices modificaciones CSS :D

Breve repaso a Java para crear servicios web conectables con PHP

Miércoles, 24 de febrero de 2010 | sin comentarios home title

Para crear Servicios Web necesitamos tener unas nociones básicas del lenguaje Java a partir de las que accederemos a los elementos que vamos a construir en nuestros ejemplos.

Lanzamos NetBeans, vamos a crear, a partir del proyecto de la lección anterior,

clases para construir modelos: elementos, pilotos (elemento), viper(elemento) ,computador y nexus (computador).
Clases para excepciones que se generarán en las clases piloto, viper y nexus, lanzadas desde Prueba.

Lo primero es construir el Elemento:

 
// Web 2.0: Arquitectura Orientada a Servicios en Java.
// Introducción a JAVA
// CLASE DEL MODELO Elemento
 
 
package es.ugr.battlegalactica.modelo;
 
 
// Clase Elemento
// @author Juan Belón Pérez
public class Elemento {
// Siguiente elemento
private static long nextId = 0;
// ID del Elemento
protected long id = 0;
// Constructor de Elemento sin argumentos
// @return Elemento
public Elemento() {
this.id = ++Elemento.nextId;
}
//Devuelve el Id de la clase
// @return long
public long getId() {
return id;
}
// Devuelve el contador actual de ID's de Elementos
// @return long
public long getNextId(){
 return Elemento.nextId;
}
 
}

Ahora, podemos ,a partir de este elemento construir Pilotos que hereden de este:

 
// Web 2.0: Arquitectura Orientada a Servicios en Java.
// Introducción a JAVA
// CLASE DEL MODELO Piloto que hereda del Modelo Elemento
package es.ugr.battlegalactica.modelo;
 
// Clase Piloto, hereda de Elemento
// @author Juan Belón Pérez
public class Piloto extends Elemento {
// Nombre del piloto
private String nombre;
// Destreza del piloto
private int destreza;
// Constructor de Piloto
//@param nombre
// @param destreza
public Piloto(String nombre, int destreza) {
this.nombre   = nombre;
this.destreza = destreza;
}
//
// Devuelve el valor de destreza de un piloto
// @return int
public int getDestreza() {
return destreza;
}
 
// Devuelve el nombre de un piloto
// @return String
public String getNombre() {
return nombre;
}
 
}

y lo mismo que para Piloto pero con Viper (que son naves):

// Web 2.0: Arquitectura Orientada a Servicios en Java.
// Introducción a JAVA
// CLASE DEL MODELO Viper que hereda del Modelo Elemento
 
package es.ugr.battlegalactica.modelo;
 
import es.ugr.battlegalactica.modelo.excepciones.NoHayArmamentoException;
 
 
// Clase Viper (naves)
// @author Juan Belón Pérez
public class Viper extends Elemento {
 
// Nombre del Viper
private String nombre;
 
// Cantidad de armamento (nºde proyectiles)
private int armamento;
 
 
// Constructor de Vipers
//@param nombre String
 
public Viper(String nombre) {
this.nombre = nombre;
this.armamento = 0;
}
 
// Devuelve la cantidad de munición del Viper
// @return int
public int getArmamento() {
return armamento;
}
// Devuelve el nombre del Viper
// @return String
public String getNombre() {
return nombre;
}
 
// Pone munición al Viper en la cantidad dada
// @param armamento
public void setArmamento(int armamento) {
this.armamento = Math.abs(armamento);
}
 
// Dispara con la munición disponible, decrementa el armamento
// @throws NoHayArmamentoException
public void disparar() throws NoHayArmamentoException{
--this.armamento; // = (this.armamento==0)?0:(--this.armamento);
if (this.armamento&lt;0){
this.armamento = 0;
throw new NoHayArmamentoException("No queda munición en este viper ("+
this.getId()+")");
}
}
}

Ahora repasaremos lo que es una interfaz o clase abstracta (no se puede instanciar sino que sirve como modelo para tener varias implementaciones distintas, por ejemplo, una clase base de datos con distintas tecnologías: mysql, oracle,etc). Construimos la clase Computador para realizar una implementación más tarde llamada Nexus

 
// Web 2.0: Arquitectura Orientada a Servicios en Java.
// Introducción a JAVA
// CLASE DEL MODELO Computador para el
//  computador de la estrella de combate
 
 
package es.ugr.battlegalactica.modelo;
 
import es.ugr.battlegalactica.modelo.excepciones.PilotoNoEncontradoException;
import es.ugr.battlegalactica.modelo.excepciones.ViperNoEncontradoException;
import java.util.Iterator;
 
 
// Clase Computador
// @author Juan Belón Pérez
//
public interface Computador {
//
//Registra un Viper en el Computador
//@param v Viper
//
void guardarViper(Viper v);
///
//Registra un Piloto en el Computador
//@param p
//
void guardarPiloto(Piloto p);
//////Devuelve el Viper asociado al id especificado
//@param id
//@return Viper
//
Viper obtenerViper(long id) throws ViperNoEncontradoException;
//////Devuelve el Piloto asociado al id especificado
//@param id
//@return Piloto
//
Piloto obtenerPiloto(long id) throws PilotoNoEncontradoException;
//////Devuelve un iterador de los Vipers registrados en el Computador
//@return Iterator
//
Iterator listarVipers();
//////Devuelve un iterador de los Pilotos registrados en el Computador
//@return Iterator
//
Iterator
listarPilotos();
}

Recordar también lo que son los iteradores…ahora vamos a dar el código para implementar la interfaz Computador con la clase Nexus:

//
//Web 2.0: Arquitectura Orientada a Servicios en Java.
//Introducción a JAVA
//CLASE DEL MODELO Nexus que implementa el Computador para el
// computador de la estrella de combate
//
 
package es.ugr.battlegalactica.modelo;
 
import es.ugr.battlegalactica.modelo.excepciones.PilotoNoEncontradoException;
import es.ugr.battlegalactica.modelo.excepciones.ViperNoEncontradoException;
import java.util.ArrayList;
import java.util.Iterator;
 
//////Clase Nexus - un Computador de la estrella de combate
//@author Juan Belón Pérez
//
public class Nexus implements Computador {
//////Pilotos registrados en el Computador Nexus
//
private static ArrayList
pilotos_nexus;
//////Vipers registrados en el Computador Nexus
//
private static ArrayList vipers_nexus;
//////Constructor del Computador Nexus
//
public Nexus() {
init_Nexus();
}
//////Inicializador del Computador Nexus
//
private void init_Nexus(){
pilotos_nexus = new ArrayList
();
vipers_nexus = new ArrayList();
}
public void guardarViper(Viper v) {
vipers_nexus.add(v);
}
 
public void guardarPiloto(Piloto p) {
pilotos_nexus.add(p);
}
 
public Viper obtenerViper(long id) throws ViperNoEncontradoException {
for (Viper v: vipers_nexus)
if (v.getId()==id) return v;
throw new ViperNoEncontradoException("Viper no encontrado: "+id);
//    return null;
}
 
public Piloto obtenerPiloto(long id) throws PilotoNoEncontradoException {
for (Piloto p: pilotos_nexus)
if (p.getId()==id) return p;
throw new PilotoNoEncontradoException("No se ha encontrado el piloto:"
+ id);
//   return null;
}
 
public Iterator listarVipers() {
return Nexus.vipers_nexus.iterator();
}
 
public Iterator
listarPilotos() {
return Nexus.pilotos_nexus.iterator();
}
 
}

Para probar las excepciones haremos que cuando se dispare una viper ,si la cantidad de armamento es 0 lance una excepción de tipo “NoHayArmamentoException”:

//
//Web 2.0: Arquitectura Orientada a Servicios en Java.
//Introducción a JAVA
//CLASE PARA EXCEPCIONES DEL MODELO VIPER -&gt; Disparo
//
package es.ugr.battlegalactica.modelo.excepciones;
 
//////Clase para lanzar excepciones cuando se intenta disparar sin munición
//desde un Viper
//@author Juan Belón Pérez
//
public class NoHayArmamentoException extends Exception {
//////Constructor de Excepción con mensaje
//@param message
//
public NoHayArmamentoException(String message) {
super(message);
}
//////Constructor
//
public NoHayArmamentoException() {
}
 
}

Creamos una clase de excepciones para la clase Piloto, en este caso para cuando se intenta encontrar un Piloto que no existe:

//
//Web 2.0: Arquitectura Orientada a Servicios en Java.
//Introducción a JAVA
//CLASE PARA EXCEPCIONES DEL MODELO Piloto -&gt; busquedas
//
 
package es.ugr.battlegalactica.modelo.excepciones;
 
////////@author Juan Belón Pérez
//
public class PilotoNoEncontradoException extends Exception {
 
//////Constructor con mensaje
//@param message
//
public PilotoNoEncontradoException(String message) {
super(message);
}
//////Constructor
//
public PilotoNoEncontradoException() {
}
 
}

Lo mismo que antes, para Vipers:

//
//Web 2.0: Arquitectura Orientada a Servicios en Java.
//Introducción a JAVA
//CLASE PARA EXCEPCIONES DEL MODELO Viper -&gt; busquedas
//
 
package es.ugr.battlegalactica.modelo.excepciones;
 
////////@author Juan Belón Pérez
//
public class ViperNoEncontradoException extends Exception {
//////Constructor con mensaje
//@param message
//
public ViperNoEncontradoException(String message) {
super(message);
}
 
public ViperNoEncontradoException() {
}
 
}

Por último la clase Prueba para probar todo lo que hemos construido:

//
//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.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 elementos;
private static ArrayList
pilotos;
private static ArrayList 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
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 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(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(23);
} catch (ViperNoEncontradoException ex){
System.err.println("\n\t"+ex.getMessage());
}
}
//Inicializador de elementos, pilotos, vipers y Nexus (vipers y pilotos)
private static void init(){
Viper v_aux;
elementos = new ArrayList();
elementos.add(new Elemento());
elementos.add(new Elemento());
 
pilotos = new ArrayList
();
pilotos.add(new Piloto("Juax",120));
pilotos.add(new Piloto("Sara",110));
 
vipers = new ArrayList();
v_aux = new Viper("Trueno");
v_aux.setArmamento(3);
vipers.add(v_aux);
v_aux = new Viper("Rayo");
v_aux.setArmamento(4);
vipers.add(v_aux);
 
nexus = new Nexus();
nexus.guardarPiloto(new Piloto("Migue",130));
nexus.guardarPiloto(new Piloto("Jesús",130));
v_aux = new Viper("Trueno");
v_aux.setArmamento(4);
nexus.guardarViper(v_aux);
v_aux = new Viper("Fuego");
v_aux.setArmamento(5);
nexus.guardarViper(v_aux);
}
 
}

La salida que debe mostrar es la siguiente:

Prueba del modelo de datos BattleStarGallactica
Prueba de creación de elementos:
1,2,
Prueba de creación de pilotos:

ID:3,Nombre:Juax,Destreza:120
ID:4,Nombre:Sara,Destreza:110

Prueba de creación de vipers:

#1# Disparando con el viper ID:5,Nombre:Trueno,Armamento:3
El nuevo armamento del viper con ID:5 y Nombre: Trueno ahora tiene 2 unidad/es
#1# Disparando con el viper ID:6,Nombre:Rayo,Armamento:4
El nuevo armamento del viper con ID:6 y Nombre: Rayo ahora tiene 3 unidad/es
#2# Disparando con el viper ID:5,Nombre:Trueno,Armamento:2
El nuevo armamento del viper con ID:5 y Nombre: Trueno ahora tiene 1 unidad/es
#2# Disparando con el viper ID:6,Nombre:Rayo,Armamento:3
El nuevo armamento del viper con ID:6 y Nombre: Rayo ahora tiene 2 unidad/es
#3# Disparando con el viper ID:5,Nombre:Trueno,Armamento:1
El nuevo armamento del viper con ID:5 y Nombre: Trueno ahora tiene 0 unidad/es
#3# Disparando con el viper ID:6,Nombre:Rayo,Armamento:2
El nuevo armamento del viper con ID:6 y Nombre: Rayo ahora tiene 1 unidad/es
#4# Disparando con el viper ID:5,Nombre:Trueno,Armamento:0

Error al disparar:No queda munición en este viper (5)

El nuevo armamento del viper con ID:5 y Nombre: Trueno ahora tiene 0 unidad/es
#4# Disparando con el viper ID:6,Nombre:Rayo,Armamento:1
El nuevo armamento del viper con ID:6 y Nombre: Rayo ahora tiene 0 unidad/es

Prueba de creación de Nexus con Pilotos:

Piloto Migue, ID:7
Piloto Jesús, ID:8

Prueba de creación de Nexus con Vipers:

Viper Trueno, ID:9
Viper Fuego, ID:10

Prueba de búsqueda (el último:8) de Pilotos en Nexus:
Jesús

Prueba de búsqueda de Vipers (el último:10) en Nexus:
Fuego

Comprobar que se generan las excepciones buscando un Piloto falso:23

Comprobar que se generan las excepciones buscando un Viper falso:23

No se ha encontrado el piloto:23

Viper no encontrado: 23
BUILD SUCCESSFUL (total time: 0 seconds)

Para descargar el código y probar, hay un comprimido aquí.

« Volver al Curso de Arquitectura de Servicios Java para PHP ó ver más cursos »

Instalación y configuración de NetBeans para creación de servicios Java

Martes, 23 de febrero de 2010 | 8 comentarios home title

En este tutorial, vamos a ver cómo instalar y configurar NetBeans para trabajar tanto con Java como con PHP y crear nuestros primeros servicios, Pruebas de Unidad de las funciones de las clases,etc.

INSTALACIÓN de NetBeans

Descargar e instalar Java SE JDK 6 de Sun y su Documentación (ZIP): aquí
Descargar e instalar NetBeans: aquí (recomendado instalarlo en una ruta sin espacios)
Arrancar NetBeans, actualizar, y después ir a “Tools -> Java Platforms -> J2SE -> JDK 1.6″ (o vuestra versión) y pinchar en la pestaña JavaDoc -> Add Zip/Folder -> y elegís el fichero ZIP de la documentación del paso uno, ahora podemos consultar la documentación al estar en cualquier miembro de la SE JDK mediante el segundo botón del ratón -> “Show JavaDoc”

CREACIÓN del PRIMER PROYECTO CON NetBeans:

Vamos al menú: File -> New Project -> Elejimos el tipo Java -> Java Application
En el nombre ponemos “BSGModelo” y en “Create Main Class” ponemos: es.ugr.battlegalactica.Prueba
este nombre indica que la clase se llama Prueba e irá dentro de un paquete cuya jerarquía empieza por battlegalactica como contenedor dentro de UGR dentro de España…
Se debe de haber creado la estructura de directorios y los ficheros necesarios

Ahora dejaremos el código fuente de Prueba.java como sigue:

//
//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;
 
//
//Clase con los 3 primeros ejercicios propuestos
//@author Juan Belón Pérez
//
public class Prueba {
 
//
//Función principal.
//Imprime por pantalla un mensaje fijo.
//Dependiendo de si en los argumentos, separados por comas,
//se usa el título Adama, se saluda a la persona de distinta forma
//que si no se usa o se usa Piloto.
//@param args la linea de argumentos del programa
//
public static void main(String[] args) {
System.out.println("Prueba del modelo de datos BattleStarGallactica");
String todo ="";
String[] nombres ;
for (int i=0; i&lt;args.length; i++){
todo += args[i]+" ";
}
System.out.println("Cadena de entrada: \n- -\n" + todo + "\n- -\n");
nombres = todo.split(",");
for (int i=0; i&lt;nombres.length; i++){
System.out.println(crearSaludoRespeto(nombres[i]));
}
}
//
//Utiliza los espacios para separar los títulos y las comas para separar
//las personas. Devuelve un saludo con el respeto adecuado al rango.
//@param String nombre
//@return String
//
public static String crearSaludoRespeto(String nombre){
String saludo = "";
if (nombre==null) return "Hay alguien ahi?";
String[] partes = nombre.split(" ");
 
if (partes.length&gt;1){
if (partes[0].equalsIgnoreCase("adama")){
saludo = "Bienvenido, comandante " + partes[1];
} else if (partes[0].equalsIgnoreCase("piloto")) {
saludo = "Bienvenido, piloto " + partes[1];
} else { //nombre compuesto
saludo = "Bienvenido, civil " + nombre;
}
} else { //solo nombre, es un civil
if (partes.length&gt;0)
saludo = "Bienvenido, civil " + nombre;
else
saludo = "Hay alguien ahi?";
}
return saludo;
}
}

Ahora compilamos, y para probar que funciona en todos los casos le metemos las siguientes entradas a mediante el menú : Pestaña “Projects -> BSGModelo” -> Segundo botón del ratón-> “Set configuration -> Customize…” y en argumentos colocamos la cadena: Adama Juax,Piloto Migue,Sara,Jesús González, la salida debe ser como esta:

Prueba del modelo de datos BattleStarGallactica

Cadena de entrada:

- -

Adama Juax,Piloto Migue,Sara,Jesús González

- -

Bienvenido, comandante Juax

Bienvenido, piloto Migue

Bienvenido, civil Sara

Bienvenido, civil Jesús González

BUILD SUCCESSFUL (total time: 0 seconds)
Sólo resta, crear una prueba para esta clase mediante el menú del segundo botón sobre es.ugr.battlegalactica: “Tools -> Create JUnit Tests” -> desmarcamos “Test Finalizer” por ahora, ya os explicaré por qué…-> OK

Para probar todos los casos de la función crearSaludoRespeto primero quitamos todo de testMain para que no falle ya que no hace nada y luego añadimos las pruebas a la función testCrearSaludoRespeto y dejamos el fichero tal que así:

 
package es.ugr.battlegalactica;
 
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
 
//
////@author webser22
//
public class PruebaTest {
 
public PruebaTest() {
}
 
@BeforeClass
public static void setUpClass() throws Exception {
}
 
@AfterClass
public static void tearDownClass() throws Exception {
}
 
@Before
public void setUp() {
}
 
//
//Test of main method, of class Prueba.
//
@Test
public void testMain() {
 
}
 
//
// Test of crearSaludoRespeto method, of class Prueba.
//
@Test
public void testCrearSaludoRespeto() {
System.out.println(
"Probando la función crearSaludoRespeto de la clase Prueba");
assertEquals("Correcto", Prueba.crearSaludoRespeto(null),
"Hay alguien ahi?");
assertEquals("Correcto", Prueba.crearSaludoRespeto("Adama Juax"),
"Bienvenido, comandante Juax");
assertEquals("Correcto", Prueba.crearSaludoRespeto("Piloto Migue"),
"Bienvenido, piloto Migue");
assertEquals("Correcto", Prueba.crearSaludoRespeto("Sara"),
"Bienvenido, civil Sara");
assertEquals("Correcto", Prueba.crearSaludoRespeto("Jesús González"),
"Bienvenido, civil Jesús González");
}
 
}

Entonces probamos mediante el menú “Run -> Test ‘BSGModelo’ ” y ha de aparecer “passed” en el output y el mensaje “Probando la función crearSaludoRespeto de la clase Prueba” en la salida de los resultados de JUnit Results. ¿Para qué sirven las Pruebas de Unidad?

Y esto es todo, el fichero con el proyecto se puede descargar aquí, tiene la documentación generada (hay que actualizarla).

Para el que esté impaciente ,puede continuar por aprender cómo utilizar el editor NetBeans para PHP o bien volver al índice de este Curso de Arquitectura de Servicios en Java en comunicación con PHP.

Curso de Arquitectura de Servicios en Java en comunicación con PHP

Martes, 23 de febrero de 2010 | 8 comentarios home title

Este curso consta de diferentes partes

Instalación y configuración de NetBeans para creación de servicios Java
Breve repaso a Java y la Programación Orientada a Objetos: herencia, polimorfismo, Tipos como en C++ mediante especificaciones Clase<tipo_dato>, uso de netbeans, excepciones, etc.
Conceptos básicos de la comunicación entre aplicaciones mediante servicios: XML, XML-RPC, SOA, RSS, SAX, DOM, JDOM y WSDL
Creación del modelo de datos para los servicios web con JAVA, las operaciones de dichos servicios y los clientes que los utilizan también en JAVA
Creación del conjunto de servicios web (cloud computing) que utiliza el modelo de datos del punto 4
Tutorial de PHP e iniciación a la creación y comunicación con servicios web usando WSDL
BPEL y OpenESB: Orquestación de Servicios Web

Resumen: Otras Arquitecturas y metodologías SOA, ejercicios a realizar

Proponen: Departamento de Arquitectura y Tecnología de Computadores de la UGR
Dirección y Coordinación:
CASTILLO VALDIVIESO, PEDRO ÁNGEL (DIRECTOR) : pedro [en] atc.ugr.es
GARCÍA SÁNCHEZ, PABLO (COORDINADOR): pgarcia[en]atc.ugr.es
Profesorado:
CASTILLO VALDIVIESO, PEDRO ÁNGEL (Propio): pedro[en]atc.ugr.es
GARCIA ARENAS, Mª ISABEL (Propio): maribel[en]geneura.ugr.es
GARCÍA SÁNCHEZ, PABLO (Propio): pgarcia[en]atc.ugr.es
GONZÁLEZ PEÑALVER, JESÚS (Propio) : jesus[en]atc.ugr.es
LOPEZ MONTELLANO, MIGUEL ANGEL (Nacional)

Licencia del curso: GPL

El Curso en la UGR >

Aplicación web para inmobiliarias – proyectos y multimedia

Sábado, 20 de febrero de 2010 | 6 comentarios home title

Esta es una aplicación multilenguaje del año 2007 con zenphp. Se incluye un administrador interno con capacidad para subir ficheros e imágenes asociados a los inmuebles así como enviar direcciones de youtube para insertar conjuntamente con la descripción de aquellos.
Las cabeceras se pueden cambiar por cada entrada de inmueble de cada categoría, además ,las plantillas contienen un gestor de imágenes con las que se construye una galería con fotografías dentro de la página de cada inmueble…

Las plantillas XHTML + CSS se crearon por Agencia Q4 en el 2007.