En esta entrada quiero describir una propuesta de estructura de una aplicación MVC que toma como base la que implementa Struts. Evidentemente esta solución no aporta nada si ya tienes decidido utilizar Spring o el propio Struts; pero si se desea realizar una aplicación sencilla si hacer uso de ellas, la propuesta que se describe permite tener una solución bien estructura y sencilla.

¿Qué debes saber antes de continuar? Al menos los conceptos de servlet y JSP deberías tenerlos claros; y todo lo ello conlleva: paso de parámetros, redijir a una JSP desde el servlet, paso de atributos, sesiones, etc.

Como siempre utilizaremos Apache Tomcat como contenedor J2EE y Eclipse como entorno de desarrollo.

La entrada la he dividido en tres bloques: idea general de la estructura, elementos que se necesitan y organización de los mismos.

Ideal general

La estructura que se presenta pretende separar el control de acceso a la aplicación, la lógica de negocio y la lógica de presentación. Es decir, que haya un único punto de entrada a la funcionalidad, que cada función sea independiente y se puede añadir nueva de forma dinámica y que la presentación sólo se dedique a «pintar» datos y no realice ninguna funcionalidad propia de la lógica de negocio.

Elementos de la estructura

Para lo cual vamos a utilizar tres elementos principales, acción/modelo, vista y controlador, y dos secundarios, beans (o también POJOs) y la lógica de negocio o servicios.

Controlador: esta parte será implementada por un servlet; el cual recibe todas las peticiones y las procesa para verificar que el usuario tiene permiso de acceso y puede ejecutar la acción solicitada.

Para independizar el servlet de la acción concreta a ejecutar todas las clases que implementan la funcionalidad de la aplicación deberán heredar de una clase padre Accion. De esta forma se puede declarar una variable de dicho tipo y asignarle el tiempo de ejecución el objeto correspondiente a la clase de la acción a realizar.

Accion accion = new AccionListarArticulos();
accion.ejecutar();

El listado de acciones (en realidad objetos de subclases de la clase Accion, como hemos visto) se instanciará cuando el servlet se cargue en memoria; de esta forma estará disponible para todas las peticiones que se realicen al controlador. Es decir, no creamos un objeto de la acción cada vez que el servlet recibe una petición sino que utilizamos una tabla para guardar, debidamente referenciado, un objeto de cada una de las acciones.

Al finalizar la ejecución de la acción el controlador redije la petición a la vista para que genere la página que se envía al navegador.

Acción: es la encargada de realizar la funcionalidad deseada para lo cual hará uso de la lógica de negocio o servicios que estime oportunos. En el caso de que se trate de operaciones de búsqueda creará un array con los objetos a enviar a la vista; y en general toda la información que ésta necesite.

Vista: es la encargada de generar la página HTML que se envía al navegador del cliente. Recibe la información de la acción y procede a mostrarla en la página. En ningún caso accede a la lógica de negocio o realizar alguna acción que no sea, por así decirlo, «pintar» datos. Esta parte se implementa con una JSP.

Organización y flujo de ejecución

Una vez que se han descrito los elementos de la estructura vamos a colocar cada uno de ellos y a establecer el flujo de ejecución; lo que también servirá para conocerlos.

Partamos, por ejemplo, de una página web que tiene un enlace para mostrar el listado de artículos de una tienda:

http://localhost:8080/aplicacion/ServletControl?ID_ACCION=LISTAR_ARTICULOS

Como se puede observar en dicho enlace aparecen dos elementos fundamentales, el servlet (ServletControl) y el parámetro que identifica la acción a ejecutar (ID_ACCION).

Cuando dicha petición llega al servlet este debe recuperar el objeto que se corresponde con la acción solicitada, ejecutarla y redijir a la JSP que generará la web a enviar al navegador.

Accion accion = (Accion) this.tablaAcciones.get(request.getParameter(«ID_ACCION»));

String jsp = accion.ejecutar(request, response);

this.getServletContext().getRequestDispatcher(jsp).forward(request,response);

Una vez que la petición llega a la JSP, ésta recupera los atributos que le pudieran haber pasado desde la acción y procede a generar la página HTML que se envía al navegador.

ArrayList<Item> items = (ArrayList<Item>) request.getAttribute(«LISTADO_ITEMS»);

Logotipo de Apache Axis 2

En esta entrada voy a explicar los pasos a seguir para crear un servicio web con Apache Axis2 y un cliente que lo utilice. La idea es implementar el típico HolaMundo pero a través de un servicio web. El cliente invocará el método que está en el servidor, el cual le devolverá el tan famoso «Hola Mundo!!».

