Pero lo más importante es que, como una solución NoSQL, Cassandra rompe con la larga historia y teoría de las bases de datos relacionales por otro modelo con un almacenamiento híbrido del tipo “clave ⇒ valor”, totalmente descentralizado y mucho más fácil de escalar que MySQL.

Por ese motivo es que ahora Digg quiere alejarse tanto como puedan de LAMP, comenzando por cambiar MySQL por Cassandra:

“Nuestra principal motivación para alejarnos de MySQL es la creciente dificultad de construir una aplicación de alto rendimiento con escrituras intensivas en un conjunto de datos que crece rápidamente, sin un final a la vista.

A medida que nuestro sistema crece, es importante abarcar múltiples data centers para redundancia y performance de la red, para agregar capacidad o reemplazar sin downtimes nodos que hayan fallado. Planeamos continuar usando hardware común y continuar asumiendo que fallará regularmente. Todo esto es crecientemente difícil con MySQL”.

Cassandra fué desarrollado por Facebook, pero ahora es de código abierto amparado bajo la licencia de Apache. Digg también prometió comenzar a contribuir sus propias mejoras y modificaciones.

En el procesamiento para cloud compiting hace falta una base de datos realmente rápida…

Si os preguntáis por qué se sigue utilizando MySQL o NoSQL en lugar Oracle que tiene un mayor rendimiento: leer más quizás el tema de las licencias responda a vuestra pregunta…

O también puede responderos a esta pregunta el que la facilidad tiene que ver mucho con HTML5 y su WebSimpleDB API…

NoSQL se basa en unos patrones, además del de “tipo=>valor”, aquí teneis un tutorial…veamos un ejemplo sencillo usando la librería más simple que he encontrado en PHP: OneFile -> OneSQL:

// SELECT * FROM $table WHERE $property $comparator
//                    $value        AND $prop2 $comp2 $val2
function nosql_selectAllFromWhereAnd($table,$property,$comparator,
$value  ,$prop2,$comp2,$val2)

// UPDATE $table SET $prop=$new
//                    WHERE $searchfor=$value         AND $also=$val
function nosql_updateSetWhereEqualsAnd($table,$prop,$new,
$searchfor,$value  ,$also,$val)

// DELETE FROM '$table' WHERE '$property'
//                  $comparator '$value' AND  '$prop' $comp '$val'
function nosql_deleteFromWhereAnd($table,$property,
$comparator,$value,$prop,$comp,$val)

“…te invitamos a la sesión informativa que tendrá lugar en Barcelona el próximo martes 16 de marzo de las 18.30 a las 20.00 horas…”

de un curso online de e-business para empresas, casualmente con los Módulos Propuestos:

• Privacidad.
• Mobile Commerce.
• Métodos de pago electrónico.
• Web Services

Más información »

Aquí he hablado de e-business, servicios web, privacidad y métodos de pago electrónico, es a lo que me dedico habitualmente, a construir tiendas online con pasarelas de pago, gestores documentales con acceso por grupo de usuario y distintos privilegios asi como a diseñar diversos servicios web que ofertan a los clientes operaciones para que puedan integrarlos en sus aplicaciones ya sean para móbiles, web o de escritorio.

Entre los temas que se ha abordado en este blog aún no aparecen los micropagos por sms de lo que hablaré pronto (uno de cada cuatro internautas usa su móvil para acceder a algún servicio de pago según el AECEM-FECEMD). Pero por ahora vamos a centrarnos en las herramientas para empresas, recursos software de los que se dispone actualmente, quizás, primero debamos echar un vistazo al

Y ahora veamos, todos estamos acostumbrados a usar desde los tiempos de las UseNet, grupos de noticias como el de webmasters de la UGR, y ahora ,más o menos recientemente, blogs como Wordpress, redes sociales para relaciones entre empresas como Linked in, pero quizás las compañías estén menos en contacto con herramientas como Skype para comunicarse con los comerciales, en definitiva esta es una lista que nos hace ver Internet como una herramienta empresarial:

• BizLayer: plataforma de tramitación electrónica que ofrece a las empresas una solución global para gestionar sus facturas electrónicamente, abarcando todo el ciclo de vida básico de una factura (emisión, recepción y gestión de estados, ejemplo: efec.cert.fnmt.es )
• Jiibe: una aplicación online donde los usuarios indican cual es su puesto de trabajo y, mediante una serie de preguntas, determinarán desde rotundamente falso a completamente verdadero cada una de ellas, tanto para el trabajo actual como el ideal… jiibe.com
• Mashable -> analizar redes sociales, trabajos líder dentro de redes : jobs.mashable.com
• ActiveCollab-> gestión de projectos y herramienta colaborativa para equipos de gente : activecollab.com
• Mic2000 (ERP) aplicación Cliente/Servidor, pensada para las empresas de cualquier tamaño ->mic2000.com/
• Seresnet: portal cuyo objetivo es la promoción del comercio electrónico entre las PYMES y las grandes empresas del sector de la distribución, desarrollado sobre una plataforma Web que garantiza el funcionamiento y la seguridad de los intercambios comerciales a través de Internet -> www.seresnet.com
• Openbravo: econocido desarrollador de soluciones profesionales en software libre para empresas, que ofrece la primera alternativa real al software propietario para empresas. Su sistema en entorno web de gestión integral de empresas (ERP) y de gestión de punto de venta (PoS), openbravo.com
• agpd.es -> Agencia Española de Protección de datos, más info sobre seguridad: datageston.net
• trackglobe : La nube o Cloud Computing es una tecnología que permite a los usuarios disponer de servicios tecnológicos. Las Soluciones Cloud de TrackGlobe (CloudSite, CloudCommerce y CloudMarketing) le permiten gestionar toda su presencia en Internet sin necesidad de instalar ni actualizar
• b2b 2000: business to business (¿qué es?, ejemplo-> universia & apple): riesgo de monopolizar mercado
• Overlap: desarrollo de equipos humanos e innovación de proyectos comerciales
• Monster.es (empresas) : buscar candidatos, cv’s, contratación y colgar ofertas de trabajo
• elogos.es: oferta de formación y desarrollo de élogos se configura a partir del cliente, de sus necesidades de negocio, entendidas a partir del conocimiento sectorial específico de las áreas de Tecnología de la Información y las Comunicaciones, Sector Financiero, Administración Pública, Industria, Construcción y Energía
• etc.

En este punto y antes de continuar, el esquema que debemos tener en mente es el siguiente:

Para comprender mejor el esquema necesitamos conocer algunos conceptos, pero ¿para qué necesitamos software avanzado de empresas para hacer e-business?…es decir…

