Monthly Archives: March 2009

Principios de Programacion – Encapsulacion

Published / by Renan Huanca / 3 Comments on Principios de Programacion – Encapsulacion

Nota preliminar
El presente articulo es resultado de la lectura del libro First Head Design Patterns. Después de haber leído un poco el libro y haber aplicado algunos conceptos, veo que es importante compartir estos principios para lograr que el trabajo que realizamos los desarrolladores sea mas fácil y mas efectivo. 🙂

Introducción

A lo largo del desarrollo de una aplicación el 99.99% de las veces nos vemos obligados a modificar lo que ya habíamos definido.

El la vida real, las razones son muchísimas, pero acá listo algunas genéricas:

  • Nuestro cliente nos pide una modificación por que alguna circunstancia cambio.
  • Nos damos cuenta que lo que definimos no estaba bien.
  • Encontramos un punto de mejora.

Entonces podemos concluir que solo hay una constante en el transcurso de la fase de desarrollo:

CAMBIO

Encapsulación

Para afrontar este reto solo tenemos la opción de en lo posible discernir que partes de nuestra aplicación cambien mas y cuales no.


Principio de Diseño

Identificar los aspectos de tu aplicación que pueden cambiar y separarlos de aquellos que no.
(fuente: Head First Desing Patterns – Intro to Design Patterns)

Osea, si vemos que hay aspectos de una aplicación que cambiaran muy frecuentemente, por decirlo así por cada con cada requerimiento del cliente entonces tenemos que separar ese aspecto de los demás y encapsularlo para que después podamos modificarlo sin afectar al resto de la aplicación.

Es ahí donde nacen los Patrones de diseño, y si me permiten decirlo fue uno de los grandes aportes de la Programación Orientada a Objectos y Java.

Un ejemplo

Uno de los ejemplos mas claros que encontré fue el patrón Modelo Vista Controlador.

El patrón MVC (en su abreviación en ingles), nos permite separar la lógica de control de los datos y de la vista.

Revisemos paso a paso que es cada elemento:

Vista, es el elemento que se encarga de desplegar datos. generalmente en el mundo java son jsps.
Controlador, es el elemento encargado de recibir los pedidos hechos por la vista y ejecutar o llamar a algun metodo para procesar la información enviada.
Modelo, es el encargado de manejar la información al nivel de la base de datos.

Este problema fue resuelto muchísimas veces. la mas básica siempre fue con servlets. Denle un vistazo a este ejemplo de MVC usando servlets.

Extraje una porción del código para poder ser explicado.

(fuente: Arquitectura MVC : El Controlador)

private void 	procesarPeticion(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
	String url = request.getRequestURI();
	String accion = null;
	// no siempre voy a recibir una accion por lo que hay que prevenir errores
	if(url.contains(".accion")){
		accion = url.substring(url.lastIndexOf("/") + 1 , url.indexOf(".accion"));
	}else{
		accion = "inicio";
	}
	if("Estadistica".equals(accion)){
		// Si quiero mostrar las estadisticas:
		Estadistica es = new Estadistica();
		es.mostrarEstadisticas(request, response);

	}else if("Guardar".equals(accion)){
		// Si quiero guardar una opinion
		EncuestaAccion ea = new EncuestaAccion();
		ea.recogeDatos(request, response);
	}else{
		// Si no, dirijo al índice
		Inicio i = new Inicio();
		i.muestraIndex(request, response);
	}
}

Como notaran en el código, se tiene un método llamado procesarPeticion. En el cual hay una secuencia de sentencias if para definir que porción de código ejecutar.

Que es lo que cambia? Lo que cambia son las porciones de codigo dentro de las sentencias if.

Que es lo que no cambia? Lo que no cambia son las sentencias if, claro cambiara un poco el string que que compara, pero por lo general esta estructura se mantienen siempre en cualquier servlet que este implementando MVC.

Que es lo que se separa con la encapsulacion? Lo que se separa sera sencilla y simplemente las sentencias if.

Para que separamos lo que no cambia? Separamos para que el resto del código se pueda modificar sin afectar el resto. Es decir queremos la habilidad de solamente escribir código que realizar las operaciones necesarias sin afectar el código que esta alrededor o aumentar ilegibilidad.

Como se aplica la Encapsulación?

Es acá donde se aplica este principio de identificar los aspectos que cambian y separarlos de los que no.

