Lenguaje Programacion Avanzado II 2017 PDF

1
LENGUAJE DE PROGRAMACIÓN AVANZADO II

INGENIERÍA DE SISTEMAS
FACULTAD DE CIENCIAS BÁSICAS E INGENIERÍA
2
El módulo de estudio de la asignatura Lenguaje de Programación Avanzado II es propiedad de la Corporación

Universitaria Remington. Las imágenes fueron tomadas de diferentes fuentes que se relacionan en los derechos
de autor y las citas en la bibliografía. El contenido del módulo está protegido por las leyes de derechos de autor
que rigen al país.
Este material tiene fines educativos y no puede usarse con propósitos económicos o comerciales.
AUTOR
Porfirio Álvarez Arango
Ingeniero de Sistemas MSc (C) Dirección Estratégica e Ingeniería de Software
porfirioalvarez@gmail.com
Nota: el autor certificó (de manera verbal o escrita) No haber incurrido en fraude científico, plagio o vicios de
autoría; en caso contrario eximió de toda responsabilidad a la Corporación Universitaria Remington, y se declaró
como el único responsable.
RESPONSABLES
Jorge Mauricio Sepúlveda Castaño
Decano de la Facultad de Ciencias Básicas e Ingeniería
jsepulveda@uniremington.edu.co
Martha Lucía Duque Ramírez

Vicerrectora modalidad distancia y virtual
mduque@uniremington.edu.co
Francisco Javier Álvarez Gómez

Coordinador CUR-Virtual
falvarez@uniremington.edu.co
GRUPO DE APOYO
Personal de la Unidad CUR-Virtual Derechos Reservados
EDICIÓN Y MONTAJE
Primera versión. 2017.

Esta obra es publicada bajo la licencia Creative Commons.
Reconocimiento-No Comercial-Compartir Igual 2.5 Colombia.
3
TABLA DE CONTENIDO
Pág.
1 MAPA DE LA ASIGNATURA ...............................................................................................................................6
2 UNIDAD 1 LOS ENTERPRISE BEAN (EJB)............................................................................................................7
2.1 EL CONTENEDOR EJB ................................................................................................................................7
2.1.1 BENEFICIOS DE LOS ENTERPRISE BEAN ............................................................................................9
2.1.2 FUNCIONAMIENTO DE LOS COMPONENTES EJB ..............................................................................9
2.2 TIPOS DE BEANS..................................................................................................................................... 10
2.2.1 TIPOS DE EJB .................................................................................................................................. 10
2.2.2 COMUNICACIÓN CON UN EJB ....................................................................................................... 11
2.2.3 EJEMPLO BÁSICO DE UN EJB.......................................................................................................... 12
2.2.4 CREAR EL PRIMER EJB .................................................................................................................... 12
2.2.5 ACCESANDO UN SESSION BEAN .................................................................................................... 16
2.2.6 UTILIZANDO JNDI Y UN SERVLET COMO CLIENTE ......................................................................... 19
2.2.7 SINTAXIS DE NOMBRES JNDI PORTABLES ...................................................................................... 21
3 UNIDAD 2 LA CAPA WEB................................................................................................................................ 23
3.1.1 INTRODUCCIÓN ............................................................................................................................. 23
3.1.2 OBJETIVO GENERAL ....................................................................................................................... 23
3.1.3 OBJETIVOS ESPECÍFICOS ................................................................................................................ 23
3.2 ESTRUCTURA.......................................................................................................................................... 24
3.2.1 ESTRUCTURA BÁSICA ..................................................................................................................... 24
3.2.2 CABECERA ...................................................................................................................................... 24
3.2.3 COMENTARIOS EN HTML ............................................................................................................... 25
3.2.4 SALTOS DE LÍNEA ........................................................................................................................... 25

4
3.2.5 VÍNCULOS ...................................................................................................................................... 27
3.2.6 IMÁGENES...................................................................................................................................... 27
3.2.7 TABLAS ........................................................................................................................................... 28
3.2.8 COMBINAR COLUMNAS ................................................................................................................. 29
3.2.9 FORMULARIOS ............................................................................................................................... 30
3.2.10 CAJAS DE TEXTO............................................................................................................................. 31
3.2.11 ÁREAS DE TEXTO ............................................................................................................................ 31
3.2.12 BOTONES DE COMANDO ............................................................................................................... 31
3.2.13 BOTONES DE RADIO....................................................................................................................... 32
3.2.14 CAJAS DE CHEQUEO....................................................................................................................... 32
3.2.15 HTML5............................................................................................................................................ 33
3.2.16 URL ................................................................................................................................................. 34
3.2.17 FECHAS........................................................................................................................................... 34
3.3 ESTILO .................................................................................................................................................... 36
3.3.1 APLICACIÓN DE FORMATOS EN LÍNEA .......................................................................................... 37
3.3.2 APLICANDO LOS FORMATOS A LA PRIMERA ETIQUETA ................................................................ 39
3.3.3 CSS EN ARCHIVO ............................................................................................................................ 39
4 UNIDAD 3 LOS SERVICIOS WEB (WEB SERVICES) .......................................................................................... 41
4.1.1 INTRODUCCIÓN ............................................................................................................................. 41
4.2 TIPOS DE SERVICIOS WEB ...................................................................................................................... 41
4.3 SERVICIOS WEB SOAP ............................................................................................................................ 42
4.3.1 DEFINICIÓN DE SERVISIO WEB ...................................................................................................... 42
4.3.2 WSDL.............................................................................................................................................. 43
4.3.3 GESTOR DE SERVICIOS WEB DE NETBEANS ................................................................................... 43

5
4.3.4 INTERFAZ DE INVOCACIÓN DINÁMICA (DII) .................................................................................. 45
5 UNIDAD 4 PERSISTENCIA ............................................................................................................................... 46
5.1.1 INTRODUCCIÓN ............................................................................................................................. 46
5.1.2 OBJETIVO GENERAL ....................................................................................................................... 46
5.1.3 OBJETIVOS ESPECÍFICOS ................................................................................................................ 46
5.2 CONCEPTOS DE ORM ............................................................................................................................. 47
5.2.1 RELACIONES ................................................................................................................................... 47
5.2.2 CLAVES PRIMARIAS Y TIPOS DE DATOS ......................................................................................... 47
5.2.3 OBJETOS Y VALIDACIONES ............................................................................................................. 49
5.2.4 ARQUITECTURA ............................................................................................................................. 49
6 GLOSARIO ...................................................................................................................................................... 57
7 BIBLIOGRAFÍA ................................................................................................................................................ 58
6
1 MAPA DE LA ASIGNATURA
7
2 UNIDAD 1 LOS ENTERPRISE BEAN (EJB)

Es una clase en Java con características que la hacen más potente y robusta. Los Enterprise Bean son
componentes del lado del servidor desarrollados en Java que luego se pueden reutilizar y ensamblar en
distintas aplicaciones que se requieran para la empresa. En una aplicación de control de inventario, por
ejemplo, los beans empresariales (Enterprise beans) podrían implementar la lógica empresarial en los métodos
llamados validarNivelInventario y ordernarProducto. Al invocar estos métodos, los clientes pueden acceder a
los servicios de inventario proporcionados por la aplicación.
El desarrollo basado en componentes promete un paso más en el camino de la programación orientada a

objetos. Con la programación orientada a objetos puedes reutilizar clases, pero con componentes es posible
reutilizar mayor nivel de funcionalidades e incluso es posible modificar estas funcionalidades y adaptarlas a
cada entorno de trabajo particular sin tocar el código del componente desarrollado.
Una forma sencilla de comprender que es un componente es verlo como un objeto tradicional con un conjunto
de servicios adicionales soportados en tiempo de ejecución por el contenedor de componentes o contenedor
EJB.
Los EJB pueden ser programados una vez y ejecutados luego en cualquier servidor de aplicaciones Java.
En la figura se puede observar a la derecha el código java del lado del servidor que para este caso es un
Enterprise Java Bean que se ejecuta dentro de un contenedor de EJB’s, este código puede ser utilizado por una
aplicación llamada cliente (izquierda), el código del cliente realiza una petición al componente EJB que puede
ser una llamada local si está en la misma máquina virtual o una llamada remota si se encuentra fuera del
servidor o máquina virtual, si la llamada es remota se hace uso del protocolo RMI. RMI significa Remote
Method Invocation y hace parte de Java SE.
Este es apenas un tipo de cliente, pero se pueden tener clientes de diferente tipo como clientes de escritorio,
clientes web, de aplicaciones móviles u otros tipos de clientes.
2.1 EL CONTENEDOR EJB