¿Para qué sirven las herramientas de software avanzado de e-business?

1. Son aplicaciones para la empresa que siguen el modelo de línea de negocio, de hecho, empresas como Telefónica ya las están utilizando
2. Soporte a operaciones:
   -  Planificación de Recursos de la Empresa (ERP) -> gestión e integración de dichos recursos
   -  Sistemas de Gestión de la Cadena de Suministros: las empresas pueden prever las demandas del mercado, innovar respuestas ante sus volubles condiciones y coordinar las operaciones en todas las redes globales. Oracle SCM proporciona soluciones sectoriales específicas que están basadas en las mejores aplicaciones y abarcan desarrollo de producto, gestión de la demanda, planificación de ventas y operaciones, gestión del transporte y gestión de suministros. Ejemplo: Oracle Supply Chain Management (SCM)
   -  PRM : Gestión de Relaciones entre Socios -> automatización de tareas entre vendedores y canales indirectos. Las sencillas herramientas de PRM ofrecen visibilidad del rendimiento de su canal, y ayudan a gestionar de forma efectiva los socios para hacerlos más productivos y más implicados en el éxito.Aumento de la facturación y cartera de clientes, aumento de vínculos gracias a técnicas de venta cruzada.
   -  OSS – Sistema de Soporte de Operaciones -> para proveedores de Servicios a la hora de implementarlos, ejemplo: Nokia
   - Inteligencia de Negocio : ver más
3. Soporte administrativo y apoyo:
   -  ERM: Gestión de derechos digitales
   -  KM: Gestión del conocimiento
   -  Inmótica -> automatización de edificios corporativos, hoteleros, empresariales y similares para reducir costes y consumo energético (edificios inteligentes)
4. Sistemas comerciales:
   -  BSS -> Sistema de Soporte al Negocio : recopilar información y análisis de datos de clientes (ejemplo banco y el dato entero de arquitectura) -> fijar precios
   
   -  CRM -> mejora la rentabilidad. Es la Combinación de Acciones Estratégicas orientadas a fortalecer las relaciones con los Clientes. Es un proceso integrado de marketing, ventas y servicios dentro de una organización orientado a gestionar el Principal ACTIVO de la Empresa: “La Información de sus Clientes”; con el fin de  Retenerlos y Rentabilizarlos; y todo soportado en la Tecnología de la Información. La Tecnología hace posible este Objetivo, colaborando en mejorar los Procesos Comerciales de Ventas y Servicios al Cliente. Ejemplo.
   SugarCRM.
5. Social Media: incursión de las empresas en las redes sociales …¿Cómo empezar?
6. e-business + TIC (Tecnologías de la Información y la Comunicación): niveles…

Ahora pasaremos a explicar un poco mejor esto de los niveles del punto 5

• Entrada: todo negocio tiene un comienzo, se ha de realizar un estudio de marketing en el emplazamiento sea este virtual o físico antes de lanzarse a la aventura
• Consolidación: una vez realizado el estudio comenzamos con las primeras campañas de productos
• SCM : Sistema de Gestión de Suministros -> en otras palabras, preveer las demandas del mercado una vez consolidado
• ERP: Planificación de recursos de la Empresa:
  - Aplicaciones multi-modulares -> soluciones integrales (a veces), diseñadas para administrar procesos internos del negocio y la optimización de la cadena de valor…apps: factura., contabilidad , compras, producción, transporte, informes de gestión y RRHH
• BI (Inteligencia de Negocio) y KM (Gestión del Conocimiento) vistos anteriormente
• CRM : Gestión de las relaciones con los clientes: anticipar ,conocer y satisfacer las necesidades y los deseos de los clientes:
  - Mantenimiento y satisfacción de la cartera de clientes
  - Búsqueda de servicios personalizados para mantener la lealtad de nuestros clientes y maximizar su valor
  - Búsqueda de procesos de captación de nuevos clientes, mantenimiento de redes sociales, gestión de reclamaciones, tickets (PHP-Ticket), etc.
• Aplicaciones tácticas
  - Datawarehouse: base de datos orientada al apoyo en toma de decisiones, consultas cruzadas de fuentes variadas, como se dijo sobre Bing vs Google en el Congreso SEO de Bilbao 2010-> ver manual
  - DDS : almacenamiento de datos operativos -> datos para Datawarehouse
  - Reporting: fácil acceso a información en los Datawarehouse
  - CRM analítico: estudiar el comportamiento de los clientes y actuar en resonancia
• Aplicaciones estratégicas:
  - EIS: Sistemas de Información para Ejecutivos -> wiki
  – BI (Inteligencia de Negocio) : información disponible de cada departamento para organizarla y procesarla de acuerdo al modelo de la toma de decisiones por medio de los directivos
• Aplicaciones de integración:
  - EAI: Integración de Aplicaciones de Empresa -> Arquitectura tecnológica de la que se puede disponer dentro de la empresa, formas de compartirla, información de fuentes y aplicaciones corporativas heterogéneas…

Resumen de herramientas e-business:

¿Cómo influye la cadena de valor en el e-business?

Porter propuso esta cadena como principal herramienta para identificar fuentes de generación de valor para el cliente, es decir, actividades estratégicas en la empresa ,ya sean:

• Primarias: contribuyen directamente a obtener productos para el consumidor: logística de entrada/salida de materias primas, marketing, servicios de venta y post-venta,etc.
• De soporte: que proporcionan los inputs e infraestructura necesaria para las primarias: la propia infraestructura de la empresa, gestión de rrhh, desarrollo tecnológico, etc.

Por ejemplo, las intranets proporcionan una infraestructura y un significado de las actividades secundarias…

Las empresas pueden crear valor a través de la recogida, organización, selección, resumen y distribución de la información, por lo que pueden aumentar su eficacia si trasladan actividades de la cadena de valor real a la cadena de valor virtual presentada:

Las cuatro fuentes potenciales de creación de valor en el e-business son: la eficacia->aumento de simetrías de información, las sinergías -> verticales(servicios postventa) u horizontales (hardware) conjuntos que proporcionan más valor, la retención -> encontrar motivaciones de compra, innovación -> nuevas formas de estructurar procesos.

Seguramente hay muchas herramientas más disponibles, algún comentario?

En el vídeo se muestran los pasos que hay que dar, sin llegar a profundizar demasiado en los algoritmos: se crea una entrada en la sección de contenidos (expedientes -> asociados) con un enlace a un formulario que previamente habremos creado en la sección de intranet -> formularios gracias al generador de enlaces, y hemos configurado para que sea la tabla asociada a ese formulario la que el algoritmo interno trata con los datos ,generando automáticamente un modelo de datos y las acciones del controlador que permiten la visualización de los datos correctamente.

