Download Reporte Proyecto Parte 1. Sistema para el Registro, Control y
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.