Y en esta tarea uno de los primeros frameworks que tuvo éxito fue Struts.

Struts Abstrajo el aspecto que siempre se repite, que es el de ejecutar una porción de código basado en un parámetro, lo encapsulo y nos dejo a los desarrolladores la parte que cambia.

Lamentablemente no pude encontrar un ejemplo de struts en español, pero encontré un en ingles que habla del DistpatchAction.

Acá un ejemplo de código de como seria la anterior sevlet usando el DistpatchAction de struts.


public class EncuestaAction extends DispatchAction
{

	public ActionForward estadistica(
	ActionMapping mapping,
	ActionForm form,
	HttpServletRequest request,
	HttpServletResponse response) throws Exception{
		System.out.println("You are in add function.");
		// Si quiero mostrar las estadisticas:
		Estadistica es = new Estadistica();
		es.mostrarEstadisticas(request, response);
	}

	public ActionForward Guardar(
	ActionMapping mapping,
	ActionForm form,
	HttpServletRequest request,
	HttpServletResponse response) throws Exception
	{
		// Si quiero guardar una opinion
		EncuestaAccion ea = new EncuestaAccion();
		ea.recogeDatos(request, response);
	}
} 

Esto es lo que se gana con la encapsulacion:

  • Código mas legible
  • Se definen metodos para las operaciones que se necesitan.
  • Ya no nos preocupamos de mantener instrucciones if y mantener casos especiales

De esta forma, Struts a encapsulado lo que cambia en favor de permitirnos modificar y adicionar métodos solo para lo que necesitamos. Si usáramos la servlet cualquier modificación afectaría a lo que esta alrededor de esta. Imagínate manejar excepciones. Seria un caos. tendría que decidir si colocar un try catch dentro de cada porción de código que necesita o talvez uno global y luego manejar casos especiales.

Si tienen comentarios o creen que falta mejorar los ejemplo por favor conocer. 🙂

Acá les dejo unos links para consulta adicional:

Como Instalar PHPJavaBride (Hola Mundo PHP-Java-Bridge)

Published / by Renan Huanca / 14 Comments on Como Instalar PHPJavaBride (Hola Mundo PHP-Java-Bridge)

Introducción

Vamos a realizar una instalación básica del PHPJavaBridge, y a la vez llamar a una clase java que haga un Hola Mundo.

Pre requisitos

1. ApacheTomcat 5.5+
2. PHP y Apache instalados – phpinfo() corriendo.

Bajar PHP-Java-Bridge e instalar en Tomcat

Se lo puede bajar de http://php-java-bridge.sourceforge.net/pjb/download.php (Ojo si por ahí a cambiado el url hacer un google download phpjavabridge). Generalmente yo bajo el paquete binario.

Una vez en el sitio de download bajamos el archivo php-java-bridge_5.x.x_documentation.zip. Bajamos este por que esta mas completo aunque en este instante solo necesitamos el war file.

Descomprimimos el archivo y dentro de este encontraremos el archivo JavaBridge.war.

Copiamos JavaBridge.war al directorio webapps de tomcat.

A veces si uno esta en linux, cuando se levanta el tomcat, no se descomprime automáticamente el war. En este caso hechos mano del root user y descomprimimos manualmente el war file, convirtiéndolo primero a zip y luego descomprimir con el comando unzip JavaBridge.zip -d JavaBridge.

Ok, ahora levantamos el tomcat y nos vamos a la pagina http://localhost:8080/JavaBridge/test.php.

Si todo va bien, aparecerá la pagina de información de php que es generado por el método phpinfo() .

Enlace con servidor Apache http

Creamos el enlace con el siguiente comando:

ln -s /opt/apache-tomcat-5.5.27/webapps/JavaBridge /var/www/JavaBridge

Como verán, creamos un link a la carpeta donde se encuentra el JavaBridge dentro de tomcat en la carpeta principal de apache.

Ahora vamos al browser y abrimos: http://localhost/JavaBridge/test.php. Una vez mas, si to va bien aparece la pagina de información de php.

Hola Mundo desde java

public class HelloWorld {
    public String sayHello(){
        return "Hello World";
    }
}

Creamos la clase anterior, la compilamos y la copiamos la clase compilada a un folder dentro de /var/www. puede ser algo como testjava.

Java dice Hola a PHP 🙂

