Download primefaces crud generador para netbeans

UNIVERSIDAD CENTRAL DEL ECUADOR
PORTADA
FACULTAD DE INGENIERÍA CIENCIAS FÍSICAS Y
MATEMÁTICA
CARRERA DE INGENIERÍA EN INFORMÁTICA
“PRIMEFACES CRUD GENERADOR PARA NETBEANS”
TRABAJO DE GRADUACIÓN PREVIO A LA OBTENCIÓN
DEL TÍTULO DE INGENIERO INFORMÁTICO
AUTOR: PATRICIO GUSTAVO EGAS CLAVIJO
TUTOR: ING RENE ALFONSO CARRILLO FLORES
QUITO – ECUADOR
2015
DEDICATORIA
Esta tesis la dedico a mi madre, a mi padre y a mi hermana, ya que gracias
a los valores y formación inculcados de parte de mi madre y todo el amor
que me brindo siempre me apoyo en todo y el ejemplo de mi padre me han
servido mucho, para ser la persona que soy hoy, sin desmerecer a mi
hermana que me apoyo durante toda mi carrera universitaria.
A mis tíos abuelos por apoyarme toda la vida y a una persona que se ha
convertido en mi consejera y me orienta en la vida a la señora muy especial
que es como mi segunda madre.
Además debo agradecer a todos aquellos excelentes Docentes que con sus
conocimientos, contribuyeron no sólo en darme el conocimiento y formación
académica respetable sino también enriquecieron mi formación personal.
ii
AGRADECIMIENTO
A Dios por sus múltiples bendiciones y permitirme cumplir mis objetivos y
darme la vida para seguir estudiando.
A mis Padres Patricio Egas que me enseñó a siempre decir la verdad y
Blanquita Clavijo por formarme para llegar a ser la persona que soy ahora ya
que sin sus enseñanzas no lo hubiera logrado agregando que siempre ha
confiado en mí y me ha brindado todo su amor.
A mi hermana Elizabeth Egas, por apoyarme en toda la carrera universitaria y
recibir sus consejos.
A mis tíos abuelos por siempre apoyar a toda mi familia, gracias por estar
presente siempre.
A la Señora Mayra Castro por darme buenos consejos y ser mi orientación y
la considero como mi segunda Madre.
A todos mis profesores de la Universidad Central del Ecuador en especial:
A mi Director de Tesis Ing. Rene Carrillo quien con su esfuerzo y dedicación,
supo guiarme en el desarrollo de este proyecto de tesis.
A los profesores: Mat. Jorge Arroba e Ing. Jorge Morales porque gracias a sus
conocimientos y experiencia han aportado en mi formación académica y me
han apoyado en el aspecto universitario y laboral.
A todas las personas que forman parte de mi vida que de una u otra forma me
han brindado su valiosa amistad.
iii
iv
v
vi
vii
CONTENIDO
PORTADA................................................................................................................................ i
DEDICATORIA ....................................................................................................................... ii
AGRADECIMIENTO .............................................................................................................. iii
CONTENIDO ....................................................................................................................... viii
LISTA DE TABLAS ................................................................................................................ xi
LISTA DE ILUSTRACIONES ................................................................................................ xi
RESUMEN ............................................................................................................................xiv
ABSTRACT ............................................................................................................................xv
CAPÍTULO I ............................................................................................................................ 1
1.
PRESENTACIÓN DEL PROBLEMA............................................................................... 1
1.1.
Introducción ................................................................................................................. 1
1.2.
Planteamiento del Problema ....................................................................................... 1
1.3.
Formulación del Problema........................................................................................... 1
1.4.
Interrogantes ................................................................................................................ 2
1.5.
Objetivos de la Investigación....................................................................................... 2
1.5.1.
Objetivo General ...................................................................................................... 2
1.5.2.
Objetivos Específicos............................................................................................... 2
1.6.
Justificación ................................................................................................................. 2
1.7.
Alcance ........................................................................................................................ 3
1.8.
Delimitación del Proyecto ............................................................................................ 3
CAPÍTULO II ........................................................................................................................... 4
2.
FUNDAMENTACIÓN TEÓRICA ..................................................................................... 4
2.1.
Lenguaje de programación Java ................................................................................. 4
2.2 PrimeFaces....................................................................................................................... 5
2.3 HTML ................................................................................................................................ 6
2.4 MYSQL ............................................................................................................................. 7
2.5
Marco de Trabajo (FRAMEWORK)............................................................................10
2.5.1 ¿Qué es un framework Web? ......................................................................................10
2.5.2 Patrón MVC ..................................................................................................................11
2.5.3
Tipos de framework Web........................................................................................14
2.5.4 Características..............................................................................................................14
viii
a.
ODBC..............................................................................................................................14
Metodología de Desarrollo Software ......................................................................15
2.5.5
CAPÍTULO III .........................................................................................................................16
ANÁLISIS DEL SISTEMA ..............................................................................................16
3
Especificación de Requerimientos .............................................................................16
3.1.
3.1.1.
Contextualización....................................................................................................16
Requerimientos Funcionales ......................................................................................16
3.2.
3.2.1.
Características principales del sistema. .................................................................16
3.2.2.
Descripción de los Actores .....................................................................................17
3.2.2.1.
Procesos de actores y roles ................................................................................18
3.2.2.1.1.
Actividades del Administrador (Crud Generator for Netbeans) ..................18
3.2.2.1.2.
Actividades del usuario del sistema ............................................................19
Requerimientos Específicos ...................................................................................19
3.2.3.
Casos de Uso .............................................................................................................20
3.3.
3.3.1.
Diagrama general de casos de uso........................................................................20
3.3.2.
Descripción de los Casos de Uso...........................................................................21
Requerimientos no funcionales ..................................................................................26
3.4.
CAPÍTULO IV.........................................................................................................................27
4.
DISEÑO DEL SISTEMA .................................................................................................27
Arquitectura del Sistema ............................................................................................27
4.1.
4.1.1.
Diseño de la Arquitectura Lógica del Sistema (PrimeFaces Crud Generator for
Netbeans) ..............................................................................................................................27
4.2.
Descripción de las Entidades .....................................................................................30
4.3.
Diseño de Interfaces...................................................................................................33
4.3.1.
Interface Sitio Web..................................................................................................33
4.3.1.1.
Instalación Herramienta ......................................................................................33
4.3.1.2.
Ejercicio Práctico .................................................................................................44
4.3.1.3.
Interfaz de Usuario ..............................................................................................60
4.3.1.4.
Interfaz Portal Web..............................................................................................65
CAPÍTULO V..........................................................................................................................72
1.
5.1
CONCLUSIONES Y RECOMENDACIONES ................................................................72
Conclusiones ..............................................................................................................72
ix
5.2
Recomendaciones ......................................................................................................73
GLOSARIO DE TÉRMINOS..................................................................................................74
BIBLIOGRAFÍA ......................................................................................................................76
x
LISTA DE TABLAS
Tabla 1: Descripción de Entidad Activación curso. (Autoría Personal) ................................30
Tabla 2: Descripción de Entidad Actores. (Autoría Personal) ..............................................31
Tabla 3: Descripción de Entidad Conferencistas. (Autoría Personal) ..................................31
Tabla 4: Descripción de Entidad Perfil. (Autoría Personal) ..................................................31
Tabla 5: Descripción de Entidad Propuesta_curso. (Autoría Personal) ...............................32
Tabla 6: Descripción de Entidad General. (Autoría Personal) .............................................32
LISTA DE ILUSTRACIONES
Ilustración 1: Modelo Vista Contralor (MVC). (Rayfield & Avraham, 2001)
11
Ilustración 2: Actividades Administrador en Netbeans. (Autoría Personal)
18
Ilustración 3: Actividades del usuario final. (Autoría Personal)
19
Ilustración 4: Diagrama de casos de uso PrimeFaces Crud Generator for Netbeans.
(Autoría Personal)
21
Ilustración 5: Diagrama casos de uso Insertar datos. (Autoría Personal)
21
Ilustración 6: Diagrama de casos de uso Modificar datos. (Autoría Personal)
22
Ilustración 7: Diagrama de casos de uso Eliminar datos Sitio Web. (Autoría Personal) 22
Ilustración 8: Diagrama de casos de uso Actualizar datos Sitio Web. (Autoría Personal) 23
Ilustración 9: Diagrama de casos de uso Administración portal web. (Autoría Personal) 23
Ilustración 10: Diagrama de casos de uso Barra de Opciones. (Autoría Personal)
23
Ilustración 11: Diagrama de caso de usos Comprar producto. (Autoría Personal).
24
Ilustración 12: Diagrama de caso de usos Chat online. (Autoría Personal)
24
Ilustración 13: Diagrama de caso de usos comentar online. (Autoría Personal)
25
Ilustración 14: Diagrama de caso de usos Contactarse. (Autoría Personal)
25
Ilustración 15: Diagrama de caso de usos ver redes sociales. (Autoría Personal)
25
Ilustración 16: Capa Presentación (Autoría Personal)
27
Ilustración 17: Capa Negocios
28
Ilustración 18: Capa Datos
28
Ilustración 19: Modelo Entidad / Relación del Sistema. (Autoría Personal)
30
Ilustración 20: Descargar JDK. (Autoría Personal)
33
Ilustración 21: Descargar Plugin PrimeFaces Crud Generator For Netbeans. (Autoría
Personal)
34
Ilustración 22: Plugin NBM descomprimido. (Autoría Personal)
34
Ilustración 23: Ventana Netbeans/tools/Plugins. (Autoría Personal)
35
Ilustración 24: Pestaña downloaded para instalar plugin. (Autoría Personal)
35
Ilustración 25: Selección plugin descomprimido. (Autoría Personal)
36
Ilustración 26: Notificación reconocimiento plugin. (Autoría Personal)
36
xi
Ilustración 27: Instalando PrimeFaces Crud Generator. (Autoría Personal)
37
Ilustración 28: Aceptando términos y condiciones. (Autoría Personal)
37
Ilustración 29: Terminando la instalación. (Autoría Personal)
38
Ilustración 30: Verificando la existencia del plugin. (Autoría Personal)
38
Ilustración 31: Pantalla descarga Netbeans. (Autoría Personal)
39
Ilustración 32: Diagrama descarga Netbeans. (Autoría Personal)
40
Ilustración 33: Pantalla inicial Netbeans. (Autoría Personal)
40
Ilustración 34: Descarga de MySQL. (Autoría Personal)
41
Ilustración 35: Pantalla inicia MySQL. (Autoría Personal)
41
Ilustración 36: Pantalla descarga PrimeFaces 4.0. (Autoría Personal)
42
Ilustración 37: Pantalla instalación PrimeFaces 4.0. (Autoría Personal)
42
Ilustración 38: Pantalla instalación PrimeFaces 4.0. Agregando nueva librería (Autoría
Personal)
43
Ilustración 39: Agregando nuevo nombre a la librería (Autoría Personal)
43
Ilustración 40: Agregando archivos para nueva librería PrimeFaces 4.0 (Autoría Personal)
44
Ilustración 41: Pantalla creación proyecto web (Autoría Personal)
45
Ilustración 42: Pantalla creación proyecto web aplicación (Autoría Personal)
45
Ilustración 43: Dando un nombre al proyecto web (Autoría Personal)
46
Ilustración 44: Configurando Servidor y versión de Java EE (Autoría Personal)
46
Ilustración 45: Configurando Servidor y versión de Java EE (Autoría Personal)
47
Ilustración 46: Configurando Java Server Faces (Autoría Personal)
47
Ilustración 47: Configurando Java Server Faces componentes (Autoría Personal)
48
Ilustración 48: Configurando Java Server Faces escogiendo librería (Autoría Personal) 48
Ilustración 49: Finalizando configuración (Autoría Personal)
49
Ilustración 50: Ubicando el cursor en el proyecto (Autoría Personal)
49
Ilustración 51: Ubicando el cursor para aplicar Crud (Autoría Personal)
50
Ilustración 52: Seleccionando opciones para mapeo de base de datos (Autoría Personal)
50
Ilustración 53: Cargando tablas de la base de datos (Autoría Personal)
51
Ilustración 54: Seleccionan tablas de la base de datos (Autoría Personal)
51
Ilustración 55: Configurando mapeo y dando nombre al paquete (Autoría Personal)
52
Ilustración 56: Configurando mapeo de base de datos (Autoría Personal)
53
Ilustración 57: Clases generadas por mapeo de base de datos (Autoría Personal)
54
Ilustración 58: Archivo persistence.xml (Autoría Personal)
54
Ilustración 59: Configurando PrimeFaces Crud (Autoría Personal)
55
Ilustración 60: Configurando PrimeFaces Crud mapeo de base de datos (Autoría
Personal)
55
Ilustración 61: Configurando PrimeFaces Crud Generator (Autoría Personal)
57
Ilustración 62: Configurando PrimeFaces Crud Generator CSS3 (Autoría Personal)
57
Ilustración 63: Configurando PrimeFaces Crud Generator CSS3 agregando jar (Autoría
Personal)
58
xii
Ilustración 64: Configurando PrimeFaces Crud Generator CSS3 agregando jar a la librería
(Autoría Personal)
58
Ilustración 65: Configurando PrimeFaces Crud Generator CSS3 agregando líneas de
código (Autoría Personal)
59
Ilustración 66: Ventana con tema nuevo (Autoría Personal)
59
Ilustración 67: Pantalla Inicial (Autoría Personal)
60
Ilustración 68: Pantalla pestaña mantenimiento (Autoría Personal)
61
Ilustración 69: Pantalla ejemplo en base de datos perfil (Autoría Personal)
61
Ilustración 70: Insertando un nuevo registro (Autoría Personal)
62
Ilustración 71: Registro insertado (Autoría Personal)
62
Ilustración 72: Ver registro insertado (Autoría Personal)
63
Ilustración 73: Editando registro (Autoría Personal)
63
Ilustración 74: Registro Editado (Autoría Personal)
64
Ilustración 75: Borrando registro (Autoría Personal)
64
Ilustración 76: Filtrando registros (Autoría Personal)
64
Ilustración 77: Pagina Inicial portal web (Autoría Personal)
65
Ilustración 78: Pagina quienes somos (Autoría Personal)
65
Ilustración 79: Pagina tienda (Autoría Personal)
66
Ilustración 80: Pagina frameworks (Autoría Personal)
66
Ilustración 81: Pagina documentación (Autoría Personal)
67
Ilustración 82: Pagina faq y chat (Autoría Personal)
67
Ilustración 83: Pagina contactos (Autoría Personal)
68
Ilustración 84: Pagina post y comentarios (Autoría Personal)
68
Ilustración 85: Pagina noticias (Autoría Personal)
69
Ilustración 86: Página miembro del equipo (Autoría Personal)
69
Ilustración 87: Paginas en línea (Autoría Personal)
70
Ilustración 88: Configuración herramienta SEO (Autoría Personal)
70
Ilustración 89: Canal de YouTube
71
xiii
RESUMEN
“PRIMEFACES CRUD GENERADOR PARA NETBEANS”
El presente proyecto define, diseña y desarrolla un análisis de la herramienta
“PrimeFaces” Crud Generador para Netbeans, soportado fundamentalmente
por el lenguaje de programación Java y PrimeFaces.
Realiza un proyecto de programación web en cuestión de minutos ahorra
mucho tiempo, además mapea a las entidades de la base de datos por lo cual
se puede hacer operaciones como insertar, eliminar, consultar, actualizar,
utiliza el patrón de diseño Abstract Facade.
Para realizar mantenimiento en nuestra página web es excelente, también se
puede modificar el código para adaptarlo a nuestro gusto.
DESCRIPTORES:
PRIMEFACES CRUD GENERADOR FOR NETBEANS /JAVA/JAVA SERVER
FACES/PRIMEFACES/GENERADOR DE CODIGO WEB/CSS3/BASE DE
DATOS
xiv
ABSTRACT
“PRIMEFACES CRUD GENERATOR FOR NETBEANS”
This project defines, designs and develops a "PrimeFaces" Crud Generator
tool for Netbeans analysis, mainly supported by Java language and
PrimeFaces programming.
Make a web programming project in few minutes saves time, also maps entities
from the database so it is able to perform operations such as: insert, delete,
query, and update applying the Abstract Façade design pattern.
In order to perform a maintenance about our website is excellent, it can also
modify the code to adapt it into different preferences.
DESCRIPTORS:
PRIMEFACES CRUD GENERATOR FOR NETBEANS / JAVA / JAVA
SERVER FACES / PRIMEFACES / WEB CODE GENERATOR / CSS3 /
DATABASE
xv
xvi
xvii
xviii
CAPÍTULO I
1. PRESENTACIÓN DEL PROBLEMA
1.1. Introducción
En la actualidad existe suficiente información en internet de cómo programar
páginas web en lenguaje Java, razón por la cual se usa ese conocimiento para
realizar entornos de páginas web con JSF (JAVA SERVER FACES), de una
manera manual (insertar código línea a línea).
La información es muy amplia respecto a las distintas versiones de Java EE y
JSF y no saber por cual versión comenzar a aprender, no obstante nace la
idea de crear páginas web con entorno Java de una manera automática y que
facilite al usuario su fácil uso y mantenimiento.
Esta herramienta es un generador Crud de PrimeFaces que realiza un
proyecto web, en cuestión de minutos ahorra mucho tiempo, además mapea
a las entidades de la base de datos por lo cual se puede hacer operaciones
como insertar, eliminar, consultar, actualizar.
El presente proyecto de Tesis que se pretende desarrollar, un análisis de la
herramienta “PrimeFaces Crud Generator for Netbeans” para realizar
proyectos web.
1.2. Planteamiento del Problema
La escasez de herramientas de generación de código Java de una manera
automática en entornos web y optimizar el tiempo al momento de generar un
proyecto es vital en el día a día, para crear sistemas informáticos de manera
eficiente.
1.3. Formulación del Problema
¿Se puede generar código JSF de una manera automática y con un entorno
amigable con el usuario respecto al mantenimiento de un sistema?
1
1.4. Interrogantes
Las cuestiones que se han bosquejado al realizar el trabajo de investigación
son:
¿Cómo se podrá realizar la generación de código automática en Java en un
entorno web?
¿Cómo poder implementar un canal de YouTube para el beneficio de las
personas interesadas?
1.5. Objetivos de la Investigación
1.5.1.
Objetivo General
Realizar un análisis de la generación de código Java en un entorno web y con
base de datos, apoyándose de la herramienta “PrimeFaces Crud Generator
for Netbeans.”
1.5.2.
Objetivos Específicos
 Implementación de código JSF en Java de una manera automática con