Lo primero de todo es descargarse la versión de Axis2 adecuada (recomiendo los binarios). Esta es la página del proyecto.

Una vez que lo hemos descargado e instalado (en mi caso descomprimir) abrimos eclipse y configuramos Axis2. En Window->Preferences->Web Services->Axis2 Preferences ponemos la ruta hasta la instalación de Axis2, en mi caso C:\Archivos de programa\Axis\axis2-1.6.2

y en la misma ventana de preferencias seleccionamos «Server and Runtime» y en el campo «Web Service Runtime» seleccionamos el valor «Apache Axis2».

A continuación creamos un proyecto web (Dynamic Web Project), un paquete (edu.ucam.webservices) y una clase, HolaMundo, que hará de servicio. Dicha clase tendrá el método a invocar y cuyo código es:

public String diHola(){
 System.out.println("Voy a decir hola");
 return "Hola Mundo!!";
 }

El siguiente paso es crear y registrar el servicio. Para ello sobre la clase recién creada pulsamos botón derecho New -> Other -> Web Service

La primera pantalla debe quedar como la imagen anterior. Lo correcto sería selecciona «Top down» es decir crear la descripción del servicio (WSDL) y a partir de ella la clase, pero para facilitar el desarrollo lo hacemos al revés «Bottom up» (primero la clase y luego la descripción).

Seguimos todos los pasos del wizard. En uno de ellos nos pedirá arrancar el servidor (si no lo está).

A continuación abrimos un navegador y vamos a la dirección «http://localhost:8080/ServicioWebHolaMundo/axis2-web/» (sólo hay que cambiar la parte subrayada por el contexto que tengáis en vuestra aplicación)

Os aparece una página de inicio de Axis2 con un enlace que pone Services. Al navegar hacia el, aparece el listado de servicios web desplegados, debe aparecer HolaMundo. La ruta de ese enlace se corresponde con el wsdl del servicio web creado (lo copiamos en el porta papeles).

El penúltimo paso es generar el cliente (stub) del servicio web. El fichero que se genera contiene todos los elementos (clases) necesarios para invocar el servicio web desde la aplicación cliente; hace las veces de proxy. Botón derecho sobre la clase New -> Other -> Web Service Client.

En «Service definition» ponemos la url hacia el wsdl que hemos copiado del paso anterior: http://localhost:8080/ServicioWebHolaMundo/services/HolaMundo?wsdl

Sólo queda crear una clase cliente con el método main y el siguiente código para invocar el servicio web:

public static void main(String[] args) {
 try {
    //Se crea un objeto del proxy hacia el servicio web
    HolaMundoStub holaMundo = new HolaMundoStub();

    //Este objeto representa al parámetro.
    DiHola diHola = new DiHola();

    //Se invoca el método del servicio web y se obtiene la respuesta.
    DiHolaResponse respuesta = holaMundo.diHola(diHola);

    //Se muestra la respuesta.
    System.out.println(respuesta.get_return());
 } catch (AxisFault e) {
    e.printStackTrace(); 
 } catch (RemoteException e) {
    e.printStackTrace();
 }
 }

En ningún momento se crea un objeto de la clase HolaMundo, se instancia la clase que hace de proxy hacia el servicio web HolaMundoStub. Además se utilizan las clases que representan el método a invocar (DiHola) y la respuesta al mismo (DiHolaResponse).

En esta entrada, que es continuación de esta otra, vamos a crear un servlet utilizando una de las  herramientas que proporciona Eclipse. Evidentemente es importante conocer el concepto de Servlet antes de leerla.

Antes de implementar la clase que implementa el servlet vamos a crear un paquete que la contenga. Para ello…

Botón derecho sobre la carpeta src, New -> Package, introducimos el nombre «edu.ucam.servlets» y pulsamos «Finish». Ya tenemos el paquete que contendrá todos los servlets de nuestra aplicación. «Sólo» queda crear el servlet…

• Sobre el paquete que acabamos de crear, botón derecho, New -> Servlet

• Aparece la primera ventana del proceso de creación del servlet. Ponemos el nombre de la clase -MiPrimerServlet- y pulsamos «Next».

• Aparece una segunda ventana donde se introduce el mapeo de URL y servlet; es decir, desde que URLs se va a ejecutar. Por defecto en la sección «URL mappings» aparece «/MiPrimerServlet», que es el nombre de la clase. Nosotros pulsaremos en «Add…» para añadir el mapping «/MiServlet». Pulsamos en «Next».