Para la programación de Enterprise Java Beans, lo primero con lo que se debe contar es con un servidor de
aplicaciones que puede ser de código libre como Tomcat (TomEE), GlassFish o JBoss o también puede ser de
pago como WebSphere de IBM o WebLogic de Oracle, para este curso se utilizará GlassFish.
8
El contenedor de componentes se denomina contenedor EJB y es algo así como el sistema operativo en el que
éstos residen y que se ejecuta dentro del servidor de aplicaciones. Se debe recordar que en Java existe un
modelo de programación de objetos remotos denominado RMI. Con RMI es posible enviar peticiones a objetos
que están ejecutándose en otra máquina virtual Java. Se puede ver un componente EJB como un objeto
remoto RMI que reside en un contenedor EJB que le proporciona un conjunto de servicios adicionales.
A diferencia de los objetos clásicos desarrollados hasta ahora, los componentes, enterprise bean, residen en un
contenedor EJB que los envuelve proporcionando una capa de servicios añadidos, los más importantes son los
siguientes:
 Manejo de transacciones: apertura y cierre de transacciones asociadas a las llamadas a los métodos del
bean.
 Seguridad: comprobación de permisos de acceso a los métodos del bean.
 Concurrencia: llamada simultánea a un mismo bean desde múltiples clientes.
 Servicios de red: comunicación entre el cliente y el bean en máquinas distintas.
 Gestión de recursos: gestión automática de múltiples recursos, como colas de mensajes, bases de datos o
fuentes de datos en aplicaciones heredadas que no han sido traducidas a nuevos lenguajes/entornos y
siguen usándose en la empresa.
 Persistencia: sincronización entre los datos del bean y tablas de una base de datos.
 Gestión de mensajes: manejo de Java Message Service (JMS).
 Escalabilidad: posibilidad de constituir clusters de servidores de aplicaciones con múltiples hosts para
poder dar respuesta a aumentos repentinos de carga de la aplicación con sólo añadir hosts adicionales.
 Adaptación en tiempo de despliegue: posibilidad de modificación de todas estas características en el
momento del despliegue del bean.
Y muchas otras características como:
 Llamadas asíncronas
 Llamadas remotas
 Web Services
 Inyección de dependencias
 Acceso a pool de conexiones
 Manejo de tareas programadas
 Manejo de mensajería
 Interceptores
Los servidores de aplicaciones Java (principalmente los de pago) agregan otras características como clustering,
balanceo de cargas y tolerancia a fallos lo que permite crear aplicaciones de misión crítica con operación 7x24
todo el año.
9
2.1.1 BENEFICIOS DE LOS ENTERPRISE BEAN

Por varias razones, los enterprise beans simplifican el desarrollo de grandes aplicaciones distribuidas. En primer
lugar, debido a que el contenedor EJB proporciona servicios a nivel de sistema a enterprise beans, el
desarrollador bean puede concentrarse en resolver problemas empresariales.
El contenedor EJB, en lugar del desarrollador bean, es responsable de los servicios a nivel de sistema, como la
administración de transacciones y la autorización de seguridad.
En segundo lugar, debido a que los beans en lugar de los clientes contienen la lógica de negocio de la
aplicación, el desarrollador de cliente puede centrarse en la presentación del cliente. El desarrollador de cliente
no tiene que codificar las rutinas que implementan reglas de negocio o acceso a bases de datos. Como
resultado, los clientes son más ligeros, un beneficio que es particularmente importante para los clientes que se
ejecutan en dispositivos pequeños como móviles o tabletas.
En tercer lugar, debido a que los enterprise beans son componentes portátiles, el ensamblador de aplicaciones
puede crear nuevas aplicaciones a partir de beans existentes. Siempre que utilicen las API estándar, estas
aplicaciones pueden ejecutarse en cualquier servidor compatible con Java EE.
2.1.2 FUNCIONAMIENTO DE LOS COMPONENTES EJB

El funcionamiento de los componentes EJB se basa fundamentalmente en el trabajo del contenedor EJB. El
contenedor EJB es un programa Java que corre en el servidor y que contiene todas las clases y objetos
necesarios para el correcto funcionamiento de los enterprise beans.
En la figura se puede ver una representación del funcionamiento básico de los enterprise beans. En primer
lugar, puedes ver que el cliente que realiza peticiones al bean y el servidor que contiene el bean están
ejecutándose en máquinas virtuales Java distintas. Incluso pueden estar en distintos hosts. Otra cosa a resaltar
es que el cliente nunca se comunica directamente con el enterprise bean, sino que el contenedor EJB
proporciona un EJBObject que hace de interfaz. Cualquier petición del cliente (una llamada a un método de
negocio del enterprise bean) se debe hacer a través del objeto EJB, el cual solicita al contenedor EJB una serie
de servicios y se comunica con el enterprise bean. Por último, el bean realiza las peticiones correspondientes a
la base de datos.
10
El contenedor EJB se preocupa de cuestiones como:
 ¿Tiene el cliente permiso para llamar al método?
 Hay que abrir la transacción al comienzo de la llamada y cerrarla al terminar.
 ¿Es necesario refrescar el bean con los datos de la base de datos?
2.2 TIPOS DE BEANS

En versiones previas a la versión 3.0 de los EJB el desarrollador debía crea varias clases e interfaces para hacer
funcionar un EJB, por ejemplo, una interfaz local o remota o ambas y un archivo de configuración XML
conocido como deployment descriptor o descriptor de despliegue que contenía toda la configuración del EJB.
A partir de la versión 3.0 se comenzaron a usar anotaciones (@) para la configuración de los EJB dentro de las
mismas clases y las versiones posteriores continúan agregando y simplificando todas las tecnologías Java
Empresariales a través del concepto de anotaciones.
La figura muestra la configuración de un EJB a partir de la versión 3.0.
Lo primero es tener una clase base de Java conocida como POJO (Plain Old Java Object), a esta clase se le
agrega una anotación en su definición y esto da como resultado un Enterprise Java Bean de la versión 3.0 en
adelante.
2.2.1 TIPOS DE EJB

Enterprise Java Bean de sesión. Invocados por el cliente para ejecutar una operación de negocio específica,
con la siguiente clasificación:
 Stateless: Este tipo de EJB no mantiene ningún estado del usuario, no guarda ningún tipo de
información después de terminada una transacción o incluso durante la transacción, se utiliza en la
definición la anotación @Stateless.
11
 Stateful: Este tipo de EJB guarda el estado de la actividad del usuario, por ejemplo si se tiene
programado un carrito de compras el estado del cliente se puede recordar inclusive una vez terminada
la transacción pero si la aplicación se despliega nuevamente o el servidor se reinicia esta información
de estado se pierde, la anotación correspondiente es @Stateful.
 Singleton: Este EJB usa el patrón de diseño singleton lo cual indica que de este tipo de EJB sólo podrá
haber una instancia en memoria del objeto. Se utiliza normalmente cuando se almacena información
en caché, su respectiva anotación es @Singleton.
En la mayoría de los casos se utilizarán los EJB de tipo Stateless pues los Stateful normalmente se cubren
utilizando en la capa web el alcance o escope Session.
Los Stateless nos permitirán ejecutar los métodos que contienen la lógica de negocio de la aplicación y
normalmente esta lógica de negocio no guarda ningún tipo de información relacionada con ningún usuario
pues normalmente las reglas de negocio son genéricas para todos los usuarios.
Otro tipo de Enterprise Java Bean
2.2.2 COMUNICACIÓN CON UN EJB
La figura muestra nuevamente el código del lado del cliente y el código del lado del servidor el EJB.
El EJB puede definir interfaces que pueden ser de tipo Local que se utilizan cuando el cliente se encuentra
dentro del mismo servidor Java, de esta forma se evita la sobrecarga de procesamiento al utilizar llamadas
remotas de tipo RMI.
El EJB puede también exponer sus métodos de negocio a través de una interface remota –Remote-, se usa
cuando el código del cliente está fuera del servidor de aplicaciones Java, o sea, en una máquina virtual de Java
diferente por lo que se necesitan hacer llamadas remotas para poder ejecutar los métodos de negocio del EJB
expuesto.
A partir de la versión 3.1 se ha incluido el concepto de No Interface, es una forma de simplificar la