base de datos(MYSQL)
 Generación de código automático mediante la herramienta de PrimeFaces
Crud Generator for Netbeans
 Implementar un canal de YouTube explicando cómo se instala y funciona
la herramienta y compartir ese conocimiento con el resto del mundo.
1.6. Justificación
En la actualidad no se cuenta con un generador de código Java de páginas
web y con hojas de estilo de calidad, Es oportuno realizar este estudio para
optimizar tiempo al momento de realizar un proyecto extenso.
2
1.7. Alcance
A continuación se detalla los módulos previstos para el presente proyecto:
MODULO HERRAMIENTA
1. PROGRAMACIÓN
 Utilización de la herramienta PrimeFaces Crud Generator for Netbeans
para la generación de código Java
 Utilización de motor de bases de datos MYSQL.
 PrimeFaces 4.0
 Servidor de aplicaciones GlassFish 4.0
 Netbeans 7.4
MÓDULO DE ANÁLISIS
1. HERRAMIENTA DE GENERACION DE CODIGO AUTOMATICO
Se dispone de esta herramienta de PrimeFaces para la generación de código
JSF en Java.


La generación de código Java en un entorno web será específicamente
para una base de datos.
El código generado será analizado y corresponderá a una entidad en
cuestión.
1.8. Delimitación del Proyecto






