Professional Documents
Culture Documents
TITULO
ANALISIS COMPARATIVO DE LAS PLATAFORMAS J2EE Y .NET APLICADO
AL DESARROLLO DE SERVICIOS WEB
PAMPLONA COLOMBIA
NOVIEMBRE DE 2008
UNIVERSIDAD DE PAMPLONA
FACULTAD DE INGENIERIAS Y ARQUITECTURA
DEPARTAMENTO DE INGENIERIAS ELÉCTRICA ELECTRÓNICA SISTEMAS Y
TELECOMUNICACIONES
PROGRAMA DE INGENIERIA DE SISTEMAS
TITULO
ANALISIS COMPARATIVO DE LAS PLATAFORMAS J2EE Y .NET APLICADO
AL DESARROLLO DE SERVICIOS WEB
AUTOR
JOHN JAIRO MEDEZ ROMERO
DIRECTOR
MSC. (C). JORGE OMAR PORTILLA JAIMES.
PAMPLONA – COLOMBIA
NOVIEMBRE DE 2008
UNIVERSIDAD DE PAMPLONA
FACULTAD DE INGENIERIAS Y ARQUITECTURA
DEPARTAMENTO DE INGENIERIAS ELÉCTRICA ELECTRÓNICA SISTEMAS Y
TELECOMUNICACIONES
PROGRAMA DE INGENIERIA DE SISTEMAS
TITULO
JURADO CALIFICADOR:
PAMPLONA COLOMBIA
NOVIEMBRE DE 2008
DEDICATORIA
Mi esposa y mis hijos que han sido una nueva bendición de Dios;
donde su apoyo de una forma u otra jamás se ha apartado de mí.
A Mis padres que siempre han sido un gran ejemplo a seguir, por lo
que siempre me he sentido orgullosos de ellos en todo momento y
circunstancia.
Sorcha Carey
Un hombre con una idea nueva es un loco hasta que la idea triunfa.
Marc Twain
Flora Larsson
AGRADECIMIENTOS
CAPITULO I_________________________________________________________________________30
INTRODUCCIÓN_____________________________________________________________________30
1.1 DESCRIPCIÓN DEL PROBLEMA ___________________________________________________ 31
1.2 JUSTIFICACIÓN __________________________________________________________________ 32
1.3 OBJETIVOS DEL PROYECTO ____________________________________________________ 33
1.3.1 Objetivo General __________________________________________________________________________ 33
1.3.2 Objetivos Específicos _______________________________________________________________________ 33
CAPITULO 2 ______________________________________________________________________34
MARCO HISTORICO Y CONCEPTUAL ______________________________________________34
2.1 Estado del arte a nivel mundial ____________________________________________________ 34
2.2 Estado del arte a nivel nacional y local_____________________________________________ 35
2.2.1 Nacional _________________________________________________________________________________ 35
2.2.2 Local ____________________________________________________________________________________ 35
2.3 Historia de los Servicios Web _____________________________________________________ 36
2.3.1 La era de las redes locales. __________________________________________________________________ 36
2.3.2 La era de Internet y la Web. _________________________________________________________________ 37
2.3.3 Evolución histórica de la Web. _______________________________________________________________ 38
2.4 Definiciones de Los Servicios Web ________________________________________________ 39
2.5 Requisitos de un Web Service_____________________________________________________ 40
2.6 Web Services Protocol Stack______________________________________________________ 40
2.6.1 XML_____________________________________________________________________________________ 41
2.6.2 Protocolo de acceso de objeto Simple (SOAP)____________________________________________________ 42
2.6.2.1 Estructura de un mensaje Soap________________________________________________________ 43
2.6.2.2 Ventajas de utilizar Soap _____________________________________________________________ 43
2.6.3 WSDL ___________________________________________________________________________________ 44
2.6.3.1 Descripción del Wsdl ______________________________________________________________________ 45
2.6.4 UDDI ____________________________________________________________________________________ 46
2.6.4.1 Los datos manejados por UDDI se dividen en tres categorías_____________________________ 46
2.7 Dinámica de los Servicios Web ____________________________________________________ 47
2.8.1 Que es .NET? ______________________________________________________________________________ 48
2.8.2 Principales objetivos de la plataforma .NET _____________________________________________________ 48
2.8.6 Principales lenguajes soportados por .NET. _____________________________________________________ 49
2.8.4 Arquitectura .NET __________________________________________________________________________ 50
2.8.3 ¿Qué es .NET Framework?___________________________________________________________________ 51
2.8.5 Framework 3.0 Y 3.5 ________________________________________________________________________ 52
2.9 Plataforma J2EE _________________________________________________________________ 53
2.9.1 Definición de J2EE __________________________________________________________________________ 53
2.9.2 Arquitectura J2EE.__________________________________________________________________________ 53
2.9.3 Características de J2EE.______________________________________________________________________ 54
2.9.3.1 Paquetes de aplicaciones _____________________________________________________________ 55
2.9.3.2 Lenguajes soportado por J2EE________________________________________________________ 57
2.9.3.2.1 Java ______________________________________________________________________________ 57
CAPITULO IV _______________________________________________________________________70
ANÁLISIS COMPARATIVO ENTRE J2EE Y .NET _____________________________________________70
4.1 Seguridad a nivel de mensajes ____________________________________________________ 70
4.1.1 Algunas especificaciones soportada por J2EE____________________________________________________ 70
4.1.1.1 La plataforma J2EE (JEE 5) de Sun Microsystems ______________________________________ 70
4.1.1.2 GlassFish___________________________________________________________________________ 70
4.1.1.3 NetBeans___________________________________________________________________________ 70
4.1.1.4 WSIT ______________________________________________________________________________ 70
4.1.2 Algunas especificaciones soportadas por .NET ___________________________________________________ 71
4.1.2.1 Visual Studio .NET __________________________________________________________________ 71
4.1.2.1.1 Web Services Enhancements _____________________________________________________ 72
4.1.2.1.2 Windows Communication Foundation (WCF) _______________________________________ 72
4.1.3 Autentificación de usuarios usando UserNameTokens en J2EE y .NET de acuerdo a la
especificación de WS-Security _____________________________________________________________________ 73
4.1.3.1 Aplicación UserName Tokens en .NET utilizando WSE __________________________________ 73
4.1.3.1.1 Servicio Web ____________________________________________________________________ 73
4.1.3.1.2 Cliente consumiendo un WS con seguridad a nivel de mensaje _______________________ 76
4.1.3.2 Aplicación UserName Tokens en J2EE con NetBeans ___________________________________ 77
4.1.4 Análisis de seguridad a nivel de mensaje _______________________________________________________ 80
4.2 Portabilidad. _____________________________________________________________________ 82
4.2.1 Análisis de la Portabilidad en J2EE ____________________________________________________________ 82
4.2.2 Análisis de la Portabilidad en .NET _____________________________________________________________ 82
4.3 NetBeans 6.5 frente Visual Studio .NET 2008_______________________________________ 83
4.3.1 Especificaciones ___________________________________________________________________________ 83
4.3.2 Prueba 1 _________________________________________________________________________________ 84
4.3.2 Prueba 2 _________________________________________________________________________________ 84
4.3.3 Prueba 3 _________________________________________________________________________________ 85
4.3.4 Prueba 4 _________________________________________________________________________________ 85
4.3.5 Realizando un Servicio Web _________________________________________________________________ 86
4.3.5.1 NetBeans 6.5 _______________________________________________________________________ 86
4.3.5.2 Visual Studio .NET 2008 _____________________________________________________________ 86
4.3.5.3 Prueba 5 ___________________________________________________________________________ 87
4.3.5.4 Método del Servicio Web en VS .NET. _________________________________________________ 88
4.3.5.5 Método del Servicio Web en NetBeans_________________________________________________ 88
4.3.5.6 Prueba 6 ___________________________________________________________________________ 91
4.3.5.7 Testear el Servicio Web y ver el Wsdl desde VS ________________________________________ 91
4.3.5.8 Testear el Servicio Web y ver el Wsdl desde NetBeans__________________________________ 92
4.3.5.9 Realizando cambios en el método del WS en VS _______________________________________ 93
4.3.5.10 Realizando cambios en el método del WS en NetBeans ________________________________ 93
4.3.6 Conexión a Bases de datos. __________________________________________________________________ 94
4.3.6.1 Conexión en NetBeans_______________________________________________________________ 94
4.3.6.2 Conexión en VS _____________________________________________________________________ 95
4.3.7 Consumiendo un servicio Web en J2EE utilizando NetBeans _______________________________________ 96
4.3.7.1 Copiando la URL del Servicio ________________________________________________________ 96
4.3.7.2 Generando una Clase _______________________________________________________________ 97
4.3.7.3 Agregando Métodos a La Clase ______________________________________________________ 99
4.3.7.4 Llamando una operación del Servicio Web _____________________________________________ 99
4.3.8 Consumiendo un servicio Web en .NET utilizando Visual Studio ___________________________________ 100
4.3.8.1 Dimensionado una variable tipo Servicio Web en VS ___________________________________ 101
4.3.9 Análisis de NetBeans Frente Visual Studio _____________________________________________________ 102
4.4 Interoperabilidad _______________________________________________________________ 104
4.4.1 WS – I___________________________________________________________________________________ 104
4.4.2 Interoperabilidad con METRO y WCF _________________________________________________________ 106
4.4.3 Análisis de la Interoperabilidad ______________________________________________________________ 108
4.4.3.1 Posibles problemas al utilizar WS de diferentes plataformas (J2EE, .NET) ________________ 109
4.4.3.2 El DataSet como un tipo de dato especifico de .NET ____________________________________ 109
4.4.3.3 El código de un WS que devuelve un DataSet _________________________________________ 110
4.4.3.4 Analizando el WSDL generado por el WS .NET que devuelve un DataSet_________________ 111
4.4.3.5 Analizando el mensaje Soap generado por un WS utilizando DataSet ____________________ 111
4.5 Desempeño____________________________________________________________________ 114
4.5.1 Reporte de la configuración del Test__________________________________________________________ 114
4.5.1.1 J2EE______________________________________________________________________________ 114
4.5.1.2 NET ______________________________________________________________________________ 115
4.5.2 Resumen del estado de las transacciones _____________________________________________________ 116
4.5.2.1 J2EE______________________________________________________________________________ 116
4.5.2.2 .NET ______________________________________________________________________________ 116
4.5.2.3 Análisis 1 __________________________________________________________________________ 117
4.5.3 Tiempo contra la cuenta de usuarios activos___________________________________________________ 117
4.5.3.1 J2EE______________________________________________________________________________ 117
4.5.3.2 .NET ______________________________________________________________________________ 117
4.5.3.3 Análisis 2 __________________________________________________________________________ 118
4.5.4 Hits por segundos ________________________________________________________________________ 118
4.5.4.1 J2EE______________________________________________________________________________ 118
4.5.4.2 .NET ______________________________________________________________________________ 119
4.5.4.3 Análisis 3 __________________________________________________________________________ 119
4.5.5 Tiempo contra el rendimiento ______________________________________________________________ 119
4.5.5.1 J2EE______________________________________________________________________________ 120
4.5.5.2 .NET ______________________________________________________________________________ 120
4.5.5.3 Análisis 4 __________________________________________________________________________ 121
4.5.6 Distribución de los errores para todas las transacciones _________________________________________ 121
4.5.6.1 J2EE______________________________________________________________________________ 121
4.5.6.2 .NET ______________________________________________________________________________ 121
4.5.6.3 Análisis 5 __________________________________________________________________________ 122
4.5.7 El tiempo contra el porcentaje de error _______________________________________________________ 122
4.5.7.1 .NET ______________________________________________________________________________ 122
4.5.8 Reporte del tiempo De respuesta ___________________________________________________________ 123
4.5.8.1 J2EE______________________________________________________________________________ 123
4.5.8.2 .NET ______________________________________________________________________________ 123
4.5.8.3 Análisis 6 __________________________________________________________________________ 124
4.5.9 El tiempo contra el tiempo de respuesta (Detallado)____________________________________________ 124
4.5.9.1 J2EE______________________________________________________________________________ 124
4.5.9.2 .NET ______________________________________________________________________________ 125
4.5.9.3 Análisis 7 __________________________________________________________________________ 125
4.5.10 Usuarios contra el tiempo de respuesta _____________________________________________________ 125
4.5.10.1 J2EE_____________________________________________________________________________ 126
4.5.10.2 .NET _____________________________________________________________________________ 126
4.5.10.3 Análisis 8 _________________________________________________________________________ 126
4.5.11 Usuarios contra el rendimiento ____________________________________________________________ 127
4.5.11.1 J2EE_____________________________________________________________________________ 127
4.5.11.2 .NET _____________________________________________________________________________ 127
4.5.11.3 Análisis 9 _________________________________________________________________________ 127
4.5.12 Cuellos de botellas - Reporte de análisis _____________________________________________________ 128
4.5.12.1 J2EE_____________________________________________________________________________ 128
4.5.12.2 .NET _____________________________________________________________________________ 129
4.5.12.3 Análisis 10 ________________________________________________________________________ 129
4.5.13 El tiempo contra el tiempo de las páginas descargadas _________________________________________ 129
4.5.13.1 J2EE_____________________________________________________________________________ 130
4.5.13.2 .NET _________________________________________________________________________________ 130
4.5.13.3 Análisis 11 ________________________________________________________________________ 130
4.5.14 Reporte del tamaño de páginas ____________________________________________________________ 130
4.5.14.1 J2EE_____________________________________________________________________________ 131
4.5.14.2 .NET _____________________________________________________________________________ 131
4.5.14.3 Análisis 12 ________________________________________________________________________ 131
4.5.15 Reporte de las páginas descargada _________________________________________________________ 132
4.5.15.1 J2EE_____________________________________________________________________________ 132
4.5.15.2 .NET _____________________________________________________________________________ 132
4.5.15.3 Análisis 13 ________________________________________________________________________ 133
4.5.16 Resumen de los reportes _________________________________________________________________ 133
4.5.16.1 J2EE_____________________________________________________________________________ 133
4.5.16.2 .NET _____________________________________________________________________________ 134
4.5.16.3 Análisis 14 ________________________________________________________________________ 134
4.5.17 Analizando el desempeño entre J2EE y .NET utilizando otras Investigaciones ________________________ 135
4.5.17.1 Test realizado _____________________________________________________________________ 135
4.5.17.2 Resultado del Test _________________________________________________________________ 135
4.5.17.3 Análisis de Maneesh _______________________________________________________________ 136
4.5.18 Análisis Final ____________________________________________________________________________ 137
El siguiente trabajo se constituye en un estudio que abarca los diferentes aspectos más
relevantes que se deben tener en cuenta a la hora de escoger entre J2EE y .NET, en el
contexto de los servicios web. Se realizó un análisis comparativo donde se muestra las
principales ventajas y desventajas. Así mismo se implementó un prototipo de servicio y
cliente web en cada plataforma
En el capítulo III se analizan los principales aspectos en que se relacionan J2EE y .NET
en el nivel de servicios web, el cual proporcionó una base para seleccionar los criterios
que se compararon. También se justifican las herramientas seleccionadas para realizar
dicho comparativo.
Portabilidad. En este criterio se estudia la maquina virtual de java (JVM) para J2EE
y el lenguaje común en tiempo de ejecución (CLR) para .NET.
IDEs. Para realizar la comparación entres los dos IDEs se utilizaron pruebas de
tiempo de respuestas, para realizar algunas tareas específicas que involucre el
desarrollo de un Servicio Web en cada herramienta. Además se estudio las
opciones, flexibilidad, facilidad que brinda cada herramienta al desarrollador para
lograr un juicio más real, aparte de las obtenidas por las pruebas de tiempo de los
dos IDEs
The next project is a study covering different aspects most relevant to be taken into
account when choosing between J2EE and .NET in the context of Web Services. A
comparative analysis was realized, where one shows the principal advantages and
disadvantages. Likewise there implemented a prototype of service and client web in every
platform.
In chapter I discussed the problem that leads to the development of this Investigation with
his respective justification and set the objectives of the project.
In Chapter II are defined some concepts of Web Services showing the different standards
to which these are based. Also the principal attributes are studied so much of the platform
J2EE and of the platform .NET.
In Chapter III There are analyzed the principal aspects in which they relate J2EE and .NET
in the level of services web, which provided a base to select the criteria that were
compared. Also the tools justify themselves selected to realize comparative saying.
Security. Studied the security level of message, analyzing the specification of WS-
Security, and showing a basic implementation in both platforms.
Portability. In this approach studied the Java Virtual Machine (JVM) for J2EE and
the common language runtime (CLR) for .NET.
IDEs. To make the comparison between the two IDEs, using evidence-time
responses to perform some specific tasks that involve the development of a Web
Service in each tool. In addition, study the options, flexibility, ease afforded to every
developer tool to achieve a more real than those obtained by testing time for the
two IDEs.
Interoperability. Is initiate the analysis, studying the interoperability to slant Metro
and WCF. Also there carried out a client J2EE and NET to consume Web Services
in both platforms. Also examined types of data sent back or returned by Web
Services to determine the degree of interoperability.
Performance. There was studied the performance of both platforms realizing test
with AdventNet QEngine increased users and loads of works.
CAPITULO I
INTRODUCCIÓN
Es muy cierto que los sistemas de información, programas u otros, han tenido un gran
impacto en consecuencias positivas en la sociedad moderna. Estos mismos sistemas a
medida que crecen de forma acelerada, también lo hacen las necesidades que dan
soporte a dichas tecnologías, y con ellos se crean nuevos retos y así se producen o nacen
nuevas tecnologías. De este modo los servicios web se pueden ver como la respuesta o
solución de algunas necesidades causada por las interacciones de sistemas
heterogéneos, aunque los servicios web no es la única solución a este problema, cuando
se emplean de forma adecuada generan ciertas ventajas.
Una de las mayores ventajas de los servicios web es sin duda alguna la posibilidad de
interactuar con otras aplicaciones implementadas en el mismo o en diferentes sistemas
operativo, aportando así interoperabilidad que es aprovechado por los sistemas
distribuidos y la arquitectura SOA, además de fomentar algunos estándares y protocolos,
por la naturaleza misma de esta tecnología.
Hoy la plataforma J2EE al igual que la plataforma .NET son las principales alternativas
para desarrollar soluciones que se basen en clientes y servicios web, ya que ambas
ofrecen lo necesario para llevar a cabo de forma satisfactoria soluciones empresariales.
Igualmente son J2EE y .NET las plataformas más utilizadas en el mercado, conllevando a
que se genere una rivalidad que es de gran controversia al intentar definir o establecer
fortalezas y debilidades existentes, generando justamente una dificultad latente a la hora
de escoger entre J2EE y .NET.
Una de las principales causas de este problema, es que se mitifican algunas
características propias de estas plataformas ocasionando a veces, desviar u opacar las
ventajas reales que cada plataforma puede aportar sobre ciertas necesidades
particulares. Lo anterior, produce dificultad y cierto grado de confusión en la etapa de
selección de una plataforma apropiada.
Por otro lado, Se desarrolla la documentación técnica necesaria y suficiente para ejecutar
la implementación de un servicio y cliente en ambas plataformas, con el fin comprobar en
efecto que los servicios web es un mecanismo eficaz para conseguir la interoperabilidad
entre J2EE y .NET, y para incrementar los conocimientos prácticos de cada plataforma
estableciendo un nivel adicional de garantía al comparativo realizado.
Este estudio ayuda a tener una noción más clara del funcionamiento arquitectónico, de las
principales característica, de las ventajas o desventaja que ofrece cada plataforma.
Soportado en cada análisis y conclusiones producto del resultado de cada criterio
comparado.
1.2 JUSTIFICACIÓN
Actualmente los servicios web han tomado más fuerzas en todo lo que se refiere a los
desarrollos e implementaciones de aplicaciones distribuidas, que necesitan las empresas
o corporaciones para ejecutar su lógica de negocio.
Por eso, la importancia de realizar un estudio comparativo de las dos plataformas más
importante del mercado actual, verificando cual se adapta y se ajusta más a los
requerimientos mismos de la aplicación que se pretende desarrollar. Buscando con ello,
una orientación mucho más real, tanto a las empresas como a los desarrolladores o a las
personas que tienen la responsabilidad de elegir en que plataforma realizaran sus
aplicaciones web.
Realizar un análisis comparativo entre las dos plataformas para el desarrollo de los
servicios web de acuerdo a los criterios establecidos.
A nivel mundial se encontraron algunos trabajos y artículos sobre servicios web y también
comparativos entre J2EE y .NET. Algunos de estos se describen a continuación
Estado del Arte de la Tecnología de Web Services. Esta trabajo realizado por
Edgardo A. Romero M. se fundamentó en el Desarrolló de una investigación
bibliográfica sobre los web services así como las principales tecnologías de
implementación, con el fin de mostrar su influencia en los factores tecnológicos y
económicos de la sociedad [01].
Algoritmo de emparejamiento de perfiles en Servicios Web Semánticos. Este
artículo creado por José J. Samper, Eduardo carrillo y Juan J. Martínez. describe
las principales características de un algoritmo de emparejamiento de Servicios
Web Semánticos y los principales componentes relacionados con el proceso de
implementación.
2.2.1 Nacional
2.2.2 Local
En los 90's, algunas estructuras de objetos, como COM (Component Object CODEL) de
Microsoft y CORBA (Common Object Request Broker Architecture), que se comercializó
como una iniciativa entre proveedores de OMG (Grupo de Gestión de Objetos), cobraron
popularidad [1].
La extensión de las redes locales a principios de los 90's, y la conexión entre máquinas se
volvió una prioridad. Los proveedores y las organizaciones que ya contaban con sus
propias estructuras de modelo-objeto, las ampliaron para permitir la comunicación a
través de redes [1].
OMG estableció el IIOP (Internet Inter-ORB Protocol) como protocolo de comunicación
estándar de CORBA [1].
Uno de los primeros protocolos para la comunicación mediante el protocolo HTTP, que
permite llamar a procedimientos remotos sin importar el lenguaje de desarrollo o el
sistema operativo fue XML-RPC, sin embargo a pesar de ser el primero en este campo y
de las ventajas que ofrece la mayoría de proveedores optaron por su sucesor SOAP
(Simple Object Access Protocol) [1].
El concepto de Web Services comenzó a tomar forma definitiva con la introducción de
SOAP como protocolo de mensajería entre computadores. A pesar de que su nombre
pueda parecer que requiere del uso de determinados objetos, SOAP especifica el formato
del mensaje que accede e invoca a los objetos, en vez de especificar los objetos en sí
[1].
En mayo del año 2000, el W3C (World Wide Web Consortium http://www.w3c.org/)
reconoció la propuesta de SOAP presentada de forma conjunta por un conglomerado de
empresas (Ariba Inc., CommerceOne Inc., Compaq Computer Corp., Microsoft Corp.,
Development Corp., IBM Corp, Hewlett-Packard Co., etc). Siendo desarrollado en base a
un estándar abierto [1].
Con el surgimiento del Internet las aplicaciones en la web partieron usando el lenguaje de
etiquetas HTML, permitían usar la web como medio para distribuir documentos estáticos,
estos se alojaban en servidores Web que usaban el protocolo de comunicación HTTP,
luego la información se desplegada por navegadores web en cualquier cliente en el
mundo que los invocara por medio de una dirección web conocida como URL, con el paso
del tiempo se observo la necesidad de generar información dinámicamente, como
solución a este problema, se desarrollaron aplicaciones web, usando códigos fuente
escritos en diferentes lenguajes de programación como ASP, PHP, PERL, etc. Estos
códigos fuentes se alojaban y se ejecutaban en servidores web, estos generaban HTML
en forma dinámica [1].
Existen múltiples definiciones sobre lo que son los Servicios Web, lo que muestra su
complejidad a la hora de dar una adecuada definición que englobe todo lo que son e
implican. A continuación se presentan algunas de ellas:
Los Servicios Web basados en XML permiten que las aplicaciones compartan
información y que además invoquen funciones de otras aplicaciones
independientemente de cómo se hayan creado las aplicaciones, cuál sea el
sistema operativo o la plataforma en que se ejecutan y cual sea el dispositivo
utilizado para tener acceso a ellas [03].
2.5 Requisitos de un Web Service
Amigabilidad con Internet: La solución debe poder funcionar para soportar clientes
que accedan a los servicios remotos desde internet.
La Pila de protocolos para Servicios Web, es una colección de protocolos para redes de
Computadores que son utilizados para definir, localizar, implementar y hacer que un
Servicio Web interactúe con otro. La Pila de Protocolos para servicios está comprendida
principalmente por cuatro áreas:
Mensajería XML: responsable por la codificación de mensajes en un formato común
XML así que ellos puedan ser entendidos en cualquier extremo de una conexión de
red. Actualmente, esta área incluye protocolos tales como XML-RPC, SOAP y REST.
2.6.1 XML
Es el protocolo de comunicaciones que usan los Web Services. Define los mecanismos
por los cuales un Web Service, es invocado y cómo devuelve los datos. SOAP es un
estándar definido por W3C y creado a partir de un grupo de trabajo integrado por varias
asociaciones.
2.6.2.1 Estructura de un mensaje Soap
2.6.3 WSDL
Puesto que la notación que utiliza WSDL es XML significa que es un idioma de
programación neutral, basado en estándares (W3C) y que puede utilizarse desde una
gran variedad de plataformas y lenguajes [01].
Figura 6. Ejemplo de un documento Wsdl
Información de los tipos de datos para todos los mensajes de petición y respuesta.
2.6.4 UDDI
Es un elemento básico sobre el que se asientan los Web Services, hace posible que
empresas pueden tanto publicar como encontrar Web Services. UDDI provee un
mecanismo para que los negocios se "describan" a sí mismos y los tipos de servicios que
proporcionan. Los Web Services son registrados para que los posibles usuarios puedan
encontrarlos, tales negocios publicados pueden ser buscados, consultados o
"descubiertos" por otros negocios utilizando mensajes SOAP. Un registro UDDI es como
la lista de los Web Services, es decir, una entrada en UDDI es un archivo XML que,
realizando una similitud con las páginas amarillas, describe el proveedor y los servicios
que ofrece [01].
Actualmente .NET soporta una gran variedad de lenguajes de programación. Entre los
principales lenguajes soportados por .NET se encuentran los siguientes:
3. La capa de acceso a datos: capa que contiene las clases que interactúan con
las base de datos. Éstas surgen con la necesidad de mantener la
cohesión o clases altamente especializadas que ayuden a reducir la
dependencia entre las clases y capas. Aquí se encuentra la clase de métodos
estáticos que permite uniformizar las operaciones de acceso a datos a través de
un único conjunto de métodos [07].
Microsoft ha lanzando el nuevo Framework 3.5 La versión Framework .NET 3.5 no tiene
grandes diferencias con la versión 3.0, solamente fue un agregado de más librerías. Lo
interesante se presenta en la versión 3.0. Los nuevos componentes son: Windows
Presentation Foundation (WPF), Windows Communication Foundation (WCF) y
Windows Workflow Foundation (WF) [10].
El concepto J2EE, Java 2 Enterprise Edition es la arquitectura creada por Sun para el
desarrollo de todo tipo de aplicaciones para empresas y usuarios en general facilitando
las herramientas necesarias para la programación en el lenguaje Java, las cuales facilitan
el manejo de los conceptos necesarios para el desarrollo de aplicaciones más avanzadas
de desarrollo, implementación y administración de software empresarial. Sun lo define
como un estándar para el desarrollo de aplicaciones empresariales multicapa,
simplificando las aplicaciones empresariales basándolas en componentes modulares y
estandarizados, proveyendo un completo conjunto de servicios a estos componentes, y
manejando muchas de las funciones de la aplicación de forma automática, sin necesidad
de una programación compleja.
J2EE contiene un completo conjunto de APIs, algunas de las cuales están insertas dentro
de la arquitectura J2SE que se agregan a la arquitectura. Éstas permiten la ejecución
entre las distintas capas.
EAR (Enterprise Archive file): un archivo EAR es un archivo JAR que contiene
una aplicación J2EE. Utilizando archivos EAR es posible unir un número de
diferentes aplicaciones J2EE usando los mismos componentes sin necesidad
de códigos extra solo incluyéndolos dentro de este módulo.
2.9.3.2.1 Java
Para escoger algunos criterios a tener en cuenta para realizar el análisis comparativo
entre las dos plataformas, es necesario estudiar y analizar los aspectos en que se
relacionan, de acuerdo al grado de relevancia que posea. En la siguiente tabla se ilustran
algunos aspectos importantes que tienen en común las dos plataformas, aunque se han
escogido los que afectan o se involucran al momento de realizar un servicio Web.
Portabilidad.
Interoperabilidad.
Desempeño.
El hecho de que se haya tomado la seguridad en el desarrollo de los servicios Web como
criterio de comparación, es porque para los sistemas distribuidos la seguridad constituye
uno de los principales desafíos.
3.3.2 Portabilidad
3.3.4 Interoperabilidad
3.3.5 Desempeño
R(S, T)
IDEs (NetBeans 6.5 para J2EE, Visual Studio 2008 para .NET).
Servidores (Sun Application Server 9,2 de J2EE en su versión libre (GlassFish), IIS
de .NET).
3.5.1 IDE
3.5.1.1 NetBeans
NetBeans IDE es una herramienta para que los programadores puedan escribir, compilar,
depurar y ejecutar programas. Está escrito en Java pero puede servir para cualquier otro
lenguaje de programación. Existe además un número importante de módulos para
extender el NetBeans IDE. NetBeans IDE es un producto libre y gratuito sin restricciones
de uso.
NetBeans es un proyecto de código abierto de gran éxito con una gran base de usuarios,
una comunidad en constante crecimiento, y con cerca de 100 socios en todo el mundo.
Sun MicroSystems fundó el proyecto de código abierto NetBeans en junio 2000 y continúa
siendo el patrocinador principal de los proyectos [05].
Para desarrollar Servicios Web J2EE o JEE5 existen diversos IDE de desarrollo, algunos
de estos son de uso libre y otro de uso propietario, este último se debe comprar y adquirir
una licencia de uso. Se escoge NetBeans para realizar tanto la comparación como el
prototipo de Servicio Web, ya que, es una herramienta de uso libre, robusta, y que
incorpora lo necesario para el perfecto desarrollo y consumo de los Servicios Web. A
demás la versión 6.5 de NetBeans es la más reciente el cual tiene nuevas característica y
mejoras de la versión antecesora NetBeans 6.1. Con esta IDE es posible escribir
aplicaciones J2EE 1.3, 1.4, JEE5 y en el desarrollo de servicios Web permite escoger con
que versión de SOAP trabajar (1.1, 1.2).
Microsoft Visual Studio es un entorno de desarrollo integrado (IDE, por sus siglas en
inglés) para sistemas Windows. Soporta varios lenguajes de programación tales como
Visual C++, Visual C#, Visual J#, ASP.NET y Visual Basic .NET, aunque actualmente se
han desarrollado las extensiones necesarias para muchos otros.
Visual Studio permite a los desarrolladores crear aplicaciones, sitios web, así como
servicios web en cualquier entorno que soporte la plataforma.
Antes para crear aplicación .NET era únicamente posible desde la IDE visual Studio que
se ejecuta en el sistema operativo Windows. No obstante con el nuevo proyecto mono es
posible crear servicios Web desde sistemas operativo como Linux, aunque el proyecto
aun no está terminado se ha optado por escoger el visual Studio, el cual posee las
herramientas necesarias para desarrollar los WS, y es posible descargar una versión
preview del visual Studio 2008 en español, que es actualmente una de las últimas
versiones de este IDE. Además permite escoger en que Framework trabajar, las opciones
que presenta son: 2.0, 3.0, 3.5, en el desarrollo de servicios Web genera SOAP 1.1 y 1.2
[05]
Existen varias razones por las cuales se opto por GlassFish. NetBeans 6.5 trae incluido el
GlassFish (Sun Application Server 9.2) el cual es libre para desarrollar servicios Web. Uno
de los objetivo de GlassFish es que ha sido diseñado para competir con Weblogic y
Websphere y hasta ahora lleva 3 versiones, es robusto escalable y fue el primer servidor
de aplicaciones certificado para Java EE 5, aunque soporta J2EE.
Internet Information Server, IIS, es una serie de servicios para los computadores que
funcionan con Windows. Originalmente era parte del Option Pack para Windows NT.
Luego fue integrado en otros sistemas operativos de Microsoft destinados a ofrecer
servicios, como Windows 2000 o Windows Server 2003. Windows XP Profesional,
Windows Vista incluye una versión limitada de IIS. Los servicios que ofrece son: FTP,
SMTP, NNTP y HTTP/HTTPS.
Este servicio convierte a un computador en un servidor de Internet o Intranet, es decir,
que en las computadoras que tienen este servicio instalado se pueden publicar páginas
web tanto local como remotamente (servidor web).
El servidor web se basa en varios módulos que le dan capacidad para procesar distintos
tipos de páginas, por ejemplo Microsoft incluye los de Active Server Pages (ASP) y
ASP.NET. También pueden ser incluidos los de otros fabricantes, como PHP o Perl [05].
Se selecciono el IIS, ya que es el servidor insignia de Microsoft, el cual soporta asp, aspx,
servicios Web. A demás viene con el sistema operativo Windows XP SP 2, que es el
sistema operativo del sistema cómputo en el cual, se realizará tanto la comparación como
el prototipo de servicios Web para las plataformas J2EE y .NET. El IIS brinda facilidad a la
hora de desplegar servicios Web y también se encuentra la documentación para varios
idioma.
JEE 5 Java Platform, Enterprise Edition o Java EE (anteriormente conocido como Java 2
Platform, Enterprise Edition o J2EE hasta la versión 1.4), es una plataforma de
programación Java con arquitectura de N niveles distribuida, basándose ampliamente en
componentes de software modulares ejecutándose sobre un servidor de aplicaciones. La
plataforma Java EE está definida por una especificación. Similar a otras especificaciones
del Java Community Process, Java EE es también considerada informalmente como un
estándar, debido a que los suministradores deben cumplir ciertos requisitos de
conformidad para declarar que sus productos son conformes a Java EE [05].
3.5.4.1 Java
3.5.5.1 Java DB
El Java DB de Sun es la distribución de código abierto Apache Derby cien por ciento
tecnología Java para base de datos, el cual viene integrado en la versión de NetBeans
6.5.
La base de datos que se realizará para llevar a cabo el prototipo propuesto de WS .NET,
no requiere una excesiva potencia, la cual hace ideal el uso de este sistema de gestión
de BD, además Access posee facilidad para integrarse de forma perfecta con el resto de
aplicación de Microsoft, en este caso Visual Studio .NET.
AdventNet Es una empresa de Software que tiene su sede principal en Estados unidos,
otras en: México, Inglaterra, India, China, Japón y otras. Ofrecen diferentes productos
empresariales; productos para base de datos, productos para testear la Web, entre otros.
Lleva varios años en el mercado de software y tiene una gran reputación a nivel mundial.
Ya que existen muchas investigaciones en las cuales se utilizan algunas herramientas de
esta empresa como:
Para tener una mejor compresión de los términos y conceptos que se nombren a
continuación, es necesario Ver ANEXO I [SEGURIDAD A NIVEL DE MENSAJE EN LOS
SERVICIOS WEB], y ver el apartado 4.4.2 Interoperabilidad con METRO y WCF.
4.1.1.2 GlassFish
A partir de la versión 2.0 soporta: SOAP 1.1/2.0, WSDL 1.1, trae soporte para METRO
que incluye WS-Security [15]. Para ver más sobre METRO ir al apartado 4.4.2.
4.1.1.3 NetBeans
4.1.1.4 WSIT
WS-Security.
WS-SecurityPolicy.
WS-SecureConversation.
WS-Trust.
Desde sus versión 2003 utiliza plugin o complementos que se pueden descargar e instalar
para agregar mejora a los WS construido en .NET. Uno de estos complementos son Web
Services Enhancements (WSE), Development Kit (WSDK), WCF (viene integrado con
Visual Studio 2008) [15].
4.1.2.1.1 Web Services Enhancements
Para ver más sobre WCF ir al apartado 4.4.2. WCF incluye un número significativo
de tecnologías relacionadas con los WS entre las que destacan SOAP, WSDL,
WS-Policy, en el área de arranque y configuración. WS-Addressing, WS-
AtomicTransaction, en el área de transaccionabilidad. WS-Coordination, WS-
ReliableMessaging en el área de fiabilidad. En el área de seguridad, implementa
un conjunto de estándares de seguridad publicados por el consorcio OASIS, como
son:
WS-Security.
WS-SecurityPolicy.
WS-SecureConversation.
WS-Trust.
Para aplicar UserName Token (Ver Anexo I, III, IV) en el caso de la plataforma J2EE es
posible mediante la construcción programática de la cabecera Soap, o en algunos casos
depende del IDE en que se esté trabajando, utilizando así una ayuda Wizard de un SDK
de WS-Security de J2EE que sea soportado por la herramienta de desarrollo como WSIT,
o en otros la herramienta como tal trae integrada la característica para aplicar la
especificación de WS-Security.
Para tener una mejor compresión de los siguientes ejemplos es necesario consultar el
Apartado 4.3, Anexos III y Anexo IV.
using System;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Web;
using System.Web.Services;
using System.Security.Permissions;
using Microsoft.Web.Services;
using Microsoft.Web.Services.Security;
using Microsoft.Web.Services.Security.Tokens;
namespace samples.webbish6
{
[ WebService(Description="Hello World",
Namespace="http://samples.webbish6.com/")]
public class HelloWorld : System.Web.Services.WebService
{
public HelloWorld()
{
//Esta llamada es requerida por el ASP.NET Web Services
Diseñador
InitializeComponent();
}
/// <summary>
/// Método requerido para el Diseñador de apoyo - no
modificar
///el contenido de este método con el editor de código.
/// </summary>
private void InitializeComponent()
{
}
/// <summary>
/// Limpiar los recursos que se utilizan
/// </summary>
protected override void Dispose( bool disposing )
{
if(disposing && components != null)
{
components.Dispose();
}
base.Dispose(disposing);
}
#endregion
/*
* Restringir el acceso al manjador de token solamente para asambleas
que se han
* concedido derechos suficientes para ejecutar código no
administrado, que
* incluye WSE - para garantizar el propio nombre de usuario, usted
debe utilizar SSL
*/
[SecurityPermission(SecurityAction.Demand,
Flags= SecurityPermissionFlag.UnmanagedCode)]
public class CustomUsernameTokenManager : UsernameTokenManager
{
/*Para implementar un administrador de username token, debe
anular
* el metodo de AuthenticateToken para que vuelva la contraseña
* que se corresponde con el nombre de usuario, aprobada en el
token
*/
protected override string AuthenticateToken(UsernameToken
myNameToken)
{
// Asegurando que el mensaje SOAP enviado
// no pase un null en el UsernameToken
if (myNameToken == null) throw new
ArgumentNullException();
// Para retornar
string myPwd;
/*
Aquí se suele llamar a un método que recibe la copia local
* de la contraseña suministrada por el nombre de usuario
* desde una ubicación segura myPWD cadena =
GetSecurelyStoredPassword (myNameToken.Username);
* Y SE RETORNA myPWD;
*/
myPwd = hardCodedPwd;
return myPwd;
}
}
}
4.1.3.1.2 Cliente consumiendo un WS con seguridad a nivel de mensaje
(Aplicación de Consola)
using System;
using Microsoft.Web.Services;
using Microsoft.Web.Services.Security;
using Microsoft.Web.Services.Security.Tokens;
using HelloWorldClient.HelloWorldWebService;
namespace HelloWorldClient
{
class HWClient
{
[STAThread]
static void Main(string[] args)
{
string myName="";
string myPwd="";
try
{
if (args.Length<2)
{throw new ApplicationException("Por favor agregue
un nombre de usuario y password");}
myName = args[0];
try
{
// LLamando el metodo del Web Services
response = myService.GetHelloWorld();
}
catch(Exception ex)
{
Console.WriteLine(ex.ToString());
}
Console.WriteLine(response);
}
}
}
[17].
Para ver sobre como implementar un servicio web con WCF y sus principales
características consultar [31].
Se crea un nuevo proyecto en NetBeans tipo aplicación web para realizar un Web
Services.
Se crea el WS
Se crea un Cliente que consuma Dicho WS
Se hace click en Runtime como se muestra a continuación.
La seguridad ha sido uno de los aspectos más desarrollados en los últimos tiempos en el
área de servicios web. Sun y Microsoft se agruparon para trabajar en este tema,
buscando con ello que además de que la seguridad sea interoperable, sea estándar en
cualquiera de las dos plataformas tecnológicas. Lo anterior evidencia el hecho de que en
este aspecto la seguridad ofrecida tanto por J2EE como por .NET abarca el mismo
conjunto de especificaciones. Por ejemplo, ambas plataformas soportan las
especificaciones de seguridad a nivel de mensaje como WS-Security, esto quiere decir
que si en J2EE se implementa la encriptación del mensaje Soap utilizando la
especificación de WS-Security y un intruso logra desencriptar el mensaje Soap utilizando
un ataque, entonces también es posible violar la seguridad en .NET. Por consiguiente si
una especificación de seguridad es violada, ambas plataformas se ven afectadas, ya que,
ellas se apoyan en las mismas especificaciones.
Ambas plataformas muestra cierto grado simplicidad para implementar algunas o las
principales especificaciones de seguridad, eliminando en ese aspecto la ventaja de una
plataforma frente a la otra. No obstante en la aplicación de UserNameTokens que se
estudio anteriormente, es posible destacar hasta cierto nivel la facilidad que presenta
J2EE frente a .NET en la implementación de esta especificación de seguridad, utilizando
NetBeans, sin embargo es necesario tener en cuenta que en cada IDE de desarrollo para
J2EE que soporte WS-Security es diferente su implementación en lo concerniente a la
facilidad que pueda brindar a los desarrolladores.
4.2 Portabilidad.
Aunque es cierto que la portabilidad aun no es posible en un cien por ciento, a través del
estudio realizado de la JVM de J2EE y el CLR de .NET (Ver ANEXO II [ESTUDIO DE LA
PORTABILIDAD DE J2EE Y .NET]), es posible deducir el siguiente análisis:
Se consigue una mejor portabilidad con la plataforma J2EE donde existe JVM
para la mayoría de los Sistemas Operativos.
La mayoría de los IDEs o FrameWork para desarrollar servicios web en J2EE (se
pueden descargar en el caso de ser gratuito o comprar en el caso de usar licencia
comercial), se pueden instalar en diversos sistemas operativos, ejemplo de esto es
tener el IDE Eclipse para el sistema operativo Windows realizar un servicio web y
luego llevar ese proyecto y abrirlo en el IDE Eclipse pero en el sistema operativo
Linux y el proyecto de servicio web no presentaría ningún problema.
Por lo general los proyectos de servicios web realizado en estos IDE generan un
(.WAR, EAR, o JAR) que contiene toda la aplicación, que es el equivalente a un
.Class de un programa Java; este archivo se puede transportar a diferentes
sistemas operativos y utilizando algún servidor de aplicación que soporte las
característica con que se creó el servicio web es posible desplegarlo para ser
accedido mediante un cliente.
Aunque a través del Proyecto Mono se obtendrán portabilidad hasta cierto punto
con .NET, aun el proyecto no está terminado al cien por ciento y no hay versiones
para cada SO y para cada versión.
Según [18] se afirma que todo lo que se realiza en mono funciona en .NET, pero a
lo contrario no se obtiene la misma compatibilidad.
4.3.1 Especificaciones
4.3.2 Prueba 1
4.3.2 Prueba 2
Nota: El IDE visual Studio 2008 posee un servidor de desarrollo Asp.NET, el cual brinda al
desarrollar velocidad a la hora de desarrollar cualquier aplicación, en este caso Servicios
Web.
4.3.3 Prueba 3
Uso del Procesador Al iniciar Visual Studio .NET: Pico más alto 91 %
aproximadamente por 1 Segundo
4.3.4 Prueba 4
Visual Studio .NET permite trabajar diferentes proyectos en la misma instancia del Visual
que se ejecute, y también permite crear otras instancias para trabajar los proyectos en
instancias diferentes. A diferencia de NetBeans que solo permite trabajar todos los
proyectos en una sola instancia. Cabe mencionar que para trabajar varios proyectos en
una misma instancia es más intuitivo NetBeans que Visual Studio
4.3.5 Realizando un Servicio Web
4.3.5.3 Prueba 5
El segundo tiempo que aparece en NetBeans es debido que este no crea servicios Web
“netamente puros”, ya que, es necesario por ejemplo crear una aplicación Web, que
corresponde al primer tiempo y luego a este crearle un nuevo servicio Web que
corresponde al segundo tiempo.
Al realizar un nuevo proyecto de Servicio Web en Visual Studio .NET 2008, genera un
método de de Servicio Web por defecto. Cuyo nombre es HelloWorld y tiene como retorno
un String por defecto, el cual permite modificarlo: al borrar y escribir código; ya sea el
nombre del método, el retorno del método, la programación del método y la variable de
retorno final. También es posible agregar nuevos métodos al mismo servicio Web al
escribir un nuevo método o al copiar al método y realizándole los cambios respectivos
desde el nombre, retorno, programación. Las librerías que aparecen al principio fueron
generadas de forma automática en el momento de crear un nuevo servicio Web.
A diferencia de Visual .NET 2008 NetBeans, no crea ningún método por defecto genera
2 opciones para crear el método:
Que termina generando el siguiente método en NetBeans equivalente del HelloWorld solo
hay que modificar el retorno por un “HelloWorld” de Visual Studio, y que es posible, tanto
escribir el código de la implementación, como crear otros métodos; realizando los pasos
antes mencionados.
No se destaca las 13 líneas de códigos de Visual Studio frente a las 10 líneas de códigos
NetBeans; ya que estas son generadas automáticamente por cada IDE, lo importante son
las líneas de código de las implementaciones complejas que se pretenda realizar.
4.3.5.6 Prueba 6
Tiempo que demora cada IDE en compilar y subir el Servicio Web en su respectivo
Servidor
Cuando se ejecuta o se sube el servicio Web en visual Studio de forma correcta aparece
una página en el browser como la siguiente
Donde se puede testear el servicio haciendo click en el nombre del método “HelloWorld”
y ver el WSDL haciendo click en “descripción de servicio”
4.3.5.8 Testear el Servicio Web y ver el Wsdl desde NetBeans
En NetBeans se puede testear o ver el archivo WSDL haciendo click derecho sobre el
servicio Web del proyecto y escoger la opción de test Web Service
Para testear el servicio Web se hace click en el botón que tiene el nombre del método el
cual se le quiere aplicar. Para ver el WSDL se debe hacer click en link “WSDL File”
Es necesario tener en cuenta a la hora de construir servicios Web en NetBeans, que no
se puede crear un servicio Web con el mismo nombre del método de ese mismo Servicio
Web, a diferencia de Visual Studio.
Para realizar un cambio de nombre del método, tipo de retorno, parámetros de entradas,
del servicio Web en visual Studio se realizan manualmente adicionando y sustrayendo el
código necesario para llevar a cabo los cambios que a si se requieran. No es posible
cambiar el nombre del servicio Web desde el mismo Visual Studio.
Tanto NetBeans como Visual Studio ofrecen un explorador o ventanas para agregar
servidores de BD. Creación de bases de datos, conexión de datos, ejecución de consultas
de BD.
4.3.6.2 Conexión en VS
Figura 44. Asistente para agregar una nueva conexión en visual Studio
Una aplicación ASP.NET debe conectar con una base de datos a través de un proveedor
de OLE DB. Éste actúa como un intérprete que permite a la aplicación ASP.NET
comunicarse con una base de datos [19].
Se crea un nuevo proyecto por defecto de este ejemplo una aplicación Web como se
explico en el apartado (4.3.5.1). Se hace click derecho y se escoge la opción Web Service
Client como se observa a continuación:
Luego se copia la URL del Wsdl en WSDL URL no importa si el servicio es J2EE o .NET
como se indica en la siguiente figura
Figura 46. Asistente de Adición de Referencia Web
Luego aparece el siguiente Wizard El cual pide el nombre de la clase y el paquete en que
va estar contenida la clase que se creará
Luego se hace click derecho dentro de este método para llamar el WS_Reference como
se muestra en la siguiente figura:
Se crea un nuevo proyecto por defecto de este ejemplo una aplicación Web como se
explico en el apartado (4.3.5.2). Se hace click derecho y se escoge la opción Agregar
Referencia Web como se observa a continuación:
Luego aparece el siguiente Wizard y se pega la dirección URL del servicio Web, se le
coloca un nombre a esta referencia en este caso “MiServicio” y por último se le da click en
Agregar Referencia
Figura 56. Asistente de Referencia Web
Al ser visual Basic .NET un lenguaje orientado a evento se procede a programar en “Load
Page” haciendo click en el botón diseño y luego hacer doble click en alguna parte de la
página, el cual genera el siguiente código:
Figura 58. Método Page_Load
Luego se dimensiona una variable tipo servicio Web y utilizando la auto completación es
posible manipular los métodos que contenga de acuerdo a lo que se necesite o de
acuerdo a la forma que se vaya a emplear:
Luego de haber estudiado y comparado los tiempos que demora en realizar algunas
operaciones básicas para construcción de Servicios Web tanto en NetBeans como en
Visual Studio se pueden concluir los siguientes aspectos:
Iniciar Visual Studio requiere un tiempo promedio mucho menor que NetBeans lo
cual genera además de un ahorro en el tiempo para realizar cualquier tipo de
aplicación, también esto implica un consumo mucho menor de los recursos del
sistema computo en el momento de realizar un arranque de Visual Studio frente
NetBeans IDE.
Normalmente cuando se realizan Servicios Web es necesario ejecutar un servidor
de aplicación. En el caso de NetBeans el GlassFish tarda un tiempo largo si se
compara con el servidor IIS que utiliza Visual Studio el cual hay una diferencia
promedio de aproximadamente 35 segundos de acuerdo a los datos arrojados en
la prueba 2.
Aunque VS posee mayor soporte de lenguaje que NetBeans, el problema principal del
Visual Studio es que Microsoft solo tiene disponible esta herramienta para el entorno de
sistema operativo Windows, obligando a si a desarrollar el servicio web bajo este sistema
operativo a diferencia de NetBeans que hay disponibilidad en diferentes SO,
proporcionando así más flexibilidad a los desarrolladores que empleen esta herramienta
frente a VS, a demás en el caso particular de los WS es posible transportar el archivo
.WAR generado por NetBeans y llevarlo a otras plataformas acoplándose con otros
servidores de aplicación y SO.
4.4 Interoperabilidad
4.4.1 WS – I
Correcto:
<wsse:SecurityTokenReference xmlns:wsse='http://docs.oasis-
open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd'>
<wsse:KeyIdentifier ValueType='http://docs.oasis-open.org/wss/oasis-wss-saml-
token-profile-1.0#SAMLAssertionID'>
uuid: 006ab385-35e0-41b1-b0f5-ccef5090c1b0
</ PSES: KeyIdentifier>
</ PSES: SecurityTokenReference>
Incorrecto:
<! - Este ejemplo es incorrecto porque el PSES: KeyIdentifier elemento
le falta un atributo ValueType por lo tanto conflicto con R6602 ->
<wsse:SecurityTokenReference xmlns:wsse='http://docs.oasis-
open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd'>
<wsse:KeyIdentifier> uuid: 006ab385-35e0-41b1-b0f5-ccef5090c1b0 </
PSES: KeyIdentifier>
</ PSES: SecurityTokenReference>
Incorrecto:
<! - Este ejemplo es incorrecto porque el PSES: KeyIdentifier elemento
tiene un valor incorrecto para el atributo ValueType por lo tanto, en
conflicto con R6603 ->
<wsse:SecurityTokenReference xmlns:wsse='http://docs.oasis-
open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd'>
<wsse:KeyIdentifier ValueType='http://docs.oasis-open.org/wss/oasis-
wss-saml-token-profile-1.0#SAML'>
uuid: 006ab385-35e0-41b1-b0f5-ccef5090c1b0
</ PSES: KeyIdentifier>
</ PSES: SecurityTokenReference>
Incorrecto:
<! - Este ejemplo es incorrecto porque el PSES: KeyIdentifier ha
EncodingType un atributo por lo tanto, en conflicto con R6604 ->
<wsse:SecurityTokenReference xmlns:wsse='http://docs.oasis-
open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd'>
<PSES: KeyIdentifier ValueType = 'http://docs.oasis-
open.org/wss/oasis-wss-saml-token-profile-1.0 # SAMLAssertionID "
EncodingType = 'xs: string'>
uuid: 006ab385-35e0-41b1-b0f5-ccef5090c1b0
</ PSES: KeyIdentifier>
</ PSES: SecurityTokenReference>
Según [35] y [36] Existen algunos Stack que se basan en las normas o perfiles de WS-I.
Como son METRO y WCF.
Según [16], Metro contiene a JAX-WS (lo que incluye a JAXB, JAXP, StAX, SAAJ;
utilizado para el mapeo de XML a objetos y viceversa) y WSIT (Tecnología de
Interoperabilidad de los Servicios Web) que garantizar la interoperabilidad y una mejor
fiabilidad, seguridad, y transaccionabilidad de los servicios web. Según [15], WCF integra
un conjunto de tecnologías proporcionadas por .NET Framework, tales como ASMX),
.NET Remoting, Enterprise Services y Web Services Enhancements. Para ver más sobre
WSIT ir al apartado 4.1.1.4 y para WSE ir al apartado 4.1.2.1.1.
Sun Microsystems y Microsoft conjuntamente prueban Metro contra WCF, para garantizar
que los servicios y clientes Web de Sun, interoperen con las aplicaciones de servicio web
de WCF y viceversa. Estas pruebas garantizan que los objetivos de interoperabilidad
siguientes sean realizados:
Servicios y Clientes Web WCF pueden acceder y consumir Servicios web de Metro
Como dice en [35], estas pruebas de interoperabilidad se realizan en las siguientes áreas
Transaccionabilidad, Fiabilidad de Mensajes, Seguridad a nivel de mensajes.
La red se encuentra con más tráfico que el ancho de banda asignado puede
manejar.
Una manera de hacer frente a estos problemas es codificando los objetos binarios a fin de
optimizar la aplicación SOAP en el tiempo de procesamiento y en el ancho de banda
necesario para transmitir el mensaje a través de la red. En resumen, XML debe ser
optimizado para servicios web. Esto es exactamente lo que hace la tecnología de
optimización de mensajes. Se asegura de que los mensajes Soap de los Servicios Web
sean transmitidos a través de la Internet de la manera más eficiente [35].
Este prototipo de WS no presento ningún tipo de problema tanto en J2EE como en .NET,
el cual demuestra de forma clara que es posible conseguir interoperabilidad entre estas
dos plataformas con la utilización de servicios web.
Con tipos de datos tanto primitivos o simple (como: int, float, boolean, u otros) como
complejos (arraylist, vector, otros) no se presento ningún error. El único inconveniente se
generó al realizar un WS en la plataforma .NET, al momento de retornar un DataSet,
aplicado a la base de datos del prototipo .NET.
Imports System.Web
Imports System.Web.Services
Imports System.Web.Services.Protocols
Imports System.Data.OleDb
Imports System.Data
' Para permitir que se llame a este servicio web desde un script, usando
ASP.NET AJAX, quite la marca de comentario de la siguiente línea.
' <System.Web.Script.Services.ScriptService()> _
<WebService(Namespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class Service
Inherits System.Web.Services.WebService
<WebMethod()> _
Public Function BUSCAR(ByVal nombre_de_banco As String) As DataSet
Dim conexion As OleDbConnection
Try
conexion = New
OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0; " & "Data
Source=C:\banconet.mdb;")
Dim Qry As String = "Select * From " &
nombre_de_banco
Dim cmd As New OleDbCommand(Qry, conexion)
Dim ds As New DataSet
Dim da As New OleDbDataAdapter(cmd)
If conexion.State <> Data.ConnectionState.Open Then
conexion.Open()
End If
da.Fill(ds)
conexion.Close()
Return ds
Catch ex As Exception
Return Nothing
End Try
End Function
End Class
Debido a que la estructura del Dataset no se conoce hasta tiempo de ejecución, no hay
manera para el WSDL de describir su estructura interna. El valor de retorno (elemento
BUSCARResponse) del método BUSCAR tiene dos elementos, un elemento de tipo any
(<s:any/>) que es en efecto un tipo de objeto y un XML Schema (<s:schema>) que en
tiempo de ejecución describirá la estructura del DataSet de retorno [37].
A continuación se muestra el resultado del mensaje Soap producido por el método antes
descrito
Figura 61. Mensaje Soap Del DataSet Parte1
Al utilizar DataSet se generan varios problemas debido a que el desarrollador del cliente
no sabe la estructura del objeto que el método devolverá, no podrán generar un proxy
muy útil. El segundo problema cuando se utiliza DataSet desde un servicio web es la
gran cantidad de datos que se envía. El XML anterior sólo describe la estructura de un
DataSet con una tabla. Mientras se añaden tablas, relaciones y claves, el Schema se
vuelve más complejo y más grande. De hecho, rápidamente puede adquirir un tamaño
mayor que los datos que se devuelven [37].
El test se realizo con 25 usuarios virtuales con repeticiones por usuarios de 500. Las
URLs que se utilizaron es la de cada aplicación clientes del prototipo realizado. Ver
[Anexo III y IV]
4.5.1.1 J2EE
4.5.1.2 NET
La grafica del resumen del estado de las transacciones provee o muestra las peticiones
pendientes en un instante, las respuestas pendientes, como el estado de las respondidas.
La descarga al iniciar y la descarga al terminar.
4.5.2.1 J2EE
4.5.2.2 .NET
Las 2 tablas anteriores refleja que J2EE recibió 12500 peticiones que equivalen a los 25
usuarios virtuales activados con repeticiones por cada uno de 500, el cual respondió
todas las peticiones generando respuesta para cada usuario. A diferencia de .NET que
aunque respondió 12500 peticiones, recibió más de esa cantidad, ya que, el tiempo de
respuesta en algunas peticiones expiro, lo cual el programa de test genero peticiones
adicionales para completar las 12500 peticiones.
Esta grafica muestra el conteo de los usuarios virtuales activos durante la ejecución del
test.
4.5.3.1 J2EE
4.5.3.2 .NET
Esta grafica muestra el número de peticiones HTTP/S hechas por los usuarios Virtuales al
servidor durante cada segundo de la ejecución
4.5.4.1 J2EE
4.5.4.3 Análisis 3
Se observa que el número de peticiones hechas por los usuarios virtuales al Servidor
J2EE toma diferentes valores desde 1 hasta 25, a diferencia del IIS que aunque también
fluctúa lo hace en menor grado. Esta diferencia de valores es producida por la diferencia
de rendimiento de cada uno.
El siguiente gráfico muestra la cantidad de datos en bytes que los usuarios virtuales
recibieron del servidor en segundos. Esto depende de la carga y la transacción que el
usuario realiza.
4.5.5.1 J2EE
4.5.5.2 .NET
Se observa que el rendimiento de Bytes por Segundo presentado en GlassFish fue menor
que el presentado en el IIS, ya que se presentaron valores máximos aproximados de 21
000 Byte/Seg y de 72 000 Bytes/Seg respectivamente.
Este gráfico indica el porcentaje de error en cada tipo del error expresado como un
porcentaje de errores totales en cada transacción.
4.5.6.1 J2EE
4.5.6.2 .NET
4.5.6.3 Análisis 5
Denegación de direcciones IP. Los servicios IIS permiten limitar las aplicaciones de forma
que sólo sirvan un número determinado de solicitudes, lo que podría resultar útil para
denegar el acceso a los usuarios o direcciones IP que se sabe que tienen malas
intenciones. No obstante el otro error presentado en el IIS no se encontró código de error
específico, el cual se asume como algunas peticiones pendiente producido por qué expiro
el tiempo de respuesta, tal vez producido por un posible cuello de botella.
4.5.7.1 .NET
Este gráfico indica la proporción del error expresada como un porcentaje de golpes o Hit
totales durante la ejecución del test para cada transacción.
4.5.8.1 J2EE
4.5.8.2 .NET
De las anteriores tablas cabe destacar que el promedio de respuesta del servidor de .NET
fue menor que del GlassFish cuyos valores respectivos fueron 1254 ms. y 1378 ms.
Obteniéndose así una diferencia de 124 milisegundos, lo que hace que el IIS sea unos
milisegundo más rápido, dándole así más velocidad a las aplicación realizada en .NET y
que trabajen con el servidor IIS. No obstante en el test se presentaron valores superiores
e inferiores en tiempo de respuestas, ya que estos valores no son constantes si no
variables en el tiempo.
Este gráfico muestra el promedio del tiempo de respuesta de cada transacción con el
tiempo. De este gráfico es posible identificar las transacciones que tiene un tiempo de
respuesta largo.
4.5.9.1 J2EE
4.5.9.3 Análisis 7
Se observa claramente que al principio el Servidor IIS respondía con valores de 63000
milisegundos antes de activar cualquier usuario virtual, luego cuando se activaron los 24
usuarios el servidor respondió con valores de aproximadamente 49000 milisegundos y
luego al activar el último usuario bajo el tiempo de respuesta de acuerdo a la Tabla 25. El
servidor GlassFish a diferencia del IIS empezó con tiempos de respuesta mucho menor;
estos valores fueron aproximadamente 30000 milisegundos antes de activar cualquier
usuario, cuando se activaron los 25 usuarios el servidor respondió con valores menores
de 2000 milisegundo de acuerdo a la Tabla 26.
Este gráfico muestra el tiempo que el servidor tomó para responder contra la cuenta de
usuarios a ese punto de tiempo. Ayuda a identificar el tope de los usuarios simultáneo
máximo que el servidor puede responder tan rápidamente como sea posible.
4.5.10.1 J2EE
4.5.10.2 .NET
4.5.10.3 Análisis 8
Inicialmente el IIS inicio con 24 usuarios con un tiempo de respuesta del servidor
aproximadamente 49000 milisegundos y bajo a menos 1000 milisegundo al activar el
usuario número 25, en menos de 1 segundo. A diferencia del Servidor de J2EE que activo
los 25 usuarios con un tiempo menor de 700 milisegundos y lo mantuvo “constante”
4.5.11 Usuarios contra el rendimiento
Este gráfico muestra la cantidad de datos en bytes que recibieron del servidor. Esto
depende de la carga y las transacciones ejecutadas por los usuarios. Ayudas a estudiar
los datos a la velocidad transferida del servidor de aplicación.
4.5.11.1 J2EE
4.5.11.2 .NET
4.5.11.3 Análisis 9
Inicialmente el IIS inicio con 24 usuarios con un rendimiento por descargas medidos en
bytes de 170 bytes por milisegundos y la velocidad de descargas aumento en menos de 1
segundo al tiempo que completo el ultimo usuario (de 24 usuarios a 25 usuarios) su nueva
velocidad de descarga era aproximadamente de 1270 bytes por milisegundos
aproximadamente. A diferencia del Servidor GlassFish que activo los 25 usuarios con una
velocidad de descarga de 830 bytes por milisegundos, el cual se mantuvo constante.
Donde es notable la ventaja que tiene el servidor IIS frente al de GF con una diferencia
entre ambos de aproximadamente de 500 bytes por milisegundos permitiendo ser más
veloz
4.5.12.1 J2EE
4.5.12.3 Análisis 10
Este gráfico muestra el promedio del tiempo de las página transmita o descargada para
todas las transacciones por tiempo. Ayuda a identificar los picos en tiempos de descargas
cuando el servidor es continuamente cargado
4.5.13.1 J2EE
4.5.13.2 .NET
4.5.13.3 Análisis 11
4.5.14.2 .NET
4.5.14.3 Análisis 12
Este grafico muestra el tiempo de descarga por páginas, imagines y otros contenidos por
cada Página.
4.5.15.1 J2EE
4.5.15.2 .NET
Esta página muestra los detalles de ejecución del test como el estado de las
transacciones, los errores de la prueba detalla en gráfico, promedio del tiempo respuesta,
la cuenta del usuario, el tiempo de descarga de las páginas, promedios, etc.
4.5.16.1 J2EE
4.5.16.3 Análisis 14
En el resumen anterior se muestra la diferencia entre los 2 test realizado a J2EE y .NET
respectivamente el primero de mora un tiempo de 1896 segundos y el segundo demora
1856 segundos, una diferencia de 40000 milisegundos. El primero tuvo un tiempo mínimo
de respuesta promedio en el servidor de 1378 milisegundo el segundo tuvo 1254
milisegundos. El primero tuvo un tiempo mínimo de páginas descargadas de 60
milisegundo el segundo tuvo un tiempo mínimo de 7 milisegundo. El primero tuvo un
rendimiento mínimo de 5509 bytes/segundos el segundo tuvo un mínimo de 14533 bytes /
segundos. El primero tuvo un total de 1 MB transferido, el segundo tuvo un total de 2 MB
transferido.
4.5.17 Analizando el desempeño entre J2EE y .NET utilizando otras Investigaciones
En esta investigación se crearon cuatro clientes, dos en ASP.NET y dos en JSP. Uno de
los clientes ASP .NET accede a los servicios web desarrollados en EJB, mientras que el
otro accede de forma similar a los servicios web desarrollados en ASP .NET. Del mismo
modo, uno de los clientes JSP invoca los servicios web desarrollados en ASP .NET y el
otro accede a los servicios web desarrollados en EJB. Los cuatro clientes se comparan
para diferentes cargas y estrés.
Después de haber realizado el test con AdventNet QEngine para evaluar cual plataforma
presenta un mayor de Desempeño se concluye lo siguiente:
Además del test que se presenta en este capítulo se hicieron repeticiones del
mismo con más o con menos usuarios y se observo que el rendimiento medido en
la descarga de bytes por milisegundo que se observo en las tablas del apartado
4.5.11, en las repeticiones de los test para el caso del servidor GlassFish siempre
se mantuvo constante, en caso del servidor IIS se obtuvieron valores por encima
de los obtenidos con GlassFish, los valores máximos obtenidos en otros test
fueron de aproximadamente 45000 bytes por milisegundos.
Presupuesto General
Personal $ 2.808.000
Material inventariable $ 1.840.000
Material No
inventariable $ 222.000
TOTAL $ 4.870.000
PERSONAL
Descripción Dedicación Cantidad Valor-Mes Meses Valor Total
Director de proyecto 2 Horas semanales 1 $ 0 6 $ 0
Autor 8 Horas diarias 1 $ 468.000 6 $ 2 808 000
Total $ 2.808.000
Material Inventariable
Descripción Cant Valor Total
Computador Intel(R)/Celeron(R)2.80GHz/1,5-GB RAM/
1. DVD-RW/CD-RW/Monitor de 15 pul AOC 1 $ 1400000 $ 1400000
2. Mesas para computador 1 $ 150000 $ 150000
3. Sillas para computador 1 $ 50000 $ 50000
4. Impresora de tinta APOLLO P-2600 1 $ 130000 $ 130000
5. Scanner 1 $ 110000 $ 110000
Total $ 1840000
Material No Inventariable
Descripción Cant Valor Total
1. CD 12 $ 1000 $ 12000
2. Papelería, Fotocopias, impresiones 1 $ 60000 $ 60000
3. Tinta negra para Impresora Apollo 1 $ 40000 $ 40000
4. Tinta de color para Impresora Apollo 1 $ 60000 $ 60000
5. Memoria USB de 512 MB 1 $ 50000 $ 50000
Total $ 222000
FUENTES DE FINANCIACIÓN
Para la realización de este trabajo de grado los recursos económicos fueron totalmente
financiados por mis padres y demás familiares.
MARCO LEGAL
Java DB: Java DB se basa en el Apache Derby proyecto de código abierto, el cual
se puede descargar es su última versión de [29], pero para la realización del
prototipo se utilizo el Java DB que viene integrado con el IDE NetBeans.
Tanto NetBeans como Visual Studio son herramientas potentes que ayudan a
crear aplicaciones por capas, y a que los desarrolladores se concentren
únicamente en la lógica de negocio. En el desarrollo de servicios web cada una
demostró tener los instrumentos necesarios para construir servicios y clientes web.
La ventaja obtenida al comparar los dos IDE se encuentra a favor de Visual Studio.
Aspectos como el IDE marca la diferencia cuando el factor tiempo de desarrollo, es
de suma importancia en lo que se pretende realizar, aun cuando se trata de
servicios web o de cualquier clase de aplicación, decidiéndose así por optar por
una solución .NET cuando se da esta clase necesidad.. Por otro se resalta el
hecho que NetBeans es una de tantas herramientas para construir servicios en
J2EE. Además cuando se cuenta con aplicaciones con diferentes sistemas
operativos, la utilización de Visual Studio se convierte en un problema. Entonces
en un escenario como este la mejor solución es J2EE, ya que, la mayoría de las
herramientas para construir servicios se pueden instalar en cualquier sistema
operativo.
Tanto J2EE como .NET ofrecen un buen grado de desempeño óptimo, para
realizar soluciones empresariales basadas en Servicios Web, y aunque en las
pruebas realizadas se nota una superioridad de .NET, sería bueno realizar otras
pruebas con otras características, como se menciona en las recomendaciones de
este documento. No obstante de acuerdo a los resultados obtenidos de las
pruebas realizadas de desempeño, se recomienda utilizar servicios web .NET para
lograr el máximo desempeño, y de acuerdo a Maneesh como se estudio en [21],
se aconseja si es posible, utilizar clientes construidos en la misma plataforma
donde se realizaron los servicios web como tal, para conseguir un mejor
desempeño.
RECOMENDACIONES
Este documento puede ser utilizado para investigaciones futuras donde se estudie o se
analicen criterios de comparación en un área diferente a los servicios web como por
ejemplo componentes o aplicaciones web, entre otros.
Algoritmo: Un algoritmo es una serie de pasos organizados que describe el proceso que
se debe seguir, para dar solución a un problema específico.
API: Interfaz de Programación de Aplicaciones.
ASP: Active Server Pages (ASP) es una tecnología de Microsoft.
BD: Base de Datos.
CLASS: Extensión generado al compilar una clase Java en Bytecode
Código Gestionado: Código de un programa de computador que se ejecuta bajo la
gestión de una máquina virtual.
Código No Gestionado: Código de un programa de computador que se ejecuta
directamente por la CPU del computador.
Componente de Software: son aquel recurso desarrollado para un fin concreto y que
puede formar solo o junto con otro/s, un entorno funcional requerido por cualquier proceso
predefinido. Son independientes entre ellos, y tienen su propia estructura e
implementación.
Containers: Contenedores.
CPU: Unidad de Proceso Central.
Deploya(r): Desplega(r).
Desencriptar: Proceso inverso de encriptación que permite ver una información que se
había protegido.
ENCRIPTAR: Acción de proteger información para que no pueda ser leída sin una clave.
FIREWALL: Corta Fuegos, es un elemento de hardware o software utilizado en una red
de computadoras para controlar las comunicaciones, permitiéndolas o prohibiéndolas
según las políticas de red que haya definido la organización responsable de la red.
FTP: Protocolo de transferencia de Archivos.
GET: Comando del Protocolo HTTP que solicita el recurso ubicado en la URL especifica.
GF: Servidor GlassFish de J2EE.
HTML: Lenguaje de Marcas de Hipertexto
HTTP: Protocolo de transferencia de Hipertexto
HTTP/S: Protocolo de transferencia de Hipertexto seguro
IDE: Entorno de Desarrollo Integrado.
IU: Interfaz usuario.
JAXP: API de Java para el Procesamiento de XML
JDBC: Conectividad de Bases de Datos de Java.
JSP: Java Server Pages, que en español seria Páginas de Servidor Java. Es una
tecnología orientada a crear páginas web con programación en Java.
JVM: Maquina Virtual de Java
LP: Lenguaje de programación.
Llave Pública: Clave que se utiliza para desencriptar información.
Llave Privada: Clave que se utiliza para encriptar una información.
NNTP: Network News Transfer Protocol
POST: Comando del Protocolo HTTP que Envía datos al programa ubicado en la URL
especificada.
ROUTER: Enrutador.
SAAJ: SOAP with Attachments API for Java. Suministra una manera estándar de enviar
documentos XML sobre Internet desde la plataforma Java.
SCHEMA: Es un vocabulario basado en XML para describir instancias de documentos
XML. Un “schema” describe una clase de documentos, del cual pueden haber varias
instancias. Esta relación es parecida a la que hay entre clases y objetos en los sistemas
orientados a objetos.
SI: Sistemas de Información.
SMTP: Simple Mail Transfer Protocol (SMTP), Protocolo Simple de Transferencia de
Correo.
SQL: Lenguaje de Consulta Estándar o Universal.
StAX: Streaming API for XML. Para tratar los documentos XML de forma más rápida.
SUN: Sun Microsystems, empresa productora de software.
URI: Identificador Uniforme de Recursos.
URL: Localizador Uniforme de Recursos.
VS: Visual Studio.
W3C: World Wide Web Consortium.
WS: Web Service(s). Servicio(s) Web.
WSS: WS-Security.
BIBLIOGRAFÍA Y REFERENCIAS WEB
[01] Edgardo Alberto Romero Masis. Estado del Arte de la Tecnología de Web Services.
Septiembre del 2004. Disponibilidad Septiembre 2008.
http://www.juliux.org/tesis/webservices/Web_Services_final.doc.
[02] Vadim Paz Madrid Gorelov y Juan Francisco De Paz Santana. Articulo Servicios
Web. Disponibilidad Septiembre 2008. http://zarza.usal.es/~fgarcia/doctorado/iweb/05-
07/Trabajos/ServiciosWeb.pdf
[03] Consorcio World Wide Web. Guía Breve de Servicios Web. Disponibilidad
Septiembre 2008. http://www.w3c.es/
[07] Miguel Ángel Garrido Pino. Evaluación Comparativa de aplicaciones Web entre J2EE
y Microsoft. NET. 2006. Disponibilidad Septiembre 2008.
http://biblioteca.uct.cl/tesis/miguel-garrido/tesis.pdf
[08] Lía Molinari. Arquitecturas Orientadas a Web Services abril 2004 Disponibilidad
marzo 2007 http://www.sedici.unlp.edu.ar/search/request.php
[13] Geir Bostad. Supporting SAM: Infrastructure Development for Scalability Assessment
of J2EE Systems. October 2006. Disponibilidad Septiembre 2008.
http://daim.idi.ntnu.no/masteroppgaver/IME/IDI/2002/3289/masteroppgave.pdf
[17] Ejemplo de UserNameTokens. Securing .NET Web Services with the WS-Security
Protocol. Disponibilidad Septiembre 2008.
http://www.devx.com/dotnet/Article/19986#codeitemarea
[18] Artículo Servicios web con Mono. Disponibilidad Septiembre 2008. http://ruido-
blanco.net/blog/archivos/2003/09/18/servicios-web-con-mono/
[19] Consumidores y proveedores OLE DB. http://msdn.microsoft.com/
[22] William Vásquez Romero y Juan Guillermo Rojas. Mecanismos de Control de Acceso
en Web Services. Diciembre 2004. Disponibilidad Septiembre 2008.
http://www.javeriana.edu.co/biblos/tesis/ingenieria/Tesis208.pdf
[24] Jorgen Thelin. Identity, Security, and XML Web Services. Disponibilidad Septiembre
2008. http://www.idealliance.org/papers/dx_xmle03/papers/03-04-06/03-04-06.pdf
[28] Nathalie M. Aquino Salvioni Juan Carlos Frutos Acosta. Fundamentos de la Máquina
Virtual Java y el Entorno .NET. Octubre de 2002. Disponibilidad Septiembre 2008.
http://www.jeuazarru.com/docs/Java_y_PuntoNET.pdf
[29] Chad Vawter y Ed Roman. J2EE vs. Microsoft.NET. Junio de 2001. Disponibilidad
Septiembre 2008. http://www.sun.com/
[32] Adrián Delfino, Sebastián Rivero, Marcelo San Martín. Ingeniería de Tráfico en Redes
MPLS. http://iie.fing.edu.uy/investigacion/grupos/artes/fce/net -
te/Ingenieria_de_Trafico_en_Redes_MPLS.pdf
[37] Paul Ballard Top 5 Web Service Mistakes. Mayo 2005. Disponibilidad Septiembre
2008. http://www.theserverside.net/tt/articles/showarticle.tss?id=Top5WSMistakes
[38] John Jairo Méndez R. Análisis comparativo entre J2EE y .NET. Noviembre 2008.
http://www.j2ee-vs-net.blogspot.com/
ANEXO I
El hecho de publicar una serie de servicios Web accesibles a todo el mundo puede
suponer una ventaja comercial, pero en ocasiones, la seguridad en determinados
servicios puede ser de vital importancia, y es necesario evitar acceso de terceros a la
información que viaja en los mensajes SOAP, o la alteración de los mismos y evitar
ataques de negación de servicio. Para poder ofrecer al cliente seguridad en la
comunicación con los proveedores de servicios se utiliza una combinación de las
siguientes características, según [22]:
2. Tipos de ataques
3.1 WS-Policy
Así como el nombre lo implica, WS-Policy permite a una organización que expone un Web
Service especificar una política para ese servicio. La política detalla que capacidades y
limitaciones presenta un servicio en materia de seguridad, por ejemplo, qué tipo de
algoritmo cifrado soporta y que parámetros necesitan para la encriptación. La política
puede ser utilizada para descubrir de un servicio, sus capacidades y limitaciones en
materia de seguridad, similar a cómo WSDL se utiliza para describir las características
generales de un servicio [34].
3.2 WS-Trust
Describe como las relaciones de confianza son creadas, direct o brokered. En el caso de
los Web Services y la seguridad, la confianza significa que se puede confiar en relación
con la autenticidad y la autorización de una entidad, si un tercero en que puedes confiar
da fe de ello. Ejemplos comunes de confianza son los modelos de PKI (modelo de
confianza jerárquica) y PGP (un modelo de red de confianza). El modelo WS-Trust
también permite que la delegación y la suplantación se lleven a cabo. Esto significa que
un mensaje SOAP no es enviado directamente al usuario final, sino que un programa de
software actúa en su nombre, un token de seguridad que contiene información se retorna
de vuelta al usuario final insertado en el mensaje. [34].
3.3 WS-SecureConversation
3.4 WS-Federation
3.5 WS-Authorization
3.6 WS-Privacy
3.7 WS-Security
Según [24] las especificaciones de WS-Security defines los siguientes tipos de Tokens de
seguridad:
UserNameTokens.
Seguridad de Tokens con Firmas
UserNameTokens
Verificador / Firma
El Token muestra que ha sido firmado, de conformidad con la Firma Digital XML de la
especificación [XML Signature], y el uso de la información clave del certificado X.509 para
calcular el hash de la firma [24].
ANEXO II
1. Plataforma .NET
1.1 CLR
La plataforma .NET, desarrollada por Microsoft, ofrece al igual que otras propuestas como
java la ventaja de que la programación, no se realice para un determinado procesador o
sistema operativo como anteriormente se hacía, si no por el contrario Microsoft adopta
esta idea en .NET creando CLR, que viene siendo el equivalente en .NET del JRE de
Java utilizado por J2EE.
Las DLL's, es un problema que radica en que al sustituirse bibliotecas antiguas por
nuevas, puede que aplicaciones antiguas que fueron diseñadas para ser
ejecutadas con las bibliotecas antiguas, dejen de funcionar correctamente o
simplemente dejen de funcionar. En la plataforma .NET, las versiones nuevas de
las bibliotecas DLL pueden coexistir con las versiones antiguas. Esto facilita
mucho la tarea de instalación y desinstalación de software.
Ejecución multiplataforma
Integración de lenguajes
Recolección de basura
El CLR incluye un recolector de basura, que evita que el programador tenga que
tener en cuenta cuándo es necesario liberar la memoria de los objetos que ya no
se utilizan. Este recolector es una aplicación que se activa cuando se crea un
nuevo objeto y no exista memoria para crearlo. El recolector busca en la memoria
dinámica de la aplicación por aquellos objetos que no pueden ser accedidos a
través del código de la aplicación, y los elimina, liberando la memoria necesaria
para crear el nuevo objeto. Gracias al recolector de basura, se evitan errores muy
típicos como el acceso a objetos que ya no existen, eliminación de objetos ya
borrados o agotamiento de memoria por no eliminar los objetos innecesarios.
Seguridad de tipos
Aislamiento de procesos
Soporte Multihilo
Según [28], para poder ejecutar el lenguaje intermedio de Microsoft (MSIL), primero se
debe convertir éste, mediante un compilador Just-In-Time (JIT) o jitter, es el que genera el
código máquina real que se ejecuta en la plataforma del cliente. Common Language
Runtime proporciona un compilador JIT para cada arquitectura de CPU compatible. De
esta forma se consigue con .NET independencia de la plataforma de hardware. La
compilación JIT la realiza el CLR a medida que el programa invoca métodos. El código
ejecutable obtenido se almacena en la memoria caché del computador, siendo
recompilado de nuevo sólo en el caso de producirse algún cambio en el código fuente.
Este jitter se distribuye en tres versiones:
jitter normal: Es el que se suele usar por defecto, y sólo compila el código MSIL a
código nativo a medida que va siendo necesario, pues así se ahorra tiempo y
memoria al evitarse tener que compilar innecesariamente código que nunca se
ejecute. Para conseguir esto, el cargador de clases del CLR sustituye inicialmente
las llamadas a métodos de las nuevas clases que vaya cargando por llamadas a
funciones auxiliares (stubs) que se encarguen de compilar el verdadero código del
método. Una vez compilado, la llamada al stub es sustituida por una llamada
directa al código ya compilado, con lo que posteriores llamadas al mismo no
necesitarán compilación [28].
jitter económico: Funciona de forma similar al jitter normal, solo que no realiza
ninguna optimización de código al compilar sino que traduce cada instrucción
MSIL, por su equivalente en el código máquina sobre la que se ejecute. Esta
especialmente pensado para ser usado en dispositivos empotrados que dispongan
de poca potencia de CPU y poca memoria, pues aunque genere código más
ineficiente es menor el tiempo y memoria que necesita para compilar. Es más,
para ahorrar memoria este jitter puede descargar código ya compilado que lleve
cierto tiempo sin ejecutarse y sustituirlo de nuevo por el stub apropiado. Por estas
razones, este es el jitter usado por defecto en Windows CE, sistema operativo que
se suele incluir en los dispositivos empotrados antes mencionados. Otra utilidad
del jitter económico es que facilita la adaptación de la plataforma .NET a nuevos
sistemas, porque es mucho más sencillo de implementar que el normal. De este
modo, gracias a él es posible desarrollar rápidamente una versión del CLR que
pueda ejecutar aplicaciones gestionadas aunque sea de una forma poco eficiente,
y una vez desarrollada es posible centrarse en desarrollar el jitter normal para
optimizar la ejecución de las mismas [28].
prejitter: Se distribuye como una aplicación en línea de comandos llamada
ngen.exe mediante la que es posible compilar completamente cualquier ejecutable
o librería (cualquier ensamblado en general) que contenga código gestionado y
convertirlo a código nativo, de modo que posteriores ejecuciones del mismo se
harán usando esta versión ya compilada y no se perderá tiempo en hacer la
compilación dinámica.
Como parte de la compilación MSIL en código nativo, el código debe pasar un proceso de
comprobación, a menos que el administrador haya establecido una directiva de seguridad
que permita al código omitir esta comprobación. En esta comprobación se examina el
MSIL y los metadatos para determinar si el código garantiza la seguridad de tipos, lo que
significa que el código sólo tiene acceso a aquellas ubicaciones de la memoria para las
que está autorizado. La seguridad de tipos ayuda a aislar los objetos entre sí y, por tanto,
ayuda a protegerlos contra daños involuntarios o maliciosos. Además, garantiza que las
restricciones de seguridad sobre el código se aplican con toda certeza. Por ejemplo, un
código no permite el acceso a los campos de un objeto si esta acción sobrecarga las
ubicaciones de memoria [28].
Los tipos de datos básicos admitidos son bool, char, byte, short, int, long, float,
double, string y object.
En [05], dice que Mono es el nombre de un proyecto de código abierto iniciado por Ximian
y actualmente impulsado por Novell (tras su adquisición de Ximian), para crear un grupo
de herramientas libres, basadas en GNU/Linux y compatibles con .NET según lo
especificado por el ECMA.
Mono proporciona las funciones necesarias para crear servicios web, esto incluye las
tecnologías XML, SOAP, ASP.NET, y Remoting así como el acceso a bases de datos, a
través ADO.NET, de tipo Oracle, MySQL, DB2, SQL Server, o Progress.
Mono posee importantes componentes útiles para desarrollar software:
Una biblioteca de clases que puede funcionar en cualquier lenguaje que funcione
en el CLR (Common Language Runtime).
Un compilador para el lenguaje C#, MonoBasic (la versión para mono de Visual
Basic), Java y Python.
2. Plataforma J2EE
(En inglés Java Virtual Machine, JVM) es un programa nativo, es decir, ejecutable en una
plataforma específica, capaz de interpretar y ejecutar instrucciones expresadas en
un código binario especial (el Java bytecode), el cual es generado por el compilador del
lenguaje Java. El código binario de Java no es un lenguaje de alto nivel, sino un
verdadero código máquina de bajo nivel, viable incluso como lenguaje de entrada para
un microprocesador físico. Como todas las piezas del rompecabezas Java, fue
desarrollado originalmente por Sun Microsystems. La JVM es una de las piezas
fundamentales de la plataforma Java. Básicamente se sitúa en un nivel superior al
Hardware del sistema, y este actúa como un puente que entiende tanto el bytecode, como
el sistema sobre el que se pretende ejecutar. Así, cuando se escribe una aplicación Java,
se hace pensando que será ejecutada en una máquina virtual Java en concreto, siendo
ésta la que en última instancia convierte de código bytecode a código nativo del
dispositivo final.
Un usuario sólo necesita el JRE para ejecutar las aplicaciones desarrolladas en lenguaje
Java, mientras que para desarrollar nuevas aplicaciones en dicho lenguaje es necesario
un entorno de desarrollo, denominado JDK, que además del JRE (mínimo imprescindible)
incluye, entre otros, un compilador para Java [27].
El concepto de máquina virtual es antiguo. Fue usado por IBM en 1959 para describir uno
de los primeros sistemas operativos que existieron en la historia de la computación, el
VM. En 1970, el ambiente de programación de SmallTalk llevó la idea a un nuevo nivel y
construyó una máquina virtual para soportar abstracciones orientadas a objetos de alto
nivel, sobre las máquinas subyacentes.
Las máquinas virtuales tienen varias ventajas importantes. La primera es que presentan
un medio excelente para alcanzar la portabilidad. Otra de las ventajas importantes, es que
introduce otro nivel de abstracción y de protección, entre la computadora y el software que
ejecuta sobre ella. Esto cobra particular importancia en un ambiente donde el código que
se ejecuta proviene de algún lugar del mundo y es escrito por alguna "buena" persona
[26].
Es posible decir que los lenguajes totalmente interpretados, como Tcl y JavaScript,
también poseen las cualidades de ser altamente portables y seguros, pero existe una
diferencia importante entre este tipo de lenguajes y los basados en una máquina virtual: la
eficiencia.
Los lenguajes basados en una máquina virtual, comúnmente son más rápidos que los
totalmente interpretados, debido a que utilizan una arquitectura de código intermedio. La
idea es dividir la tarea de ejecutar un programa en dos partes. En la primera, se realiza el
análisis léxico y sintáctico del programa fuente, para generar el programa en instrucciones
del procesador virtual (código intermedio) y en el segundo paso, se itera sobre el código
intermedio para obtener la ejecución final del programa.
Sun utiliza el término "Máquina Virtual Java", para referirse a la especificación abstracta
de una máquina de software para ejecutar programas Java. La especificación de esta
máquina virtual, define elementos como el formato de los archivos de clases de Java
(.class), así como la semántica de cada una de las instrucciones que componen el
conjunto de instrucciones de la máquina virtual. A las implantaciones de esta
especificación se les conocen como "Sistemas en Tiempo de Ejecución Java". Ejemplos
de Sistemas de tiempo de ejecución son el Navegador de Nestcape, el Explorador de
Microsoft y el programa Java (incluido en el JDK). Un sistema de tiempo de ejecución
incluye típicamente:
Muchas de las instrucciones del procesador virtual Java, son muy similares a las que se
pueden encontrar para los procesadores comunes y corrientes, como los Intel, es decir,
incluyen los grupos de instrucciones típicos como los aritméticos, los de control de flujo,
de acceso a memoria, a la pila, etcétera.
Una de las características más significativas del conjunto de instrucciones del procesador
virtual Java, es que están basadas en la pila y utilizan "posiciones de memoria"
numeradas, en lugar de registros. Esto es hasta cierto punto lógico, debido a que la
máquina virtual está pensada para correr sobre sistemas con procesadores
sustancialmente diferentes. Es difícil hacer suposiciones sobre el número o tipo de
registros que estos pudiesen tener [26].
2.10 El verificador de Java
Una de las principales razones para utilizar una máquina virtual, es agregar elementos de
seguridad a un sistema, por lo que si un intérprete falla o se comporta de manera
aleatoria, debido a código mal formado, es un problema muy serio. La solución trivial a
este problema sería incluir código encargado de capturar errores y verificar que el código
sea correcto.
Los diseñadores de Java tomaron otro camino. Cuando estaban diseñando el conjunto de
instrucciones para la máquina virtual de Java, tenían dos metas en mente. La primera era
que el conjunto de instrucciones fuera similar a las instrucciones que se pueden encontrar
en los procesadores reales. La segunda era construir un conjunto de instrucciones que
fuera fácilmente verificable.
En Java, justo después de que se obtiene una clase del sistema de archivos o de Internet,
la máquina virtual puede ejecutar un verificador que se encargue precisamente de
constatar que la estructura del archivo de clase es correcta. El verificador se asegura que
el archivo tenga el número mágico (0xCAFEBABE) y que todos los registros que contiene
el archivo tengan la longitud correcta, pero aún más importante, comprueba que todos los
códigos de operación sean seguros de ejecutar. Es importante notar que Java no necesita
que el verificador se ejecute sobre el archivo de clase, sino que es activado por el sistema
en tiempo de ejecución y sólo sobre clases que el mismo sistema decida. Por lo común,
las clases verificadas son las provenientes de Internet [26].
Hoy en día la situación se acerca mucho a la de los programas compilados, sobre todo en
lo que a la rapidez en la ejecución del código se refiere. Las siguientes graficas se
muestran cómo actúa el sistema runtime en los diversos casos que hasta ahora pueden
darse y sobre el último lanzamiento que hace SUN, el HotSpot que promete interpretar
los ByteCodes de forma más rápida. [25].
2.13.5 HotSpot
Lo último en que trabaja Sun es HotSpot, una herramienta que incluye un compilador
dinámico y una máquina virtual para interpretar los Bytecodes, tal como se muestra en la
figura 73. Cuando se cargan los Bytecodes producidos por el compilador por primera vez,
éstos son interpretados en la máquina virtual. Cuando ya están en ejecución, el profiler
mantiene información sobre el rendimiento y selecciona el método sobre el que se va a
realizar la compilación. Los métodos ya compilados se almacenan en un caché en código
máquina nativo. Cuando un método es invocado, esta versión en código máquina nativo
es la que se utiliza, en caso de que exista; en caso contrario, los ByteCodes son
reinterpretados. La función control que muestra el diagrama es como un salto indirecto a
través de la memoria que apunta tanto al código máquina como al interpretado, aunque
Sun no ha proporcionado muchos detalles sobre este extremo [25].
Los servicios Web Realizado tanto para J2EE como para .NET, son en lo posible iguales
en cuanto a funcionalidades respecta. El prototipo consiste en 4 aplicaciones de bancos
para realizar giros electrónicos; cuya función es enviar dinero de una cuenta a otra
cuenta sea del mismo banco o de otros bancos. Dos de estos bancos se construyeron en
J2EE y los otros 2 en .NET. Se utilizó dos BD una para cada plataforma y en cada una se
realizan 2 tablas que representan bancos diferentes por lo que entre ella no hay ninguna
relación.
Especificaciones
Se abrió el VS.
Imports System.Web
Imports System.Web.Services
Imports System.Web.Services.Protocols
Imports System.Data.OleDb
Imports System.Data
' To allow this Web Service to be called from script, using ASP.NET AJAX,
uncomment the following line.
' <System.Web.Script.Services.ScriptService()> _
<WebService(Namespace:="http://tempuri.org/")> _
<WebServiceBinding(ConformsTo:=WsiProfiles.BasicProfile1_1)> _
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Public Class Service
Inherits System.Web.Services.WebService
<WebMethod()> _
Public Function LLEGA_GIRO(ByVal nombre_de_banco As String, ByVal
num_de_cuenta As Integer, ByVal giro As Integer) As String
Dim conexion As OleDbConnection
Dim comando As OleDbCommand
Dim consulta As String
Dim datos_de_consulta As OleDbDataReader
Try
conexion = New
OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0; " & "Data
Source=C:\banconet.mdb;")
conexion.Open()
consulta = "SELECT deposito FROM " & nombre_de_banco & "
WHERE num_cuenta = " & num_de_cuenta
consulta = "UPDATE " & nombre_de_banco & " SET deposito = " &
dinero_total & " WHERE num_cuenta = " & num_de_cuenta
comando.ExecuteNonQuery()
conexion.Close()
Return ok
Catch ex As Exception
Return "nada" ''ex.ToString
End Try
End Function
Giro: que es una variable tipo entero, el cual trae el valor del giro
Las siguiente variables que se crearon en el método, son para realizar la conexión
ejecutar, la conexión un String para escribir el SQL de la consulta y objeto tipo
OleDbDataReader para guardar los datos devuelto y poder manipularlos de
acuerdo como se necesiten.
Se creó otro método en el servicio Web para realizar el retiro del dinero
<WebMethod()> _
Public Function RETIRO_DINERO(ByVal nombre_de_banco As String, ByVal
num_de_cuenta As Integer, ByVal contrasena As Integer, ByVal dinero As
Integer) As String
Dim conexion As OleDbConnection
Dim comando As OleDbCommand
Try
conexion = New
OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0; " & "Data
Source=C:\banconet.mdb;")
conexion.Open()
Dim consulta As String = "SELECT deposito FROM " &
nombre_de_banco & " WHERE num_cuenta = " & num_de_cuenta & "AND clave = "
& contrasena
dinero_total = datos_de_consulta.GetInt32(0)
End While
dinero_total = dinero_total - dinero
If dinero_total >= 0 Then
End Function
Entran cuatro valores como parámetro:
Luego a través de una operación matemática y un If; se sabe si esa cuenta tiene
el monto o cantidad de dinero suficiente para llevar a cabo la transacción
Si tiene el dinero suficiente para realizar un giro de dinero, de acuerdo al valor que
entro como parámetro “dinero”; se procede a realizar una UPDATE para actualizar
el nuevo monto que queda en la cuenta.
Se prueba el método
Cuando se crea un proyecto Web es necesario configurar el sito, para que funcione y se
desplegué correctamente en el IIS
Se puede probar el servicio Web en el IIS, haciendo click derecho en el sitio Web y
escogiendo la opción examinar.
Se muestra la opción para testear los métodos y de ver el Wsdl, al igual como se
hizo con el servidor de desarrollo
Figura 89. Testear y ver el WSDL con el IIS.
El servicio Web hecho en .NET está listo para ser consumido y la URL del WSDL
que lo describe es:
http://localhost/SERVIBANCO_A_B/Service.asmx?WSDL.
Especificaciones
Cuando se ha hecho la conexión, se crean las tablas haciendo click derecho sobre
Tables y escogiendo Create Table.
Después se le da click en ok y se procede a realizar otra tabla con los mismo campos y
tipos de datos y con el nombre banco2. Posteriormente se insertaron datos utilizando
comando de SQL en el Wizard
Se abrió el NetBeans
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.annotation.Resource;
import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.sql.DataSource;
/**
*
* @author JOHNX
*/
@WebService()
public class SERVICIO {
/* hacienda la connexion co la BD se realiza con un Wizard*/
@Resource(name = "conexion1")
private DataSource conexion1;
/**
* Web Service operation
*/
@WebMethod
public String LLEGA_GIRO(@WebParam(name = "nombre_de_banco") String
nombre_de_banco, @WebParam(name = "num_de_cuenta") int num_de_cuenta,
@WebParam(name = "giro") int giro) {
try{
Connection con = conexion1.getConnection();
Statement stm = con.createStatement();
String consul="";
ResultSet rs = stm.executeQuery(consul);
rs.next();
String devolver =rs.getString(1);
} catch(SQLException y){
return "nada";
}
return "ok";
}
/**
* Web Service operation
*/
@WebMethod
public String RETIRO_DINERO(@WebParam(name = "nombre_de_banco") String
nombre_de_banco, @WebParam(name = "num_de_cuenta") int num_de_cuenta,
@WebParam(name = "contrasena") int contrasena, @WebParam(name = "dinero") int dinero)
{
try{
Connection con = conexion1.getConnection();
Statement stm = con.createStatement();
String consul="";
rs.next();
String devolver =rs.getString(1);
if(saldo >= 0) {
consul="update \""+nombre_de_banco+"\" set \"deposito\" = "+saldo+" where
\"num_cuenta\" ="+num_de_cuenta+"";
stm.executeUpdate(consul);
} else {
return "nada";
}
} catch(SQLException y){
return "nada";
}
return "ok";
}
}
Los métodos son parecidos del servicio Web en J2EE al de .NET, ambos tienen 2
métodos LLEGA_GIRO y RETIRO_DINERO reciben 3 y 4 parámetros
respectivamente. En J2EE Se realiza una conexión se preparan los estamentos,
se ejecuta la consulta este devuelve un ResultSet el cual se manipula con next ().
Consiste en una aplicación Web que consuma los servicios Web hechos en J2EE y .NET.
Se abrió el VS.
Como visual Studio es orientado a evento se hizo doble click en el botón ENVIAR
GIRO, y se le programó lo siguiente:
Else
'Dim nombreBanco1 As String
Dim numcuenta1 As Integer = TextBox1.Text
Dim clave As Integer = TextBox2.Text
wsnet.LLEGA_GIRO(banco_inicioV, numcuenta1,
giro)
End If
Else
resultado = wsj2ee.LLEGA_GIRO(banco_destinoV,
numcuenta2, giro)
If (resultado = "ok") Then
Response.Write("se realizo la transaccion en
forma satisfactoria")
Else
wsnet.LLEGA_GIRO(banco_inicioV, numcuenta1,
giro)
End If
End If
Else
resultado = wsj2ee.RETIRO_DINERO(banco_inicioV,
numcuenta1, clave, giro)
If (resultado = "ok") Then
If (banco_destinoV = "banco1" Or banco_destinoV =
"banco2") Then
resultado = wsj2ee.LLEGA_GIRO(banco_destinoV,
numcuenta2, giro)
If (resultado = "ok") Then
Response.Write("se realizo la transaccion en
forma satisfactoria")
Else
wsj2ee.LLEGA_GIRO(banco_inicioV, numcuenta1,
giro)
End If
Else
resultado = wsnet.LLEGA_GIRO(banco_destinoV,
numcuenta2, giro)
If (resultado = "ok") Then
Response.Write("se realizo la transaccion en
forma satisfactoria")
Else
wsj2ee.LLEGA_GIRO(banco_inicioV, numcuenta1,
giro)
End If
End If
Else
'' /****************************/
End If
End If
End Sub
End Class
Explicando el código
Los demas if hacen lo mismo: buscar que si retiro de dinero y llega giro
pertenecen a los bancos soportados por J2EE. o .Net, o si pertenecen a ambos
en algún orden.
Consiste en una aplicación Web que consuma los servicios Web hechos en J2EE y .NET.
Se abrió el NetBeans
Se llamó los Web Services hecho en (J2EE, .NET) como se explico en (4.3.7)
Se creó una clase en la aplicación como se explico en (4.3.7.2) con dos métodos
retirar_dinero, llega_giro para llamar los métodos apropiados del Web Services de
acuerdo a su funcionalidad. Al igual que en .NET se utilizan unos If para
determinar a qué banco corresponde y así que WS usar.
package PAQ;
/**
*
* @author JOHNX
*/
public class clase1 {
}
else
{
try { // Call Web Service Operation
paquete_ser2.Service service = new paquete_ser2.Service();
paquete_ser2.ServiceSoap port = service.getServiceSoap();
// TODO initialize WS operation arguments here
java.lang.String nombreDeBanco = nombre_banco;
int numDeCuenta = numero_cuenta;
int contrasena = clave;
}
//{
//return null;
}
else
{
try { // Call Web Service Operation
paquete_ser2.Service service = new paquete_ser2.Service();
paquete_ser2.ServiceSoap port = service.getServiceSoap();
// TODO initialize WS operation arguments here
java.lang.String nombreDeBanco = nombre_banco;
int numDeCuenta = num_cuenta;
// TODO process result here
java.lang.String result = port.llegaGIRO(nombreDeBanco, numDeCuenta, giro);
System.out.println("Result = "+result);
if (result.equals("ok"))
return "ok";
else
return "nada";
} catch (Exception ex)
{
// TODO handle custom exceptions here
return ex.toString();
}
// return null;
}
}
Utilizando la palette se creó el formulario, la tabla, los texto, combo, botón para
capturar los valores y enviarlo a la clase
Explicando el código
Los códigos fuentes anteriores tienen la misma funcionalidad del código fuente antes
explicado en el cliente .NET.