comunicación con el EJB siempre y cuando las llamadas sean locales, es decir, dentro del mismo servidor.
12
2.2.3 EJEMPLO BÁSICO DE UN EJB

En el siguiente fragmento de código se puede observar la estructura general de un EJB el cual puede o no
implementar una interface local o remota y puede tener uno o varios métodos de negocio.
Observar que antes de la definición de la clase se ha agregado la anotación @Stateless lo que convierte la clase
en un EJB de sesión sin estado.
La clase Calculadora también podría haber implementado una interface local o remota para lo cual se tendría
que haber incluido la anotación @Local o @Remote.
2.2.4 CREAR EL PRIMER EJB

El objetivo del ejercicio es crear EJB de sesión simple que devulva el resultado de sumar dos números basados
en dos parámetros de tipo entero.
Lo primero, en NetBeans crear un nuevo proyecto desde File/New Project… o desde el ícono de la barra de
herramientas como se muestra en la figura siguiente.
El siguiente paso del asistente se debe elegir en la lista de categorías java EE (1) y en la de proyectos Enterprise
Appñication (2).
13
Nos pregunta en el siguiente paso el asistente por el nombre del proyecto (1), y la ubicación (2), como
sugerencia la ubicación debe ser un lugar de fácil recordación ya que de lo contrario NetBeans guardará el
proyecto en la carpeta de documentos del usuario. Para este ejemplo, se ha elegido como nombre
calculadoraEJB y como localización el Escritorio.
En el último paso el asistente muestra los módulos que se pueden incluir en el proyecto o aplicación
empresarial que se está configurando, en el módulo EJB es donde se creará el bean de sesión del ejercicio y
por lo tanto es obligatorio.
El módulo de aplicación no es necesario por lo pronto para este ejercicio.
Al hacer clic en Finalizar, el IDE crea tres proyectos: CalculadoraEJB, CalculadoraEJB-ejb y CalculadoraEJB-war
que se puede observar en la pestaña Projects, CalculadoraEJB en el nombre del proyecto o aplicación
empresarial, CalculadoraEJB-ejb es el nombre del módulo donde se crearán los EJB y CalculadoraEJB-war es el
módulo donde se creará la capa web de la aplicación.
14
Si expande el nodo CalculadoraEJB en la ventana Proyectos, puede ver que el proyecto de la aplicación
empresarial no contiene ningún origen. Todas las fuentes estarán contenidas en los dos módulos que el
asistente creó y que se enumeran en el nodo Java EE Modules.
El El proyecto de la aplicación empresarial sólo contiene detalles de configuración y de paquete de la

aplicación. Cuando crea y ejecuta una aplicación empresarial, el IDE crea un archivo EAR y despliega el EAR en
el servidor. En algunos casos, el proyecto de la aplicación empresarial contendrá archivos descriptivos de
implementación con información adicional, pero no se requieren archivos descriptivos de implementación
cuando se crea una Se
Se procederá ahora a crear el EJB de sesión sin estado o Stateless.
1. En el menú File elegir New File… mostrará la ventana del asistente

2. En la ventana del asistente seleccionar en la lista Categories la opción Enterprise JavaBeans y en la
lista File Types la opción Session Bean.
Aparecerá luego la última ventana del asistente como se muestra en la siguiente figura.
15
 Se debe proporcionar un nombre, para este ejemplo ha sido Calculador.

 Se debe digitar un nombre de paquete, como para los proyectos Java vistos en cursos anteriores. El IDE
sugiere siempre poner las clases dentro de paquetes, para el ejercicio se ha puesto el nombre beans
 Elegir uno de los tres tipos Session Bean, se deja por defecto Stateless.
 Por último, se puede o no crear una interface para exponer los servicios del EJB, no elegir ninguno.
Al hacer clic en Finalizar, el IDE despliega un código inicial de la clase, luego de eliminar los comentarios
aparecería asi:
package beans;
import javax.ejb.Stateless;
import javax.ejb.LocalBean;
@Stateless
@LocalBean
public class Calculador {
// se adicionan los métodos de la
// lógica del negocio.
}
Notar que la clase claculador está precedida por las anotaciones @Stateless y @LocalBean, esta última indica
que no se ha utilizado ninguna interface para el EJB.
Es hora de programar un método que hace parte de la lógica del negocio, un método que sume dos valores
enteros.
16
La clase calculador completa ahora se debe ver así:
package beans;
import javax.ejb.Stateless;
import javax.ejb.LocalBean;
@Stateless
@LocalBean
public class Calculador {
public int suma(int x, int y) {
return x + y;
}
}
Luego de tener la clase completa, o sea el EJB de sesión y por lo menos uno de sus métodos, se debe
Desplegar la aplicación en el servidor GlassFish para lo cual en la ventana Projects se debe hacer clic derecho
sobre el proyecto CalculadoraEJB (1) y elegir la opción Deploy (2).
Después de unos segundos en la pestaña GlassFish Server 4.1.1 se debe ver un mensaje indicando que
CalculadoraEJB has sido desplegada satisfactoriamente (3).
2.2.5 ACCESANDO UN SESSION BEAN

Existen varios métodos para tener acceso a un bean de sesión.
17
Utilizando inyección de dependencias (dependecy injection) y utilizando un serviet como cliente.
Un bean de sesión tiene un valor limitado por sí mismo. Para ser útil debe ser utilizado por un cliente tal como
una página servlet o JSF. A continuación, se verá cómo usar la inyección de dependencia para usar una session
Bean en un servlet.
Se procederá ahora a crear el servlet.
1. En el proyecto WAR Calculadora EJB-war hace clic derecho y elegir la opción New.
2. En el submenú elegir Servlet, si no se encuentra buscarlo por Other y luego en la categoría Web.
Aparecerá luego la ventana del asistente para crear el Servlet como se muestra en la siguiente figura.
Ya se debe estar familiarizado con estos asistentes.
 Básicamente se solicita el nombre del servlet, al ser un nombre de clase debe iniciar por mayúscula.
 Recordar que debe incluir un nombre de paquete.
El siguiente paso del asistente se debe dejar con las opciones que vienen por defecto.
Al hacer clic en Finalizar, el IDE despliega un código inicial de serviet , luego de eliminar los comentarios y
adicionar el código para acceder al Session Bean, quedaría así:
package servlet;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ejb.EJB; 1
import beans.Calculador; 2
18
@WebServlet(name = "ServletPruebaCalc", urlPatterns = {"/ServletPruebaCalc"})

public class ServletPruebaCalc extends HttpServlet {
@EJB 3
private Calculador calculador; 4
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
try (PrintWriter out = response.getWriter()) {
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println("<head>");
out.println("<title>Prueba de Session Bean Calculador</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>La suma de 27 y -9 es: " + calculador.suma(27, -9) + "</h1>"); 5
out.println("</body>");
out.println("</html>");
}
}
}
 En el servlet se ha inyectado el EJB Calculador como se muestran en las líneas marcadas como 3 y 4.
 Observar que por lo anterior se han importado las respectivas clases, líneas 1 y 2.
 Por último, en la línea 5 se puede observar que ha invocado el método calculador.suma de EJB
