http://programadorphp.org -- Se trata de un tutorial para construir servicios web con Java en NetBeans sobre un servidor como Glassfish utilizando un Modelo de Datos complejo con operaciones implementadas para usar el protocolo SOAP con ficheros XML : WSDL.

1. Programador PHP.ORG – Juan Belón
Composición de servicios Web:
“Battlestar Galactica”
para el Curso de Arquitectura de Servicios
en Java en comunicación con PHP

2. ¿Qué vamos a aprender?
o Composición de servicios web para obtener un
funcionamiento complejo
 Invocaciones de los servicios Web para construir flujo de
trabajo en servidor.
 Cloud computing → Procesamiento distribuido

3. El modelo de datos

4. El modelo de datos
El objeto Elemento nos permite poder atacar a todos los
objetos del modelo ya que están todos referenciados por
un identificador
En universo están todas las galaxias
Las estrellas de combate están en las galaxias
Los vipers necesitan pilotos para volar
Los pilotos pueden estar inactivos

5. ¿Que vamos a hacer?
o Vamos a envolver el modelo con una capa de integración
de servicios para
 Crear una estrella de combate
 Preparar una estrella de combate, para un enfrentamiento
entre “vipers” (para los no profanos como yo, “cazas”)
 Lanzar los vipers al combate.
 Conocer el estado de las estrellas de combate después del
enfrentamiento 1.

6. Creamos el proyecto web
o Lo llamamos “BattlestarGalacticaWeb”
 Creamos un paquete nuevo para contener los servicios
 es.ugr.cursows.battlestar.service
 Añadimos la referencia al modelo

7. AstilleroService
o La clase “EstrellaDeCombate” posee 2 métodos para
crear estrellas de combate
 SalirDelAstillero() → Crea una nueva estrella de combate en
 la galaxia “Andromeda” llamada “Galactica”
 SalirDelAstillero(String nombre) → Crea una nueva estrella
 de combate llamada como el parámetro “nombre” en
Galaxia

8. AstilleroService (2)
o Creamos el servicio web: “AstilleroService”
 Creamos la operación nuevaEstrellaDeCombate
 Parámetro de entrada: ninguno
 Salida: Estrella de combate
 Creamos la operación nuevaEstrellaDeCombateNombrada
 Parámetro de entrada:
String nombre
 Salida:
Estrella de combate

9. AstilleroService (3)

10. Creamos el cliente
o Creamos un nuevo proyecto java, lo llamamos
BattlestarGalacticaClient
 Creamos un nuevo “package”
 es.ugr.cursows.battlestar.client
 Añadimos como dependencia el modelo
 Registramos el servicio Astillero
previamente creado como aprendimos
en la lección anterior

11. Astillero
o Creamos la clase Astillero en
es.ugr.cursows.battlestar.client
o La clase astillero será un cliente de AstilleroService por lo
que tendrá dos métodos equivalente a las operaciones de
AstilleroService
 nuevaEstrellaDeCombate
 nuevaEstrellaDeCombateNombrada

12. Astillero (2)
Creamos un test (Junit) para probar nuestro Astillero
En “Test packges” creamos un “package”
es.ugr.cursows.test.battlestar.client
Sobre este nuevo “package” creamos un nuevo Junit
llamado “TestAstillero”
Añadimos dos test (recordad que un test es un método que está
precedido por @Test)
NuevaEstrella
NuevaEstrellaNombrada

13. Astillero (3)

14. Astillero (4)
Los resultados

15. EstrellaDeCombateService
o Vamos a hacer un servicio que nos permita manejar la
estrella de combate del servidor.
 Obtener vipers
 Obtener vipers preparadas
 Obtener pilotos
 Obtener pilotos activos
 Preparar viper
 Lanzar Vipers

16. EstrellaDeCombateService
o Volvemos al proyecto BattlestarGalacticaWeb
o Creamos un nuevo servicio web para controlar las
estrellas de combate.
 Lo llamamos EstrellaDeCombateService
o Creamos una nueva operación para cada una de las
necesidades vista en la transparencia anterior
 Todos los métodos empiezan en por buscar la estrella de
combate solicitada.

17. EstrellaDeCombateService (2)
Obtener pilotos

18. EstrellaDeCombateService (3)
Obtener pilotos Activos

19. EstrellaDeCombateService (4)
Obtener vipers

20. EstrellaDeCombateService (5)
Obtener Vipers preparados

21. EstrellaDeCombateService (6)
Preparar un viper

22. EstrellaDeCombateService (7)
Lanzar el escuadrón de vipers preparados

23. ComputadoraDeCombateService
o Hemos creado un servicio Web para crear estrellas de
combate que serán nuestros almacenes de vipers.
o Hemos creado un servicio Web para gestionar cada una
de estos almacenes de vipers las “Estrellas de combate”
o Ahora vamos a crear un servicio web que nos permita
decidir un combate entre dos escuadrones de una estrella
de combate:
 Creamos un nuevo servicio web llamado
 CalculadorDeCombateService que será la interfaz del objeto
 “ComputadoraDeCombate”

24. CalculadorDeCombateService (2)
o Posee una única operación
 Combate
 Parámetros de entrada
o Listado de vipers. Escuadrón Rojo
o Listado de vipers. Escuadrón Azul
 Parámetro de salida
o InformeDeCombate. Objeto que describe que es lo que ha
sucedido en un combate

25. CalculadorDeCombateService (3)
El combate:

26. Todo listo en el servidor
Una vez completados los 3 servicios web el modelo de
battlestar galactica y su simulación de combate está lista para
ser usada por un cliente.

