Download Reporte Proyecto Parte 1. Sistema para el Registro, Control y

Survey
yes no Was this document useful for you?
   Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Document related concepts
no text concepts found
Transcript
Reporte Proyecto Parte 1.
Sistema para el Registro, Control y Generación de Estadísticas de Proyectos
de Investigación Educativa.
Importancia de los sistemas de información.
El auge de los Sistemas de Información (IS, Information System, por sus siglas en
inglés) en el mundo contemporáneo, ha sido vertiginoso. Resultando común que
instituciones y empresas cuenten con recursos tecnológicos que faciliten tareas
rutinarias y complejas a través de la adquisición y/o desarrollo de sistemas
computarizados.
Por lo anterior, es necesario que el personal que desea hacer uso de estos medios,
posea el conjunto de conocimientos necesarios que le permitan definir con
precisión sus requerimientos de información y establecer una alternativa
adecuada en su solución.
Un IS es un conjunto de elementos interrelacionados con el propósito de prestar
atención a las demandas de información de una organización, para elevar el nivel
de conocimientos que permitan un mejor apoyo a la toma de decisiones y
desarrollo de acciones. Los elementos que conforman un IS se presentan a
continuación:
 Elementos de entrada: Son los recursos que ingresan al sistema para ser
procesados. Por ejemplo: materias primas, energía, datos, etc.
 Procesamiento: Comprende los procesos de transformación que convierten
los elementos de entrada en elementos de salida.
 Elementos de salida: Es la transferencia de elementos que han sido
generados mediante un proceso de transformación hacia su destino final.
Ejemplos: productos terminados, servicios prestados, información
procesada, agua potable, etc.
 Retroalimentación: Se refiere a la comunicación de los resultados y
consecuencias de las acciones y decisiones a quien las origina.
 Control: Comprende el monitoreo del desempeño del sistema y la evaluación
de la retroalimentación para verificar los resultados alcanzados y
compararlos con los previstos, determinar las desviaciones, también
adoptar las medidas correctivas necesarias para regular la acción y
asegurar el cumplimiento de objetivos.
La WEB
En informática, la World Wide Web (WWW) o Red informática mundial es un
sistema de distribución de información basado en hipertexto o hipermedios
enlazados y accesibles a través de Internet. Con un navegador web, un usuario
visualiza sitios
web compuestos
de páginas
web que
pueden
contener texto, imágenes, vídeos u otros contenidos multimedia, y navega a través
de ellas usando hiperenlaces.
Un sitio web es una colección de páginas web relacionadas y comunes a un
dominio de Internet o subdominio en la World Wide Web en Internet.
Una página web es un documento HTML/XHTML que es accesible generalmente
mediante el protocolo HTTP de Internet.
Todos los sitios web públicamente accesibles constituyen una gigantesca World
Wide Web de información (un gigantesco entramado de recursos de alcance
mundial).
A las páginas de un sitio web se accede frecuentemente a través de un URL raíz
común llamado portada, que normalmente reside en el mismo servidor físico. Los
URL organizan las páginas en una jerarquía, aunque los hiperenlaces entre ellas
controlan más particularmente cómo el lector percibe la estructura general y cómo
el tráfico web fluye entre las diferentes partes de los sitios.
Propuesta Detallada.
Para la entrega de esta primera parte del proyecto, nos dimos a la tarea de
seleccionar las tecnologías y frameworks que nos proveerán todos los
componentes y funcionalidades para la construcción de nuestro sistemas. Se
mencionan a continuación:
 Java Server Faces.
o Ice Faces.
 Hibérnate
 MySQL.
Para el almacenamiento y hasta el momento la realización de nuestras pruebas
vamos a utilizar el servidor apache Tomcat.
Java Server Faces
JSF es un marco de trabajo para crear aplicaciones java J2EE basadas en el patron
MVC de tipo 1. JSF tiene como característas principales:
-Utiliza páginas JSP para generar las vistas, añadiendo una biblioteca de etiquetas
propia para crear los elementos de los formularios
HTML.