Ahora con el php 🙂


sayHello()
?>

require_once, nos permite conectarnos con el java bridge.

java_require, nos permite definir el classpath. Aqui tenemos que declarar los paths donde se encuentran nuestras clases y librerias en jar.

new Java(), nos permite instanciar una clase java.

Y al final llamamos al método sayHello() que nos devuelve un string que luego es impreso por la funcion echo de php.

Bueno hasta aqui por hoy. Hasta la proxima. 🙂

Reporte maestro-detalle usando JRXMLDatasource de JasperReports 3.1.2

Published / by Renan Huanca

Introducción

Este es un ejemplo de como realizar un reporte maestro detalle usando JasperReports.
Vamos a generar un simple pdf con el detalle de una factura(Invoice).
También pueden ver Como usar el JRXmlDataSource de JasperReports 3.1.2, para una introducción al JRXmlDataSource.

Archivo XML de datos

bueno, esta es la parte mas simple. 🙂

(invoice.xml)




    BP-0123
    03/01/2009
    ACME INC
    BP102USA
    
        
            Iphone 6000G
            12
            4000
        
        
            Lenovo T61P
            5
            7000
        
        
            Xbox 123
            2
            1000
        
        
            GOLDPATH 1
            4
            400
        
    

Como verán, solo definimos datos como, nombre del cliente y el detalle de los productos.

Creación de diseños invoice.jrxml y invoice-detail.jrxml

Tanto los diseños del reporte maestro y detalle son los mismos. Como el de detalle es el mas simple lo listare primero y luego el maestro.

(invoice-detail.jrxml)





	
	

	
		
	
	
		
	
	
		
	

	
		
	
		
			
			
		
		
			<band height="0"  isSplitAllowed="true" >
			</band>
		
		
			
			
		
		
			
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
			
		
		
			
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
			
		
		
			
			
		
		
			
			
		
		
			
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
			
		

Como veran, se definen tres campos para los productos: name, quantity y amount, luego estos campos son desplegados en el área de detalle del reporte.

Ademas tambien estamos declarando una variable llamada totalAmount, que nos sirve calcular el total de la factura.

(invoice.jrxml)





	
	

	

	
		
	
	
		
	
	
		
	
	
		
	

		
			
			
		
		
			<band height="0"  isSplitAllowed="true" >
			</band>
		
		
			
				
					
					
					
						
					
				
				
			
		
		
			
			
		
		
			
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
					
						
					
				
				
				
					
					
                    
				
			
		
		
			
			
		
		
			
			
		
		
			
			
		

Acá es donde se pone un poco confuso 🙂 Donde tenemos que poner nuestra atención es en el elemento subreport. Este elemento también puede ser creado usando el iReport.

reportElement, define la posición donde se encontrara el subreporte.

dataSourceExpression, en la expresion estamos indicando que vamos a usar el un sub data source, del data source principal del reporte.
“detailPath”, es una xpath que indicara la fuente de datos del subreporte.

subreportExpression, contiene la localización del diseño compilado del reporte de detalle, en consecuencia este es el path de un archivo .jasper.

Java

package bo.sumasoftware.hellojasperreports;

import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.engine.data.JRXmlDataSource;

import java.util.HashMap;

/**
 * @author renan
 */
public class WriteInvoiceBasic {
    public static void main(String[] args) throws JRException {
        JasperCompileManager.
                compileReportToFile( "src/main/jrxml/invoice.jrxml","invoice.jasper");
        JasperCompileManager.
                compileReportToFile( "src/main/jrxml/invoice-detail.jrxml","invoice-detail.jasper");

        JasperReport master = (JasperReport)JRLoader.loadObject("invoice.jasper");
        JRXmlDataSource xmlDataSource = new JRXmlDataSource("src/main/xml/invoice.xml", "/invoice");
        HashMap hashMap = new HashMap();
        hashMap.put("detailPath","/invoice/products/product");
        JasperPrint jasperPrint = JasperFillManager.fillReport(master, hashMap, xmlDataSource);
        JasperExportManager.exportReportToPdfFile(jasperPrint, "invoice-basic.pdf");
    }
}

Compilación de los reportes. Como veran lo primero que hacemos es compilar los reportes maestro y detalle. al compilar estamos creando los respectivos archivos .jasper de cada reporte.
Hacemos esto, ya que en el reporte maestro se necesita pasar un archivo .jasper.