El sitio web es visible únicamente en una máquina local.
La base de datos es un ejemplo base en MySQL que será cargada
previamente en Netbeans
En el canal de YouTube se contestara todas las inquietudes de los
usuarios
Se utiliza GlassFish 4.0 como servidor de aplicaciones
Se utiliza PrimeFaces 4.0 para la generación de las interfaces JSF
Se utiliza el motor de base de datos MySQL
3
CAPÍTULO II
2. FUNDAMENTACIÓN TEÓRICA
2.1. Lenguaje de programación Java
Definición
Java
es
un
lenguaje
de
programación
de
propósito
general, concurrente, orientado a objetos que fue diseñado específicamente
para tener tan pocas dependencias de implementación como fuera posible. Su
intención es permitir que los desarrolladores de aplicaciones escriban el
programa una vez y lo ejecuten en cualquier dispositivo (conocido en inglés
como WORA, o "write once, run anywhere"), lo que quiere decir que
el código que es ejecutado en una plataforma no tiene que ser recompilado para
correr en otra. Java es, a partir de 2012, uno de los lenguajes de programación
más populares en uso, particularmente para aplicaciones cliente-servidor de
web, con unos 10 millones de usuarios reportados. (GOSLING, 2005)
El lenguaje de programación Java fue originalmente desarrollado por James
Gosling de Sun Microsystems (la cual fue adquirida por la compañía Oracle) y
publicado en 1995 como un componente fundamental de la plataforma Java de
Sun Microsystems. Su sintaxis deriva en gran medida de C y C++, pero tiene
menos utilidades de bajo nivel que cualquiera de ellos. Las aplicaciones de Java
son generalmente compiladas a bytecode (clase Java) que puede ejecutarse
en cualquier máquina virtual Java (JVM) sin importar la arquitectura de la
computadora subyacente. (GOSLING, 2005)
La compañía Sun desarrolló la implementación de referencia original para
los compiladores de Java, máquinas virtuales, y librerías de clases en 1991 y
las publicó por primera vez en 1995. A partir de mayo de 2007, en cumplimiento
con las especificaciones del Proceso de la Comunidad Java, Sun volvió a
licenciar la mayoría de sus tecnologías de Java bajo la Licencia Pública General
de GNU. Otros también han desarrollado implementaciones alternas a estas
tecnologías de Sun, tales como el Compilador de Java de GNU y el GNU
Classpath.
4
El lenguaje Java se creó con el principal objetivo:
Debería usar el paradigma de la programación orientada a objetos.
Orientado a Objetos
La primera característica, orientado a objetos, se refiere a un método de
programación y al diseño del lenguaje. Aunque hay muchas interpretaciones
para Orientado a Objetos, una primera idea es diseñar el software de forma que
los distintos tipos de datos que usen estén unidos a sus operaciones. Así, los
datos y el código (funciones o métodos) se combinan en entidades llamadas
objetos. Un objeto puede verse como un paquete que contiene el
“comportamiento” (el código) y el “estado” (datos). El principio es separar
aquello que cambia de las cosas que permanecen inalterables.
Frecuentemente, cambiar una estructura de datos implica un cambio en el
código que opera sobre los mismos, o viceversa. Esta separación en objetos
coherentes e independientes ofrece una base más estable para el diseño de un
sistema software. El objetivo es hacer que grandes proyectos sean fáciles de
gestionar y manejar, mejorando como consecuencia su calidad y reduciendo el
número de proyectos fallidos. (GOSLING, 2005)
2.2 PrimeFaces
Definición
PrimeFaces es una librería de componentes para JavaServer Faces (JSF) de
código abierto que cuenta con un conjunto de componentes enriquecidos que
facilitan la creación de las aplicaciones web. PrimeFaces está bajo la licencia
de Apache License V2. Una de las ventajas de utilizar PrimeFaces, es que
permite la integración con otros componentes como por ejemplo RichFaces.
(http://es.wikipedia.org/wiki/PrimeFaces, 2015)
Propiedades
Conjunto de componentes en (Editor de HTML, autocompletar, cartas, gráficas
o paneles, entre otros).
Soporte de Ajax con despliegue parcial, lo que permite controlar qué
componentes de la página actual se actualizarán y cuáles no.
Tiene 25 temas prediseñados:
Componente para desarrollar aplicaciones web para teléfonos móviles,
especiales para IPhone, Palm, Android y teléfonos móviles Nokia.
5
2.3 HTML
Definición
HTML, siglas de HyperText Markup Language («lenguaje de marcas de
hipertexto»), hace referencia al lenguaje de marcado para la elaboración de
páginas web. Es un estándar que sirve de referencia para la ela-boración de
páginas web en sus diferentes versiones, define una estructura básica y un
código (denominado código HTML) para la definición de contenido de una
página web, como texto, imágenes, videos, entre otros. Es un estándar a cargo
de la W3C, organización dedicada a la estandarización de casi todas las
tecnologías ligadas a la web, sobre todo en lo referente a su escritura e
interpretación. (LUJÁN MORA, 2002)
El lenguaje HTML basa su filosofía de desarrollo en la referenciación. Para
añadir un elemento externo a la página (imagen, vídeo, script, entre otros.),
este no se incrusta directamente en el código de la página, sino que se hace
una referencia a la ubicación de dicho elemento mediante texto. De este modo,
la página web contiene sólo texto mientras que recae en el navegador web
(interpretador del código) la tarea de unir todos los elementos y visualizar la
página final. Al ser un estándar, HTML busca ser un lenguaje que permita que
cualquier página web escrita en una determinada versión, pueda ser
interpretada de la misma forma (estándar) por cualquier navegador web
actualizado. (LUJÁN MORA, 2002)
Sin embargo, a lo largo de sus diferentes versiones, se han incorporado y
suprimido diversas características, con el fin de hacerlo más eficiente y facilitar
el desarrollo de páginas web compatibles con distintos navegadores y
plataformas (PC de escritorio, portátiles, teléfonos inteligentes, tabletas, etc.).
Sin embargo, para interpretar correctamente una nueva versión de HTML, los
desarrolladores de navegadores web deben incorporar estos cambios y el
usuario debe ser capaz de usar la nueva versión del navegador con los
cambios incorporados. Normalmente los cambios son aplicados mediante
parches de actualización automática (Firefox, Chrome) u ofreciendo una nueva
versión del navegador con todos los cambios incorporados, en un sitio web de
descarga oficial (Internet Explorer). Un navegador no actualizado no será
capaz de interpretar correctamente una página web escrita en una versión de
HTML superior a la que pueda interpretar, lo que obliga muchas veces a los
desarrolladores a aplicar técnicas y cambios que permitan corregir problemas
de visualización e incluso de interpretación de código HTML. Así mismo, las
páginas escritas en una versión anterior de HTML deberían ser actualizadas o
6
reescritas, lo que no siempre se cumple. Es por ello que ciertos navegadores
aún mantienen la capacidad de interpretar páginas web de versiones HTML
anteriores. Por estas razones, aún existen diferencias entre distintos
navegadores y versiones al interpretar una misma página web.
2.4 MYSQL
Definición
MySQL es un sistema de gestión de bases de datos relacional, multihilo y
multiusuario con más de seis millones de instalaciones. MySQL AB —desde
enero de 2008 una subsidiaria de Sun Microsystems y ésta a su vez de Oracle
Corporation desde abril de 2009— desarrolla MySQL como software libre en un
esquema de licenciamiento dual. (CLABURN, 2007)
Por un lado se ofrece bajo la GNU GPL para cualquier uso compatible con esta
licencia, pero para aquellas empresas que quieran incorporarlo en productos
privativos deben comprar a la empresa una licencia específica que les permita
este uso. Está desarrollado en su mayor parte en ANSI C.
MySQL es patrocinado por una empresa privada, que posee el copyright de la
mayor parte del código. Esto es lo que posibilita el esquema de licenciamiento
anteriormente mencionado. Además de la venta de licencias privativas, la
compañía ofrece soporte y servicios. Para sus operaciones contratan
trabajadores alrededor del mundo que colaboran vía Internet. MySQL AB fue
fundado por David Axmark, Allan Larsson y Michael Widenius. MySQL es usado
por muchos sitios web grandes y populares, como Wikipedia, Google.
(CLABURN, 2007)
Aplicaciones
MySQL es una base de datos muy rápida en la lectura cuando utiliza el motor
no transaccional MyISAM, pero puede provocar problemas de integridad en
entornos de alta concurrencia en la modificación. En aplicaciones web hay baja
concurrencia en la modificación de datos y en cambio el entorno es intensivo
en lectura de datos, lo que hace a MySQL ideal para este tipo de aplicaciones.
Sea cual sea el entorno en el que va a utilizar MySQL, es importante monitorizar
de antemano el rendimiento para detectar y corregir errores tanto de SQL como
de programación.
7
Características
Inicialmente, MySQL carecía de elementos considerados esenciales en las
bases de datos relacionales, tales como integridad referencial y transacciones.
A pesar de ello, atrajo a los desarrolladores de páginas web con contenido
dinámico, justamente por su simplicidad. (CLABURN, 2007)
Poco a poco los elementos de los que carecía MySQL están siendo
incorporados tanto por desarrollos internos, como por desarrolladores de
software libre. Entre las características disponibles en las últimas versiones se
puede destacar:







Amplio subconjunto del lenguaje SQL. Algunas extensiones son
incluidas igualmente.
Disponibilidad en gran cantidad de plataformas y sistemas.
Posibilidad de selección de mecanismos de almacenamiento que
ofrecen diferentes velocidades de operación, soporte físico, capacidad,
distribución geográfica, transacciones...
Transacciones y claves foráneas.
Conectividad segura.
Replicación.
Búsqueda e indexación de campos de texto.
MySQL es un sistema de administración de bases de datos. Una base de
datos es una colección estructurada de tablas que contienen datos. Esta
puede ser desde una simple lista de compras a una galería de pinturas o el
vasto volumen de información en una red corporativa. Para agregar, acceder
a y procesar datos guardados en un computador, usted necesita un
administrador como MySQL Server. Dado que los computadores son muy
buenos manejando grandes cantidades de información, los administradores
de bases de datos juegan un papel central en computación, como
aplicaciones independientes o como parte de otras aplicaciones.
MySQL es un sistema de administración relacional de bases de datos. Una
base de datos relacional archiva datos en tablas separadas en vez de colocar
todos los datos en un gran archivo. Esto permite velocidad y flexibilidad. Las
tablas están conectadas por relaciones definidas que hacen posible combinar
datos de diferentes tablas sobre pedido.
MySQL es software de fuente abierta. Fuente abierta significa que es posible
para cualquier persona usarlo y modificarlo. Cualquier persona puede bajar
8
el código fuente de MySQL y usarlo sin pagar. Cualquier interesado puede
estudiar el código fuente y ajustarlo a sus necesidades. MySQL usa el GPL
(GNU General Public License) para definir qué puede hacer y qué no puede
hacer con el software en diferentes situaciones. Si usted no se ajusta al GPL
o requiere introducir código MySQL en aplicaciones comerciales, usted
puede comprar una versión comercial licenciada. (CLABURN, 2007)
Características distintivas
Las siguientes características son implementadas únicamente por MySQL:
Permite escoger entre múltiples motores de almacenamiento para cada tabla.
En MySQL 5.0 éstos debían añadirse en tiempo de compilación, a partir de
MySQL 5.1 se pueden añadir dinámicamente en tiempo de ejecución:
Los hay nativos como: MyISAM, Falcon, Merge, InnoDB, BDB, Memory/heap,
MySQL Cluster, Federated, Archive, CSV, Blackhole y Example
Desarrollados por partners como solidDB, NitroEDB, ScaleDB, TokuDB,
Infobright (antes Brighthouse), Kickfire, XtraDB, IBM DB2. InnoDB Estuvo
desarrollado así pero ahora pertenece también a Oracle.
Desarrollados por la comunidad como memcache, httpd, PBXT y Revisión.
Agrupación de transacciones, reuniendo múltiples transacciones de varias
conexiones para incrementar el número de transacciones por segundo.
Desarrollo del proyecto
El desarrollo de MySQL se fundamenta en el trabajo de los desarrolladores
contratados por la empresa MySQL AB quienes se encargan de dar soporte a
los socios comerciales y usuarios de la comunidad MySQL y dar solución a los
problemas encontrados por los usuarios. Los usuarios o miembros de la
comunidad MySQL pueden reportar bugs revisando el manual en línea que
contiene las soluciones a problemas encontrados; el historial de cambios, la
base de datos bugs que contiene bugs reportados y solucionados y en las
listas de correo MySQL.
A través de las listas de correo los usuarios pueden enviar preguntas y éstas
serán contestadas por desarrolladores brindándoles mejor soporte.
9
Licencia
La licencia GNU GPL de MySQL obliga a que la distribución de cualquier
producto derivado (aplicación) se haga bajo esa misma licencia. Si un
desarrollador desea incorporar MySQL en su producto pero desea distribuirlo
bajo otra licencia que no sea la GNU GPL, puede adquirir una licencia
comercial de MySQL que le permite hacer justamente eso.
2.5 Marco de Trabajo (FRAMEWORK)
Un marco o marco de software, es una plataforma (TECHTERMS, 2015), para
el desarrollo de software de aplicaciones. Proporciona una base sobre la que
los desarrolladores de software pueden crear programas para una
determinada plataforma. Por ejemplo, un marco puede incluir predefinidos
clases y funciones que pueden ser utilizados para procesar la entrada,
gestionar los dispositivos de hardware, e interactuar con el software del
sistema. Esto simplifica el proceso de desarrollo ya que los programadores no
tienen que reinventar la rueda cada vez que desarrollan una nueva aplicación.
Un marco es similar a una interfaz de programación de aplicaciones (API),
aunque técnicamente es un marco de trabajo incluye una API. Como su
nombre indica, un marco sirve como base para la programación, mientras que
una API proporciona acceso a los elementos admitidos por el marco. Un marco
también puede incluir bibliotecas de código, un compilador, y otros programas
utilizados en el proceso de desarrollo de software.
2.5.1 ¿Qué es un framework Web?
El concepto framework (INFORMATICA, 2015), se emplea un muchos ámbitos
del desarrollo de sistemas software, no solo en el ámbito de aplicaciones Web.
Podemos encontrar frameworks para el desarrollo de aplicaciones médicas,
de visión por computador, para el desarrollo de juegos, y para cualquier ámbito
que pueda ocurrírsenos.
En general, con el término framework, nos estamos refiriendo a una
estructura software compuesta de componentes personalizables e
intercambiables para el desarrollo de una aplicación. En otras palabras, un
framework se puede considerar como una aplicación genérica incompleta y
configurable a la que podemos añadirle las últimas piezas para construir una
aplicación concreta.
10
Los objetivos principales que persigue un framework son: acelerar el proceso
de desarrollo, reutilizar código ya existente y promover buenas prácticas de
desarrollo como el uso de patrones.
Un framework Web, por tanto, podemos definirlo como un conjunto de
componentes (por ejemplo clases en java y descriptores y archivos de
configuración en XML) que componen un diseño reutilizable que facilita y
agiliza el desarrollo de sistemas Web.
2.5.2 Patrón MVC
El modelo–vista–controlador (MVC) es un patrón de arquitectura de
software que separa los datos y la lógica de negocio de una aplicación de la
interfaz de usuario y el módulo encargado de gestionar los eventos y las
comunicaciones. Para ello MVC propone la construcción de tres
componentes distintos que son el modelo, la vista y el controlador, es decir,
por un lado define componentes para la representación de la información, y
por otro lado para la interacción del usuario. Este patrón de arquitectura de
software se basa en las ideas de reutilización de código y la separación de
conceptos, características que buscan facilitar la tarea de desarrollo de
aplicaciones y su posterior mantenimiento. (RAYFIELD, AVRAHAM, &
Avraham, 2001)
Ilustración 1: Modelo Vista Contralor (MVC). (Rayfield & Avraham, 2001)
11
Descripción del patrón
De manera genérica, los componentes de MVC se podrían definir como
sigue:
El Modelo: Es la representación de la información con la cual el sistema
opera, por lo tanto gestiona todos los accesos a dicha información, tanto
consultas como actualizaciones, implementando también los privilegios de
acceso que se hayan descrito en las especificaciones de la aplicación (lógica
de negocio). Envía a la 'vista' aquella parte de la información que en cada
momento se le solicita para que sea mostrada (típicamente a un usuario). Las
peticiones de acceso o manipulación de información llegan al 'modelo' a
través del 'controlador'.
El Controlador: Responde a eventos (usualmente acciones del usuario) e
invoca peticiones al 'modelo' cuando se hace alguna solicitud sobre la
información (por ejemplo, editar un documento o un registro en una base de
datos). También puede enviar comandos a su 'vista' asociada si se solicita
un cambio en la forma en que se presenta de 'modelo' (por ejemplo,
desplazamiento o scroll por un documento o por los diferentes registros de
una base de datos), por tanto se podría decir que el 'controlador' hace de
intermediario entre la 'vista' y el 'modelo' (véase Middleware).
La Vista: Presenta el 'modelo' (información y lógica de negocio) en un formato
adecuado para interactuar (usualmente la interfaz de usuario) por tanto
requiere de dicho 'modelo' la información que debe representar como salida.
(RAYFIELD, AVRAHAM, & Avraham, 2001)
Interacción de los componentes
Aunque se pueden encontrar diferentes implementaciones de MVC, el flujo
de control que se sigue generalmente es el siguiente:



El usuario interactúa con la interfaz de usuario de alguna forma (por
ejemplo, el usuario pulsa un botón, enlace, etc.)
El controlador recibe (por parte de los objetos de la interfaz-vista) la
notificación de la acción solicitada por el usuario. El controlador
gestiona el evento que llega, frecuentemente a través de un gestor de
eventos (handler) o callback.
El controlador accede al modelo, actualizándolo, posiblemente
modificándolo de forma adecuada a la acción solicitada por el usuario
12


(por ejemplo, el controlador actualiza el carro de la compra del
usuario). Los controladores complejos están a menudo estructurados
usando un patrón de comando que encapsula las acciones y simplifica
su extensión.
El controlador delega a los objetos de la vista la tarea de desplegar la
interfaz de usuario. La vista obtiene sus datos del modelo para generar
la interfaz apropiada para el usuario donde se reflejan los cambios en
el modelo (por ejemplo, produce un listado del contenido del carro de
la compra). El modelo no debe tener conocimiento directo sobre la
vista. Sin embargo, se podría utilizar el patrón Observador para
proveer cierta indirección entre el modelo y la vista, permitiendo al
modelo notificar a los interesados de cualquier cambio. Un objeto vista
puede registrarse con el modelo y esperar a los cambios, pero aun así
el modelo en sí mismo sigue sin saber nada de la vista. Este uso del
patrón Observador no es posible en las aplicaciones Web puesto que
las clases de la vista están desconectadas del modelo y del
controlador. En general el controlador no pasa objetos de dominio (el
modelo) a la vista aunque puede dar la orden a la vista para que se
actualice. Nota: En algunas implementaciones la vista no tiene acceso
directo al modelo, dejando que el controlador envíe los datos del
modelo a la vista. Por ejemplo en el MVC usado por Apple en su
framework Cocoa. Suele citarse como Modelo-Interface-Control, una
variación del MVC más puro
La interfaz de usuario espera nuevas interacciones del usuario,
comenzando el ciclo nuevamente.
MVC y bases de datos
Muchos sistemas informáticos utilizan un Sistema de Gestión de Base de
Datos para gestionar los datos que debe utilizar la aplicación; en líneas
generales del MVC dicha gestión corresponde al modelo. La unión entre
capa de presentación y capa de negocio conocido en el paradigma de la
Programación por capas representaría la integración entre la Vista y su
correspondiente Controlador de eventos y acceso a datos, MVC no
pretende discriminar entre capa de negocio y capa de presentación pero
si pretende separar la capa visual gráfica de su correspondiente
programación y acceso a datos, algo que mejora el desarrollo y
mantenimiento de la Vista y el Controlador en paralelo, ya que ambos
cumplen ciclos de vida muy distintos entre sí. (RAYFIELD, AVRAHAM, &
Avraham, 2001)
13
2.5.3 Tipos de framework Web
Existen varios tipos de frameworks Web: orientados a la interfaz de usuario,
como Java Server Faces, orientados a aplicaciones de publicación de
documentos, como orientados e a la parte de control de eventos, como Struts
y algunos que incluyen varios elementos como Tapestry. (INFORMATICA,
2015).
La mayoría de frameworks Web se encargan de ofrecer una capa de
controladores de acuerdo con el patrón MVC o con el modelo 2 de Servlets y
JSP, ofreciendo mecanismos para facilitar la integración con otras
herramientas para la implementación de las capas de negocio y presentación.
2.5.4 Características.
a. ODBC
Open DataBase Connectivity (ODBC) es un estándar de acceso a las
bases de datos desarrollado por SQL Access Group en 1992. El objetivo
de ODBC es hacer posible el acceder a cualquier dato desde cualquier
aplicación, sin importar qué sistema de gestión de bases de datos (DBMS)
almacene los datos. ODBC logra esto al insertar una capa intermedia
(CLI) denominada nivel de Interfaz de Cliente SQL, entre la aplicación y
el DBMS. El propósito de esta capa es traducir las consultas de datos de
la aplicación en comandos que el DBMS entienda. Para que esto funcione
tanto la aplicación como el DBMS deben ser compatibles con ODBC, esto
es que la aplicación debe ser capaz de producir comandos ODBC y el
DBMS debe ser capaz de responder a ellos. Desde la versión 2.0 el
estándar soporta SAG y SQL. (MICROSOFT, 2015)
El software funciona de dos modos, con un software manejador en el
cliente, o una filosofía cliente-servidor. En el primer modo, el driver
interpreta las conexiones y llamadas SQL y las traduce desde el API
ODBC hacia el DBMS. En el segundo modo para conectarse a la base de
datos se crea una DSN dentro del ODBC que define los parámetros, ruta
y características de la conexión según los datos que solicite el creador o
fabricante.
14
Java Database Connectivity (JDBC) es un derivado inspirado en el
mismo, una interfaz de programación de aplicaciones que permite la
ejecución de operaciones sobre bases de datos desde el lenguaje de
programación Java independientemente del sistema operativo donde se
ejecute o de la base de datos a la cual se accede utilizando el dialecto
SQL del modelo de base de datos que se utilice.
2.5.5 Metodología de Desarrollo Software
Para el desarrollo del sistema se va a considerar la metodología de desarrollo
de software, RUP (Rational Unified Process) para el análisis, construcción y
documentación del sistema ya que es un modelo que cubre todo el ciclo de vida
del producto, soporta un enfoque de desarrollo iterativo e incremental,
proporciona iteraciones tempranas que se enfocan en validar y producir una
arquitectura de software, y un ciclo de desarrollo inicial que toma la forma de un
prototipo ejecutable que gradualmente evoluciona convirtiéndose en el sistema
final y además tiene implícito en su proceso de desarrollo la evaluación continua
de la calidad con respecto a los requerimientos de calidad deseados
(KRUCHTEN, 1996).
El proceso de ciclo de vida de RUP se divide en cuatro fases llamadas
(KRUCHTEN, 1996):
 Inicio: El objetivo en esta etapa es determinar la visión del proyecto. Mayor
énfasis en modelado del proyecto: objetivos, alcance, limitaciones, y
requerimientos.
 Elaboración: En esta fase el objetivo es determinar la arquitectura óptima.
Se define infraestructura y ambiente de desarrollo.
 Construcción: En esta etapa se lleva a cabo la construcción del producto
por medio de una serie de iteraciones obteniendo la capacidad operacional
inicial.
 Transición: Se pretende obtener el producto preparado para la entrega.
Pruebas beta y piloto.
Esas fases se dividen en iteraciones, cada una de las cuales produce una
pieza de software demostrable.
15
CAPÍTULO III
3
ANÁLISIS DEL SISTEMA
3.1. Especificación de Requerimientos
Este proyecto nace por la necesidad de realizar un proyecto web de una manera
muy sencilla con conexión a base de datos, que sea de fácil manejo para el
administrador y para el usuario final.
El objetivo principal es realizar un proyecto web con conexión a base de datos
de una manera rápida y eficiente, además se mostrara los casos de uso para
especificar las características de cada proceso de análisis, brindando así una
descripción detallada de los requerimientos tanto funcionales como no
funcionales del proyecto.
3.1.1. Contextualización
El Análisis busca de mostrar una manera rápida y eficiente la generación e
código automático en lenguaje java y utilizando además PrimeFaces, el Plugin
de PrimeFaces “Crud Generator for Netbeans” y como motor de base de datos
MySql.
La fuente de código generado será un ejemplo práctico utilizando una base
de datos de MySql llamada “Cursos”, y se generaran varios paquetes y
clases que se explicaran como actúan en dicho código. El objetivo del trabajo
es analizar la herramienta de Kay Wrobel que desarrollo un puglin con
PrimeFaces que genera el crud.
3.2. Requerimientos Funcionales
3.2.1. Características principales del sistema.
1) El análisis referencia un sitio web para la venta del producto donde se
visualizara una ventana principal, donde se presentaran las diferentes
opciones.
a) Inicio.- Muestra la ventana de inicio, una breve descripción de la
herramienta PrimeFaces Crud Generator for Netbeans
b) Quienes somos.- Muestra la visión y misión de la persona que suministra
el producto, además de una audio que menciona todo el texto citado.
16
c) Tienda.- Consta de dos partes una framework que es donde da una breve
descripción de nuestra herramienta y en la parte de documentación se
encontrara una vez comprado el producto la documentación para poder
manejar la herramienta así de videos explicativos e instaladores.
d) Faq y chat.- Se mostrara las inquietudes las frecuentes con sus respectivas
respuestas, y en la parte de chat será un chat online para preguntas y
respuestas en tiempo real
e) Contactos.- Donde se encuentra ubicado la persona que brinda el soporte
técnico así de códigos qr para su fácil acceso a redes sociales, YouTube,
wordpress.
f) Post y comentarios.- Un pequeño post de la herramienta y se podrá
receptar el comentario de los usuarios
g) Noticias.- Se mostraran las noticias más recientes de la herramienta
h) Miembro del equipo.- La persona que suministra el soporte técnico y quien
desarrollo el portal web y el manejo de la herramienta de Crud Generator
For Netbeans (Investigación de la herramienta)
i) Paginas en línea.- Se podrá visualizar un bloc y una revista online de la
herramienta
j) Herramientas utilizadas.- Una herramienta de cómo posicionar un sitio web
en los primeros lugares del google, herramienta SEO, propia del portal.
2) Se realizara un ejemplo práctico con una base de datos de ejemplo llamada
curso del uso de la herramienta PrimeFaces Crud Generator for Netbeans,
se presenta las diferentes opciones:
a) Home.-Es nuestra página de Inicio
b) Maintenance.-Donde mostrara las diferentes pantallas de nuestro
sistema y se podrá hacer las operaciones como, ver, insertar, modificar,
eliminar los registros, y constara con un filtro de los datos.
3.2.2. Descripción de los Actores
El Análisis de Crud Generator for Netbeans empleará los siguientes grupos
de usuarios:
Administrador: Usuario encargado del mantenimiento del sitio web CRUD
GENERATOR FOR NETBEANS.
El administrador del modelo podrá:
 Insertar nuevos datos.
 Ver los datos