Asocia a cada vista con formularios un conjunto de objetos java manejados
por el controlador (managed beans) que facilitan la recogida, mapipulación
y visualización de los valores nostrados en los diferentes elementos de los
formularios.
Introduce una serie de etapas en el procesamiento de la petición, como por
ejemplo la de validación, reconstrucción de la vista, recuperación de los
valores de los elementos, etc.
Utiliza un sencillo fichero de configuración para el controlador en formato
xml
Es extensible, pudiendo crearse nuevos elementos de la interfaz o modificar
los ya existentes.
Y lo que es más importante: forma parte del estándar J2EE. En efecto, hay
muchas alternativas para crear la capa de presentación y control de una
aplicación web java, como Struts y otros frameworks, pero solo JSP forma
parte del estándar.
Por que utilizar JSF
SF nos permite desarrollar rápidamente aplicaciones de negocio dinámicas en las
que toda la lógica de negocio se implementa en java, o es llamada desde java,
creando páginas para las vistas muy sencillas (salvo que introduzcamos mucha
maquetación HTML o Javascript)
JSF nos ofrece una serie de ventajas:





El código JSF con el que creamos las vistas (etiquetas jsp) es muy parecido
al HTML estándar. Lo pueden utilizar fácilmente desarrolladores y
diseñadores web.
JSF se integra dentro de la página JSP y se encarga de la recogida y
generación de los valores de los elementos de la página
JSF resuelve validaciones, conversiones, mensajes de error e
internacionalización (i18n)
JSF permite introducir javascript en la página, para acelerar la respuesta de
la interfaz en el cliente (navegador del usuario).
JSF es extensible, por lo que se pueden desarrollar nuevos componentes a
medida, También se puede modificar el comportamiento del framework
mediante APIs que controlan su funcionamiento.
Desde el punto de vista técnico podemos destacar los siguientes:


JSF forma parte del estándar J2EE, mientras que otras tecnologías para
creación de vistas de las aplicaciones no lo forman, como por ejemplo
Struts.
JSF dispone de varias implementaciones diferentes, incluyendo un conjunto
de etiquetas y APIs estándar que forman el núcleo del framework. Entre
estas implementaciones cabe destacar la implementación de referencia de
Sun Microsystems, actualmente desarrollada como un proyecto open

source, y la implementación del proyecto Apache, MyFaces, dotada de un
conjunto de extensiones que la hacen muy interesante para el desarrollo de
aplicaciones corporativas.
El desarrollo de JSF está realmente empezando. Las nuevas versiones del
framework recogen la funcionalidad de versiones anteriores siendo su
compatibilidad muy alta, de manera que el mantenimiento de aplicaciones
no se ve penalizado por el cambio de versiones.
Hibernate
Es una herramienta de Mapeo objeto-relacional (ORM) para la plataforma Java (y
disponible también para .Net con el nombre de NHibernate) que facilita el mapeo
de atributos entre una base de datos relacional tradicional y el modelo
de objetos de una aplicación, mediante archivos declarativos (XML) o anotaciones
en los beans de las entidades que permiten establecer estas relaciones.
Características
Como todas las herramientas de su tipo, Hibernate busca solucionar el problema
de la diferencia entre los dos modelos de datos coexistentes en una aplicación: el
usado en la memoria de la computadora (orientación a objetos) y el usado en las
bases de datos (modelo relacional). Para lograr esto permite al desarrollador
detallar cómo es su modelo de datos, qué relaciones existen y qué forma tienen.
Con esta información Hibernate le permite a la aplicación manipular los datos de la
base operando sobre objetos, con todas las características de la POO. Hibernate
convertirá los datos entre los tipos utilizados por Java y los definidos por SQL.
Hibernate genera las sentencias SQL y libera al desarrollador del manejo manual
de los datos que resultan de la ejecución de dichas sentencias, manteniendo la
portabilidad entre todos los motores de bases de datos con un ligero incremento
en el tiempo de ejecución.
Hibernate está diseñado para ser flexible en cuanto al esquema de tablas utilizado,
para poder adaptarse a su uso sobre una base de datos ya existente. También tiene
la funcionalidad de crear la base de datos a partir de la información disponible.
Hibernate
ofrece
también
un
lenguaje
de
consulta
de
datos
llamado HQL (Hibernate Query Language), al mismo tiempo que una API para
construir las consultas programáticamente (conocida como "criteria").
Hibernate para Java puede ser utilizado en aplicaciones Java independientes o en
aplicaciones Java EE, mediante el componente Hibernate Annotations que
implementa el estándar JPA, que es parte de esta plataforma.
Esencialmente es imprescindible mencionar estas tecnologías, ya que a estas
alturas ya tenemos conocimiento de lo que es el lenguaje de bases de datos
relacionados denominado MySQL, ahora proseguiremos con la definición del
entregable para esta primera parte del proyecto.
Entregables de la Primera parte del proyecto.
 Integración entre JSF, Hibernate y MySQL.