Cargando reporte maestro. Para realizar esto estamos usando la clase JRLoader y su método loadObject para leer el reporte maestro cmpilado invoice.jasper.

Creacion de JRXMLDataSource. Al crear este objeto, le pasamos como parámetro el archivo xml de datos y también una expresión xpath que indica el nodo raiz de datos para el reporte principal.

Definición de parámetros. En un HashMap estamos definiendo un parámetro llamado “detailPath”. detailPath indica contiene una expresión xpath que indica el data source del subreporte.
Esta es la parte importe. Si nos equivocamos en definir este parámetro el subreporte simplemente no mostrar información.
También tenemos que hacer notar que este es un parámetro definido en el diseño del reporte maestro y se hace referencia a este en el elemento dataSourceExpression.

Impresión del reporte. Acá ya solo se llena el reporte y luego se lo imprime en un archivo pdf.

🙂 bueno, hasta aquí por hoy. 🙂
pueden bajar el código fuente. Este es un poco diferente pero tiene dos ejemplos, uno básico y otro mas completo.

ShowModalDialog en Firefox

Published / by Renan Huanca / Leave a Comment

Este post es muy simple. 🙂

Lo bueno de firefox 3 fue que ya tiene soporte para el uso del método showModalDialog, que es una implementacion original Internet Explorer.

En fin la forma mas fácil de usar es la siguiente:

window.showModalDialog(url, “”, “toolbar:0; dialogWidth:1024px; dialogHeight:800px; status:0; resizable=1;”);

El primer parámetro es el url de la pagina que queremos abrir.

El segundo argumento es un objeto, en el cual se le pueden pasar parámetros, es decir, podríamos pasar un objeto string o json que tenga mas información :). En el ejemplo le estamos pasando un string vacio.

El tercer argumento se utiliza para indicar como se va a comportar la ventana. Es decir alto, ancho, si va o no tener barra de menus, etc.

Mas detalle lo pueden encontrar en el sitio msdn de microsoft 🙂

Hasta la próxima.

Como instalar Java JDK 1.6 en Ubuntu 8.10

Published / by Renan Huanca / 9 Comments on Como instalar Java JDK 1.6 en Ubuntu 8.10

Hola amigos,

Este tutorial lo hago para un amigo que necesita instalar el jdk java en
ubuntu.

Como notaran es un poco largo el proceso, pero gracias a los amigos de javamexico.org, vi que ubuntu ya tiene un paquete listo para instalar usundo su package manager.

El comando para instalar java es:

$ sudo apt-get install sun-java6-jdk

Lo bueno de ubuntu es que la tiene paquetes para cosas como flash y otros paquetes que no son fáciles de instalar en otras distribuciones.

Para alguno que desee probar el camino largo acá lo tienen 🙂

1. Bajar el JDK java 1.6 del sitio de Sun. http://java.sun.com/javase/downloads/index.jsp

2. Seleccionar la Java SE Development Kit (JDK)

3. Esto nos lleva a una pagina, done nos permite seleccionar el sistema operativo, por lo general yo solo selecciono Linux :).

4. Luego nos pasara a una pagina donde nos muestra los paquetes disponibles. Yo selecciono jdk-6u12-linux-i586.bin, ya que esta versión es un paquete parecido a un tar.gz.

5. Una vez ejecutado el archivo recién bajado, este nos extraerá una carpeta con el nombre jdk1.6.0_12.

6. Movemos la carpeta jdk1.6.0_12 al folder /usr/local, que es la carpeta estándar para los programas tipo gui o consola. si tienen problemas en copiar el jdk a la carpeta /usr/local, pueden llamar al nautilus con el comando

sudo nautilus

De esta forma podran acceder a la carpeta /usr/local.

7. Vamos a proceder a adicionar la variable JAVA_HOME al sistema. Para eso editamos el archivo bash.bashrc con el siguiente comando:

sudo vi /etc/bash.bashrc

Al final del archivo colocamos las siguientes instrucciones.

export JAVA_HOME=/usr/local/jdk1.6.0_12
export PATH=$JAVA_HOME/bin:$PATH

Con esto nos aseguramos que la variable JAVA_HOME siempre estara disponible en el sistema.

8. Abrimos una consola nueva y ejecutamos el comando:

java -version

El cual nos arrogara el siguiente resultado:

java version “1.6.0_12”
Java(TM) SE Runtime Environment (build 1.6.0_12-b04)
Java HotSpot(TM) Server VM (build 11.2-b01, mixed mode)

Si no funciona 🙁 bueno entonces abra que echar mano de los permisos de linux. Aca la secuencia de comandos que utilice.

sudo chmod 777 /usr/local/jdk1.6.0_12
sudo chmod -R 666 /usr/local/jdk1.6.0_12
sudo chmod 777 /usr/local/jdk1.6.0_12/bin
sudo chmod 777 /usr/local/jdk1.6.0_12/db
sudo chmod 777 /usr/local/jdk1.6.0_12/demo
sudo chmod 777 /usr/local/jdk1.6.0_12/include
sudo chmod 777 /usr/local/jdk1.6.0_12/jre

sudo chmod 777 /usr/local/jdk1.6.0_12/jre
sudo chmod 777 /usr/local/jdk1.6.0_12/lib
sudo chmod 777 /usr/local/jdk1.6.0_12/man
sudo chmod 777 /usr/local/jdk1.6.0_12/sample

sudo chmod 777 /usr/local/jdk1.6.0_12/bin/*

Como verán estoy colocando permiso 777 a todas las carpetas (ojo solo carpetas) :). Tambien se esta colocando 777 a los archivos dentro de bin. el resto esta con permiso 666.

Eso seria todo. Hasta la próxima 🙂

Como usar el JRXmlDataSource de JasperReports 3.1.2 (Hola Mundo JRXmlDataSource)

Published / by Renan Huanca / 1 Comment on Como usar el JRXmlDataSource de JasperReports 3.1.2 (Hola Mundo JRXmlDataSource)

Introducción

Este articulo muestra como usar utilizar el JRXmlDataSource de jasperReports.
Como fuente de datos usaremos un archivo XML y la salida sera un archivo PDF.
Para los que quieren una introducción acerca del archivo de definición de reporte, pueden ver: Comenzando con JasperReports (de David R. Heffelfinger) – Traducción

Definiendo el archivo de datos.

Lo nombraremos data.xml y tendrá el siguiente contendido.



    
        Carlos
        Rodrigues
        34
        12345678
    
    
        Esteban
        Arce
        21
        00000001
    
    
        Milton
        Laura
        50
        12003001
    
    
        Luis
        Pimentel
        45
        11004011
    

Creamos el archivo de definición del reporte.(helloJasperReportXML.jrxml)

Este archivo lo genere con la herramienta iReport. le quite la mayoría de los tags y lo deje con lo mas esencial para explicarlo.



    
        
    
    
        
    
    
        
    
    
        
    
    
        
            
                
                
                
            
            
                
                
                
            
            
                
                
                
            
            
                
                
                
            
        
    

<field>, Define un campo que sera usado en el reporte. En este caso estamos definiendo 4 fields: FIRST_NAME, LAST_NAME, AGE y ID. Como verán, dentro de cada <field> hay un elemento <fieldDescription> este es como un mapa entre el field que sera usado en el reporte y el origen de datos. En Esta caso el origen de datos esta dado por el nombre del tag que corresponde en el archivo data.xml.
Importante: Para obtener los datos estamos usando en este caso XPATH, si quisieremos sacar una propiedad tendriamos que usar algo como @firstName

<textField>, este elemento se usa para, definir en que posición del reporte se desplegara un campo. Como verán tiene tres sub elementos: <reportelement>, que define la posición, <textElement>, que indica es es un campo texto y <textFieldExpression>, que indica de que field viene la informacion.

Creamos la clase HelloXMLJasperReport.

package bo.sumasoftware.hellojasper;
import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.data.JRXmlDataSource;
import java.util.HashMap;

/**
 * @author renan
 * @since Mar 11, 2009 4:39:00 PM
 */
public class HelloXMLJasperReport {
    public static void main(String args[]) throws Exception {
        JasperReport jasperReport = JasperCompileManager.compileReport("src/main/resources/helloHasperXML.jrxml");
        JRXmlDataSource xmlDataSource = new JRXmlDataSource("src/main/resources/data.xml","users//user");
        JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap(), xmlDataSource);
        JasperExportManager.exportReportToPdfFile(jasperPrint, "report_from_xml.pdf");
    }
}