Se ve también como funciona el generador y todas las funciones asociadas a la gestión de permisos por grupo de usuarios…

El gestor documental además permite la selección de permisos por grupos de usuarios (configurables) para artículos de cada sección además de por operación (crear, mostrar, grabar, editar, borrar,etc)

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

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.

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

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 <b>$wsdl</b>";
$client = new SoapClient($wsdl);
$avail = $client->__getFunctions();
echo '<ul>';
foreach($avail as $func)
{
echo "<li>" . $func . "</li>";
}
echo '</ul>';

echo '<hr><pre>';
echo highlight_string( file_get_contents(__FILE__));
echo '</pre>';

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);

Ver ejemplo funcionando: aquí

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

« Volver al Curso de Servicios Web

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

1. 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.
2. 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 »

CREAR DIRECTORIO DE XML:

1. Dentro de las propiedades del Proyecto Java Web “Excalibur” en la categoría de Sources  -> Package Folder -> Add Folder -> creamos el directorio “XML” dentro de “src” y de etiqueta (label) ponemos “XML”. Aquí vamos a colocar nuestros ficheros WSDL para ver como se construyen servicios web a partir de estos, pero primero el método sencillo…ahora se puede añadir al esquema de forma gráfica cualquier dato y se formatea por el sistema ,podemos crear un servicio web a partir del fichero…

CREAR SERVICIO WEB

1. En el paquete “es.ugr.battlegalactica.servicios” -> botón derecho  -> New -> Web services -> Web Service -> “construccionNexus”. Añadir el constructor de la clase y la variable estática Nexus nexus de ésta clase, que se incializa en dicho constructor…

CREAR OPERACIÓN PARA AÑADIR UN USUARIO CON SUS PILOTOS Y SUS NAVES ASOCIADAS

1. Segundo botón en el código dentro de la clase “construccionNexus” -> “Insert Code…” -> “Add Web Service Operation” -> le llamamos “crearUsuarioConPilotosYnaves”
2. En return type (tipos devueltos) ponemos java.lang.Long y así, si es -1 ha ocurrido un error y en otro caso es el ID del nuevo usuario
3. Para los parámetros necesitamos que tenga: un nombre y password de usuario,un nombre de piloto  y un nombre de nave; por lo que empezamos por añadir el primer campo con name: “datos_usuario” , type: Choose -> find type -> buscamos “usuario” y seleccionamos el del modelo de datos de BSGModelo, ahora hacemos lo propio para “datos_piloto” -> Piloto y “datos_nave” -> Viper. Pinchamos en “OK” y se genera el código en Java, sólo hemos de meter los datos correspondientes que nos pasa tan amablemente el servicio web a la base de datos de Nexus ,tal como hacíamos en Prueba.java…
   la función de la operación debe quedar así:

   @WebMethod(operationName = "crearUsuarioConPilotosYnaves")
   public Long crearUsuarioConPilotosYnaves(@WebParam(name = "datos_usuario")
   Usuario datos_usuario, @WebParam(name = "datos_piloto")
   Piloto datos_piloto, @WebParam(name = "datos_nave")
   Viper datos_nave) {
   
   if (nexus.obtenerUsuario(datos_usuario.getUsuario())!=null ){
   //El usuario ya existe, salir!
   return new Long(-1);
   }
   
   //Añadir Viper
   Viper v  = null;
   try { //Buscar viper:
   v = nexus.obtenerViper(datos_nave.getNombre());
   } catch (ViperNoEncontradoException ex){
   //La nave no existe, la añadimos
   v = new Viper(datos_nave.getNombre());
   v.setArmamento(datos_nave.getArmamento());
   } finally {
   //En otro caso, la nave es la misma?
   if (!v.getId().equals(datos_nave.getId())){
   //No es la misma, error
   return new Long(-1);
   }
   }
   
   //Añadir piloto:
   Piloto p = null;
   try {
   p = nexus.obtenerPiloto(datos_piloto.getId());
   } catch (PilotoNoEncontradoException ex){
   //NO Existe el piloto, crearlo
   p = new Piloto(datos_piloto.getNombre(), datos_piloto.getDestreza(),
   v.getId());
   nexus.guardarPiloto(p);
   } finally {
   //El piloto existe, tiene la misma ID?
   if (!p.getId().equals(datos_piloto.getId())){
   return new Long(-1);
   }
   }
   ArrayList<Long> lista_pilotos = new ArrayList<Long>();
   lista_pilotos.add(p.getId());
   
   //Añadir el usuario con los datos almacenados ya en Nexus:
   Usuario u = new Usuario(
   datos_usuario.getUsuario(),
   datos_usuario.getPassword(),
   lista_pilotos );
   
   nexus.guardarUsuario(u);
   
   return u.getId();
   }
   

   Para probarla primero hacemos click con el segundo botón del ratón en el proyecto Excalibur > Deploy ,esto instalará la aplicación web con la nueva operación compilada, ahora vamos a la lista de servicios web y pulsamos en test Web Service, ya podemos añadir usuarios con un piloto y una nave

CREAR OPERACIÓN PARA HACER UN LOGIN CON USUARIO Y PASSWORD

1. Una vez creado un usuario en la base de datos la función para hacer un login es tan simple como esta:

   @WebMethod(operationName = "hacerLogin")
   public String operation(@WebParam(name = "usuario")
   String nombre_usuario, @WebParam(name ="password") String contrasena) {
   //TODO write your implementation code here:
   Usuario u = nexus.obtenerUsuario(nombre_usuario);
   if (u==null) return "El usuario no existe";
   else if (u.getPassword().equals(contrasena)){
   return "Acceso concedido";
   } else {
   return "Contraseña inválida";
   }
   }
   

   Recordar que para testear los servicios podemos hacerlo en SOAP UI:
   

CREAR OPERACIÓN PARA OBTENER UN LISTADO DE USUARIOS

1. Es simplemente crear un listado a partir de recorrer el array de estos y devolverlo para que lo analice sintácticamente el sistema y devuelva la construcción XML correspondiente:

   public List<Usuario> listadoUsuarios() {
   List<Usuario> listado = null;
   for (Iterator<Usuario> iter = nexus.listarUsuarios(); iter.hasNext(); ){
   listado.add(iter.next());
   }
   return listado;
   }
   

