Otras Arquitecturas y metodologías SOA, ejercicios

home title Jueves, 11 de marzo de 2010 | 5 comentarios home title

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

BPEL y OpenESB: Orquestación de Servicios Web

home title Miércoles, 10 de marzo de 2010 | 2 comentarios home title

Introducción a BPEL y OpenESB

Normalmente integrar este tipo de servicios en multinacionales tiene un coste realmente alto, gracias a las herramientas que vemos en este curso se hace mucho más fácil la tarea.

La siguiente presentación de la mano de Pablo García Sánchez nos da las nociones básicas de ESB y JBI, para la integración empresarial de aplicaciones compuestas que generan un flujo de trabajo dinámico, además de dar algunas ventajas, vocabulario, y ejemplos de BPEL.

Bpel y Open Esb:

Necesitamos descargar los componentes ESB para nuestro servidor Glassfish así como para el IDE Netbeans, aunque os recomiendo el Java EE 5 Tools Bundle Installer y java ee sdk 6 preview ya que trae soporte para SOA para Glassfish y Netbeans 6.5.1 con todos los módulos instalados para trabajar con BPEL.

Veamos un ejemplo práctico con servicios web en vídeo:

Lo que hago es crear un nuevo proyecto tipo BPEL Module (recordar no crear un proyecto en un directorio con acentos), añadir un WSDL Externo desde

http://webservices.daehosting.com/services/TemperatureConversions.wso?WSDL

y un nuevo BPEL Process, para la entrada del BPEL creamos un WSDL local con un parámetro, la entrada de temperatura y un parámetro de salida que es la respuesta.

Por último existe un tutorial de BPEL disponible aquí.

« Volver al Curso de Servicios Web

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

home title Lunes, 1 de marzo de 2010 | 3 comentarios home title

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

Breve repaso a Java para crear servicios web conectables con PHP

home title Miércoles, 24 de febrero de 2010 | 2 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

home title 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

  1. Descargar e instalar Java SE JDK 6 de Sun y su Documentación (ZIP): aquí
  2. Descargar e instalar NetBeans: aquí (recomendado instalarlo en una ruta sin espacios)
  3. 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:

  1. Vamos al menú: File -> New Project -> Elejimos el tipo Java -> Java Application
  2. 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…
  3. Se debe de haber creado la estructura de directorios y los ficheros necesarios
  4. 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;
}
}
  5. 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)
  6. 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
  7. 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.

footer
jbelon © | sitemap.xml