JasperCompileManager, nos permite crear una instancia de JasperReport que viene de compila nuestro archivo de definición de reporte, como verán se le pasa la ruta del mencionado archivo. Generalmente si no definiste bien los fields, te dará un error acá.

JRXmlDataSource, al crear la instancia le estamos pasando dos parámetros: path, que es el camino de nuestro archivo de datos y una expresión xpath, que indica de que parte del archivo xml se extraerá la información. En este caso con “users//user”, estamos indicando que recogeremos todos los elementos user que estan dentro del elemento users.

JRXmlDataSource, nos permite pasar pasar el DataSource y algunos parámetros antes de imprimirlo.

JasperExportManager, finalmente nos ayuda a imprimir el reporte en un archivo pdf…. 🙂 fuiiiu fue largo el caminio.

Nota para los usuarios de iReport, si quieres usar esta herramienta para visualizar el reporte, tendrás que adicionar:


	
 

como primer elemento hijo del tag <jasperReport≶ y una conexión XML referenciando al archivo data.xml. Con querySring, indicamos de donde se obtendrá la información.

También comparto el código fuente :), que también tiene aparte un ejemplo con base de datos.

Hasta la próxima :), si tienes comentarios no duden en hacerlos.

Comenzando con JasperReports (de David R. Heffelfinger) – Traducción

Published / by Renan Huanca / Leave a Comment

Nota preliminar: Este articulo es la traducción de un buen articulo que encontré para comenzar con JasperReports.

El articulo original se encuentra en Getting Started With JasperReports

Comenzando con JasperReport (de: David R. Heffelfinger)

Recientemente estuve buscando herramientas de reporting para un proyecto en la que pronto trabajare. Una de las herramientas que estaba viendo fue JasperReports. JasperReports es librería open source (LGPL) muy popular para realizar reportes escrito en java. Infortunadamente no esta muy bien documentado y yo tuve un tiempo muy difícil en hacer un simple reporte. Después de alguna investigación, finalmente fui capaz de generar un simple reporte, este articulo resume que se necesita hacer para comenzar con JasperReports. Vean Recursos para mas información en como encontrar información adicional y documentación acerca de JasperReports.

Comenzando

Los reportes de JasperReports son definidos en archivos xml, los cuales por convención tienen la extensión jrxml. Un típico archivo jrxml contiene los siguientes elementos:

<jasperReport>– El elemento raíz.

<title>– Su contenido se imprime una sola vez al comienzo del reporte.

<pageHeader>– Su contenido se imprime al comienzo de cada pagina en el reporte.

<detail>– contiene el cuerpo del reporte.

<pageFooter>– su contenido se imprime al pie de cada pagina en el reporte.

<band>– define una sección de reporte, todos los elementos de arriba contienen un elemento band como su único elemento hijo.

Todos los elementos son opcionales, excepto por el elemento raiz jasperReport, Aqui esta un ejemplo de un archivo jrxml.





 
    
      
        
        
      
    
  

Para este ejemplo simple, yo omití los elementos opcionales <title>, <pageHeader> y <pageFooter>. El elemento <staticText>, no sorprendentemente, muestra texto estático en el reporte, como se puede ver, este contiene un simple elemento <text> definiendo el texto que sera desplegado.

El archivo jrxml necesita ser “compilado” a un formato binario especifico de JasperReports, esto puede ser conseguido llamando al método compileReport() de la clase net.sf.jasperreports.engine.JasperCompileManager. Hay muchas versiones sobrecargadas de este método, en nuestro ejemplo, nosotros usaremos el que toma un simple parámetro String, consulte la documentacion para mas detalles de otras versiones del metodo.

public class JasperReportsIntro
{
  public static void main(String[] args)
  {
    JasperReport jasperReport;
    JasperPrint jasperPrint;
    try
    {
      jasperReport = JasperCompileManager.compileReport(
          "reports/jasperreports_demo.jrxml");
      jasperPrint = JasperFillManager.fillReport(
          jasperReport, new HashMap(), new JREmptyDataSource());
      JasperExportManager.exportReportToPdfFile(
          jasperPrint, "reports/simple_report.pdf");
    }
    catch (JRException e)
    {
      e.printStackTrace();
    }
  }
}