Buenas prácticas de programación: Los servicios web son un tipo de comunicación, añadir lógica de programación resulta en algo no-generalizable y por lo tanto ,no reutilizable. Resumiento: hay que hacer una conversión de los datos de un modelo de datos en un modelo de datos de un servicio web,i.e.,las clases con su lógica de programación en Java a un modelo del servicio y luego el paso inverso. Entre medias están las páginas web u otros clientes que los utilizan con su propia lógica. Por ello se recomienda diseñar los servicios web lo último, cuando ya tenemos todo lo que necesitamos en cuanto a datos y lógica interna con ellos, separar cada fichero WSDL para cada servicio es recomendable por si necesitamos cambiar algo y nos cuesta menos trabajo.

CREAR CLIENTES PARA CONECTARSE A LOS SERVICIOS WEB

1. En el proyecto “Excalibur” creamos el paquete “es.ugr.battlegalactica.servicios” y dentro de este -> segundo botón del ratón-> New -> Other -> Web Services -> Web Service Client -> seleccionamos del proyecto “Excalibur” el Servicio Web “construccionNexus” -> OK ; y ahora en package ponemos “es.ugr.battlegalactica.clientes”. Esto debe crearnos todas las clases Java para comunicarse con las operaciones del Servicio Web. Pero para saber que funcionan usamos un JUnit Test , creamos un paquete llamado “es.ugr.battlegalactica.clientes” y dentro un nuevo JUnit Test para clases existentes, elegimos la clase a testear y hacemos como en la primera lección las unidades de prueba.

< Volver al curso de Arquitectura de Servicios Web con JAVA y PHP

Glassfish es el servidor de aplicaciones Web de Sun, como hay que crear un “dominio” dentro del servidor de aplicaciones y esto consume muchos recursos no se utiliza en máquinas convencionales ya que el coste de implementación de un servidor de dominios puede ser demasiado elevado por la carga que supone dicha tarea a pesar de que se puede implementar sobre Apache.

Si instalamos la última versión de Netbeans con Glassfish podemos pasar directamente a la sección de Crear el Modelo de datos al que acceder desde Servicios Web

Podemos configurar nuestro dominio tanto con la consola como dentro de NetBeans, usando la interfaz de usuario. Vamos a ver cómo se hace de las dos formas, primero con la consola:

1. Descargar Glassfish: aquí e instalar con el comando:
   java -Xmx256m -jar glassfish-installer-v2.1.1-b31g-windows.jar
   y ahora, entrar en el directorio glassfish, establecer las variables de entorno JAVA_HOME a vuestro directorio de instalación JDK y lo mismo para PATH añadiéndole el directorio de glassfish,  entonces ejecutamos el comando:
   lib\ant\bin\ant -f setup.xml
   desde el directorio de glassfish.
2. Ir a la herramienta de administración por consola del servidor, está en:
   glassfish/bin/asadmin.bat
   ahora vamos a crear un dominio mediante la instrucción (en la consola del server):
   create-domain –user nombre_usuario_admin –adminport numero_puerto nombredominio
   en nuestro caso usaremos el dominio Excalibur con usuario root y el puerto 6666:
   create-domain –user root –adminport 6666 excalibur
   esto debe de tardar un poquito, se habrá creado un directorio para el dominio en glassfish/domains/excalibur,y ahora,  justo después, “levantaremos” el dominio en el servidor con la instrucción:
   start-domain excalibur
3. Ahora podréis hacer uso de la dirección http://localhost:6666 con los datos de usuario para administrar el server. Podéis pararlo con stop-domain.
   Sólo os diré que en mi máquina,al cargar el servidor y crear el dominio, me empezó a consumir su proceso 30MB de RAM,tras iniciar dicho dominio ya iba por 178MB y subiendo…imaginaos un servidor de decenas o cientos de dominios en memoria…más de 900MB pasa perfectamente…y además, esto en un servidor IBM es normal para un único proceso.

Después de trabajar en lecciones anteriores con NetBeans, ya deberíamos conocer las ventajas de utilizar este IDE …

1. Arrancar NetBeans, ir a la pestaña de Servicios -> Servidores -> Segundo botón del ratón -> añadir servidor ->
   si os dá un error o no sale ninguna ventana necesitáis actualizar vuestra versión del JDK de Java y reinstalar la última versión de NetBeans que trae una versión de Glassfish 3. Servidores  -> iniciar -> http://localhost:4848/
2. Para comprobar que el servidor está funcionando vamos a crear un nuevo proyecto de tipo Java web -> Web Application -> compilar y Ejecutar ,en el navegador debe aparecer un “Hola Mundo”

Ahora vamos a aprender cómo se crean servicios web que utilicen complejas estructuras de datos así como colecciones y anotaciones,  reutilizables, desde distintos clientes que realicen las operaciones desde JAVA o PHP. También aprenderemos a definir un fichero WSDL para crear un servicio ,ambas cosas con Netbeans y usaremos JAX-WS para construir los clientes automáticamente, es decir, el cliente del servicio web (programa que lo usa desde la máquina de un usuario que se conecta a los servicios de un servidor) traduciendo los mensajes que se comunican por el protocolo SOAP.

Crear el Modelo de datos para Servicios Web (Web services) con Java en Netbeans

Resumen de lo que vamos a hacer: crear un servicio web para registrar (en nuestro modelo de datos) usuarios, pilotos y naves en la base de datos de la clase que implementa el computador…recordar el proyecto BSGModelo…

Gracias a una clase llamada administracion que crea los usuariosse le asocia un piloto y a éste una nave (viper), todo esto queda almacenado en el modelo de datos del computador Nexus que se ejecuta sobre el servidor Excalibur (glassfish) y que lanza excepciones construidas por nosotros al nivel de aplicaciones y servicios web.

Abrir el proyecto de la lección 2: BSGModelo y haremos lo siguiente:

