Curso de PHP y servicios Web

Domingo, 7 de marzo de 2010 | 11 comentarios home title

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

Introducción a PHP – Programador PHP – UGR

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

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

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

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

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

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

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

Código fuente de serversimple.php:

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

Ver ejemplo funcionando: aquí

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

« Volver al Curso de Servicios Web

Servicios web y Cloud Computing con JAVA, SOAP y PHP

Domingo, 7 de marzo de 2010 | sin comentarios home title

DONDE ESTAMOS

Nos encontramos en un punto en el curso de Arquitectura de servicios web en el que ya hemos construido el modelo de datos que nos sirve como borrador para gestionar toda la información que ofertan los servidores y que los clientes tratan, así como de manipular esta información gracias a los servicios web que sirven de interfaces para dicha tarea.

¿QUÉ VAMOS A HACER?

Ahora vamos a centrarnos en la composición de servicios web para obtener un funcionamiento complejo mediante la invocación de estos servicios, concretamente a sus operaciones para construir un flujo de trabajo en nuestros servidores.

INTRODUCCIÓN

El nuevo modelo de datos basado en el que vimos en la lección anterior ( creación de servicios web con netbeans y glassfish ) para hacer las primeras pruebas con servicios web está diseñado para crear automáticamente pilotos y naves en un universo, de modo que se ha suprimido el usuario y se han añadido una clase Universo y una clase Galaxia para simular una pelea entre Vippers asociados a ella dentro de una clase EstrellaDeCombate. Dentro de Universo se encuentran todas las Galaxias y las estrellas de combate están dentro de éstas. Recordar que los vipers necesitan pilotos para volar y estos pilotos pueden estar o no activos.

¿CÓMO LO VAMOS A HACER?

Envolviendo el modelo de datos en una capa de integración de servicios web lo primero, así podemos crear una estrella de combate y prepararla para que que se pueda enfrentar a otra, lanzando las naves al combate, para después conocer su estado tras el enfrentamiento.

COMENZAMOS

Crear un nuevo proyecto Java Web llamado “BattleStarGallacticaWebServer”, y dentro de este creamos un nuevo paquete (Java package) llamado
es.ugr.cursows.battlestar.service
Como era de esperar necesitamos añadir a las librerías el JAR del modelo de datos (código fuente y documentación ,también está la documentación online): BSGModelo Universo.JAR.
Para no hacer demasiado extenso este guión, uso esta presentación:
Composicion de servicios web: ejemplo de BattleStarGalactica

Ver más presentaciones de Juan Belón Pérez »

Lo importante de esta lección es aprender a crear servicios web y comunicarlos para ofrecer Servicios de Cloud Computing…

Según esta empresa, esto es CloudComputing:

Y algo más sobre Cloud Computing : Cloud Sharing:

Las posibilidades se van haciendo cada vez mayores…el futuro de la evolución de la web pasa por aquí…

« Volver al Curso de Servicios Web | Ir a la siguiente lección »

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

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

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:

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

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

Segundo botón en el código dentro de la clase “construccionNexus” -> “Insert Code…” -> “Add Web Service Operation” -> le llamamos “crearUsuarioConPilotosYnaves”
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

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

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

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

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

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.
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
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 …

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

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.

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&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”

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”.