Un archivo jrxml necesita ser compilado solo una vez, pero para este ejemplo este es compilado cada vez que la aplicación es ejecutada. Antes de que un reporte sea generado, este necesita ser “llenado” con información, esto es conseguido callando al método fillReport() de la clase net.sf.jasperreports.engine.JasperFillManager, aquí vamos a usar uno que recibe tres parámetros, una instancia de net.sf.jasperreports.engine.JasperReport, una java.util.HashMap conteniendo cualquier parámetro pasado al reporte, y una instancia de una clase que implementa la interface net.sf.jasperreports.engine.JRDataSource. La linea que consigue nuestro ejemplo de arriba es

jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap(), new JREmptyDataSource());

Ya que nuestro simple reporte no toma parametros, le pasamos un HashMap vacio como segundo parametro, y una instancia de net.sf.jasperreports.engine.JREmptyDataSource como tercer parametro.

JREmptyDataSource es una clase muy conveniente incluida en JasperReports, este es básicamente un DataSource sin información.

Finalmente, en nuestro ejemplo, nosotros exportamos el reporte a un archivo PDF, de esta manera este puede ser leido por Adobe Acrobat, XPF, Evince, o cualquier otro lector de PDF, la linea que realiza este ejemplo es

JasperExportManager.exportReportToPdfFile(jasperPrint, “reports/simple_report.pdf”);

Los parámetros se explican por si mismos.

Conclusión

JasperReports una maquina de reportes open source muy popular, esta guía provee suficiente información para comenzar con JasperReports. Para información adicional por favor vean mi libro JasperReports For Java Developers.

Recursos

Displaying JasperReports PDF Reports on the Browser
Creating Database Reports With JasperReports
JasperReports’ Web Site
JasperReports For Java Developers – un Libro de JasperReports escrito por el autor de este articulo – David R. Heffelfinger

Como activar el wireless (wifi) en una laptop Lenovo T61p y CentOS 5.1

Published / by Renan Huanca / Leave a Comment

Hola amigos,

Este fin de semana me estoy dedicando a reinstalar mi laptop Lenovo T61p con CentOS 5.1

Aca les comparto los pasos que realize para activar mi wireless

1. Verifique que mi targeta wireless es del tipo intel-wireless-4965-(ag/agn), eso lo hice de la forma mas inocente 🙂 Me fui al menu system > administration > network y adicione de forma manual mi tarjeta wireless, claro no funciono, pero por lo menos averigue el modelo de mi tarjeta wireless

2. Bueno buscando y rebuscando en internet entonces encontre el siguinete link 🙂