1. Ya que todo servicio se construye a partir de un Proyecto Web, vamos a crear un nuevo proyecto web: File -> New Project -> Java Web -> Web Application , nombre: “Excalibur”, para que podamos almacenar datos y confeccionar asociaciones entre el proyecto BSGModelo y el proyecto de Aplicación Web con Servicios llamado “Excalibur” vamos a este proyecto -> segundo botón en “Libraries” -> Add Project -> seleccionar BSGModelo y Add Project JAR files.
2. Ahora vamos a modificar el proyecto “BSGModelo”, “en es.ugr.battlegalactica.modelos” -> botón derecho -> New -> Java Class -> nombre: “Usuarios”, como tenemos que asociar los vipers y los pilotos, debemos cambiar primero la clase pilotos para meter dentro una lista de vipers, crear en usuarios una lista de pilotos en la clase usuarios y luego añadir una lista de usuarios en nexus. El código ha quedar así:
   

   Descargar BSGModelo_usuarios.

   Para que probemos todos estos cambios, hemos hecho cambios a la función Main de la clase Prueba.java:

   /*
   * Web 2.0: Arquitectura Orientada a Servicios en Java
   * Primer Modelo: BSGModelo con la clase Prueba
   * @author Juan Belón Pérez
   */
   
   package es.ugr.battlegalactica;
   
   import es.ugr.battlegalactica.modelo.Elemento;
   import es.ugr.battlegalactica.modelo.Nexus;
   import es.ugr.battlegalactica.modelo.Piloto;
   import es.ugr.battlegalactica.modelo.Usuario;
   import es.ugr.battlegalactica.modelo.Viper;
   import es.ugr.battlegalactica.modelo.excepciones.NoHayArmamentoException;
   import es.ugr.battlegalactica.modelo.excepciones.PilotoNoEncontradoException;
   import es.ugr.battlegalactica.modelo.excepciones.ViperNoEncontradoException;
   import java.util.ArrayList;
   import java.util.Iterator;
   
   /**
   * Clase con los 3 primeros ejercicios propuestos
   * @author Juan Belón Pérez
   */
   public class Prueba {
   private static ArrayList<Elemento> elementos;
   private static ArrayList<Piloto> pilotos;
   private static ArrayList<Viper> vipers;
   private static Nexus nexus;
   /**
   * Función principal.
   * Imprime por pantalla un mensaje fijo.
   *
   * @param args la linea de argumentos del programa
   */
   public static void main(String[] args) throws NoHayArmamentoException, PilotoNoEncontradoException, ViperNoEncontradoException {
   System.out.println("Prueba del modelo de datos BattleStarGallactica");
   /*crear dos elementos e imprimir sus identificadores en la consola.
   Si todo ha ido bien se deberían escribir los identificadores 1 y 2*/
   init();
   System.out.println("Prueba de creación de elementos:");
   for (Elemento e: elementos){
   System.out.printf("%d,",e.getId());
   }
   System.out.println("\nPrueba de creación de pilotos:\n");
   for (Piloto p: pilotos){
   System.out.printf("ID:%d,Nombre:%s,Destreza:%d\n",p.getId(),p.getNombre(),
   p.getDestreza());
   }
   System.out.println("\nPrueba de creación de vipers:\n");
   for (int i=0; i<4; i++){ //Disparar 4 veces con todos los vipers:
   for (Viper v: vipers){
   System.out.printf("#%d# Disparando con el viper ID:%d,Nombre:%s," +
   "Armamento:%d\n",(i+1),v.getId(),v.getNombre(),v.getArmamento());
   try {
   v.disparar();
   } catch (NoHayArmamentoException e){
   System.err.println("\n\tError al disparar:"+e.getMessage()+"\n");
   }
   System.out.printf("\tEl nuevo armamento del viper con ID:%d y Nombre: %s"+
   " ahora tiene %d unidad/es\n",
   v.getId(),v.getNombre(),v.getArmamento());
   }
   }
   System.out.println("\nPrueba de creación de Nexus con Pilotos:\n");
   Iterator<Piloto> iter_piloto = nexus.listarPilotos();
   Piloto aux_piloto = null;
   while (iter_piloto.hasNext()){
   aux_piloto = iter_piloto.next();
   System.out.printf("Piloto %s, ID:%d\n", aux_piloto.getNombre(),
   aux_piloto.getId());
   }
   System.out.println("\nPrueba de creación de Nexus con Vipers:\n");
   Iterator<Viper> iter_viper = nexus.listarVipers();
   Viper aux_viper = null;
   while (iter_viper.hasNext()){
   aux_viper = iter_viper.next();
   System.out.printf("Viper %s, ID:%d\n", aux_viper.getNombre(),
   aux_viper.getId());
   }
   if (aux_piloto!=null){
   System.out.println("\nPrueba de búsqueda (el último:" +
   aux_piloto.getId()+") de Pilotos en Nexus:\n" +
   nexus.obtenerPiloto(aux_piloto.getId()).getNombre());
   }
   if (aux_viper!=null){
   System.out.println("\nPrueba de búsqueda de Vipers (el último:"+
   aux_viper.getId()+") en Nexus:\n" +
   nexus.obtenerViper(aux_viper.getId()).getNombre()
   );
   }
   
   System.out.println("\nComprobar que se generan las excepciones "+
   "buscando un Piloto falso:23\n");
   try {
   aux_piloto = nexus.obtenerPiloto(new Long(23));
   } catch (PilotoNoEncontradoException ex){
   System.err.println("\n\t"+ex.getMessage());
   }
   System.out.println("\nComprobar que se generan las excepciones "+
   "buscando un Viper falso:23");
   try {
   aux_viper = nexus.obtenerViper(new Long(23));
   } catch (ViperNoEncontradoException ex){
   System.err.println("\n\t"+ex.getMessage());
   }
   
   try {
   Usuario usuario = nexus.obtenerUsuario("juaxix");
   System.out.println("\nCreación de un usuario ("+
   usuario.getUsuario() + " con piloto: " +
   
   (nexus.obtenerPiloto(
   usuario.getPilotos().get(0)
   ).getNombre()) + " y viper asociado a este piloto: "+
   nexus.obtenerViper(
   nexus.obtenerPiloto(
   (nexus.obtenerUsuario(usuario.getId()).getPilotos().get(0))
   ).getNaves().get(0)
   ).getNombre()
   );
   System.out.flush();
   } catch (PilotoNoEncontradoException ex){
   System.err.println("\n\t"+ex.getMessage());
   /* } catch (ViperNoEncontradoException ex){
   System.err.println("\n\t"+ex.getMessage());*/
   } catch (Exception ex){
   System.err.println("\n\tNEXUS LOG:"+ex.getMessage());
   }
   }
   /**
   * Inicializador de elementos, pilotos, vipers y Nexus (vipers
   * , pilotos y usuarios)
   */
   private static void init(){
   Viper v_aux;
   elementos = new ArrayList<Elemento>();
   pilotos   = new ArrayList<Piloto>();
   vipers    = new ArrayList<Viper>();
   nexus     = new Nexus();
   elementos.add(new Elemento());
   elementos.add(new Elemento());
   
   v_aux = new Viper("Trueno");
   v_aux.setArmamento(4);
   vipers.add(v_aux);
   
   pilotos.add(new Piloto("Migue",120,v_aux.getId()));
   v_aux = new Viper("Rayo");
   v_aux.setArmamento(4);
   vipers.add(v_aux);
   pilotos.add(new Piloto("Sara",110,v_aux.getId()));
   
   //INTRODUCIR DATOS EN NEXUS:
   v_aux = new Viper("Trueno");
   v_aux.setArmamento(4);
   nexus.guardarViper(v_aux);
   Piloto juax = new Piloto("Juax",130,v_aux.getId());
   nexus.guardarPiloto(juax);
   
   v_aux = new Viper("Fuego");
   v_aux.setArmamento(5);
   nexus.guardarViper(v_aux);
   nexus.guardarPiloto(new Piloto("Jesús",130,v_aux.getId()));
   //Creación de un usuario en Nexus:
   ArrayList<Long> lista_pilotos_usuario = new ArrayList<Long>();
   lista_pilotos_usuario .add(juax.getId());
   Usuario usuario = new Usuario("juaxix" /*nombre usuario*/
   , "juaxix" /* password */
   ,lista_pilotos_usuario /* lista de ids de pilotos asociados */
   );
   nexus.guardarUsuario(usuario);
   
   }
   
   }
   

   La idea del modelo de datos es parecida a un modelo de cajas:
   
   La nueva línea que ha de mostrar la ejecución de esta clase (el proyecto BSGModelo) es:

   “Creación de un usuario (juaxix con piloto: Juax y viper asociado a este piloto: Trueno”

3. Para usar los servicios, creamos un nuevo paquete, en el proyecto Java Web llamado “Excalibur” ->  “Source Packages” -> botón derecho -> New -> Java Package -> llamado “es.ugr.battlegalactica.servicios”.

Continuar >

< volver al Curso de Arquitectura de Servicios Web con JAVA + XML + PHP

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:

1. Dispondremos primero de un editor: SOAP UI ,descargar e instalar
2. 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

3. 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 “?”
4. 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:
   
5. 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…
6. 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:

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

4. 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)…
5. 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
   
   }
   

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

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

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<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 -> 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() {
}

}