• Llegamos a la última ventana del proceso de creación del servlet, donde se le indica a Eclipse los métodos que queremos sobreescribir (doPost, doGet, init, etc.). Dejamos marcado doGet y pulsamos en «Finish».

response.setContentType("text/html");

ServletOutputStream out = response.getOutputStream();

out.println("<html>");

out.println("<head><title>Hola Mundo</title></head>");

out.println("<body>");

out.println("<h1>Hola mundo!!!</h1>");

out.println("</body></html>");

Arrancamos el servidor (botón derecho sobre el proyecto, run as, run on server) y pegamos esta URL en el navegador: http://localhost:8080/miaplicacion/MiServlet. Si todo ha ido bien debe aparece un precioso «Hola mundo!!!» :-).

Para poder seguir esta entrada se necesita eclipse en su empaquetado IDE for Java EE Developers (http://www.eclipse.org/downloads/)

• Una vez descargado y desplegado arrancamos eclipse y si no lo está seleccionamos la vista J2EE.

• En el menú seleccionamos: File -> New -> Dynamic Web Project

• Aparece una primera ventana donde vamos a configurar dos parámetros: nombre del proyecto y el entorno de ejecución (es decir, Tomcat). Se resaltan los campos.

• El nombre del proyecto es evidente :-), le voy a poner «miaplicacion». Sólo hay que tener cuidado en una cosa. Si en el futuro no se cambia el nombre del contexto será el mismo que el del proyecto; por tanto, para acceder a la aplicación pondremos en el navegador http://localhost:8080/miaplicacion.
• Para configurar el entorno de ejecución hay que pulsar en «New Runtime…». Y aparece esta ventana

• Seleccionamos «Apache Tomcat v6.0» y pulsamos en «Next >»

• En la ventana que aparece (ver imagen superior) pulsamos en «Browse…», seleccionamos el directorio donde se encuentra desplegado Tomcat y pulsamos «Finish…».
• Volvemos a la pantanlla inicial donde pulsamos en «Finish…»

• El proyecto ya está creado. Aparece una pantalla como esta:

Desde este momento ya tenemos creado el proyecto y configurado un entorno de ejecución J2EE para que eclipse pueda levantar el servicio. ¿Qué nos falta? Darle al play

• Botón derecho sobre el proyecto, Run as -> Run on Server.  Aparece la siguente pantalla

• Si no lo está seleccionamos el entorno de ejecución creado anteriormente (Apache Tomcat v6.0)
• Pulsamos en «Finish»

Si todo ha ido correctamente el servidor arranca, se puede comprobar ya que aparece en la consola el texto «INFO: Server startup in X ms», pero en la página que se muestra en el navegador hay un error «Estado HTTP 404 – /miaplicacion/». Esto se debe a que no hay ninguna página HTML en el raíz del servidor. Vamos a crear un hola mundo web

Sobre la carpeta WebContent, botón derecho, New -> HTML file. Aparece una ventana donde se pide el nombre del fichero, ponemos «index» (la extensión la pone automáticamente eclipse). Pulsamos en «Finish».

Aparece el código de la página. Dentro de las etiquetas body ponemos el texot «Hola Mundo!!!». Guardamos el fichero.

Volvemos a la pestaña donde antes teníamos el error (se trata de un navegador integrado con eclipse) y pulsamos F5.

En estas apareció Swing para solucionar estos «problemas». ¿La clave? Utiliza Java 2D para invocar subrutinas de bajo nivel en vez de utilizar el módulo de interfaz de usuario de alto nivel del S.O. Es decir, el elemento es el mismo en cualquier plataforma.

Entrar en todos los detalles de una interfaz gráfica nos daría para escribir un libro. Es por eso que sólo quiero hacer una pequeña introducción a los aspectos básicos de la misma.

Tres elementos son los que podemos considerar como fundamentales:

• Componentes: elementos gráficos tales como botones, cuadros desplegables, cuadros de texto, etc.
• Contenedores: elementos que contienen otros componentes o contenedores, por ejemplo JPanel o JFrame.
• Layouts: diseño aplicable a los contenedores, es la forma de distribuir los componentes dentro del contenedor.

La diferencia entre contenedores y componentes es clara, unos contienen a otros. Pero… ¿que es eso del layout? Como su propio nombre indica es un diseño que se aplica a los contenedores. Es decir, nos echa una mano a la hora de colocar los componentes en los contenedores. Por ejemplo, si tenemos el diseño BorderLayout el contenedor se divide en cinco zonas (como se puede ver en la siguiente imagen):

De esta forma podemos indicar fácilmente que un botón u otro contenedor se incluya en la parte sur del contenedor principal. Existen varios tipos de layouts, y también existe la posibilidad de establecer a null el layout de un contenedor e indicar la posición donde colocar el componente.