17
 Modificar datos.
 Eliminar los datos
 Filtrar los datos
Usuarios Final: Un usuario común utilizara el portal web en la nube:
http://frameworkuce.wix.com/ucentral
Los usuarios podrán:








3.2.2.1.
Visualizar el portal web
Comprar el producto
Chatear en línea
Dejar comentarios
Comunicarse con un representante
Ver bloc, revista relacionada a la herramienta.
Ver noticias
Ver herramienta especial utilizada SEO
Procesos de actores y roles
3.2.2.1.1. Actividades del Administrador (Crud Generator for Netbeans)
Al administrador configura y el sitio web para uso del usuario en Netbeans.
Ilustración 2: Actividades Administrador en Netbeans. (Autoría Personal)
18
3.2.2.1.2. Actividades del usuario del sistema
El usuario del sistema puede navegar por el sitio, con la opción de visualizar
el portal web, comprar la herramienta, chatear, comentar, ver preguntas
frecuentes, ver bloc y revista en línea.
Ilustración 3: Actividades del usuario final. (Autoría Personal)
3.2.3. Requerimientos Específicos
Usuario del Final:
 El usuario podrá acceder al portal web que se encuentra en la nube
 El usuario puede comprar el producto en línea
19
 El usuario no necesitará conocimientos de programación, base de datos o