[/source]

Creamos una clase de excepciones para la clase Piloto, en este caso para cuando se intenta encontrar un Piloto que no existe:
[sourcecode lang="java"]
/*
* Web 2.0: Arquitectura Orientada a Servicios en Java.
* Introducción a JAVA
* CLASE PARA EXCEPCIONES DEL MODELO Piloto -> 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 -> 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<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 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<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<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>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>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í:

   /*
   * To change this template, choose Tools | Templates
   * and open the template in the editor.
   */
   
   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() {
   /*  System.out.println("main");
   String[] args = null;
   Prueba.main(args);
   // TODO review the generated test code and remove the default call to fail.
   fail("The test case is a prototype.");*/
   }
   
   /**
   * 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.

1. Instalación y configuración de NetBeans para creación de servicios Java
2. 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.
3. Conceptos básicos de la comunicación entre aplicaciones mediante servicios: XML, XML-RPC, SOA, RSS, SAX, DOM, JDOM y WSDL
4. 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
   
5. Creación del conjunto de servicios web (cloud computing) que utiliza el modelo de datos del punto 4
6. Tutorial de PHP e iniciación a la creación y comunicación con servicios web usando WSDL
7. BPEL y OpenESB: Orquestación de Servicios Web

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

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

En este caso vamos a echar mano del framework de la empresa Zend que casualmente se utiliza en Magento como base y alguna otra tienda ( soloprecios.es ) también,… este artículo de la zona de programadores de Zend Framework, nos recomienda primero echar un vistazo al manual para escribir una extensión…, en este punto, quizás , os decantéis por olvidaros de Zend y queráis echar un vistazo a la herramienta que usan en Facebook: HiHop, sinceramente os recomiendo leer  los informes de las unidades de prueba realizadas por Sebastian Bergmann primero.

En el artículo de paulosman, se explica cómo configurar el makefile (para compilar C++) para que se incluya la extensión de PECL con phpize , además es tan apañao que incluye incluso una macro para hacer la llamada a la función ZEND_GET_MODULE() que necesita el framework para asociar la clase con PHP, tras realizar estos pasos podemos usar :

 php -d"extension=nombre_de_mi_extension.so" -m

para añadir la extensión recién compilada (tras usar phpize y make) a Apache u otro servidor (con Zend) ,ahora que tenemos el esqueleto básico de dicha extensión cargada en el servidor, el sistema de construcción de PHP sabe que tiene que compilar las clases C++ (definidas e implementadas fuera de la extensión) que se sincronizarán por medio de los objetos en C++ de Zend y la función externa ZEND_GET_MODULE(nombre_de_mi_extension)

¿Alguna duda?, aquí estamos…

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

El diseño XHTML+CSS+FLASH de la página es de Agencia Q4.

En el vídeo se muestra el funcionamiento de Magento tanto como cliente como administrador de la tienda, se tradujo a través de la administración interna el texo a inglés ya que en el año 2007 no existían muchos colaboradores que contribuyeran al proyecto.

Se pueden ver como se puede configurar las categorías que se deben mostrar primero, la galería de imágenes y la administración de contenidos : proyectos e información del estudio.

1. Introducción
2. Implementación de un caso real
3. Resultados
4. Conclusiones
5. Comentarios
6. Futuro: la web 3d

INTRODUCCIÓN C/C++ A TRAVÉS DE PHP:

He estado investigando después de leer una noticia enviada por WebGranada que decía que los chicos de Facebook han hecho una herramienta que transforma el código de PHP a C++ y que al realizar las tareas con lenguaje de la máquina (bajo nivel),como es lógico ,es más rápido ,sin embargo, me preguntaba hasta que punto es más rápido…como no he visto nada serio que me convenza me he decidio por hacer mis propias pruebas con este tipo de construcción de webs a través de lenguaje C/C++ en lugar de PHP, e incluso escribir el código en PHP y pasarlo a C++…

De hecho, esto ya existía desde hace tiempo,…cualquiera puede implementar una herramienta como: The PHP to C++ Translation tool…que no es más que un programa en C++ que analiza sintácticamente un programa en PHP y lo pasa a C++ para que se pueda compilar y colgar en el servidor , por ejemplo la plataforma SWAD está escrita en este lenguaje y la especificación CGI…pero lo difícil es hacerlo bien, como casi siempre jeje

El debate que existe en Internet, ronda, en parte, a la cuestión de que no se va a conseguir una verdadera experiencia de mejora de velocidad en cuanto a interacción y carga de páginas, sobre todo en las que no tienes más de un número máximo, digamos, de más de miles de usuarios…ni tampoco, a la hora de conectarse a la base de datos ya que es algo que no suele mejorarse demasiado de una tecnología a otra ,no más de un 20%…

Sí que se notará cuando se realicen búsquedas y otras operaciones complejas con los datos ya que un programa en C++ está optimizado en memoria mucho más que PHP,siempre y cuando el programador haya llevado cuidado a la hora de escribir el código…además, al funcionar PHP como un módulo (extensión) del Servidor (por ejemplo Apache), tiene sus propios límites de memoria y ciclos de ejecución, darle los datos de entrada a un programa en C++ y que realice tareas complejas es más eficiente según qué casos…

IMPLEMENTACIÓN DE UN CASO REAL

Aquí propongo un ejemplo sencillo para demostrar en qué casos es mejor C++ que PHP, para empezar, si queremos ir probando todo lo que vamos haciendo, podemos crearnos un directorio en nuestro servidor llamado  “c++”, recordar añadirlo al .htaccess:
RewriteRule ^c\+\+(.*) – [PT]
…para que Apache no procese ese directorio con otra regla, (si le ponemos un password mejor)…ahora, un script sencillo para ejecutar programas como si estuviéramos en una consola:
shell.php:

<html>
<head>
<script type="text/javascript">
function loadXML(_cmd) {
url="/c++/shell_exec.php";
if (window.XMLHttpRequest) {
// codigo para IE7+, Firefox, Chrome, Opera, Safari
xmlhttp=new XMLHttpRequest();
} else {// para IE6, IE5
xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
}
xmlhttp.open("GET",url+"?cmd="+_cmd,false);
xmlhttp.send(null);
document.getElementById('test').innerHTML=xmlhttp.responseText;
if (document.frmT.b.checked)
document.frmT.cmd.value="";
document.frmT.cmd.focus();
}

</script>
<title>Exec</title>
</head>

<body>

<div id="test">
<h2>CONSOLA</h2>
</div>
<form name="frmT" onsubmit="loadXML(document.frmT.cmd.value); return false;">
<input type="text" name="cmd" />
<input type="checkbox" name="b" value="1" id="b"><label for="b">Borrar</label>
</form>
<button type="button" onclick="loadXML(document.frmT.cmd.value); return false;">run</button>
</body>
</html>

Este código llamará, usando el truquito AJAX, al siguiente fichero PHP (ojo!: más peligroso):

shell_exec.php

$t = trim($_GET['cmd']);
if (empty($t)) die("Escribe un comando chatin");

echo $_GET['cmd']."<br>";
echo str_replace("\n","<br>",passthru($_GET['cmd']));

Ahora podemos utilizarlo invocando directamente la URL:

Ya podemos probar nuestros programas en C++ subiéndolos y compilándolos online (si nuestro servidor tiene gcc), o bien, haciendo una llamada al programa compilado directamente por nosotros en local…Para los que son más de Windows, podéis instalar cygwin y descargar las librerías para hacer compilaciones de Linux: crosscompilers for cygwin (existe una versión para 64bits de las librerías), descomprimiéndolas en el directorio cygwin para poder llamar a g++-linux, por Ejemplo para compilar The PHP to C++ Translation tool:

$ g++-linux -o php2cpp php2cpp.cpp

No debe de darnos ningún error o advertencia…ahora podemos usar el comando desde el servidor para pasar un fichero en lenguaje php a un fichero en lenguaje C++ mediante:

./php2cpp entrada.php salida.cpp

de nuevo debemos compilar la salida para obtener un binario…

$g++-linux -o salida salida.cpp

Una vez que tenemos los binarios podemos usar la consola improvisada en el navegador, para dar permisos de ejecución a aquellos mediante
chmod 750 salida

Y entonces podemos cargar el programa desde el servidor como antes (una vez subido,claro)
./salida

Un ejemplo básico de C,sería una búsqueda binaria de datos,por ejemplo de triadas de vértices (x,y,z) de un conjunto de polígonos, dentro de un conjunto mayor,pero para no complicarnos, usaremos un array unidimensional, de valores dobles, un código como el siguiente nos vale:

#include <stdio.h>
#include <time.h>
#define tamanio 500
int busquedaBinaria(double *matrizOrdenada, int primero,
int ultimo, double llave);

int main ()
{
clock_t t_antes,t_despues;
double t,aux;
int i,k;
srandom(time(0));

for (k=1000; k<=3000; k+=1000){
t_antes = clock();
double *m =  malloc (sizeof(double)*tamanio*k);
for (i=0; i<tamanio*k; i++) {
m[i] = (double) (rand()%1000)+1;
}

aux = busquedaBinaria(m,0,tamanio*k,m[(int) (tamanio*k)/2]);
free(m);
t_despues = clock();
t = (((double)(t_despues - t_antes)) / CLOCKS_PER_SEC);
printf("<br><h1>%f</h1>segundos",t);
}
return 0;
}

/**
* @brief function busquedaBinaria:
*     Busca desde matrizOrdenada[primero]..matrizOrdenada[ultimo] por llave.
*  @returns: indice del elemento encontrado, la llave,
*          en otro caso -(indice donde se puede insertar)-1.
*  @param int matrizOrdenada array de sorted (ascending) values.
*  @param int primero
*  @param int ultimo
*  @llave double llave
*  @return int
*/
int busquedaBinaria(double *matrizOrdenada, int primero,
int ultimo, double llave) {
while (primero <= ultimo) {
// calcula el punto medio
int mid = (primero + ultimo) / 2;
if (llave > matrizOrdenada[mid])
// repite la busqueda si no esta en la mitad
primero = mid + 1;
else if (llave < matrizOrdenada[mid])
// repite la busqueda en la otra mitad
ultimo = mid - 1;
else // encuentra el item, lo devuelve
return mid;
}
// no encontrado
return -(primero + 1);
}