Una implementación básica de una ventana podría ser un JFrame, que tiene un JPanel con un BorderLayout y este un JButton en el sur.

//Creamos el marco
 JFrame jFrame = new JFrame();

 //Creamos el panel principal
 JPanel jPanel = new JPanel();

 //Establecemos el layout del panel
 jPanel.setLayout(new BorderLayout());

 //Creamos un botón y lo añadimos al panel en el sur
 JButton jButton = new JButton("Aceptar");        
 jPanel.add(jButton,BorderLayout.SOUTH);

 //Establecemos el panel principal del marco
 jFrame.setContentPane(jPanel);

 //Cambiamos el tamaño y lo hacemos visible
 jFrame.setSize(200, 200);
 jFrame.setVisible(true);

Si se ejecuta el código anterior se obtiene el siguiente resultado:

Podemos encontrar una similitud entre los elementos que componen la ventana y un cuadro. El JFrame sería el marco, el JPanel sería el lienzo y el layout, con el resto de componentes, sería el dibujo en sí.

Aquí dejo la primera creación :-), tiene dos partes por la limitación de espacio en YouTube. ¿Críticas? Todas,  pero sobretodo la falta de calidad en la imagen. No me preocupa mucho en estos dos vídeos ya que están muy comentados y no es muy difícil seguirlos pero… no hay excusa. El próximo irá mejor.

Parte 1: http://www.youtube.com/watch?v=qMvALOI6G7Y

Parte 2: http://www.youtube.com/watch?v=Kwh_VpNZ2-E

También dejo el código fuente de la clase creada. De esta forma podéis verlo ya que en el vídeo queda borroso.  HolaMundo

Por ejemplo, en el formulario principal podemos tener un campo de texto para introducir el DNI y mostrar en el formulario detalle el listado de productos comprados por esa persona.

¿Y como se hace esto en Java? Muy sencillo. Creamos una serie de elementos gráficos que harán las veces de formulario principal (JTextField, JComboBox, etc.) e incluimos debajo de este una tabla donde aparecerán los distintos registros asociados a la búsqueda.

Como no podía ser de otro modo la clase que implementa en Java la tabla es JTable. Mucho hay escrito sobre el manejo de la misma (por ejemplo, aquí, aquí o aquí) por lo que sólo me voy a centrar en cómo «rellenarla» con datos.

Si le has echado un vistazo a los enlaces anteriores habrás visto que asociado al concepto de Tabla está el de Modelo de tabla (del inglés Table Model). Resumiendo, un modelo no es más que una manera de simplificar el acceso a contenido tabular (la típica tabla de datos). De esta manera la tabla queda independiente de la forma en la que se guardan los datos. Como se puede observar en la siguiente imagen JTable no tiene ni idea de la clase que implementa la interfaz TableModel. Lo único que le interesa es que alguien le proporcione los datos, y para ello invoca los métodos de la interfaz que estarán implementados en alguna de las subclases.

¿Qué vamos a hacer nosotros? Pues muy fácil, crear una subclase de DefaultTableModel y sobreescribir los métodos necesarios para que devuelva los datos que nosotros tenemos guardados en un ArrayList. La JTable invocará los métodos que necesite para mostrar los datos pero no se ejecutará la implementación de DefaultTableModel si no el código que nosotros hemos realizado. La estructura de clases quedará de la siguiente forma:

Para que el ejemplo quede un poco más «interesante» he creado una interfaz gráfica donde se muestra un JComboBox con un listado de clientes; de tal forma que al seleccionar uno de ellos se muestren las ventas realizadas por él. Para guardar el listado de ventas de cada cliente se ha utilizado una tabla hash donde cada entrada (identificada por el DNI) contiene un ArrayList con objetos de la clase Venta.

Una vez que sabemos donde guardar el listado de ventas de un cliente ya sólo nos queda mostrarlo en la tabla. Como se ha comentado anteriormente lo único que tenemos que hacer es sobreescribir una serie de métodos de DefaultTableModel en MiTableModel. Veamos cuales:

getColumnCount: nos devuelve el número de columnas del modelo. Ya que el listado de columnas está definido en el array nombreColumnas en la VentanaPrincipal, sólo tendremos que obtener el tamaño de este.

getColumnName(int column): nos devuelve el nombre de una columna. Para obtenerlo sólo tenemos que recuperar del array nombreColumnas el valor de la posición indicada por parámetro ‘column’.