diseño gráfico para poder navegar por la aplicación.
Aplicación:
 La aplicación se ejecutara en un entorno web respecto “Crud Generator
For Netbeans”.
3.3. Casos de Uso
3.3.1. Diagrama general de casos de uso
20
Ilustración 4: Diagrama de casos de uso PrimeFaces Crud Generator for
Netbeans. (Autoría Personal)
3.3.2. Descripción de los Casos de Uso
CU1. Insertar Datos
Actor: Administrador
Descripción: El Administrador podrá interactuar con todos los datos de la
aplicación.
Ilustración 5: Diagrama casos de uso Insertar datos. (Autoría Personal)
CU2. Modificar Datos
Actor: Administrador
Descripción: El Administrador podrá modificar los datos de la aplicación.
21
Ilustración 6: Diagrama de casos de uso Modificar datos. (Autoría Personal)
CU3. Eliminar datos
Actor: Administrador
Descripción: El Administrador podrá gestionar eliminar los datos del sitio web.
Ilustración 7: Diagrama de casos de uso Eliminar datos Sitio Web. (Autoría
Personal)
CU4. Actualizar datos
Actor: Administrador
Descripción: El Administrador podrá actualizar del sitio web.
22
Ilustración 8: Diagrama de casos de uso Actualizar datos Sitio Web. (Autoría
Personal)
CU5. Gestionar Portal Web (nube)
Actor: Administrador
Descripción: El Administrador podrá administrar el portal web.
Ilustración 9: Diagrama de casos de uso Administración portal web. (Autoría
Personal)
CU6. Barra de opciones
Actor: Usuario Final
Descripción: El Usuario final podrá tener acceso a los contenidos dentro del
sitio web.
Ilustración 10: Diagrama de casos de uso Barra de Opciones. (Autoría Personal)
23
CU7. Comprar producto
Actor: Usuario Final
Descripción: El Usuario final podrá tener acceso a los contenidos dentro del
sitio web para realizar la compra del producto.
Ilustración 11: Diagrama de caso de usos Comprar producto. (Autoría Personal).
CU8. Chatear
Actor: Usuario Final
Descripción: El Usuario final puede chatear online.
Ilustración 12: Diagrama de caso de usos Chat online. (Autoría Personal)
CU9. Comentar
Actor: Usuario Final
Descripción: El Usuario final puede comentar en el portal web.
24
Ilustración 13: Diagrama de caso de usos comentar online. (Autoría Personal)
CU10. Contactarse
Actor: Usuario Final
Descripción: El Usuario final puede mandar un mail para contactar a soporte
técnico.
Ilustración 14: Diagrama de caso de usos Contactarse. (Autoría Personal)
CU11. Ver Redes Sociales
Actor: Usuario Final
Descripción: El Usuario final puede ver Facebook, Twitter, YouTube, etc.
Ilustración 15: Diagrama de caso de usos ver redes sociales. (Autoría Personal)
25
3.4. Requerimientos no funcionales
Describen de manera general los atributos del sistema, así tenemos:
RNF1. Usabilidad
El portal web debe ser amigable con el usuario, el mismo podrá comprar la
herramienta “Crud Generator for Netbeans” de una manera muy intuitiva, podrá
utilizar todas las funciones de una manera muy entendible
Respecto a la aplicación en Java “Crud Generator for Netbeans” el usuario
podrá dar su fácil mantenimiento una vez generado el código en Netbeans
RNF2. Disponibilidad
El sistema estará en capacidad de dar respuesta al acceso de todos los
usuarios y sus procesos (Portal web), de igual manera respecto a la aplicación
“Crud Generator for Netbeans”.
RNF3. Escalabilidad – Capacidad
El sistema “Crud Generator for Netbeans” deberá garantizar el crecimiento del
volumen de la información almacenada que se manejará en la base de datos.
RNF4. Portabilidad
La aplicación “Crud Generator for Netbeans”, al estar desarrollada en lenguaje
java, podrá ser portada de una plataforma.
26
CAPÍTULO IV
4. DISEÑO DEL SISTEMA
Como beneficio del análisis meticuloso de los requisitos del sistema se
describe a continuación el diseño del “Crud Generator for Netbeans”, explicando
el modelo de la base de datos y diagramas que nos permitan identificar como
se ha construido el sistema además de la creación de su portal web.
4.1. Arquitectura del Sistema
La IEEE Std 1471-2000 (IEEE, 2015), da una definición respecto a la
Arquitectura de Software manifiesta:
“La Arquitectura de Software es la organización fundamental de un sistema
incorporado en sus componentes, las relaciones entre ellos, el ambiente y los
principios que orientan su diseño y evolución”.
4.1.1. Diseño de la Arquitectura Lógica del Sistema (PrimeFaces Crud
Generator for Netbeans)
En esta sección se presenta la estructura lógica de la arquitectura del sistema.
Uno de los patrones arquitectónicos más utilizados para el desarrollo de
aplicaciones orientadas a objetos en la actualidad es el denominado
“arquitectura multi-capa”.
Por definición las aplicaciones JEE utilizan una arquitectura multicapa,
permitiendo separar lógicamente y en algunos casos físicamente, los aspectos
de presentación de la aplicación (interfaz de usuario), la lógica del negocios
(funcionalidad del sistema) y la gestión de los datos (bases de datos o archivos
planos).
La Capa de Presentación
La que ve el usuario (también se la
denomina "capa de usuario"), presenta el
sistema al usuario, le comunica la
información y captura la información del
usuario en un mínimo de proceso (realiza un
filtrado previo para comprobar que no hay
errores de formato). También es conocida
27
Ilustración 16: Capa Presentación (Autoría
Ilustración 16: Capa Presentación
Personal)
(Autoría Personal)
como interfaz gráfica y debe tener la
característica de ser "amigable" (entendible
y fácil de usar) para el usuario. Esta capa se
comunica únicamente con la capa de
negocio.
La Capa de Lógica de Negocios
Es donde residen los programas que
se ejecutan, se reciben las peticiones
del usuario y se envían las respuestas
tras el proceso. Se denomina capa de
negocio (e incluso de lógica del
negocio) porque es aquí donde se
establecen todas las reglas que deben
cumplirse. Esta capa se comunica con
la capa de presentación, para recibir
las solicitudes y presentar los
resultados, y con la capa de datos,
para solicitar al gestor de base de
datos almacenar o recuperar datos de
él. También se consideran aquí los
programas de aplicación.
Ilustración 17: Capa Negocios
La Capa de Datos
Es donde residen los datos y es la
encargada de acceder a los mismos.
Está formada por uno o más gestores
de bases de datos que realizan todo el
almacenamiento de datos, reciben
solicitudes de almacenamiento o
recuperación de información desde la
capa de negocio.
A continuación se detallará la
arquitectura de PrimeFaces Crud
Generator for Netbeans en cada una
de las capas, así tenemos:
28
Ilustración 18: Capa Datos
1. CAPA DE PRESENTACIÓN
o CAPA DEL CLIENTE
El cliente administrador o usuario para acceder a esta aplicación debe
utilizar un navegador, se recomienda utilizar navegadores actualizados
como por ejemplo: Firefox, Google Chrome. Para ingresar al portal web o
a la ejecución de la herramienta de PrimeFaces Crud Generator for
Netbeans
o CAPA WEB
El usuario al integrarse al sistema se le presenta un menú de control y
las opciones a las que tiene acceso. Sea en el portal web y en la
herramienta de PrimeFaces Crud Generator for Netbeans.
Toda la capa de presentación ha sido desarrollada con la implementación
PrimeFaces 4.0 además del Plugin de PrimeFaces Crud Generator for
Netbeans que pertenece al estándar Java Server Faces. Toda la lógica del
control de pantallas, ingreso de datos para reportes es realizado a nivel de
esta capa.
2. CAPA DE LÓGICA DE NEGOCIO
La lógica de negocio se encuentra dentro de esta capa. Técnicamente en
el contenedor EJB 3 se encuentran los session beans que contienen
dicha lógica de negocio.
3. CAPA DE DATOS
Se utilizará ODBC para conectar con Java Netbeans.
4. BASE DATOS
En función a los requerimientos especificados en el capítulo anterior, se
usó como gestor de base de datos, MySql.
o MODELO Entidad / Relación
En este modelo encontraremos un conjunto de objetos básicos llamados
(tablas, entidades), que son los elementos principales que se identifican
en el problema a resolver. Cada entidad posee sus propios elementos o
características denominadas atributos.
29
Por otro lado también están las relaciones que se representan mediante
enlaces de unión entre las tablas (entidades).
Ilustración 19: Modelo Entidad / Relación del Sistema. (Autoría Personal)
4.2.
Descripción de las Entidades
1.- Activacioncurso: Almacena los datos, del temario, conferencista, fecha y
hora que se dictara el curso.
ATRIBUTOS
Nombre
Tipo
codActivacionCurso int
Temario
varchar
Conferencista
varchar
FechaInicio
FechaFin
HoraInicio
HoraFin
varchar
varchar
varchar
varchar
Descripción
Código único
Tema del Curso
Nombre
Conferencista
Fecha de Inicio
Fecha Fin
Hora de Inicio
Hora Final
Tabla 1: Descripción de Entidad Activación curso. (Autoría Personal)
30
2.- Actores: Lista de personas que intervienen en la conferencia
ATRIBUTOS
Nombre
Codactores
Nombre
Tipo
int
varchar
Funcion
varchar
Descripción
Código único actores
Nombre del Actor
Función
que
desempeña
Tabla 2: Descripción de Entidad Actores. (Autoría Personal)
3.- Conferencistas: Almacena datos de los conferencistas:
ATRIBUTOS
Nombre
Tipo
Descripción
Codconferencistas
Int
Número único
Nombre
del
Conferencista
Fecha
disponible
Disponibilidadinicial varchar
inicial
Disponibilidadfinal
varchar
Fecha disponible final
Hora
de
inicio
Horainicio
varchar
conferencia
Hora
de
fin
Horafin
varchar
conferencia
Puntuación
de
la
Puntacion
int
conferencia
codperfil
int
Código del perfil (FK)
Tabla 3: Descripción de Entidad Conferencistas. (Autoría Personal)
Nombres
varchar
4.- Perfil: Almacena los datos, correspondientes al perfil de cada persona:
ATRIBUTOS
Nombre
Tipo
Descripción
cod_perfil
int
Código único
Descripción
profesión
Tabla 4: Descripción de Entidad Perfil. (Autoría Personal)
nom_perfil
varchar
31
5.- Propuesta_curso: Almacena los datos, correspondientes de la propuesta
de parte del tutor que va a dictar la conferencia.
ATRIBUTOS
Nombre
Tipo
Descripción
Codpropuestacurso
int
Nombre
varchar
Hora
varchar
Código único
Nombre
tema
conferencia
Hora de conferencia
Fecha
de
la
conferencia
Aprobación
de
Aprobacion
boolean
conferencia
Tabla 5: Descripción de Entidad Propuesta_curso. (Autoría Personal)
Fecha
varchar
6.- Temarios: Almacena los datos, correspondientes al tema de la conferencia
ATRIBUTOS
Nombre
Tipo
Descripción
Codtemarios
int
Código único
Nombre
de
conferencia
Subtemas
varchar
Nombre subtema
Código
codconferencistas int
Conferencistas (FK)
Tabla 6: Descripción de Entidad General. (Autoría Personal)
Nombre
varchar
32
4.3. Diseño de Interfaces
A continuación se presentará el formato estándar de las pantallas, en cada una
de las partes.
4.3.1. Interface Sitio Web
4.3.1.1. Instalación Herramienta
Los instaladores son:



NetBeans 7.4 Última versión (https://netbeans.org/downloads/)
PrimeFaces 4.0 Última versión (http://www.primefaces.org/downloads.html)
MySql
o
cualquier
base
de
datos
a
usar
(http://dev.mysql.com/downloads/mysql/)
Nota si no tenemos el JDK instalamos si nos descargamos la versión completa de
NetBeans no nos pedirá el JDK si no lo tienen está aquí para descargárselo
http://www.oracle.com/technetwork/es/java/javase/downloads/index.html
Ilustración 20: Descargar JDK. (Autoría Personal)
Pasos a seguir para la instalación de Plugin PrimeFaces Crud Generator:
http://sourceforge.net/projects/nbpfcrudgen/
33
Introducción
1) Conseguir el Plugin
2) El módulo está siendo comunicado como un módulo plugin de NBM (Archivo
binario) instalable.
3) Descargue el archivo plugin nbpfcrudgen
Ilustración 21: Descargar Plugin PrimeFaces Crud Generator For Netbeans.
(Autoría Personal)
4) Descomprimir el archivo que contiene un archivo NBM.
Ilustración 22: Plugin NBM descomprimido. (Autoría Personal)
5) En NetBeans e ir a Herramientas-> Plugins.
34
Ilustración 23: Ventana Netbeans/tools/Plugins. (Autoría Personal)
6) Haga clic en la ficha Descargado.
Ilustración 24: Pestaña downloaded para instalar plugin. (Autoría Personal)
7) Haga clic en el botón Add Plugins y vaya a la ubicación que ha descargado
el archivo de NBM.
8) Seleccione el archivo y haga clic en Aceptar.
35
Ilustración 25: Selección plugin descomprimido. (Autoría Personal)
9) El módulo aparecerá en la lista de módulos cargados.
10) Haga clic en Instalar. El NetBeans IDE instalador aparecerá con un resumen
de los módulos listos para ser instalados.
Ilustración 26: Notificación reconocimiento plugin. (Autoría Personal)
11) Haga clic en Siguiente y acepte el acuerdo de licencia. Nota: actualmente no
existe una licencia adjunta al módulo, pero es la intención del autor para
liberarlo tanto bajo licencias GPL y CDDL.
36
Ilustración 27: Instalando PrimeFaces Crud Generator. (Autoría Personal)
12) El módulo no está actualmente firmado y NetBeans le avisará de ello. Si
usted no se siente cómodo de instalar código no firmado, haga clic en
Cancelar aquí y esperar a una versión más nueva que tiene la firma de un
desarrollador adjunto. Si estás bien con un código sin firmar, haga clic en
Continuar.
Ilustración 28: Aceptando términos y condiciones. (Autoría Personal)
13) NetBeans se completa la instalación. Si la versión del IDE no coincide con la
versión de la aplicación del módulo, es posible que encuentre un problema
de dependencia y el IDE no se le permitirá continuar.
37
Ilustración 29: Terminando la instalación. (Autoría Personal)
14) El módulo está instalado y se mostrará en la ficha Instalación como
PrimeFaces generador CRUD.
Ilustración 30: Verificando la existencia del plugin. (Autoría Personal)
38
Instalación otras herramientas:
1) Instalar NetBeans 7.4 el último NetBeans en el mercado si no tenemos el
instalador presionamos la dirección https://netbeans.org/downloads/
Ilustración 31: Pantalla descarga Netbeans. (Autoría Personal)
2) Descargaremos la versión completa es decir la de la última columna, Después
ejecutamos el instalador y solo es cuestión de poner siguiente y siguiente después
de unos minutos, ejecutamos NetBeans 7.4 y se muestra una pantalla a
continuación, esta versión de NetBeans viene incluido el jdk (Java Development Kit
o (JDK), es un software que provee herramientas de desarrollo para la creación de
programas en Java. Puede instalarse en una computadora local o en una unidad de
red. En otras palabras El paquete JDK contiene el entorno de desarrollo de Java de
Sun. Sirve para desarrollar programas Java y proporciona el entorno de ejecución
necesario para ejecutar dichos programas. También incluye un módulo (Plugin) para
que los navegadores puedan ejecutar programas Java. ) Que es muy importante
para su instalación.
39
Ilustración 32: Diagrama descarga Netbeans. (Autoría Personal)
3) Luego nos aparecerá una ventana como esta:
Ilustración 33: Pantalla inicial Netbeans. (Autoría Personal)
4) Después instalamos el MySql o cualquier base de datos si no tenemos el
instalador
lo
descargamos
en
la
siguiente
dirección
(http://dev.mysql.com/downloads/mysql/)
40
Ilustración 34: Descarga de MySQL. (Autoría Personal)
5) Lo instalamos con siguiente y siguiente poniendo el usuario y contraseña,
después nos aparece una ventana como esta.
Ilustración 35: Pantalla inicia MySQL. (Autoría Personal)
6) Sin embargo ahora nos toca instalar el PrimeFaces 4.0 nos descargamos
de la siguiente dirección http://www.primefaces.org/downloads.html
41
Ilustración 36: Pantalla descarga PrimeFaces 4.0. (Autoría Personal)
7) Descargamos la versión Bundle que es la versión probada. Para instalarlo
hacemos lo siguiente vamos a NetBeans y vamos a tools y libraries
Ilustración 37: Pantalla instalación PrimeFaces 4.0. (Autoría Personal)
8) Luego New library
42
Ilustración 38: Pantalla instalación PrimeFaces 4.0. Agregando nueva librería
(Autoría Personal)
9) Digitamos el nombre PrimeFaces-4.0 y damos clic en ok
Ilustración 39: Agregando nuevo nombre a la librería (Autoría Personal)
43
10) Añadimos los archivos previamente de descomprimirlos, los archivos jar:
ClassPath, Sources y JavaDoc
Ilustración 40: Agregando archivos para nueva librería PrimeFaces 4.0 (Autoría
Personal)
4.3.1.2. Ejercicio Práctico
Generar una aplicación de ejemplo vamos hacer lo siguiente:
Creación de un nuevo proyecto de aplicación Web
Importante: Si está utilizando una versión de NetBeans (7.3.1 +) que se incluye con
GlassFish 4.0 y JSF 2.2, por favor asegúrese de descargar y añadir la última
biblioteca PrimeFaces desde la página de descargas PrimeFaces. Al escribir estas
líneas, PrimeFaces ofrece la versión 4.0 en la sección de Community Downloads
(Descargas de la Comunidad). Agregar a la biblioteca para su instalación de
NetBeans en tools (Herramientas) - > Ant Libraries (Bibliotecas Ant) y lo llaman "
PrimeFaces 4.0”. Esto hará que PrimeFaces 4.0 esté disponible para el asistente
en la " aplicación Web”.
1) Haga clic en Archivo-> Nuevo proyecto.
44
Ilustración 41: Pantalla creación proyecto web (Autoría Personal)
2) Seleccione " Java Web " de las categorías y "Aplicación Web " de proyectos.
Haga clic en Siguiente.
Ilustración 42: Pantalla creación proyecto web aplicación (Autoría Personal)
3) Dele a su proyecto un nombre, por ejemplo, EjemploApp y elija la ubicación
del proyecto. Deje el resto como está y haga clic en Siguiente.
45
Ilustración 43: Dando un nombre al proyecto web (Autoría Personal)
4) Configurar las opciones de configuración del servidor de la siguiente manera:
Elija su Aplicación Server. En una instalación predeterminada, este será el servidor
GlassFish 4.0 que viene con NetBeans.
Establezca la versión Java EE a Java EE 7 Web (por defecto)
Deja la ruta de contexto como es. Haga clic en Siguiente.
Ilustración 44: Configurando Servidor y versión de Java EE (Autoría Personal)
46
5) Configure los marcos de la siguiente manera:
6) Ponga una marca de verificación junto a JavaServer Faces. En la pestaña
Libraries, utilice la biblioteca de servidor JSF 2.2
Ilustración 45: Configurando Servidor y versión de Java EE (Autoría Personal)
En la ficha Configuración, deje JSF Servlet URL patrón / faces / * y seleccione
Facelets como página Idioma preferido.
Ilustración 46: Configurando Java Server Faces (Autoría Personal)
En la ficha componentes, ponga una marca de verificación junto a PrimeFaces.
Nota: debe dar clic en la última biblioteca PrimeFaces que se agrega en " Ant
Bibliotecas"
47
Ilustración 47: Configurando Java Server Faces componentes (Autoría Personal)
Nota: Haga clic en Más para seleccionar la versión PrimeFaces si se ha registrado
más de una. El valor predeterminado es PrimeFaces 3.5. Después de seleccionar
la versión PrimeFaces de su elección, haga clic en Aceptar.
Ilustración 48: Configurando Java Server Faces escogiendo librería (Autoría
Personal)
Haga clic en Finalizar para crear el proyecto.
48
Ilustración 49: Finalizando configuración (Autoría Personal)
7) Mapeo de entidades: Tienes dos opciones para hacerlo: puede programar
sus propias entidades y unidad de persistencia, o puede dejar que NetBeans
generar entidades de una base de datos existente. Para esta aplicación de
ejemplo, se utiliza este último.
Resalte el nodo del proyecto.
Ilustración 50: Ubicando el cursor en el proyecto (Autoría Personal)
Haga clic en el proyecto-> Nuevo/ other
49
Ilustración 51: Ubicando el cursor para aplicar Crud (Autoría Personal)
Seleccione la opción Persistencia luego “Entity Classes from Database” clases de
entidad de base de datos " de los tipos de archivos. Haga clic en Siguiente.
Ilustración 52: Seleccionando opciones para mapeo de base de datos (Autoría
Personal)
8) Especificar tablas de base de datos de la siguiente manera:
50
Configurar origen de datos. Para esta aplicación de ejemplo, seleccione jdbc /
muestra de la lista. NetBeans se conecta con el servidor de base de datos
suministrada MySQL base de datos cursos y rellena las tablas disponibles.
Ilustración 53: Cargando tablas de la base de datos (Autoría Personal)
Para este ejemplo, haga clic en el botón Agregar todo. NetBeans se traslada todas
las
tablas
de
la
base
de
datos.
Haga
clic
en
Siguiente.
Ilustración 54: Seleccionan tablas de la base de datos (Autoría Personal)
51
9) Configuración de clases de entidad de la siguiente manera:
Especifique paquete. Aquí escribimos las "entidades" (todo en minúsculas) se llama
dal.entity.
Deja "Generar consulta con nombre Anotaciones para campos persistentes"
controladas
Deja "Generar JAXB Anotaciones " marcada.
Deje la marca de verificación junto a " Crear unidad de persistencia”. Haga clic en
Siguiente.
Ilustración 55: Configurando mapeo y dando nombre al paquete (Autoría
Personal)
10) Configurar las opciones de asignación de la siguiente manera:
Association Fetch: default
Collection Type: java.util.Collection (default)
Configurar las opciones de asignación de la siguiente manera:
Asociación Fetch: default
52
Colección: java.util.Collection (por defecto)
Deja todo lo demás sin marcar a excepción de "Usar nombres de columna en las
relaciones”.
Haga clic en Finalizar.
Ilustración 56: Configurando mapeo de base de datos (Autoría Personal)
11) NetBeans genera el paquete de entidades y seis clases de entidad:
Activacioncurso.java
Actores.java
Conferencistas.java
Perfil.java
PropuestaCurso.java
Temarios.java
53
Ilustración 57: Clases generadas por mapeo de base de datos (Autoría Personal)
Nota: Estas clases generada en el paquete dal.entity contiene las clases de
entidad, con métodos accesores get y set para mapear la base de datos.
También agrega un archivo persistence.xml al proyecto para hacer referencia a la
base de datos de la muestra.
Ilustración 58: Archivo persistence.xml (Autoría Personal)
12) Generación PrimeFaces Páginas de clases de entidad:
Nota: El generador de código puede detectar ahora la versión PrimeFaces y
Apache MyFaces CODI versión CDI -Extensión
Resalte el nodo del proyecto
Haga clic en Archivo-> Nuevo archivo en el menú.
54
Elija " PrimeFaces CRUD Generador " de Categorías y " PrimeFaces Páginas de
clases de entidad " de los tipos de archivos. Haga clic en Siguiente.
Ilustración 59: Configurando PrimeFaces Crud (Autoría Personal)
Haga clic en " Agregar todo >>" y haga clic en Siguiente.
Ilustración 60: Configurando PrimeFaces Crud mapeo de base de datos (Autoría
Personal)
55
13) Configurar Generar PrimeFaces páginas y clases de la siguiente manera:
Session Bean Package: controllers
Backing Bean Package: beans
Converter Package: converters
PrimeFaces Carpeta Páginas: [dejar en blanco]
Generic Include Folder: /WEB-INF/include
Entity Include Folder: /WEB-INF/include/entity
Localization Bundle Name: /Bundle
Default Rows Displayed: 10
Default Page Selector: 10, 20,30
Puede cambiar esto a lo que quiera. Esto afecta a la lista desplegable que se
muestra en la busca de PrimeFaces DataTable.
Nombre de campo artefactos para los campos extranjeros: DESCR, nombre
Deje todas las marcas de verificación en los siguientes campos:
Crear, Editar, Borrar, Ver, ordenar, filtrar
Observe la PrimeFaces Versión, MyFaces CODI Versión y JSF Versión Bibliotecas
de su ruta de clase del proyecto y puesta en marcha. Si has seguido esta aplicación
de ejemplo, verá la versión 4.0 para PrimeFaces, nada para MyFaces CODI versión
y la versión 2.2 para JSF. CODI sólo es importante para los proyectos de CDI antes
de JSF 2.2 para permitir anotaciones @ ViewAccessScoped. Las versiones
recientes de JSF comenzando con 2.2 tienen soporte nativo para CDI anotaciones
@ ViewScoped.
Ignorar los archivos existentes " sin control, a menos que previamente había
archivos generados.
Haga clic en Finalizar.
56
Ilustración 61: Configurando PrimeFaces Crud Generator (Autoría Personal)
14) Si queremos mejorar nuestra interfaz tenemos que descargar un tema de
PrimeFaces
como
ejemplo
(redmond)
vamos
a
esta
url:
http://repository.primefaces.org/org/primefaces/themes/
Ilustración 62: Configurando PrimeFaces Crud Generator CSS3 (Autoría Personal)
57
Luego agregamos a libraries el jar Redmond
Ilustración 63: Configurando PrimeFaces Crud Generator CSS3 agregando jar
(Autoría Personal)
Ilustración 64: Configurando PrimeFaces Crud Generator CSS3 agregando jar a la
librería (Autoría Personal)
58
Abrimos el archivo web.xml y agregamos lo siguiente:
<context-param>
<param-name>primefaces.THEME</param-name>
<param-value>redmond</param-value>
</context-param>
Ilustración 65: Configurando PrimeFaces Crud Generator CSS3 agregando líneas
de código (Autoría Personal)
Con eso nuestra interfaz gráfica cambia de una manera muy atractiva con css3 para
el usuario
Ilustración 66: Ventana con tema nuevo (Autoría Personal)
59
Nota:
Paquetes Creados:
Se los llama según su función. dal = capa de acceso a datos, ui = interfaz de usuario.
dal.entity contiene las clases de entidad, dal.facade contiene las clases de fachada
para acceder a las entidades. ui.bean contiene todos los controladores de JSF para
interactuar con las páginas JSF y la capa de datos. ui.util contiene clases de ayuda
y ui.converter contiene las clases de convertidor de la interfaz de usuario.
4.3.1.3. Interfaz de Usuario
 Menú Principal, con dos opciones (Home y Maintenance)
 Home: Página de Inicio
 Maintenance: Mantenimiento: Insertar, modificar, eliminar, ver registros en