27. Cliente
o Creamos un proyecto java.
 En mi caso BattlestarClient
o Creamos un “package” en “source packge” donde
crearemos nuestras clases clientes.
 es.ugr.cursows.battlestar.client
o Creamos un “package” en “Test packge” donde creamos
los test de los cliente.
 es.ugr.cursows.test.battlestar.client

28. Registramos los servicios
o Como aprendimos anteriormente, vamos a registrar los 3
servicios Web que hemos realizado.
 AstilleroService
EstrellaDeCombateService
ComputadoraDeCombateService
o El proyecto debe quedar así:

29. Astillero
Creamos una clase Astillero en
“es.ugr.cursows.battlestar.client” que será nuestra interfaz
hacia el servicio web “AstilleroService”

30. Astillero (2)
Creamos un método por cada una de las operaciones de
construcción de Estrellas de combate.
Recordad que para añadir el código de llamada solo debéis arrastrar
la definición de la “operación” que encontráis en
“Web services references”

31. Astillero (3)
nuevaEstrellaDeCombate

32. Astillero (4)
NuevaEstrellaDeCombateNombrada

33. Astillero (5)
Construimos un Junit en
“es.ugr.cursows.test.battlestar.client” llamado TestAstillero para
probar los métodos de Astillero

34. Lanzamos los test
A lanzar los test deben ser creadas dos nuevas estrellas
de combate. “Galactica” creada por el método
nuevaEstrella de combate y “Pegasus” que es el nombre
escogido para el método
nuevaEstrellaDeCombateNombrada.

35. CentroDeControlEstrellaDeCombate
Creamos una clase CentroDeControlEstrellaDeCombate
en “es.ugr.cursows.battlestar.client” que será nuestra
interfaz hacia el servicio web “EstrellaDeCombateService”

36. CentroDeControlEstrellaDeCombate (2)
Creamos un método por cada operación que hemos
definido en el servidor. Con lo que tendremos:
getPilotos
getPilotosActivos
getVipers
getVipersPreparadas
prepararViper
lanzarEscuadron
Combate *Incorporada del servicio ComputadorDeCombate”

37. CentroDeControlEstrellaDeCombate (3)
GetPilotos

38. CentroDeControlEstrellaDeCombate (4)
getPilotosActivos

39. CentroDeControlEstrellaDeCombate (5)
getVipers

40. CentroDeControlEstrellaDeCombate (6)
getVipersPreparadas

41. CentroDeControlEstrellaDeCombate (7)
prepararViper

42. CentroDeControlEstrellaDeCombate (8)
lanzarEscuadron

43. CentroDeControlEstrellaDeCombate (9)
Combate: Preparar los parámetros de entrada

44. CentroDeControlEstrellaDeCombate (10)
Combate
Devolver el resultado

45. CentroDeControlEstrellaDeCombate (11)
Construimos un Junit llamado “TestCentroDeControl” en
“es.ugr.cursows.test.battlestar.client” para probar el
cliente.
Creamos un test por cada método de la clase
CentroDeControlEstrellaDeCombate.
NOTA IMPORTANTE:
Cada vez que modifiquemos el servidor se “redespliege” y limpia su
memoria de ejecución por lo que el identificador 4
de estrella de combate se pierde. Para recuperar este identificador
solo tenemos que volver a lanzar TestAstillero

46. CentroDeControlEstrellaDeCombate (12)
Test de getPilotos

47. CentroDeControlEstrellaDeCombate (13)
Test de getPilotosActivos

48. CentroDeControlEstrellaDeCombate (14)
Test de getVippers

49. CentroDeControlEstrellaDeCombate (15)
Test de getVipersPreparadas

50. CentroDeControlEstrellaDeCombate (16)
Test de prepararViper

51. CentroDeControlEstrellaDeCombate (17)
Test de lanzarEscuadron

52. Composición de servicios
Una vez todos nuestro servicios y clientes han sido
implementados y probados podemos construir un cliente
que a partir de la composición de estos servicios realice
un trabajo.
En nuestro caso mostrar un listado de la resolución de un
combate entre cazas

53. Composición de servicios (2)
El pseudo código de nuestra composición será:
Crear las estrellas de combate
Solicitar un listado de sus vipers
Preparar las vipers hasta que nos quedemos sin pilotos o
sin vipers
Lanzar las vipers ← Se marcan como que están en el aire
Procesar el combate de vipers

54. Composición de servicios (2)
Contruimos un nuevo Junit al que llamaremos
TestBattleStar en “es.ugr.cursows.test.battlestar.client”
Sobre su un Test llamado testBattlestarGalactica
realizaremos la composición de servicios

55. Composición de servicios (3)
Creamos los clientes con los que invocaremos al servicio:
Creamos las estrellas de combate en el servidor haciendo uso del
Astillero

56. Composición de servicios (4)
Solicitamos los vipers de las estrellas de combate, y
preparamos todos los vipers posibles

57. Composición de servicios (5)
Lanzamos los vipers preparados para el combate

58. Composición de servicios (6)
Y por último, teniendo la escuadras preparadas invocamos
a la computadora de combate para conocer el desenlace

59. Composición de servicios (7)
Tras la ejecución de este test todos lo métodos son
invocados y su composición constituye la resolución del
combate

60. Composición de servicios (5)
Lanzamos los vipers preparados para el combate

61. Comprueba que todo funciona
Asegúrate de que funcionan los servicios ya que los vamos a
utilizar para la próxima lección en la que realizaremos una
orquestación de los mismos combinándolos para crear
operaciones mediante un flujo complejo de información
usando BPEL.
http://programadorphp.org