Para compilar con gcc…

Ahora el mismo programa compilado con gcc, pero en PHP:

o2.php:

srand(null);
$tamanio = 500;
for ($k=1000; $k<=3000; $k+=1000){
$t_antes = microtime(true);
$m =  array();
for ($i=0; $i<$tamanio*$k; $i++) {
$m[i] = doubleval(rand(1,1000));
}
$aux = busquedaBinaria($m,0,$tamanio*$k,
$m[($tamanio*$k)/2]);
unset($m);
$t_despues = microtime(true);
$t = $t_despues - $t_antes;
printf("<br><h1>%f</h1>segundos",$t);
}

/**
* @brief function busquedaBinaria:
*     Busca desde matrizOrdenada[primero]..matrizOrdenada[ultimo] por llave.
*  @returns: indice del elemento encontrado, la llave,
*          en otro caso -(indice donde se puede insertar)-1.
*  @param int matrizOrdenada array de sorted (ascending) values.
*  @param int primero
*  @param int ultimo
*  @llave double llave
*  @return int
*/
function busquedaBinaria(&$matrizOrdenada,
$primero, $ultimo, $llave) {
while ($primero <= $ultimo) {
$mid = ($primero + $ultimo) / 2;  // calcula el punto medio
if ($llave > $matrizOrdenada[$mid])
$primero = $mid + 1;  // repite la busqueda si no esta en la mitad
else if ($llave < $matrizOrdenada[$mid])
$ultimo = $mid - 1; // repite la busqueda en la otra mitad
else
return $mid;     // encuentra el item, lo devuelve
}
return -($primero + 1);    // no encontrado
}