la base de datos
Ilustración 67: Pantalla Inicial (Autoría Personal)
60
Pagina Maintenance
 Página de administración de la base de datos Curso
Ilustración 68: Pantalla pestaña mantenimiento (Autoría Personal)
Página perfil de ejemplo de muestra con las operaciones: Insertar, modificar,
eliminar, actualizar, ver y filtrar registros.
Ilustración 69: Pantalla ejemplo en base de datos perfil (Autoría Personal)
61
 Insertar registros
Ilustración 70: Insertando un nuevo registro (Autoría Personal)
Ilustración 71: Registro insertado (Autoría Personal)
62

Ver registro
Ilustración 72: Ver registro insertado (Autoría Personal)

Editar registro
Ilustración 73: Editando registro (Autoría Personal)
63
Ilustración 74: Registro Editado (Autoría Personal)

Borrar registro
Ilustración 75: Borrando registro (Autoría Personal)

Filtro Registro
Ilustración 76: Filtrando registros (Autoría Personal)
64
4.3.1.4. Interfaz Portal Web

Página inicial
Ilustración 77: Pagina Inicial portal web (Autoría Personal)

Página Quienes Somos
Ilustración 78: Pagina quienes somos (Autoría Personal)
65

Página Tienda
Ilustración 79: Pagina tienda (Autoría Personal)

Página Frameworks
Ilustración 80: Pagina frameworks (Autoría Personal)
66

Página documentación
Ilustración 81: Pagina documentación (Autoría Personal)

Página Faq Y Chat
Ilustración 82: Pagina faq y chat (Autoría Personal)
67

Página Contactos
Ilustración 83: Pagina contactos (Autoría Personal)

Página Post y Comentarios
Ilustración 84: Pagina post y comentarios (Autoría Personal)

Página noticias
68
Ilustración 85: Pagina noticias (Autoría Personal)

Página miembro del Equipo
Ilustración 86: Página miembro del equipo (Autoría Personal)

Paginas en línea
69
Ilustración 87: Paginas en línea (Autoría Personal)

Paginas herramienta utilizada
Ilustración 88: Configuración herramienta SEO (Autoría Personal)

Paginas canal de YouTube:
70
Ilustración 89: Canal de YouTube
71
CAPÍTULO V
1. CONCLUSIONES Y RECOMENDACIONES
5.1
Conclusiones
 Los algoritmos de optimización contribuyan positivamente en legibilidad
del código fuente, gracias al uso del patrón de diseño MVC.
 La manera de generar automáticamente el código java es realmente
optima
 Se crean diferentes clases en java según el número de tablas en el
paquete dal.entity, en código generado es para el mapeo de nuestra
base de datos con métodos get y set
 Se crea el archivo MyBundle.properties, en este archivo podemos
cambiar las palabras que se encuentran en inglés, a español por
ejemplo home por inicio, debemos hacerlo manualmente
 Se crea el archivo pfcrud.css, aquí podemos modificar nuestra interfaz