inyectado.
Luego de tener el servlet completo se debe Desplegar nuevamente la aplicación en el servidor GlassFish como
se indicón en la Figura 1.
Para probar el servlet que se acaba de crear, se ejecuta el proyecto haciendo clic en el botón de herramientas
que se indica en la figura o se presiona la tecla de función F6.
Cuando aparezca el navegador web, en la barra de direcciones agregar el nombre del servlet que se ha creado,
para este caso ServletPruebaCalc, luego de presionar Enter se podrá apreciar la ejecución del servlet que llama
al Session Bean Calculador y a su método suma el cual suma dos números pasados como parámetros.
19
Si al finalizar la ejecución que se plantea no se muestra el resultado esperado, será necesario Limpiar y
Construir nuevamente el proyecto.
Esta vez en la ventana Projects se debe hacer clic derecho sobre el proyecto CalculadoraEJB (1) se elige la
opción Clean and Buid (2)
Lo anterior limpia el proyecto de los servicios expuestos y lo resconstruye, en la ventana de logs se debe
mostrar que el procedimiento de reconstrucción ha sido exitoso (3).
Luego del Clean and Buid es necesario desplegar nuevamente el proyecto, hacer Deploy.
Hasta aquí ya se ha aprendido a crear un EJB de sesión sin estado y se ha podido a él a través de un servlet.
2.2.6 UTILIZANDO JNDI Y UN SERVLET COMO CLIENTE

No todos los clientes aceptan Inyección de Dependencias, para este tipo de clientes es necesario utilizar JNDI
aunque esta técnica es un poco más compleja.
20
La Java Naming and Directory Interface (JNDI) es una interfaz de programación (API) que proporciona
funcionalidades de nombrado y directorio a las aplicaciones escritas usando Java. Está definido para ser
independiente de cualquier implementación de servicio de directorio. Así se puede acceder a una gran
variedad de directorios de una forma común.
Sirve para configurar recursos compartidos para aplicaciones Java organizándolos por directorio con nombres
únicos. Es un servicio de nombres que permite:
 Asociar nombres con objetos.

 Permitir la búsqueda de un objeto por su nombre.
Habitualmente, los servidores web, como Apache Tomcat, JBoss, GlassFihs, etc son servidores JNDI.
Para utilizar un JNDI en un cliente.
1. Obtenga un objeto InitialContext de la aplicación.

2. Utilice el contexto para buscar el EJB.
Se modificará el proyecto anterior para cambiar el modo de Inyección de Dependencias (DI) por el de
nombrado con JNDI.
Al Session Bean Calculador y su método suma no se le hará ningún cambio, debe funcionar tal cual.
La modificación del ServletPruebaCalc implica eliminar la anotación @EJB y agregar código para realizar la
búsqueda JNDI. Este código se coloca inmediatamente antes de que el servlet Intentar bloquear.
package servlet;
import beans.Calculador;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet(name = "ServletPruebaCalc2", urlPatterns = {"/ServletPruebaCalc2"})

public class ServletPruebaCalc2 extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
21
Context context = null; 1