getRowCount: devuelve el número de filas del modelo,  que en este caso se corresponden con el listado de ventas del cliente. Dicho listado se encuentra en la tabla hash listadoVentasCliente en la VentanaPrincipal.

getValueAt(int row, int column): devuelve el valor para una celda en concreto identificada por su fila y columna. La primera es la posición row dentro del listado de ventas del cliente y la segunda es el valor de uno de los atributos del objeto Venta.

isCellEditable: devuelve false siempre. Esto hace que la celda no sea editable.

El código comentado de la clase MiTableModel se encuentra dentro del proyecto Eclipse que os dejo en Rellenar Tabla.

La estructura de clases ha quedado de la siguiente forma.

He utilizado la versión 1.6 de Java.

Pero… si la declaración del método addItem nos indica que podemos pasar por parámetro un objeto de la clase Object (o una subclase de esta, como String), ¿por qué no pasar un objeto de una clase creada por nosotros y, de esta forma, utilizar un JComboBox de forma similar a un Vector, como una colección de objetos?

Por ejemplo, pensemos que tenemos una aplicación que gestiona productos de cualquier tipo y queremos que al seleccionar un producto obtengamos los datos de dicho producto para mostrarlos por pantalla. Lo interesante sería guardar los objetos de la clase Producto dentro de combo y seleccionar el deseado.

La forma de actuar es sencilla… añadir los objetos de Producto en el combo.

Producto producto = new Producto(parámetros);

JComboBox jcb = new JComboBox();

jcb.addItem(producto);

y, cuando lo necesitemos, recuperar el producto seleccionado

Producto productoSeleccionado = (Producto) jcb.getSelectedItem();

Hasta aquí todo correcto pero… al cargar el listado de objetos en el combo vemos que el titulo mostrado es similar a este: ‘paquete1.paquete2.Producto@idDelObjeto’. Y surge la duda: ¿podemos cambiar el texto mostrado? Evidentemente la respuesta es sí. Lo único que hay que hacer es sobreescribir en la clase Producto el método toString de Object. Recordemos que esta clase es de la que heredan de manera implícita todas las clases en Java. Por tanto, sólo tendremos que añadir este método en Producto:

public String toString(){

return «nuevo texto»;

}

clave1 = valor1

clave2 = valor2

….

Veámos como podemos acceder fácilmente a cada uno de esos valores.

(Supongo que ya tenemos creado en Eclipse un proyecto Java)

1. Creamos en la raíz del proyecto el fichero de propiedades «ficheroPropiedades.properties».
2. Rellenamos este con los valores que se desee, por ejemplo nombre=Miguel Ángel Guillén.
3. Creamos una nueva clase FicheroPropiedades dentro del paquete ucam.clase4
4. Dentro del método «main» destacamos el siguiente código

//Nombre del fichero que contiene las propiedades.

String nombreFichero = «ficheroPropiedades.properties»;

//Objeto de la clase Properties donde se carga el listado de propiedades que hay en el fichero de propiedades.

Properties prop = new Properties();

//Se cargan las propiedades en el objeto ‘prop’. Como el método ‘load’ espera un objeto de una clase que herede de  InputStream utilizamos FileInputStream. De esta forma se puede leer del fichero ya que FileInputStream se encarga de ello.

prop.load(new FileInputStream(nombreFichero));

//Recuperamos el valor de la propiedad ‘nombre’ y lo mostramos por la salida estándar.

System.out.println(«Propiedad: «+prop.getProperty(«nombre»));

Al ejecutar este código se mostrará por pantalla el texto «Miguel Ángel Guillén», que es el valor de propiedad «nombre».

Adjunto un zip que incluye el proyecto Eclipse con el código de esta entrada (Workspace Properties).

La respuesta sería no siempre y cuando se hiciera lo propio con otros servicios, por ejemplo los seiscientos y pico consejeros del presidente, los ministerios de desigualdad y política territorial, el sueldo de sus señorías, … y un largo etcétera al que todos podríamos añadir algo.

Desde otro punto de vista, se puede argumentar que el gasto en I+D hay que mantenerlo en tiempos de crisis como caldo de cultivo para salir de ella. Yo me inclino más hacia esta postura, aunque tendría que haber un listado de proyectos subvencionados en el que se incluya el gasto y los resultados obtenidos; así como una dirección de correo electrónico para poder pedirles explicaciones si se han gastado mi dinero en algo ridículo. No está la cosa para ir tirando el dinero.

En fin… que si ZP no se recorta el sueldo y tampoco se quita consejeros lo menos que podría hacer es mantener el gasto en I+D para intentar salir de la crisis con nuevas iniciativas y no sólo pagando reformas de parques y jardines.