gráfica que viene por defecto
 Se crea el paquete dal.facade manualmente y contiene las clases de
fachada para acceder a las entidades.
 Se crea el paquete ui.bean contiene todos los controladores de JSF
para interactuar con las páginas JSF y la capa de datos.
 Se crea el paquete ui.util contiene clases de ayuda
 Se crea el paquete ui.converter contiene las clases de convertidor de la
interfaz de usuario.
 En el paquete entity se crean las interfaces web de cada pantalla está
escrito en código xhtml
 En el portal web sirve de gran ayuda para venta y soporte de la
herramienta
 Dicho portal web tiene herramientas intuitivas para el usuario:
1) Leer el texto en algunas páginas,
2) Preguntas y respuestas más frecuentes algo muy útil para el usuario
nuevo y antiguo si surge algún problema
3) Post y comentarios: El usuario podrá ver un pequeño bloc de la
herramienta y podrá comentar algo muy útil si surge algún problema
con la herramienta.
4) En la página de noticias se actualizara según las nuevas novedades
de nuestra herramientas es algún muy bueno para tener a los
usuarios al tanto de las nuevas versiones
5) Se explotó al máximo el wordpress y una revista online para realizar
una publicidad online para que la herramienta sea más conocida
6) Se utilizó la herramienta SEO propia del portal web para renquear
en os primeros lugares en google, ya que con solo digitar framework
uce sale en los primeros lugares
72
5.2









Recomendaciones
Al momento de generar el código de una manera automática con la
herramienta PrimeFaces Crud Generator se crea una interfaz gráfica básica
de xhtml y css3, por lo cual se recomienda cambiar la interfaz añadiendo un
tema propio de PrimeFaces muy vistoso y agradable para el usuario
Se debe probar la conexión de la base datos en Netbeans para realizar el
Crud
Para agregar un tema de PrimeFaces con Css3 se debe modificar el archivo
web.xml
Si se va a cambiar el idioma de nuestra aplicación se debe modificar el
archivo MyBundle.properties
Cuando se va a comprar la herramienta PrimeFaces Crud Generator for
Netbeans en el portal web le llegara un correo con una contraseña para que
descargue su producto seleccionado
La aplicación puede ejecutarse en cualquier motor de base de datos
Se puede modificar el código generado a conveniencia si algo no nos
satisface es decir si se genera un radio button podemos cambiarlo por un
combo box, etc.
Podrán escribir al canal de YouTube cualquier duda será respondida desde
el canal de YouTube.
En el portal web en la sección de contáctanos nos podrán escribir si surge un
problema grave, el soporte técnico estará gustoso de atenderle.
73
GLOSARIO DE TÉRMINOS
API, Una interfaz de programación de aplicaciones es un conjunto de
convenciones internacionales que definen cómo debe invocarse una
determinada función de un programa desde una aplicación.
ENCAPSULAMIENTO, Es el ocultamiento del estado, es decir, del dato
miembro, de un objeto de manera que sólo se puede cambiar mediante las
operaciones definidas para ese objeto.
FRAMEWORK, Representa una arquitectura de software que modela las
relaciones generales de las entidades del dominio, y provee una estructura y
una especial metodología de trabajo, la cual extiende o utiliza las aplicaciones
del dominio.
HERENCIA, A través de ella los diseñadores pueden crear nuevas clases
partiendo de una clase o de una jerarquía de clases preexistente (ya
comprobadas y verificadas) evitando con ello el rediseño, la modificación y
verificación de la parte ya implementada.
IEEE, El Instituto de Ingeniería Eléctrica y Electrónica abreviado como IEEE,
inglés Institute of Electrical and Electronics Engineers es una asociación
mundial de técnicos e ingenieros dedicada a la estandarización y el desarrollo
en áreas técnicas.
JSP, es una tecnología que ayuda a los desarrolladores de software a crear
páginas web dinámicas basadas en HTML, XML, entre otros tipos de
documentos.
PLUG-IN, También conocido como complemento, es una aplicación que se
relaciona con otra para aportarle una función nueva y generalmente muy
específica.
POJOs, Clases planas comunes y corrientes de Java utilizada por
programadores para enfatizar el uso de clases simples y que no dependen de
un framework en especial.
POLIMORFISMO, Se refiere a la posibilidad de enviar un mensaje a un grupo
de objetos cuya naturaleza puede ser heterogénea.
74
RDBMS (Sistema de Gestión de Bases de Datos Relacionales), se basa en el
modelo relacional como inventado. Muchas bases de datos populares
actualmente en uso se basan en la base de datos relacional modelo.
SERVLET, es una clase en el lenguaje de programación Java, utilizada para
ampliar las capacidades de un servidor. Aunque los servlets pueden responder
a cualquier tipo de solicitudes, éstos son utilizados comúnmente para extender
las aplicaciones alojadas por servidores web,
SOBRECARGA DE MÉTODOS, es la creación de varios métodos con el
mismo nombre pero con diferentes firmas y definiciones.
UI, Interfaz de usuario es un conjunto de protocolos y técnicas para el
intercambio de información entre una aplicación computacional y el usuario.
UML, El Lenguaje de Modela miento Unificado es un lenguaje gráfico para
visualizar, especificar y documentar cada una de las partes que comprende el
desarrollo de software.
URL, es una cadena de caracteres con la cual se asigna una dirección única
a cada uno de los recursos de información disponibles en la Internet.
XML, es un lenguaje de marcas desarrollado por el World Wide Web
Consortium utilizado para almacenar datos en forma legible.
75
BIBLIOGRAFÍA
ÁLVAREZ, M. (21 de Enero de 2015). Desarrollo Web. Obtenido de
http://www.desarrolloweb.com/articulos/que-es-mvc.html
ANDREEVSKAI, A., & BERGLER, S. (2006b). Semantic tag extraction from wordnet glosses. En In 5th
Conference on Language Resources and Evaluation. Genova: IT.
ANDREEVSKAI, A., & BERGLER, S. (2007). In Proceedings of the 4th International Workshop on
Semantic Evaluations. Prague: Association for Computational Linguistics.
BELIAL DIAZ, E. J. (05 de Enero de 2015). Monografias. Obtenido de
http://www.monografias.com/trabajos84/redes-sociales/redes-sociales.shtml
CARBONELL, J. (14 de Enero de 2015). Centro Virtual Cervantes. Obtenido de
http://cvc.cervantes.es/obref/congresos/sevilla/tecnologias/ponenc_carbonell.htm
CLABURN, T. (2007). Google Releases Improved MySQL Code. Obtenido de
http://es.wikipedia.org/wiki/MySQL
GARCIA, J. (21 de Enero de 2015). Ceit. Obtenido de
http://www1.ceit.es/Asignaturas/Informat2/Clases/Clases9899/Clase01/JavaEntorno/tsld
003.htm
GIL, J. V. (06 de Enero de 2015). Dataprix. Obtenido de http://www.dataprix.com/blog-it/bigdata/big-data-gestion-datos-no-estructurados
GOSLING, J. (2005). The Java language specification. Addison-Wesley,. Obtenido de
http://es.wikipedia.org/wiki/Java_(lenguaje_de_programaci%C3%B3n)
HATZIVASSILOGLOU, V., & MCKEOWN, K. R. (1997). Predicting the semantic orientation of
adjectives. En In Proceedings of ACL-97, 35th Annual Meeting of the Association for
Computational Linguistics (págs. 174-181). Madrid: Association for Computational
Linguistics.
http://definicion.de/excel/. (21 de Enero de 2015). Definicion. Obtenido de
http://definicion.de/excel/
http://es.wikipedia.org/wiki/PrimeFaces. (2015). PrimeFaces. Obtenido de
http://es.wikipedia.org/wiki/PrimeFaces
http://thesaurus.reference.com. (2007). Roget’s New Millennium Thesaurus, volume 1.3.1. Lexico
Publishing Group,LLC, 1st edition. Obtenido de http://thesaurus.reference.com
http://www.sinnexus.com/business_intelligence/. (11 de Enero de 2015). Sinnexus. Obtenido de
http://www.sinnexus.com/business_intelligence/
76
IEEE. (20 de Enero de 2015). Iso Architecture. Obtenido de http://www.iso-architecture.org/ieee1471/docs/all-about-ieee-1471.pdf
INFORMATICA, E. T. (13 de Enero de 2015). Departamento de Lenguajes y Sistemas Informaticos.
Obtenido de http://www.lsi.us.es/~javierj/investigacion_ficheros/Framework.pdf
JANSSEN, C. (06 de Enero de 2015). Techopedia. Obtenido de
http://www.techopedia.com/definition/27689/nosql-database
KAMPS, J. (2004). In Proceedings of LREC-04, 4th International Conference on. Lisbon.
KATZ, P., SINGLETON, M., & WICENTOWSKI, R. (2007). the semeval-2007 systems for task 5 and
task 14. En In Proceedings of the 4th International Workshop on Semantic Evaluations
(SemEval-2007) (págs. 336-341). Prague: Association for Computational Linguistics.
KIM, S., & HOVY, E. (2004). In Proceedings COLING-04,the Conference on Computational
Linguistics. Chicago: Geneva.
KRUCHTEN, P. (1996). Rational. Obtenido de www.rational.com/media/whitepapers/xtalk.pdf
LERMA, E. V. (21 de Enero de 2015). Adictos al trabajo. Obtenido de
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=introduccionPrimefac
es
LUJÁN MORA, S. (2002). Programación de aplicaciones web: historia, principios básicos y clientes
web. Obtenido de http://es.wikipedia.org/wiki/HTML
MICROSOFT. (15 de Enero de 2015). Soporte Microsoft. Obtenido de
http://support.microsoft.com/kb/110093/es
PACKTPUB. (21 de Enero de 2015). packtpub. Obtenido de
https://www.packtpub.com/books/content/conozca-qlikview
RAYFIELD, J. T., AVRAHAM, L. R., & Avraham, L. (2001). Web-Application Development Using the
Model/View/Controller Design Pattern. Obtenido de
http://es.wikipedia.org/wiki/Modelo%E2%80%93vista%E2%80%93controlador#cite_note3
SAHLGREN, M., KARLGREN, J., & ERIKSSON, G. (2007). Valence annotation based on seeds in word
space. En In Proceedings of the 4th International Workshop on Semantic Evaluations (págs.
296-299). Prague,Czech Republic: Association for Computational Linguistics.
SANCHEZ, A. (21 de Enero de 2015). Dataiq. Obtenido de http://dataiq.com.ar/blog/qvsourceignacio-albano/
SUEIRAS, E. (05 de Enero de 2015). Scribd. Obtenido de
http://es.scribd.com/doc/24658747/Redes-sociales-definicion#scribd
77
TECHTERMS. (12 de Enero de 2015). techterms. Obtenido de
http://techterms.com/definition/framework
TURNEY. (2002). In Proceedings of the 40th Annual Meeting on Association for Computational
Linguistics. 417-424.
WANTON, T. (16 de Noviembre de 2014). Academia.edu. Obtenido de
https://www.academia.edu/4254540/La_polaridad_de_las_opiniones
YANEZ, L. (21 de Enero de 2015). Fdi. Obtenido de
https://www.fdi.ucm.es/profesor/luis/fp/devtools/NetBeansUso.html
78