o Obtencion y puesta en marcha de los frameworks y tecnologías
inmersas.
o Ejemplo del funcionamiento de las tres tecnologías.
o Primera aplicación en la cual mediante una forma, el usuario ingresa
datos, estos son almacenados en la base de datos y finalmente son
desplegados en el navegador web.
o Código de la aplicación.
o Reporte.
A continuación se muestran los resultados obtenidos.
Ventana principal de la aplicación.
Se despliega el formulario que esta compuesto básicamente por componentes del
framework Ice Faces, en donde se realiza la inserción de la información.
La información se mapea a la base de datos relacional mediante Hibernate, es
almacenada y después se despliega en un componente de la forma.
Código
Aquí tenemos el XHTML dinámico, que se encarga de la presentación al usuario de
la interfaz, mediante los componentes para estructurar el formulario. index.xhtml
<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:ace="http://www.icefaces.org/icefaces/components"
xmlns:ice="http://www.icesoft.com/icefaces/component"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:f="http://java.sun.com/jsf/core">
<h:head>
<title>Facelet Title</title>
</h:head>
<h:body>
<h:form id="form_cliente">
<ace:panel>
<ice:panelGrid columns="2">
<ice:outputLabel value="Nombre:"/>
<ice:inputText id="txtNombre" value="#{ClienteBO.cliente.nombre}"
required="true"/>
<ice:outputLabel value="Direccion:"/>
<ice:inputText id="txtDireccion" value="#{ClienteBO.cliente.direccion}"
required="true"/>
<ice:outputLabel value="Telefono:"/>
<ice:inputText id="txtTelefono" value="#{ClienteBO.cliente.telefono}"
required="true"/>
<ice:outputLabel value="#{ClienteBO.cliente.saluda()}"/>
<ice:commandButton
action="#{ClienteBO.executeCreate()}"
value="Guardar"/>
</ice:panelGrid>
</ace:panel>
</h:form>
<ace:panel>
<ice:dataTable
value="#{ClienteBO.lista}"
var="cliente"
style="fontsize:10px">
<ice:column>
<f:facet name="header">
<h:outputText value="Identificador" />
</f:facet>
<ice:outputText value="#{cliente.idCliente}"/>
</ice:column>
<ice:column>
<f:facet name="header">
<h:outputText value="Nombre" />
</f:facet>
<ice:outputText value="#{cliente.nombre}"/>
</ice:column>
<ice:column>
<f:facet name="header">
<h:outputText value="Direccion" />
</f:facet>
<ice:outputText value="#{cliente.direccion}"/>
</ice:column>
<ice:column>
<f:facet name="header">
<h:outputText value="Telefono" />
</f:facet>
<ice:outputText value="#{cliente.telefono}"/>
</ice:column>
</ice:dataTable>
</ace:panel>
</h:body>
</html>
Las clases para el mapeo del modelo orientado a objetos al modelo relacional de la
base de datos.
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
public class HibernateFactory {
private static SessionFactory sessionFactory;
private static Log log = LogFactory.getLog(HibernateFactory.class);
/**
* Constructs a new Singleton SessionFactory
* @return
* @throws HibernateException
*/
public static SessionFactory buildSessionFactory() throws HibernateException {
if (sessionFactory != null) {
closeFactory();
}
return configureSessionFactory();
}
/**
* Builds a SessionFactory, if it hasn't been already.
*/
public static SessionFactory buildIfNeeded() throws DataAccessLayerException{
if (sessionFactory != null) {
return sessionFactory;
}
try {
return configureSessionFactory();
} catch (HibernateException e) {
throw new DataAccessLayerException(e);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
public static Session openSession() throws HibernateException {
buildIfNeeded();
return sessionFactory.openSession();
}
public static void closeFactory() {
if (sessionFactory != null) {
try {
sessionFactory.close();
} catch (HibernateException ignored) {
log.error("Couldn't close SessionFactory", ignored);
}
}
}
public static void close(Session session) {
if (session != null) {
try {
session.close();
} catch (HibernateException ignored) {
log.error("Couldn't close Session", ignored);
}
}
}
public static void rollback(Transaction tx) {
try {
if (tx != null) {
tx.rollback();
}
} catch (HibernateException ignored) {
log.error("Couldn't rollback Transaction", ignored);
}
}
/**
*
* @return
* @throws HibernateException
*/
private
static
SessionFactory
configureSessionFactory()
HibernateException {
Configuration configuration = new Configuration();
configuration.configure();
sessionFactory = configuration.buildSessionFactory();
return sessionFactory;
}
}
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package hibernatemapping;
import java.util.List;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
public abstract class AbstractDao {
throws
private Session session;
private Transaction tx;
public AbstractDao() {
HibernateFactory.buildIfNeeded();
}
protected void save(Object obj) {
try {
startOperation();
session.save(obj);
tx.commit();
} catch (HibernateException e) {
handleException(e);
} finally {
HibernateFactory.close(session);
}
}
protected void update(Object obj) {
try {
startOperation();
session.update(obj);
tx.commit();
} catch (HibernateException e) {
handleException(e);
} finally {
HibernateFactory.close(session);
}
}
protected void delete(Object obj) {
try {
startOperation();
session.delete(obj);
tx.commit();
} catch (HibernateException e) {
handleException(e);
} finally {
HibernateFactory.close(session);
}
}
protected Object find(Class clazz, Integer id) {
Object obj = null;
try {
startOperation();
obj = session.load(clazz, id);
tx.commit();
}
} catch (HibernateException e) {
handleException(e);
} finally {
HibernateFactory.close(session);
}
return obj;
protected List findByAtributte(String sql) {
List objects = null;
try {
startOperation();
Query query = session.createSQLQuery(sql);
//query.setParameter("att", att, Hibernate.STRING);
objects = query.list();
tx.commit();
} catch (HibernateException e) {
handleException(e);
} finally {
HibernateFactory.close(session);
}
return objects;
}
protected Object findUnique(String sql) {
Object obj = null;
try {
startOperation();
Query query = session.createQuery(sql);
obj = query.uniqueResult();
tx.commit();
} catch (HibernateException e) {
handleException(e);
} finally {
HibernateFactory.close(session);
}
return obj;
}
protected List findAll(Class clazz) {
List objects = null;
try {
startOperation();
Query query = session.createQuery("from " + clazz.getName());
objects = query.list();
tx.commit();
} catch (HibernateException e) {
handleException(e);
} finally {
HibernateFactory.close(session);
}
}
return objects;
protected
void
handleException(HibernateException
DataAccessLayerException {
HibernateFactory.rollback(tx);
throw new DataAccessLayerException(e);
}
}
e)
throws
protected void startOperation() throws HibernateException {
session = HibernateFactory.openSession();
tx = session.beginTransaction();
}
Conclusiones
Es importante tener bien identificado el funcionamiento de cada elemento que
conforma esta primera aplicación, como cada elemento realiza una función
especifica para el despliegue y operación de la aplicación. Es imprescindible
conocer el modelo bajo el cual este tipo de aplicaciones trabaja, provee de una gran
abstracción para realizar las operaciones de forma eficiente.