try (PrintWriter out = response.getWriter()) {
context = new InitialContext(); 2
// Ojo! las dos líneas siguietes son una sola línea de código
Calculador calculador = (Calculador) context.lookup
("java:global/CalculadoraEJB/CalculadoraEJB-ejb/Calculador"); 3
out.println("<!DOCTYPE html>");
out.println("<html>");
out.println("<head>");
out.println("<title>Servlet ServletPruebaCalc2</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>La suma de 5 y 3 es: " + calculador.suma(5, 3) + "</h1>");
out.println("</body>");
out.println("</html>");
} catch (NamingException ex) {
Logger.getLogger(ServletPruebaCalc2.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Como se indicó, lo primero es quitar la inyección @EJB (Las dos líneas).
 Primero, se declara un objeto de contexto context de tipo Context antes del bloque try/catch, línea
marcada como 1.
 Luego, dentro de try se instancia el objeto context como InitialContext(), línea 2.
 Y por último se declara un objeto Calculador a la que se le asigna el resultado de la búsqueda
(context.lookup) del EJB siguiendo la ruta como se indica en la línea 3.
Una vez establecido el Contexto, se invocó el método de búsqueda del objeto context Y se proporcionó una
referencia al EJB de Calculador. El método de búsqueda utilizó un Nombre JNDI para identificar el EJB. En este
caso, se utilizó un nombre global.
La sintaxis comienza con uno de tres prefijos diferentes. En este ejemplo, el prefijo fue java: global que
especifica un nombre global. Siguiendo el prefijo hay una serie de nombres separados por barras inclinadas. El
primer nombre era el nombre de la aplicación, CalculadoraEJB. El segundo nombre era el nombre del archivo
JAR donde el bean Se mantiene, CalculadoraEJB-ejb. Por último, el nombre del bean Calculador.
2.2.7 SINTAXIS DE NOMBRES JNDI PORTABLES

JNDI se utiliza para buscar recursos como beans de sesión dentro de una aplicación y red. Un servidor JNDI
permite registrar recursos y luego los clentes pueden buscar y usar estos recursos. A cada EJB se le asigna
automáticamente un nombre único por el servidor, aunque es posible asignar un nombre específico si lo desea.
Este nombre se combina con uno de los tres prefijos de espacio de nombres JNDI para formar un nombre JNDI
portable completo.
La tabla figura detalla los prefijos de cadenas y sus implicaciones.

22
Cadena de prefijo Visibilidad del nombre resultante

"java:global/" Un nombre accesible a nivel global
"java:app/" Sólo puede ser visto por código dentro de la misma aplicación
"java:module/" Sólo puede ser visto por código dentro del mismo módulo
Para todos los casos vistos en este tutorial, se utilizará el prefijo “java:global/”. Queda a discreción del alumno
consultar y practicar el uso de los demás prefijos. Otros clientes e interfaces remotas…
23
3 UNIDAD 2 LA CAPA WEB

3.1.1 INTRODUCCIÓN
Contenedor: Herramienta que puede contener otros controles, ejemplo de tablas y formularios.
Etiquetas: “comandos” de HTML.
Controles: Componentes de un ambiente de programación, cajas de texto, botones, combos, etc.
Formatos: Sentencias que permiten dar presentación, estilos y diseño a un sitio web.
Estructuras: Son componentes de un lenguaje de programación tales como ciclos, preguntas, selectores y
preguntas.
CRUD: Descripción de Crear, Leer, actualizar y Eliminar información.
3.1.2 OBJETIVO GENERAL

Aprender los conceptos básicos de la programación web, las etiquetas básicas, los formatos y las validaciones,
así como la construcción de un CRUD
3.1.3 OBJETIVOS ESPECÍFICOS

Identificar las principales características del HTML en su etapa de diseño para un CRUD.
24
Aplicar formatos que le den un aspecto menos plano del que se trabaja habitualmente en HTML
estándar mediante las herramientas de CSS.
Aplicar las validaciones necesarias para controlar el ingreso de la información dentro un formulario
HTML.
Elaborar un CRUD mediante JSP y Servlets.
3.2 ESTRUCTURA
El HTML (Hyper Text Markup Language) es el lenguaje con el que se escriben las páginas o estructuras web, un
lenguaje que permite colocar texto de forma estructurada, y que está compuesto por etiquetas, también
conocidas como tags o marcas, que indican el inicio y el fin de cada elemento del documento.
Los documentos HTML deben tener la extensión HTML o HTM, para que puedan ser visualizados en los
navegadores web (Browser), sean estos los más comunes como Internet Explorer, Chrome, Mozilla, Safari,
Opera, entre otros.
Los browsers se encargan de interpretar el código HTML de los documentos, y de mostrar a los usuarios las
páginas web resultantes del código interpretado.
3.2.1 ESTRUCTURA BÁSICA

<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8"/>
<title>Estructura básica</title>
</head>
<body>
</body>
</html>
La gran mayoría de las etiquetas están compuestas por una apertura y un cerrado <html> </html>, la etiqueta
que contiene el símbolo slash (/) es la que indica el cerrado, otras etiquetas no se componen por pares y se
cierran al final de ella, <br /> esta es un típico caso.
Dentro de las páginas web existe una estructura como la vista al principio, la etiqueta <html> y </html> son la
primera y la ultima de la página, es la etiqueta que enmarca lo que vamos a realizar, dentro de estas etiquetas
se ubicaran dos áreas, la cabecera (head) y el cuerpo de la página (body).
3.2.2 CABECERA
<head>…</head>
Esta etiqueta alberga el título de la página y permite la invocación de otros elementos como los scripts y las
hojas de estilo en cascada, elementos que se verán más adelante.
25
<title> primera página web </title>
Cuerpo de la página
<body>…</body>
El cuerpo de la página alberga todo el contenido que se visualizará por parte del usuario, además el <body>
podrá tener elementos como muchas otras etiquetas llamados parámetros, estos parámetros permiten darle
un diseño o formato adicional.
3.2.3 COMENTARIOS EN HTML

Con mucha frecuencia se requiere hacer comentarios o anular partes del código creado, para esto se utiliza una
etiqueta que inhabilita esta área de trabajo
<!- - comentario -->
3.2.4 SALTOS DE LÍNEA

Es el equivalente a un enter, en HTML lo enter que especifiquemos presionando la tecla o la barra espaciadora
no se verá al ejecutar la página para esto existe un grupo específico de etiquetas que presentan estos
caracteres
<br /> representara este carácter
Ejemplo de representación
Un código con las etiquetas básicas y da como resultado:

26
Se observa el título “Primer Documento Web”, además en el cuerpo se ve el fondo azul que se especificó y el
texto, pero se puede ver que el texto aparece en la misma línea y en el archivo el texto está separado por
espacios, acá entra el funcionamiento de la etiqueta <br />
Resultado
27
3.2.5 VÍNCULOS
Una de las razones principales de un sitio web es el manejo de los vínculos o links, con esta herramienta se
podrán realizar comunicaciones o llamados con otras páginas o con otros sitios
La etiqueta <a> </a> es la encargada de realizar esta tarea, se acompaña de múltiples parámetros, pero existe
uno fundamental que es href que indica la dirección o ruta donde se encuentra el archivo o el sitio web a
visitar.
El hipervínculo mostrara la palabra “Revista Enter”, pero el llamado es <a href="http://www.enter.co">, lo que
se ubica en el href es una ruta o url, después de él se ubica una descripción del texto a llamar y cierra con la
etiqueta </a>
3.2.6 IMÁGENES
El diseño de un sitio web no se limita solo a el texto, los colores o los hipervínculos, las imagines hace parte
fundamental de la presentación y de acercarse a las imágenes corporativas de las empresas.
La etiqueta que se utiliza es <img />
Se utiliza como parámetro fundamental src (source o ruta del archivo)

28
<img src="logo.png">
Estas imágenes se les pueden agregar bordes, se pueden convertir en hipervínculos.
3.2.7 TABLAS
Las tablas son contenedores, son herramientas que permiten realizar distribución de los elementos y dentro de
ellos ubicar texto, imágenes, hipervínculos y otros elementos incluyendo tablas anidadas.
Un ejemplo de tabla con 4 columnas y 3 filas.
Este un caso típico de una tabla compuesto por 5 filas y 5 columnas, es una matriz
Para la construcción de ella se requiere de otras etiquetas como son
<tr> </tr> establece el inicio y fin de una fila
<td></td> establece las celdas de la fila

29
Dentro de los parámetros más comunes están width (ancho) y border (grosor del borde)
Existe un carácter especial entre cada <td> </td> este carácter representa un espacio, en este código se
mostrarán dos filas y 5 columnas, en el carácter especial hay que tener presente que existen 256 caracteres
con este formato, algunos de los que son importantes representan las tildes y caracteres especiales que los
browsers no reconocen y que muestran un símbolo que dañaría el formato original.
Existen algunos parámetros adicionales dentro de los <tr> y los <td>, entre ellos la posibilidad de colocarle
formatos como colores e imágenes de fondo y la posibilidad de cambiar filas o columnas
3.2.8 COMBINAR COLUMNAS

Para la combinación de columnas se utiliza el parámetro colspan y el número de columnas
30
Combinar columnas
La combinación de columnas se realiza con la sentencia rowspan y el número de filas
3.2.9 FORMULARIOS
Los formularios son herramientas que permiten la interacción con el usuario, mediante estos se podrán
solicitar datos, hacer cálculos y demás operaciones
Se conforma por la etiqueta <form></form>
Igual que las tablas es un contenedor, puede llevar distintos elementos como cajas de texto, botones, listas,
etc., y contiene una serie de parámetros como son
Id: Nombre para identificar el formulario
Name: Nombre para identificar el formulario

31
Action: Especifica el archivo o la función que se realizara a la hora de enviar
los datos del formulario
Method: Representa la forma de paso de la información, existen dos opciones
tradicionales, POST y GET
elementos de los formularios
 cajas de texto
 áreas de texto
 botones de comando
 botones de radio (botones de opción)
 cajas de chequeo (casilla de verificación)
 lista / menú (comboBox)
 entre otros.
3.2.10 CAJAS DE TEXTO

<input name="caja" type="text" id="caja" size="20" maxlength="10" />
Se crea mediante la etiqueta input como muchos de los elementos de entrada de información, pero se
especifica mediante el parámetro type que es un text, id y el name (nombre) permiten la identificación de la
caja, size es el ancho que se ve y maxlength la cantidad de caracteres máximos que se pueden ingresar.
3.2.11 ÁREAS DE TEXTO

<textarea name="comentario" id="comentario" cols="45" rows="5"></textarea>
Las áreas de texto son espacios mucho más amplios que las cajas de texto, se compone por id y name para
identificarlas, cols para el número máximo de columnas que se mostraran y rows para el número máximo de
filas visibles
3.2.12 BOTONES DE COMANDO

<input type="submit" name="button" id="button" value="Almacenar">
<input type="reset" name="button2" id="button2" value="Restablecer">
Dos de los tipos de botones más comunes son los de envío y los de restablecer, igual de los demás elementos
contienes un id y name, valué para mostrar al usuario un resultado y type para determinar que elemento es, en
este caso un submit para el envío y reset para limpiar los elementos del formulario.
32
3.2.13 BOTONES DE RADIO

<input type="radio" name="radio" id="radio" value="radio">
Los botones de radio o de opción permiten seleccionar una de muchas opciones.
3.2.14 CAJAS DE CHEQUEO

<input type="checkbox" name="checkbox" id="checkbox">
Las cajas de chequeo permiten la seleccione de uno, varios, todos o ningún elemento.
Lista / Menú (Combobox)
<select name="select" id="select">

<option value="1">Sistemas</option>
<option value="2">Medicina</option>
<option value="3">Derecho</option>
</select>
Los comboBox permiten elegir de una lista de opciones, en value se especifica el valor a pasar y la otra
información fuera de la etiqueta es lo que el usuario visualizara.
33
3.2.15 HTML5
El HTML5 es una actualización del ambiente que por muchos años a estado al frente del desarrollo web, es
probablemente el cambio más significativo que ha tenido el lenguaje, para este capítulo particular se enfocaran
los cambios al manejo de formularios, teniendo en cuenta que en otras áreas también se presentaron cambios,
pero por efectos de que esta última unidad está enfocada al desarrollo y creación de CRUD se enfocara muy
particularmente a los controles.
Formulario a diseñar
Creación del formulario y tabla para la ubicación de los elementos.
Caja de texto con campos requeridos, foco y mensaje interno

34
En las cajas de texto de HTML al igual que en este primer ejemplo se utiliza id y name para identificar el
elemento según el browser, los demás elementos pueden cambiar según el alcance, además el HTML anterior a
la versión 5 solo tenía en el type, las palabras text, hidden y password, en esta versión nueva encontramos
mayor número de alternativas y se verán en los siguientes controles, para este caso particular de campos
requeridos se utiliza la sentencia required, con esto al momento de procesar la información si la caja de texto
estuviera vacía mostraría un mensaje
Desde el inicio de la digitación se indicará que incluya una arroba y los demás componentes de un correo
electrónico.
3.2.16 URL
Las cajas de texto para url tendrá esta palabra en el type, validaran que la dirección de un sitio sea cumpla las
normas mínimas.
3.2.17 FECHAS
En la versión previa de HTML para crear un formato de fechas se recurría a herramientas como JavaScript, con
el HTML5 y la instrucción date dentro del type se soluciona este impase.
35
Hora
Se agrega la instrucción time dentro del type.
Fecha y hora
Meses
Con la instrucción month en el parámetro type
Semana
Permite seleccionar el número de semana del año y representarlo en la fecha a la que corresponde.
36
Rango de números
Intervalos
3.3 ESTILO
Con mucha frecuencia en la construcción de sitios web se presenta que los formatos no son uniformes o que se
tienen que aplicar en cada página, cuando el sitio es considerablemente grande este tipo de formatos no son
administrables y se puede recurrir a la construcción de un CSS (Cascading Style Sheet) Hojas de Estilo en
Cascada.
Esta herramienta permite que de una manera simple se puedan administrar N cantidad de páginas de manera
uniforme y con una codificación simple.
37
Tipos de CSS
Existen 3 categorías para los CSS
CSS en línea: permite aplicar formatos a una etiqueta particular
CSS en bloque: permite aplicar formatos a una o varias etiquetas dentro del mismo archivo
CSS en archivo: permite la administración de múltiples páginas.
Ejemplo de una página sin formatos.
Estos bloques de código corresponden a un sitio web que no tiene formato alguno, la estructura es la siguiente.
3.3.1 APLICACIÓN DE FORMATOS EN LÍNEA

Aplicación de formatos en línea
CSS se compone de una innumerable cantidad de opciones, algunas de ellas son
Font-family: Especifica la fuente o familia de estas

38
Font-size: Determina el tamaño de la fuente que se empleara, se puede especificar en pixeles (px), puntos (pt),
pulgadas (in), centímetros(cm), milímetros(mm), picas (pc)
Text-align: Alineación del texto a la derecha (right), izquierda (left), centrado (center), justificado (justify)
Font-wieght: Intensidad de la fuente, los valores van entre 100 y 900, bold
Text-transform: Se puede trasformar el texto, upper (mayúsculas), lower (minúscula), capitalize(primera letra
en mayúscula)
Color: Especifica el color de fuente, se puede especificar en formato hexadecimal, en formato RGB o con el
nombre del color
Background-color: Color de fondo
Background-image: Imagen de fondo
Margin: En este formato se puede crear una margen de contorno, el valor que se especifique aplicara a la
derecha, izquierda, arriba y abajo
Margin-left
Margin-right
Margin-top
Margin-button
Son complementos de la anterior
Border: Especifica un borde en contorno
Border-left
Border-right
Border-top
Border-button
Text-decoration: Aplica para colocar subrayados o para quitarlos
Line-heigth: Especifica el espacio entre líneas
Width: Ancho de un elemento
Los formatos en línea solo aplican a la etiqueta que lo requiera

39
3.3.2 APLICANDO LOS FORMATOS A LA PRIMERA ETIQUETA
Arroja como resultado lo siguiente
3.3.3 CSS EN ARCHIVO

La limitante de aplicar formatos en bloque consiste en que solo serían formatos para una página, cuando se
requiere que estos formatos se den en varias páginas debemos expórtalo
En un archivo independiente con extensión CSS aplicamos los formatos
La invocación de un archivo externo se aplica de la siguiente forma
En el archivo de ejemplo ya no hay formatos, existe el llamado a un archivo que contendrá formatos globales
para todas las páginas asociadas. Todas las páginas del mismo sitio que contengan esta línea de código
mostrara el mismo formato, si se requiere un cambio de color, de fuente, de márgenes, etc., solo tendrá que
ingresar al archivo, cambiarlo y al almacenar y ejecutar cualquiera de los archivos HTML mostrara dicha
actualización.
40
Resultado
41
4 UNIDAD 3 LOS SERVICIOS WEB (WEB SERVICES)

4.1.1 INTRODUCCIÓN
Un servicio web (Web Service) es una aplicación o componente que proporciona funcionalidad para un cliente.
Los clientes suelen ser navegadores web, pero también pueden ser aplicaciones estándar. La comunicación
entre un cliente y un servicio se facilita a través de protocolos estándar que se conectan a los puntos finales
creados para los servicios. El término punto final se refiere a una ubicación específica utilizada para acceder al
servicio web.
El diseño del software tiende a ser cada vez más modular. Las aplicaciones se componen de una serie de
componentes reutilizables, llamados en este caso servicios, que pueden encontrarse distribuidos a lo largo de
una serie de máquinas conectadas en red.
Dicho de otra forma, Servicio Web se refiere a una colección de funciones o métodos a los que se puede
accedes desde cualquier lugar de Internet o de una intranet, siendo el mecanismo de invocación totalmente
independiente de la plataforma que se utilice y siendo también cualquiera el lenguaje de programación en el
que se haya implementado internamente el servicio.
Los Servicios Web permitirán distribuir la aplicación a través de Internet, pudiendo una aplicación utilizar los
servicios ofrecidos por cualquier servidor conectado a Internet. La cuestión clave cuando se habla de servicios
Web es la interoperabilidad entre las aplicaciones.
Al conectarse con un servidor web desde un navegador, el servidor devuelve la página web solicitada, que es
un documento que expondrá el navegador para que sea visualizado por el usuario, pero es difícilmente
entendible por una máquina. Podemos ver esto como web para humanos. En contraposición, los Servicios Web
ofrecen información con un formato estándar que puede ser entendido fácilmente por una aplicación. En este
caso estaríamos ante una web para máquinas.
4.2 TIPOS DE SERVICIOS WEB

Endpoint
Los servicios pueden interconectarse a través de la red. En una arquitectura orientada a servicios, cualquier
interacción punto a punto implica dos endpoints: uno que proporciona un servicio, y otro de lo consume. Es
decir, que un endpoint es cada uno de los "elementos", en nuestro caso nos referimos a servicios, que se
sitúan en ambos "extremos" de la red que sirve de canal de comunicación entre ellos. Cuando hablamos de
servicios Web, un endpoint se especifica mediante una URI.
A nivel técnico, los servicios pueden implementarse de varias formas. En este sentido, podemos distinguir dos
tipos de servicios Web: los denominados servicios Web "grandes" ("big" Web Services), los llamaremos
servicios Web SOAP, y servicios Web RESTful.
42
4.3 SERVICIOS WEB SOAP

Los servicios Web SOAP, o servicios Web "big", utilizan mensajes XML para intercomunicarse que siguen el
estándar SOAP (Simple Object Access Protocol), un lenguaje XML que define la arquitectura y formato de los
mensajes. Dichos sistemas normalmente contienen una descripción legible por la máquina de la descripción de
las operaciones ofrecidas por el servicio, escrita en WSDL (Web Services Description Language), que es un
lenguaje basado en XML para definir las interfaces sintácticamente.
El formato de mensaje SOAP y el lenguaje de definición de interfaces WSDL se ha extendido bastante, y muchas
herramientas de desarrollo, por ejemplo Netbeans, pueden reducir la complejidad de desarrollar aplicaciones
de servicios Web.
El diseño de un servicio basado en SOAP debe establecer un contrato formal para describir la interfaz que
ofrece el servicio Web. WSDL puede utilizarse para describir los detalles del contrato, que pueden incluir
mensajes, operaciones, bindings, y la localización del servicio Web. También deben tenerse en cuenta los
requermientos no funcionales, como por ejemplo las transacciones, necesidad de mantener el estado
(addressing), seguridad y coordinación
4.3.1 DEFINICIÓN DE SERVISIO WEB

Un servicio Web es un componente con las siguientes características:
 Implementa los métodos de una interfaz descrita mediante un WSDL. Dichos métodos se implementan
utilizando un EJB de sesión de tipo Stateless/Singleton o bien un componente web JAX-WS
 Un servicio Web puede tener publicada su interfaz en uno o más "registros" durante su despliegue
 La implementación de un Servicio Web, la cual utiliza solamente la funcionalidad descrita por su

especificación, puede desplegarse en cualquier servidor de aplicaciones que cumple con las
especificaciones Java EE
 Los servicios requeridos en tiempo de ejecución (run-time), tales como atributos de seguridad, se
separan de la implementación del servicio. Se utilizarán herramientas adicionales que pueden definir
dichos requerimientos durante el ensamblado o despliegue
 Un contenedor actúa como mediador para acceder al servicio
La especificación de Java EE para servicios Web define una serie de relaciones arquitectónicas requeridas para
dichos servicios, que mostramos en la siguiente figura. Se trata de relaciones lógicas que no imponen
requerimiento alguno para el proveedor del contenedor sobre cómo estructurar los contenedores y los
procesos. Como añadido para la plataforma Java EE se incluye un componente port que depende de la
funcionalidad de contenedor proporcionada por los contenedores web y EJB, y del transporte SOAP/HTTP.
43
4.3.2 WSDL
WSDL (Web Services Description Language) es un lenguaje basado en XML utilizado para describir la
funcionalidad que proporciona un servicio Web. Una descripción WSDL (fichero WSDL) de un servicio web
proporciona una descripción entendible por la máquina (machine readable) de la interfaz del servicio Web,
indicando cómo se debe llamar al servicio, qué parámetros espera, y qué estructuras de datos devuelve.
La versión actual de WSDL es la 2.0, en la que se ha cambiado el significado de la D por Definition. La nueva
versión plantea cambios de nomenclatura y estructura del fichero xml que contiene la descripción del servicio.
En este módulo vamos a utilizar la versión anterior, la 1.1, puesto que es la que está soportada actualmente
por Netbeans, así como por BPEL, que estudiaremos más adelante. En la figura siguiente mostramos la
estructura que siguen los ficheros WSDL en ambas versiones, en donde podemos observar el cambio de
nomenclatura en la versión 2.0.
4.3.3 GESTOR DE SERVICIOS WEB DE NETBEANS

En Netbeans también encontramos un gestor de servicios web, en el que tenemos disponibles algunos servicios
web externos proporcionados por terceros (Google, StrikeIron), y al que podemos añadir otros servicios,
propios o ajenos. De esta forma podemos tener un catálogo de servicios que podremos incorporar de forma
rápida a nuestras aplicaciones, e incluso probarlos desde el propio entorno.
Podemos acceder a este gestor de servicios a través de la sección Web Services de la ventana Services de
Netbeans. Aquí veremos una lista de servicios que ya vienen incluidos en Netbeans y que podremos probar o
incorporar en nuestras aplicaciones. Vamos a añadir un nuevo servicio. Para ello antes creamos un grupo en el
que incluirlo. Pulsamos con el botón derecho sobre Web Services y seleccionamos Create Group para crear el
nuevo grupo.
Vamos a añadir un servicio HelloService. Vamos a crear un grupo de nombre jTech en el que incluiremos los
servicios proporcionados por dicha entidad.
44
Pulsamos sobre el grupo con el botón derecho y seleccionamos Add Web Service ... para añadir el nuevo
servicio.
Como datos del servicio proporcionamos la dirección del documento WSDL que lo define. Además podemos
también especificar el paquete en el cual generará la librería con el stub necesario para acceder al servicio.
Cuando terminemos de introducir los datos pulsamos Add para añadir el nuevo servicio.
Una vez tenemos el servicio añadido, podemos desplegarlo para ver las operaciones que ofrece y probarlas
pulsando sobre ellas con el botón derecho y seleccionando Test Method.
Nos aparecerá una ventana en la que deberemos introducir los parámetros necesarios para invocar el servicio,
y tras ello pulsar sobre el botón Submit para invocarlo y ver el resultado obtenido.
45
También podemos utilizar los servicios del gestor en nuestras aplicaciones de forma sencilla. Simplemente
tendremos que arrastrar la operación que queramos invocar sobre el lugar del código fuente en el que
queramos hacer la llamada. Al hacer esto se añadirá a nuestro proyecto una librería (JAR) con el stub necesario
para acceder al servicio.
4.3.4 INTERFAZ DE INVOCACIÓN DINÁMICA (DII)

Mediante esta interfaz ya no utilizaremos un stub para invocar los métodos del servicio, sino que nos permitirá
invocar los métodos de forma dinámica, indicando simplemente el nombre del método que queremos invocar
como una cadena de texto, y sus parámetros como un array de objetos.
Esto nos permitirá utilizar servicios que no conocemos previamente. De esta forma podremos implementar por
ejemplo un broker de servicios. Un broker es un servicio intermediario, al que podemos solicitar alguna tarea
que necesitemos. Entonces el broker intentará localizar el servicio más apropiado para dicha tarea en un
registro de servicios, y lo invocará por nosotros. Una vez haya conseguido la información que requerimos, nos
la devolverá. De esta forma la localización de servicios se hace totalmente transparente para nosotros.
Podremos acceder con esta interfaz tanto si contamos con un documento WSDL como si no contamos con él,
pero en el caso de que no tengamos el WSDL deberemos especificar en el código todos los datos incluidos en
estos documentos que necesitemos y de los que en este caso no disponemos (endpoint, parámetros y tipos,
etc).
46
5 UNIDAD 4 PERSISTENCIA
5.1.1 INTRODUCCIÓN
ORM: Es un mapeo de objetos relacionales.
Claves Primarias: Elemento principal de una tabla que no permite que se repita información de identificación.
Tipos de datos: Elementos que permiten la clasificación de la información.
Asistente: Componente que permite realizar procesos complejos de una forma simple.
Framework: Herramienta que permite que la elaboración de un aplicativo se realice de una manera más simple
y controlada.
5.1.2 OBJETIVO GENERAL

Manejar nuevas herramientas de desarrollo como el Hibernate, conociendo las bondades de este tipo
complemento que posibilita la construcción más rápido de un aplicativo tradicional.
5.1.3 OBJETIVOS ESPECÍFICOS

Identificar las principales características de un framework
Identificar los componentes, sentencias y formas de trabajo con Hibernate

47
5.2 CONCEPTOS DE ORM

ORM (Object Relational Mapping), es una técnica de programación para convertir datos entre el lenguaje de
programación orientado a objetos y el sistema de base de datos relacional.
Ventajas
Rapidez en el desarrollo.
 Abstracción de la base de datos

 Reutilización
 Seguridad
 Mantenimiento del código
 Lenguaje propio para realizar las consultas.
5.2.1 RELACIONES
5.2.1.1 EL MAPEO RELACIONAL
La ventaja de estos sistemas es la reducción considerable de código necesario para lograr lo que se conoce
como persistencia de objetos, esto permite lograr una integración con otros patrones como el Modelo-Vista-
Controlador.
En general los sistemas de información guardan datos en BD relacionales como Oracle, mysql, sqlServer, etc,
dentro de los procesos más comunes tenemos que un departamento de una empresa tiene varios empleados,
pero un empleado pertenece solo a un departamento.
Hibernate resuelve algunos inconvenientes con la representación de un modelo relacional mediante un

conjunto de objetos, en este caso los modelos representan tablas y los atributos de las clases son los campos
de las tablas.
Para mapear un modelo relacional se pueden utilizar formatos XML o con anotaciones.
5.2.2 CLAVES PRIMARIAS Y TIPOS DE DATOS

Dentro de las características del hibernate están sus tipos de datos.
48
 Integer
 Long
 short
 float
 double
 character
 byte
 boolean
 yes_no
 true_false
 string
 date
 time
 timestamp
 text
 binary
 big_decimal
 big_integer
Muchos de ellos muy conocidos por el trabajo de java otros no tanto y más comunes en este tipo de
framework. Estos datos tienen una clasificación como.
 Fecha y hora
 Date, time y timestamp
 Boolean
 Yes_no, true_false, Boolean
 Texto
 String y text
5.2.2.1 GENERACIÓN DE CLAVES PRIMARIAS

Hibernate tiene múltiples formas de tratar las claves primarias, la más es cuando el desarrollador indica la clave
que tendrá el objeto, este proceso se conoce como “assigned”
5.2.2.2 HIBERNATE QUERY LANGUAGE

El HQL es el lenguaje de consultas del Hibérnate, este tipo de sentencias tienen algunas características que
facilitan el uso de la herramienta, aunque hay que tener presente casos como la sensibilidad de las mayúsculas
y minúsculas que en las sentencias como tal no influyen, teniendo presente que puede ser Select, seLect,
selecT y no presentaría nungún inconveniente en el trabajo.
Es muy común ver en Hibernate la instrucción from sin procesos previos como se está acostumbrado a otras
herramientas lo mismo que las uniones con la instrucción join.
Un ejemplo de este tipo de sentencia es

LENGUAJE DE PROGRAMACIÓN AVANZADO II 49
Query = “from empleado order by nombre”
Dentro de las sentencias Join se encuentran
inner join
left outer join
right outer join
5.2.3 OBJETOS Y VALIDACIONES

Las validaciones en cualquier tipo de lenguaje se convierten en elementos fundamentales para un trabajo
organizado, en hibernate es común encontrar que las validaciones están asociadas a anotaciones
@NotNull
Esta propiedad indica que no puede estar nulo
@Size (min=n, max=m):
Esta propiedad controla que la información no sea nula y que contenga un mínimo de caracteres y un máximo.
Otras validaciones son
 @AssertFalse
 @AssertTrue
 @Digits(integer=n, fraction=m)
 @Future
 @Past
 @Max(n)
 @Min(n)
 @NotNull
 @Null
 @Pattern(regexp=“r”)
 @Size(min=n, max=m).
 @Email
 @NotBlank
 @Valid
5.2.4 ARQUITECTURA
La arquitectura en términos generales del Hibenate es la siguiente.
Luego de tener una BD organizada procedemos con la configuración inicial
Complementamos con la creacion de una interfaz.

A continuacion se crea una clase LibroDAO y se crearan todos los metodos a utilizar.
Luego se crea una clase Controller.java.

Posterior a este archivo se creara el paquete vista y la clase FrmLibro.
Programacion de los botones

Con estos procesos el ejemplo quedaria funcional.

6 GLOSARIO
Contenedor: Herramienta que puede contener otros controles, ejemplo de tablas y formularios
Etiquetas: “comandos” de HTML
Controles: Componentes de un ambiente de programación, cajas de texto, botones, combos, etc.
Formatos: Sentencias que permiten dar presentación, estilos y diseño a un sitio web
Estructuras: Son componentes de un lenguaje de programación tales como ciclos, preguntas, selectores y
preguntas
CRUD: Descripción de Crear, Leer, actualizar y Eliminar información.
ORM: Es un mapeo de objetos relacionales
Claves Primarias: Elemento principal de una tabla que no permite que se repita información de identificación
Tipos de datos: Elementos que permiten la clasificación de la información.
Asistente: Componente que permite realizar procesos complejos de una forma simple
Framework: Herramienta que permite que la elaboración de un aplicativo se realice de una manera más simple
y controlada
7 BIBLIOGRAFÍA
Oracle. (2014). Java Platform, Enterprise Edition The Java EE Tutorial, Release 7.
Reese, Richard. (2011). EJB 3.1 Cookbook. Packt Publishing. UK.
Panda, Debu. (2014). EJB 3 in Action 2nd Edition. Manning Publications Co. USA.
Kodali, Raghu. (2013). Beginning EJB 3 Java EE 7 Edition. Apress.
Sandoval, Jose. (2009). RESTful Java Web Services. Packt Publishing. UK.
Kalin, Martin. (2013). Java Web Services: Up and Running. O’Reilly. USA.
Heffelfinger, David R. (2011). Java EE 6 Development with NetBeans 7. Packt Publishing. UK.
Heffelfinger, David R. (2014). Java EE 7 with GlassFish 4 Application Server 3rd Edition. Packt Publishing. UK.
Gupta, Arun. (2013). Java EE 7 Essentials. O’Reilly. USA.
Keith, Mike. (2013). Pro JPA 2 2nd Edition. Apress.

Lenguaje Programacion Avanzado II 2017 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lenguaje Programacion Avanzado II 2017 PDF

Cargado por

Copyright:

Formatos disponibles

1

LENGUAJE DE PROGRAMACIÓN AVANZADO II

El módulo de estudio de la asignatura Lenguaje de Programación Avanzado II es propiedad de la Corporación

Martha Lucía Duque Ramírez

Francisco Javier Álvarez Gómez

Primera versión. 2017.

1 MAPA DE LA ASIGNATURA ...............................................................................................................................6

2 UNIDAD 1 LOS ENTERPRISE BEAN (EJB)............................................................................................................7

2.1 EL CONTENEDOR EJB ................................................................................................................................7

2.1.1 BENEFICIOS DE LOS ENTERPRISE BEAN ............................................................................................9

2.1.2 FUNCIONAMIENTO DE LOS COMPONENTES EJB ..............................................................................9

2.2 TIPOS DE BEANS..................................................................................................................................... 10

2.2.1 TIPOS DE EJB .................................................................................................................................. 10

2.2.2 COMUNICACIÓN CON UN EJB ....................................................................................................... 11

2.2.3 EJEMPLO BÁSICO DE UN EJB.......................................................................................................... 12

2.2.4 CREAR EL PRIMER EJB .................................................................................................................... 12

2.2.5 ACCESANDO UN SESSION BEAN .................................................................................................... 16

2.2.6 UTILIZANDO JNDI Y UN SERVLET COMO CLIENTE ......................................................................... 19

2.2.7 SINTAXIS DE NOMBRES JNDI PORTABLES ...................................................................................... 21

3 UNIDAD 2 LA CAPA WEB................................................................................................................................ 23

3.1.1 INTRODUCCIÓN ............................................................................................................................. 23

3.1.2 OBJETIVO GENERAL ....................................................................................................................... 23

3.1.3 OBJETIVOS ESPECÍFICOS ................................................................................................................ 23

3.2.1 ESTRUCTURA BÁSICA ..................................................................................................................... 24

3.2.2 CABECERA ...................................................................................................................................... 24

3.2.3 COMENTARIOS EN HTML ............................................................................................................... 25

3.2.4 SALTOS DE LÍNEA ........................................................................................................................... 25

3.2.5 VÍNCULOS ...................................................................................................................................... 27

3.2.7 TABLAS ........................................................................................................................................... 28

3.2.8 COMBINAR COLUMNAS ................................................................................................................. 29

3.2.9 FORMULARIOS ............................................................................................................................... 30

3.2.10 CAJAS DE TEXTO............................................................................................................................. 31

3.2.11 ÁREAS DE TEXTO ............................................................................................................................ 31

3.2.12 BOTONES DE COMANDO ............................................................................................................... 31

3.2.13 BOTONES DE RADIO....................................................................................................................... 32

3.2.14 CAJAS DE CHEQUEO....................................................................................................................... 32

3.2.16 URL ................................................................................................................................................. 34

3.3 ESTILO .................................................................................................................................................... 36

3.3.1 APLICACIÓN DE FORMATOS EN LÍNEA .......................................................................................... 37

3.3.2 APLICANDO LOS FORMATOS A LA PRIMERA ETIQUETA ................................................................ 39

3.3.3 CSS EN ARCHIVO ............................................................................................................................ 39

4 UNIDAD 3 LOS SERVICIOS WEB (WEB SERVICES) .......................................................................................... 41

4.1.1 INTRODUCCIÓN ............................................................................................................................. 41

4.2 TIPOS DE SERVICIOS WEB ...................................................................................................................... 41

4.3 SERVICIOS WEB SOAP ............................................................................................................................ 42

4.3.1 DEFINICIÓN DE SERVISIO WEB ...................................................................................................... 42

4.3.3 GESTOR DE SERVICIOS WEB DE NETBEANS ................................................................................... 43

4.3.4 INTERFAZ DE INVOCACIÓN DINÁMICA (DII) .................................................................................. 45

5 UNIDAD 4 PERSISTENCIA ............................................................................................................................... 46

5.1.1 INTRODUCCIÓN ............................................................................................................................. 46

5.1.2 OBJETIVO GENERAL ....................................................................................................................... 46

5.1.3 OBJETIVOS ESPECÍFICOS ................................................................................................................ 46

5.2 CONCEPTOS DE ORM ............................................................................................................................. 47

5.2.1 RELACIONES ................................................................................................................................... 47

5.2.2 CLAVES PRIMARIAS Y TIPOS DE DATOS ......................................................................................... 47

5.2.3 OBJETOS Y VALIDACIONES ............................................................................................................. 49

5.2.4 ARQUITECTURA ............................................................................................................................. 49

2 UNIDAD 1 LOS ENTERPRISE BEAN (EJB)

El desarrollo basado en componentes promete un paso más en el camino de la programación orientada a

2.1 EL CONTENEDOR EJB

Y muchas otras características como:

2.1.1 BENEFICIOS DE LOS ENTERPRISE BEAN

2.1.2 FUNCIONAMIENTO DE LOS COMPONENTES EJB