1. MANUAL DEL DESARROLLADOR
Proyecto (codename) ZERO
Primer Concurso Universitario de Software Libre de CastillaLa Mancha.
Segundo Concurso Universitario de Software Libre
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
2. Índice de contenido
Acerca de este documento..................................................................................................... ....................5
¿Qué se debe saber?............................................................................................................................... ....6
El entorno de desarrollo.................................................................................................. ..........................7
NetBeans...................................................................................................................... ....................7
Sistema operativo................................................................................................................. ............7
Apache Tomcat................................................................................................................................. 7
MySQL........................................................................................................................................... ..8
JRE.................................................................................................................................
..................8
MySQL Connector driver ............................................................................................... ................8
Umbrello y DIA.......................................................................................................... .....................8
Otras herramientas.............................................................................................................. .............9
La estructura del proyecto.................................................................................................................. ......10
ZeroV1.......................................................................................................................
.........................10
Web Pages ............................................................................................................ .........................10
almacen, cliente, artículo, etc.................................................................................................. ..10
css ........................................................................................................................
.....................10
imagenes ................................................................................................................... ................11
js...............................................................................................................................................
..11
metainf y webinf....................................................................................................... ..............11
sdmenu......................................................................................................... .............................12
Configuration Files................................................................................................ ........................13
Server Resources................................................................................................................ ............13
Source Packages................................................................................................................. ............13
servlets..............................................................................................................................
.........13
Libraries ..............................................................................................................
..........................14
ModuloTPVZero........................................................................................................... ......................14
Source Packages............................................................................................................. ................14
applets...............................................................................................................................
.........14
imagenes.................................................................................................................... ................14
Test packages....................................................................................................................... ...........14
Libraries..............................................................................................................
...........................14
Test libraries...................................................................................................................................14
ClasesGeneralesZero............................................................................................... ...........................15
Source Packages.................................................................................................................. ...........15
almacenamientoDAO......................................................................................... .......................15
beans............................................................................................................................
..............16
Test packages....................................................................................................................... ...........17
Libraries..............................................................................................................
...........................17
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
5. Acerca de este documento
Este documento recoge de manera detallada información acerca de las herramientas
utilizadas para llevar a cabo el desarrollo del proyecto, de la estructura del mismo así como de las
distintas partes de esta estructura.
El objetivo es orientar a un futuro desarrollador en la organización de las aportaciones que
éste haga en el desarrollo. De ahí la importancia de detallar minuciosamente el contenido de cada
uno de las partes que incluye el proyecto.
Al ser un documento orientado a un usuario avanzado, los procesos de instalación de las
aplicaciones básicas necesarias para el desarrollo no han quedado recogidas en este documento, es
decir, no se explica como se instala el sistema operativo ni el IDE de desarrollo al considerarse
información que se sale del ámbito de este manual.
Para completar la instalación del resto de las herramientas necesarias para el correcto
funcionamiento del entorno, se invita al desarrollador a que lea la Guía rápida de instalación que
recoge los pasos necesarios para configurar el contenedor de servlets y servidor de aplicaciones
Apache Tomcat, la base de datos, la JRE e incluso la copia de seguridad de la base de datos.
Evidentemente, el contenido de este documento estará sujeto a numerosos cambios conforme
se generen nuevas revisiones de la aplicación.
Esta versión del documento corresponde a la revisión 0.0.1beta de la aplicación.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
6. ¿Qué se debe saber?
Como bien se ha comentado anteriormente, este documento está destinado a aquellos
usuarios avanzados que deseen conocer la estructura del proyecto con el fin de participar en el
desarrollo del mismo. Es por eso que resulta casi imprescindible tener unas nociones básicas de
ciertas tecnologías para poder llevar a cabo un desarrollo eficiente.
Para el desarrollo del proyecto, se consideraron desde el principio únicamente herramientas
libres, desde el sistema operativo hasta la suite ofimática necesaria para realizar la documentación.
En primer lugar, es muy recomendable revisar toda la documentación generada durante la
etapa de elicitación de requisitos y análisis. Esta documentación engloba las entrevistas con los
clientes, las historias de usuario, los diagramas UML, como son el diagrama de casos de uso, el
diagrama de clases y el diagrama de secuencia, así como todo lo relativo al diseño de la base de
datos; Modelo EntidadRelación, el esquema relacional... Únicamente conociendo el proceso de
ingeniería del software llevado a cabo se puede conocer el alcance del trabajo que se ha hecho. Por
supuesto, toda esta documentación está disponible para descarga desde la sección de documentos
de la forja.
El lenguaje de programación elegido fue java. Hay varias razones para apostar por java en el
desarrollo de software, cabe destacar el hecho de que java es un lenguaje orientado a objetos, muy
maduro, potente, con una gran comunidad de usuarios en todo el mundo, muy especialmente en el
ámbito educativo, una extensa documentación y con una curva de aprendizaje muy rápida. Esto
permite obtener resultados rápidamente.
Por la naturaleza del proyecto, basado en una arquitectura clienteservidor, se hacía
imprescindible hacer uno de las tecnologías orientadas a internet de las que dispone java.
J2EE es una plataforma de programación—parte de la Plataforma Java—para desarrollar y
ejecutar software de aplicaciones en Lenguaje de programación Java con arquitectura de n niveles
distribuida, basándose ampliamente en componentes de software modulares ejecutándose sobre un
servidor de aplicaciones.
Este tipo de desarrollos, además de java, utilizan habitualmente otros lenguajes de
programación propios del diseño web como son HTML, javascript y XML.
También se hace necesario conocer SQL (Structured Query Language). SQL es un lenguaje
declarativo de acceso a bases de datos relacionales que permite especificar diversos tipos de
operaciones sobre las mismas. Es un estandar ampliamente utilizado y que se empleará para
realizar las consultas oportunas a la base de datos MySQL que utiliza la aplicación.
Es recomendable que cualquier nueva funcionalidad que se desee implementar quede
perfectamente documentada y especialmente interesante resulta utilizar para ello el modelado
UML tal y como se ha hecho hasta ahora. El anexo A incluye una descripción acerca de los
diagramas que se han realizado en esta primera iteración del desarrollo.
Con todo esto, se está en disposición de entender todo el código generado.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
7. El entorno de desarrollo
NetBeans
Para llevar a cabo el proyecto hemos usado el IDE de desarrollo NetBeans en su versión
6.0.x sobre distintas distribuciones de GNU/Linux, todas ellas basadas en Debian. Principalmente
el trabajo se ha llevado a cabo sobre Ubuntu Feisty Fawn 7.04 x86. En el siguiente enlace se puede
descargar la versión del IDE que se ha utilizado para el desarrollo:
http://download.netbeans.org/netbeans/6.0/final/bundles/netbeans6.0.1mljavaeelinux.sh
Sistema operativo
Y aquí en este otro enlace, la versión 7.04 de Ubuntu:
http://www.ubuntu.com/getubuntu/download
Sin embargo, no es la única opción. Gran parte del desarrollo se ha hecho sobre Molinux 3.0,
una distribución basada en Debian y desarrollada por la Junta de comunidades de Castilla la
Mancha que se puede descargar desde aquí:
http://www.molinux.info/index.php?option=com_remository&Itemid=0&func=select&id=34
Apache Tomcat
Tomcat es un proyecto desarrollado por la fundación Apache. Es un contenedor de servlets
que puede funcionar como servidor web autónomo pero que habitualmente se integra con el propio
servidor Apache. Tiene una licencia libre de Apache.
La versión utilizada para el desarrollo ha sido la 6.0.16. Las características más destacables
de esta versión son:
• Implementado de Servlet 2.5 y JSP 2.1
• Diseñado para funcionar en Java SE 5.0 y posteriores
Se puede descargar desde el siguiente enlace:
http://tomcat.apache.org/download60.cgi
La instalación y configuración necesaria para el funcionamiento del mismo está recogida en
la guía rápida de instalación. Para más información acerca del proyecto Tomcat, visitar la página
del desarrollo a través del enlace anterior.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
8. MySQL
MySQL es un motor de base de datos relacional, multihilo y multiusuario ampliamente
utilizado no sólo en proyectos de software libre sino también en multitud de desarrollos
comerciales ya que dispone de dos versiones, una comercial y otra libre con licencia GPL.
MySQL pertenece a Sun Microsystems desde enero de 2008.
En las distribuciones de linux anteriormente mencionadas, está disponible desde los
repositorios. De nuevo se insta al desarrollador a consultar la guía rápida de instalación para saber
como configurar la base de datos correctamente. Por supuesto, está disponible para descarga desde
su página oficial a través del siguiente enlace:
http://dev.mysql.com/downloads/mysql/5.0.html#linux
Para facilitar la administración de la base de datos se han usado principalmente dos
herramientas, PHPMyAdmin y MySQLAdministrator.
JRE
JRE es el acrónimo de Java Runtime Environment (entorno en tiempo de ejecución Java) y se
corresponde con un conjunto de utilidades que permiten la ejecución de programas escritos en java
sobre distintas plataformas. (Linux, windows, *BSD, Solaris....).
El JRE está formado por una JVM (máquina virtual Java) que es el programa que interpreta
el código Java y además por las librerías de clases estándar que implementan el API de Java.
Ambas JVM y API deben ser consistentes entre sí, de ahí que sean distribuidas de forma conjunta.
Basta con disponer de la JRE para ejecutar las aplicaciones desarrolladas en Java, mientras
que para desarrollar nuevas aplicaciones en dicho lenguaje es necesario un entorno de desarrollo,
denominado JDK, que además del JRE (mínimo imprescindible) incluye, entre otros, un
compilador para Java. Cabe destacar NetBeans y Eclipse. De nuevo, se puede descargar de aquí:
http://javadl.sun.com/webapps/download/AutoDL?BundleId=12791
MySQL Connector driver
Librería disponible para descarga desde la web del mysql que permite comunicarnos con la
base de datos. Si no existe ya, hemos de tenerla en la carpeta lib del Tomcat.
http://dev.mysql.com/downloads/connector/j/5.1.html
Umbrello y DIA
Umbrello es una herramienta libre para crear y editar diagramas UML, que ayuda en el
proceso del desarrollo de software. Está diseñado principalmente para KDE, aunque funciona en
otros entornos de escritorio como Gnome. También esta disponible para descarga desde los
repositorios de Ubuntu/Molinux y a través de la página del proyecto:
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
9. http://uml.sourceforge.net/download.php
DIA es una aplicación gráfica de propósito general para la creación de diagramas,
desarrollada como parte del proyecto GNOME. Está concebido de forma modular, con diferentes
paquetes de formas para diferentes necesidades. Disponible para distintas plataformas (Linux,
windows...), destaca por su sencillez de uso. Al igual que Umbrello, esta disponible en los
repositorios de la distribución y aquí:
http://www.gnome.org/projects/dia/downld.html
Estas dos herramientas han sido utilizadas para realizar los distintos diagramas que se
crearon el la fase de análisis.
Otras herramientas.
Otras herramientas utilizadas han sido The Gimp, para el tratamiento esporádico de alguna
imagen, OpenOffice para crear la documentación y virtualBox para disponer de un servidor virtual
donde hacer las pruebas de conexión clienteservidor.
Una vez finalizada la instalación de todas las herramientas necesarias, podemos empezar a
trabajar.
Recordar por último que, para probar la aplicación, independientemente de que se esté
trabajando en local o desde un ordenador cliente, basta disponer de un navegador web que soporte
la máquina virtual de java (necesaria para visualizar el módulo de TPV), para poder probar la
aplicación. Se han realizado pruebas desde clientes Windows y Linux y el resultado ha sido
satisfactorio en ambos casos.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
10. La estructura del proyecto
Para empezar, en más fácil seguir este manual si se tiene abierto NetBeans con los tres
proyectos incluidos en el workspace.
Es probable que al abrir ZeroV1 sea necesario resolver algún problema de referencias,
relativas seguramente a los otros dos proyectos que forman parte de la estructura como son
ModuloTPVZero y clasesGeneralesZero. Basta con abrir estos proyectos para solucionar el
problema. Podemos movernos ahora por la estructura en forma de árbol. Procedemos a comentar
cada uno de los directorios y su contenido.
ZeroV1
Web Pages
Esta carpeta contiene todas las páginas web de las que dispone el proyecto web así como las
subcarpetas correspondientes a las distintas funcionalidades del mismo. Corresponde casi por
completo a la capa de presentación dentro del paradigma del modelo de tres capas, al cual se hace
referencia en el Anexo A. Si es necesario crear una nueva funcionalidad, entonces hay que crear
una nueva subcarpeta que identifique de forma unívoca a esta nueva funcionalidad. Para nombrar
una subcarpeta utilizaremos un nombre en singular, en minúscula y sin signos de puntuación como
tildes, diéresis o la letra ñ, por ejemplo, puntoverde. Esta nueva subcarpeta contendrá todas las
páginas web destinadas a la gestión del puntoverde.
almacen, cliente, artículo, etc
Estas subcarpetas, como se ha comentado en el ejemplo, contienen las páginas web relativas
a tareas propias de cada una de estas funcionalidades. Por ejemplo, la carpeta articulo ha de
contener nuevoArticulo.jsp, listadoArticulo.jsp, bienvenidaArticulo.html, etc. Las páginas web
incluidas en estas subcarpetas han de nombrarse, al igual que con las carpetas, evitando signos de
puntuación o especiales. Por ejemplo: miNuevaFuncionalidad.jsp.
css
Esta subcarpeta contiene todas las hojas de estilo (excepto la del menú) necesarias para la
correcta presentación de las páginas web. Hay que usar hojas de estilo siempre que se pueda
evitando en la manera de lo posible atributos en las etiquetas de maquetado. Por ejemplo,
disponemos de una hoja de estilos que se utiliza exclusivamente para aquellas páginas web
dedicadas a la inserción de registros, Ésta se llama tablaInsersionCSS.css. Si se desea crear una
nueva hoja de estilos es conveniente usar un nombre lo más identificativo posible. Si se cree
conveniente disponer de una hoja de estilos para las páginas destinadas al borrado de los registros,
independientemente de lo que estemos borrando, podemos llamarla entonces
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
11. borraRegistrosCSS.css y aplicarla en todas aquellas páginas web que creamos convenientes con el
fin de que guarden una similitud en cuanto a la presentación.
imagenes
Contiene las imágenes necesarias para la maquetación excepto las del menú, las cuales están
incluidas en su correspondiente carpeta.
js
Esta carpeta incluye los ficheros javascript que utilizaremos en nuestro proyecto web. Es
recomendable que todo el código javascript esté en ficheros *.js dentro de esta carpeta y sean
referenciados mediante enlaces en las páginas web que los usen.
metainf y webinf
Estas dos carpetas son generadas automáticamente por NetBeans y su contenido es
imprescindible para el correcto funcionamiento de la aplicación por lo que se debe saber lo que se
quiere hacer y para qué con el fin de no deteriorar su contenido.
La carpeta webinf contiene un fichero llamado web.xml que es el descriptor de despliegue
para la aplicación. Define varios parámetros que son usados cuando se despliega la aplicación en el
contenedor de Servlets/JSP Tomcat como por ejemplo el punto de entrada de la aplicación web. En
él, se hace referencia a los servlets, la página de inicio, o welcomefilelist y el DataSource del pool
de conexiones del cual se habla a continuación.
La carpeta metainf contiene el fichero context.xml. En este fichero es en el que realmente
especificaremos los parámetros de conexión a una base de datos determinada. Deberá existir una
entrada <Resource> por cada base de datos que se vaya a emplear y su nombre deberá coincidir
con el indicado en el fichero web.xml
A continuación se muestra la configuración del pool de conexiones de la base de datos:
<?xml version="1.0" encoding="UTF8"?>
<Context path="/ZeroV1" docBase="ZeroV1"
debug="5" reloadable="true" crossContext="true">
<Resource name="jdbc/mysqlDS" auth="Container"
type="javax.sql.DataSource"
maxActive="20" maxIdle="5" maxWait ="100"
username="root" password="1234"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/zero?autoReconnect=true"/>
</Context>
El elemento <Context> hace referencia al contexto donde este recurso es válido, esto es, a la
aplicación que se está desplegando. Sus propiedades path y docBase hacen referencia al nombre
de dicha aplicación.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
12. Las propiedades de configuración de <resource> son las siguientes:
name: nombre JNDI. Debe ser el mismo nombre que el indicado en web.xml.
auth: igual que <resauth> en el fichero web.xml.
type: igual que <restype> en el fichero web.xml.
username: usuario para acceder a la base de datos.
password: su contraseña.
driverClassName: nombre completo de la clase con el driver JDBC
url: url de conexión a la base de datos
maxActive: número máximo de instancias activas simultáneas para esta base de datos.
maxIdle: número máximo de conexiones simultáneas sin actividad.
maxWait: tiempo en milisegundos que esperará el sistema antes de generar una
excepción cuando se le solicita una nueva conexión y no haya ninguna disponible.
validationQuery: Consulta SQL que puede usarse para comprobar la validez de una
conexión. Debe ser un SELECT y devolver al menos una fila.
Es imprescindible por tanto que la base de datos esté correctamente configurada y que
disponga de un usuario “root” cuya clave sea “1234”.
sdmenu
Esta carpeta contiene todo lo relativo al menú que se carga a la izquierda en la ventana de
administración general. El menú se referencia en principal.jsp. La subcarpeta sdmenu que contiene
sdmenu esta formada por los ficheros *js, la hoja de estilos del menú y las imágenes.
La estructura del fichero menu.html es bastante intuitiva y añadir nuevas entradas al mismo
no supone ninguna dificultad. Basta con echarle un vistazo para comprobar que el código es
siempre igual y que únicamente hay copiar y pegar el código de una entrada para tener otra nueva.
El resto de páginas corresponden a la página de inicio de sesión index.jsp, la página del
usuario administrador, principal.jsp la cual esta dividida en 4 frames que contienen cabecera.jsp,
pie.html, bienvenida.jsp y menu.html, y la página principal del punto de venta terminalTPV.jsp en
la cual se carga el módulo del TPV.
Destacar el fichero cabecera.jsp. En un principio, se pensó en él como un fichero HTML
estático, sin embargo, se optó por usar un *.jsp al considerar que era el mejor lugar para incluir un
cerrar sesión.
Si fuese necesario añadir nuevas páginas web en la raiz del directorio web pages, es
importante considerar la categorización comentada anteriormente donde cada funcionalidad de la
aplicación dispone de una subcarpeta donde almacenar las nuevas páginas que resultasen
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
13. necesarias. Una vez más se hace incapié en el hecho de utilizar nombres significativos, en
minuscula, en singular y que no contentan caracteres especiales.
Configuration Files
Esta carpeta contiene, como su propio nombre indica archivos de configuración. Por un lado
el context.xml, el cual hemos detallado anteriormente y el manifest.xml. Necesario para generar el
paquete donde se construye la aplicación.
Server Resources
Esta carpeta no contiene actualmente ningún fichero.
Source Packages
Source Packages contiene los servlets, que son los ficheros que están en el lado del servidor
y que forman parte de la capa de la lógica de negocio de la aplicación y permiten comunicar la
capa de presentación con la capa de persistencia o de datos. El proyecto ClasesGeneralesZero
incluye el resto de clases de control de la capa de la lógica de negocio. Este proyecto se detalla más
adelante.
servlets
Un servlet es un objeto que se ejecuta en un servidor o contenedor JEE, fue especialmente
diseñado para ofrecer contenido dinámico desde un servidor web, generalmente en HTML.
Un servlet es un objeto Java que implementa la interfaz javax.servlet.Servlet o hereda alguna
de las clases más convenientes para un protocolo específico (ej: javax.servlet.HttpServlet). Al
implementar esta interfaz el servlet es capaz de interpretar los objetos de tipo HttpServletRequest y
HttpServletResponse quienes contienen la información de la página que invocó al servlet.
Cada servlet desempeña una función diferente y por tanto el código es sustancialmente
distinto al contrario que ocurre con las clases generales y las clases *DAO, las cuales tienen todas
una estructura parecida.
LoginServlet es el responsable de la autenticación de los usuarios en la aplicación.
Comprueba el usuario, la contraseña y si el usuario se encuentra ya conectado.
DesconexionServlet es el responsable de finalizar la sesión del usuario. Actualizando de esta
forma la base de datos y delvolviendo al usuario a la página de entrada.
DevolucionServlet se encarga de las peticiones de devolución de artículos durante una
compra.
VentaServlet es el encargado de proporcionar la información necesaria en las consultas que
realiza el TPV, enviándole a éste los artículos solicitados.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
14. Libraries
Esta carpeta contiene las librerias externas del proyecto, necesarias para que funcione
correctamente como son la JDK en su versión 1.6, las librerías propias del contenedor de servlets y
servidor web Apache Tomcat 6.0.16 y la librería de clases clasesGeneralesZero. Podemos
consultar todos los proyectos importados (ModuloTPVZero) en las propiedades de esta carpeta.
ModuloTPVZero
Este proyecto, de tipo class library, depende de ZeroV1 y de clasesGeneralesZero por lo
tanto, en ningún caso puede funcionar de forma autónoma ya que la iteración con la base de datos
se hace a través de un tunneling entre esta class library y el correspondiente servlet del proyecto
web.
El llamado "tunneling", quizás traducible como "atravesar un tunel" o algo parecido,
significa transmitir información que sigue un protocolo por medio de otro. En nuestro caso se
llama "HTTP tunneling" ya que usamos el protocolo HTTP para transmitir la información binaria.
Source Packages
applets
Esta carpeta incluye los applets del módulo TPV. En principio, únicamente se dispone de un
applet llamado terminalTPV.java. Se han utilizado Swing, que es una biblioteca gráfica para Java
que forma parte de las Java Foundation Classes (JFC). Incluye widgets para interfaz gráfica de
usuario tales como cajas de texto, botones, desplegables y tablas.
Además, incluye la clase tablaArticulos.java que establece el modelo del jtable donde se
cargan los artículos que se venden.
imagenes
Contiene las imágenes necesarias para la interfaz del TPV.
Test packages
Esta carpeta esta vacía.
Libraries
Contiene la JDK 1.6.
Test libraries
Contiene JUnit 4.1 y Junit 1.8.2.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
15. Uno de los problemas que se nos plantearon durante el desarrollo fue la integración del
applet del TPV en el proyecto web, incluímos por tanto un pequeño tutorial acerca de la
integración del applet con un JSP que aparece en la documentación de NetBeans:
http://qa.netbeans.org/modules/webapps/promoe/applet/applettestspec.html
ClasesGeneralesZero
Con el fin de paquetizar en la mayor medida la estructura del proyecto, se ha convenido
disponer de un proyecto adicional de tipo librería de clases destinado exclusivamente a almacenar
gran parte de las funciones propias de la capa de la lógica de negocio.
Source Packages
almacenamientoDAO
Este paquete contiene las clases que nos permiten manipular las tablas de la base de datos.
En ellas se encuentran los métodos básicos necesarios para trabajar con dichas tablas, como son
inserción, borrado, consulta y actualización.
La estructura es muy parecida en todas en ellas, en primer lugar, la declaración de las
variables, a continuación un constructor que construye, valga la redundancia, las sentencias que se
le enviarán al motor de base de datos y por otra los métodos correspondientes a cada una de las
sentencias, que son al fin y al cabo los que insertan, borran, consultan y actualizan registros.
Para nombrar a las mismas se ha seguido un procedimiento muy simple, recurrir al nombre
de las tablas de la base de datos seguido de DAO, quedando muy claro de esta manera la función de
estas clases. Únicamente así se consigue una paquetización completa de la estructura del proyecto.
El contenido, muy parecido en todas ellas es algo similar al siguiente código:
public class MiClaseDAO{
private Connection con;
private PreparedStatement pstmtInsertar;
private PreparedStatement pstmtBorrar;
private PreparedStatement pstmtActualizar;
....
public UsuarioDAO(Connection con) throws SQLException{
this.con = con;
pstmtInsertar = con.prepareStatement("INSERT INTO...");
pstmtBorrar = con.prepareStatement("...");
....
}
public ResultSet insertar(MiClase c) throws SQLException {
pstmtInsertar.clearParameters();
pstmtInsertar.setString(1,c.getCampo1());
pstmtInsertar.setDate(2,c.getCampo2());
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
16. pstmtInsertar.setInt(3,c.getCampo3());
....
pstmtInsertar.executeUpdate();
return pstmtInsertar.getResultSet();
}
public ResultSet borrar(TipoMiClase c) throws SQLException {
pstmtInsertar.clearParameters();
....
return pstmtBorrar.getResultSet();
}
public ResultSet actualizar(TipoMiClase c) throws SQLException {
pstmtActualizar.clearParameters();
.....
return pstmtActualizar.getResultSet();
}
....
}
beans
Los beans construyen los objetos que le pasamos a los métodos de las clases *DAO y que nos
permiten hacer las consultas a la base de datos.
Como en el caso anterior, se ha seguido el procedimiento de disponer de una clase general
por cada tabla de la base de datos, con el fin de modularizar al máximo posible la estructura del
proyecto.
El contenido de estas clases viene a ser algo similar a lo siguiente:
public class MiClase
{
/* Variables locales de la clase */
int idMiClase;
String nombreMiClase;
/* Constructor de la clase */
public MiClase(int idMiClase, String nombreMiClase)
{
this.idMiClase = idMiClase;
this.nombreMiClase = nombreMiClase;
}
/* Metodos de consulta */
public int getIdMiClase()
{
return this.idMiClase;
}
public String getNombreMiClase()
{
return this.nombreMiClase;
}
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
18. Base de datos
La versión del motor de base de datos utilizado para el desarrollo ha sido la 5.0.38. Como se
comentó al principio de este documento, para la administración de la base de datos se ha utilizado
una herramienta gráfica, fácil e intuitiva. Podemos utilizar PHPMyAdmin, para hacer
modificaciones en la base de datos, añadir, borrar, modificar y actualizar registros y tablas.
La ilustración anterior muestra la interfaz de la herramienta y además nos sirve para ver las
tablas que forman parte en el momento de la publicación de este manual. En la página web del
proyecto PHPMyAdmin podemos encontrar multitud de documentación sobre éste.
Las tablas, como se puede comprobar empiezan siempre por mayúscula y están en singular.
Una vez más, se insiste en mantener este patrón a la hora de crear nuevas tablas. Por ejemplo, si
deseamos crear una nueva tabla, para almacenar los pedidos a proveedor, la llamaríamos
PedidoProveedor.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
21. El servidor de Servlet/JSP Apache Tomcat
Tomcat en un contenedor de servlets y servidor web que, aunque habitualmente se integra
con el propio servidor Apache, también puede funcionar de forma autónoma. La versión utilizada
para el desarrollo ha sido la 6.0.16. Sin entrar muy en detalle, si resulta interesante conocer la
estructura de directorios. Si hemos seguido correctamente la guía de instalación rápida, la ruta de
nuestro servidor Tomcat ha de ser la que se muestra en la siguiente imagen.
La jerarquía de directorios por tanto es la que vemos Repasemos brevemente ésta:
bin arranque, cierre, y otros scripts y ejecutables
common clases comunes que pueden utilizar Catalina y las aplicaciones web
conf ficheros XML y los correspondientes DTD para la configuración de Tomcat
logs logs de Catalina y de las aplicaciones
server clases utilizadas solamente por Catalina
shared clases compartidas por todas las aplicaciones web
webapps directorio que contiene las aplicaciones web
work almacenamiento temporal de ficheros y directorios
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
22. La carpeta que nos interesa especialmente para poder ejecutar correctamente nuestra
aplicación de forma autónoma y sin necesidad de lanzarla desde el IDE de desarrollo es el
directorio webapps, en el cual, tal y como apunta la descripción, es donde ha de estar contenida
nuestra aplicación en entornos de producción. Por tanto, es aquí donde debemos copiar ZeroV1.war
desde la carpeta dist del directorio del proyecto (workspace de trabajo).
El servidor hace automáticamente el despliegue cuando lo levantamos y utiliza los ficheros
de configuración incluidos en la aplicación, como por ejemplo, el context.xml que creará el pool de
conexiones al lanzar la aplicación.
También cabe considerar el contenido de la carpeta bin, en la cual se encuentran los scripts
necesario para lanzar el servidor, pararlo, reiniciarlo y conocer su estado. Esta funcionalidad se ha
simplificado al disponer de un script que hace las tareas anteriormente comentadas. Podemos
descargarlo desde la forja:
https://forja.rediris.es/docman/view.php/282/548/init_tomcat.sh
Cuando estemos en desarrollo, podemos hacer estas mismas operaciones desde NetBeans tal
y como se muestra en la siguiente imagen.
Cuando esté disponible una versión de la aplicación lista para producción se explicarán los
pasos necesarios para lanzar Tomcat como un servicio del sistema operativo, para así poder
“olvidarnos” de él.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
23. Epílogo
Por último, recordar al posible desarrollador que existen foros de discusión donde tratar los
distintos temas sobre codificación, pruebas, bugs, nuevas funcionalidades, etc, en los cuales se le
invita a participar.
Si además se tiene interés en el proyecto se le sugiere que esté atento a las posibles revisiones
de este manual y del resto de documentación disponible. Una buena manera de estar al día es
sindicarse a los agregadores dinámicos del blog, donde informaremos puntualmente de las
novedades que vayan surgiendo.
También cabe agradecer el hecho de haber llegado hasta aquí, ya que posiblemente sea una
señal de que anteriormente se han leído el resto de páginas. Animar sin más a participar
activamente en el proyecto contribuyendo de esta manera a este pequeño sueño que supone
desarrollar un sistema de gestión comercial y contabilidad capaz de cubrir las necesidades de las
PYMES.
Suerte.
Manual del desarrollador - Proyecto (Codename) Zero (versión 0.0.1-beta)