RESULTADOS

Resultados C/C++:

Resultados PHP:

He elegido las búsquedas ya que estas operaciones de ordenación, concatenación de cadenas, etc. son más rápidas que en PHP y se pueden ver en los resultados.

Gráficas:

La gráfica muestra la diferencia de eficiencia entre C/C++ y PHP a la hora de ejecutar algoritmos complejos de búsqueda y ordenación…

Esta gráfica corresponde al benchmark entre C++ y PHP: tiempo usado, memoria usada ,código usado versus velocidad y tamaño comparando los programas más rápidos de PHP

CONCLUSIONES

Después de saber que C y C++ es mucho más rápido que PHP para manejar la memoria y realizar operaciones complejas como algoritmos de ordenación, podemos consultar algunas webs que han hecho análisis más profundos y sacan sus propias conclusiones al respecto:

• C++ vs Java vs Python vs Ruby : la primera impresión, analiza como he hecho yo, un programa en todos estos lenguajes añadiendo Java, Ruby y Python,realizando comparativas de lo mejor y lo peor de cada uno, por ejemplo la poca información de Ruby a la hora de mostrar errores en tiempo de ejecución y compilación, o los requerimientos de cada sintaxis, para poder hacer un programa, que hace que baje el tiempo de producción de una solución por ejemplo teniendo que recordar que en Python hay que escribir “self” y aumente el coste del proyecto…acaba concluyendo que Java es más productivo que C++ pero nomás que Ruby o Python que además tienen un código más bonito…, mencionando que depende de nuestros conocimientos de estos dos últimos la curva final,…como colofón, los comentarios [flame!]
• Tamaño y velocidad: una serie de análisis de lenguajes: este es uno de esos análisis de titanes, compara cualquier lenguaje, como si de un comparador de móviles o coches se tratara, dando datos y gráficas de las estadísticas de ejecución, además provee de enlaces con los ficheros con los que se realizaron las pruebas.

Como conclusión personal, pienso en C siempre que necesite un algoritmo que consuma mucho tiempo o mucho espacio en memoria del servidor, por supuesto, este tipo de programas se usan en empresas para realizar diversas operaciones…si bien, no está mal recordar que si lo que necesitamos en un listado de productos con condiciones únicas podemos utilizar un algoritmo de C o C++ embebido en PL/SQL tal como dicta el manual de Oracle…

¿Casos reales? Por ejemplo, se podría implementar un algoritmo para una búsqueda en una red social como Badoo.com, si necesitamos encontrar todas las personas con los ojos azules, aplicarle a la primera foto de cada contacto un algoritmo, primero con el comando wget() (o con PHP) nos descargamos la imagen o un rango de ellas, a un directorio de caché, llamamos al programa en C++ (exec() ,CGI, o lo que sea) que analiza la/s foto/s y nos dá una probabilidad de que los ojos azules se encuentren en ella y basándose en estos datos, marcar el perfil de la persona pasado al script como apto para añadirlo a la lista de candidatos de nuestra base de datos…esto en PHP podría tardar pues…imaginaos jaja

FUTURO: LA WEB 3D

Ni que decir tiene que el futuro nos depara webs en 3D programadas en C++ o las generaciones siguientes a este como LUA que transforma internamente el código a C++…y esto amigos, si que se nota comparado con un applet de Java :]

Abrir grecia del futuro

COMENTARIOS

De hecho existen algoritmos que estudian su probabilidad de éxito en el marketing…no es nada descabellada la idea

Es la hora de comentarme o insultarme, lo que más os guste o lo que más rabia os de

En este caso analicé anoche Badoo,una web de contactos escrita en AJAX y conseguí una única línea en JavaScript con la que puedes hacer un robot para votar a todas las personas sin restricciones de ningún tipo aprovechando un bug…

El vídeo (música de Helloween):

La potencia de FireBug

El ritmo que se consigue de votación es cada vez más vertiginoso a medida que voy obteniendo nuevos métodos para saltar de un perfil a otro hasta que consigo dar con un objeto en el árbol DOM que está conectado a toda la estructura y al que se le puede llamar directamente.

En esta web se captura el click en cualquier sitio, de forma que sólo permite el evento click en los objetos registrados, así pueden controlar la actividad completa de un usuario, la línea que permite acceder al evento click sería

$e._handlers.cl.meet_yes[0](el)

donde $e es un objeto que guarda todos los manejadores y enlaces a los objetos, _handlers todos los manejadores, cl las funciones que manejan los objetos de la interfaz registrados y meet_yes el conjunto de botones “Sí | Quizás | No”, si se sigue la traza del sí perfilando la web con el profiler de firebug encontramos que finalmente llama a la función vote que es lo único que nos interesa, ya que no tiene sentido regenerar el evento click ya que necesitaríamos construir un objeto válido con los parámetros del botón necesarios (que no se especifican) por lo que podría costarnos mucho trabajo así que llamamos a la votación indicándole que el objeto DOM es el botón “Sí”:

MeetMe.vote(document.getElementsByClassName(“meet_yes”)[0])

Ahora podemos embeber dicha línea dentro de una función para hacerla compatible con el modo de trabajar con prototipos de JavaScript:

function votar() {MeetMe.vote(document.getElementsByClassName(“meet_yes”)[0])}

y nuestro robot sería tan sencillo como este:

setInterval(“votar()”,1000);

cada segundo vota, así podeis dejarlo,si tenéis una mejor conexión podeis reducirlo a la mitad, recomiendo poner 5 segundos y meter el setInterval dentro de la función, podéis usar el fichero de ejemplo hacks_badoo.js

Supongo que arreglarán este bug…