Intel Pro Wireless 4965 (iwl4965 and iwlagn

Hasta la proxima 🙂

Como usar el MultiActionController de Spring 2.5

Published / by Renan Huanca / 20 Comments on Como usar el MultiActionController de Spring 2.5

Hola spring adictos,

Esta vez les mostrare un pequeño ejemplo de como usar el MultiActionController de Spring 2.5

Descripción del ejemplo

Bueno, esta pequeña aplicación lo único que hace es mostrar un formulario con un solo campo que corresponde al nombre de una mascota. Cada vez que se hace submit del nombre de la mascota, esta se adiciona a una lista en session llamada pets (no recomiendo usar variables en session). Luego esta lista se va desplegando en la parte inferior del formulario.

Para este ejemplo voy a asumir que ya tienen las librerías de spring y también configurado en el archivo web.xml de tu aplicación.

A  grandes rasgos lo que vamos a hacer es lo siguiente:

  • Creamos el bean Pet (solo para los propósitos de este ejemplo)
  • Crear y declarar PetController en el contexto de spring.
  • Crear el view JSP y declararlos en el contexto de spring.
  • Probar la funcionalidad.

Creamos el bean Pet (solo para los propósitos de este ejemplo)

package bo.sumasoftware.hellospring;
/**
 * @author renan
 */
public class Pet {
    String name;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Este bean, es solo para nuestro ejemplo y solo tiene una propiedad llamada name con su respectivo get y set. Se utilizara para leer datos del formulario y tambien para desplegar.

Crear y declarar PetController en el contexto de spring.

package bo.sumasoftware.hellospring;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.ArrayList;

/**
 * @author renan
 */
public class PetController extends MultiActionController {
    /**
     * This is called form http://localhost:8080/<context>/pet.do?method=form
     *
     * @param request
     * @param response
     * @param pet
     * @return
     */
    public ModelAndView form(HttpServletRequest request, HttpServletResponse response, Pet pet) {
        if(pet.getName()!=null){
            List pets = (List) request.getSession().getAttribute("pets");
            if(pets == null) {
                pets = new ArrayList();
                request.getSession().setAttribute("pets",pets);
            }
            pets.add(pet);
        }
        ModelAndView mav = new ModelAndView("pet");
        mav.getModel().put("pet", new Pet());
        return mav;
    }
}

Fuiu, es un poco largo la clase no? 🙂  pero ni modo, lo mas importante es que que estamos declarando un método con el nombre form, por si acaso esto no es un nombre especial ni nada por el estilo, puede ser cualquier nombre que ustedes definan. Lo importante es saber solo usando este nombre se podrá llamar a este método desde url o formulario.

pet, es el nombre del beanForm o commandName como se lo llama en spring. Es en este objeto que spring colocar los valores de los import del html from que viene del browser. Algo también interesante es que no es requerido definir este parámetro, también se puede colocar otros, mas información en http://static.springframework.org/spring/docs/2.0.x/reference/mvc.html#mvc-controller-multiaction.

pets, es la lista que desplegaremos en el jsp, lo interesante es que se hace proceso para crearla si no esta en session.

new ModelAndView(“pet”), de esta forma le decimos a spring a que view queremos que direccione la salida del controller.

ahora veremos como se define el controller en el contexto de spring


	
		
			
		
	


/pet.do,  es la forma de mapear la llamada desde un url. Cabe señalar que esta forma de mapeo es una de las mas basicas, spring tienes algunas como por ejemplo basado en archivo xml y tambien archivo de propiedades. ParameterMethodNameResolver, este es el que me interesa mas, con esto le estamos diciendo al controller como se van a llamar a sus metodos. Aca estamos definiendo que para llamar a algun metodo de la clase PetController, ya sera por un get(url) o post(formulario) se tiene que incluir como dato un valor llamado ‘method‘, esta variable contendra el nombre del metodo dentro del controller que queremos llamar. (para el emplo el valor que tendra sera ‘form’)

Crear el view JSP y declararlos en el contexto de spring.

Creamos un archivo con el nombre pet.jsp dentro de un folder llamado /jsp. (mas adelante la explicacion del por que)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>


Pet


    

Pet

Pet Name:

pets

${pet.name}

Este jsp, no estan largo. que bueno :), la primera parte solo es para definir los tags que vamos a usar en este caso el tag form de spring y el tag c de jstl.

Como veran se define un formulario donde se define que el action sera pet.do, osea que cuando se haga submir del formulario el request se dirigira a este. Despues se define tambien un input, que sirve para declarar un input field, que tiene el nombre name.

name=”method” value=”form”, este es el mas, mas importante, acá indicamos cual sera el método a llamar del controller, sino hacemos esto, les aseguro que tendremos muchos dolores de cabeza. Cabe tambien señalar que no es necesario que sea una constante, puede cambiar, lo puedes setear con java script o algun otro truco que conozcas. Lo importante es enviar un valor.

Despues lo que hacemo es iterar una lista que esta en session que se llama pets, se despliega el nombre y nada mas.

Ahora a mapear las views

Bueno, esta es la forma mas basica de mapear view, todos los jsps tienen que estar dentro de el folder /jsp/. Como es tan basica y tambien la mas sencilla  a veces uno no se da cuenta como es que se puede llamar a una view especifica. 🙂

La clave esta en la clase ModelAndView en el controller, si vuelven al codigo del controller veran que hay una sentencia como esta: new ModelAndView(“pet”). Lo que hara spring es buscar un archivo pet.jsp que este dentro de la carpeta jsp.

Probar la funcionalidad.

Ahora a probar,  el url para llamar al controller sera:

http://localhost:8080/hello/pet.do?method=form

Como veran, estoy colocando como paremetro extra que metodo del controller voy a llamar.

Luego aparecera un formulario como esto:

hellospring1

En el input field pueden colocar nombres de sus mascotas y veran que se iran adicionando en una lista debajo de la palabra pets.

Finalmente para aquellos que quieren ver algo mas, acá tengo el código fuente. (para los que usan maven, tambien esta el pom.xml, para los que no, tendran que incluir los jars necesarios)

Encontré un buen post acerca de como funciona el SpringMVC veanlo.

Comentarios son bien recibidos, hasta la próxima 🙂