lunes, 22 de diciembre de 2008

Woodstock migra a ICEFaces

El equipo de Netbeans tiene el agrado de anunciar la relación entre las comunidades de NetBeans y ICEFaces para facilitar la migración de los actuales usuarios de Woodstock. Con la última versión del plugin ICEface para NetBeans, puede agregar el frameworj ICEFaces a un proyecto existen y comenzar a desarrollar páginas ICEface con las aún existentes en woodstock.

Los recursos han sido creados para ayudar la migración incluyendo una guía de migración detallada y una matriz de comparación  entre los componentes de Woodstock y ICEfaces. Este solo es el inicio de la relación entre las comunidades de NetBeans y ICEfaces. Adicionamente las herramientas para migración serán planeadas para las siguientes versiones de ICEfaces.

Recursos:

jueves, 11 de diciembre de 2008

Parche 1 para NetBeans 6.5

Acaba de lanzarse el parche 1 para NetBeans 6.5
Este parche corrige errores encontrados en los módulos Auto Update Services, Ant, BlueJ Project Support, C/C++, Database, GUI Builder, GlassFish v3 Prelude, GlassFish v3 Prelude - JRuby, IDE Platform, Java, Java EE, Web Applications, Java Profiler, NetBeans 6.5, PHP, Platform, RESTful Web Services, Ruby and Rails, SaaS Services Support y UML.

Para descargarlo, utilice la opción "Ayuda > Comprobar actualizaciones" desde el IDE NetBeans 6.5.

Mas información sobre este parche, se podrá encontrar aquí: http://wiki.netbeans.org/NetBeans6.5PatchesInfo

miércoles, 10 de diciembre de 2008

Consulta...

Me ha llegado un mail de un lector de mi blog haciéndome algunas preguntas interesantes.  Y como las respuestas son interesantes, es de interés a toda la comunidad.
Antes que nada, no estoy acostumbrado a responder correos de este tipo. Para ello creé el foro http://groups.google.com/group/diesil-java de tal manera que todos podamos apoyarnos. 

Ahora sí:

Pregunta 1: Tengo un pequeño proyecto, donde tengo consultas a una base de
datos y accedo a varios archivos (.js, .css, .php); los cuales hacen
más interactiva mi web.
Mi consulta: ¿Cómo hago o construyo un "portable" de mi proyecto para
levantarlo en un servidor de aplicaciones; y que comience a funcionar
como sitio? ¿NetBeans tiene alguna herramienta... o que carpetas o
achivos del proyecto creado en NB tengo que llevarme para que desde un
Hosting pueda tener la acción deada?
Respuesta: Si presionas las teclas Ctrl+2 veras el panel "Archivos" que muestra la estructura del proyecto que estás trabajando. Son archivos físicos como se están guardando en tu disco. Existe la carpeta web, cuyo contenido es lo que deberías llevar a un servidor para ponerlo en producción. Me parece que estás mencionando proyectos php. Pero si estásn trabajando aplicaciones Java EE Web entonces deberias hacer "build" y eso creará la carpeta "dist" que es donde creará un archivo .war. Este archivo .war es el que se utiliza para desplegarlo solo en un Servidor Java EE

Pregunta 2. Mi otra consulta es la siguiente cada vez que quiero realizar un
proyecto nuevo siempre selecciono en las categorías la carpeta "WEB" y
clickeo en la opcíon donde crear un archivo simple, sigo los pasos
para crear la carpeta de mi proyecto. Y me crea por ejemplo
MiArchivo.jsp ... sí? ... Ok, comienzo a desarrollar mi código y
necesito agregar uno archivos (File) ".css", otro ".js" y no hay
problema, los agrego y sigo trabajando. Pero si quiero agregar un
archivo ".php", voy a "File" y en la lista me muestra todo menos el de
PHP.
Mi consulta: ¿Como agrago un archivo ".php" a mi desarrollo a través
de la opción File del NB? ...
Yo la solución que encontré fue crear en un editor el archivo ".php" y
lo agregué o copie el la carpeta donde está mi proyecto. Pero me
parece que sería mejor que lo pudiera hacer todo desde el NB. Es más
pude hacer que desde el NB 6.1 tener la posibilidar de crear Proyectos
en PHP y no desde el el "Early Access for PHP Editor" que biene a
parte para PHP. Es más vos en mails anteriores me indicaste como
integrarlo.
Respuesta: Una aplicación Web PHP funciona solo con archivos PHP, y se ejecuta en un servidor que permite aplicaciones PHP (Como el Apache Server + PHP). Una aplicación Web con JSP (JavaServer Pages) solo funciona en un servidor de aplicaciones Java (Java Enterprise Edition - Java EE) como el Apache Tomcat, Glassfish, JBoss, etc. Por tanto, si haces una aplicación Web que dice Java, pues solo será para java, y no puedes agregar archivos .php. O es uno, o es otro. Así que, que si deseas trabajar con PHP, debes crear un proyecto PHP. 

Te recomiendo que en el NB 6.5 descargues el complemento PHPdesde el menú Herramientas > Complementos.

Pregunta 3. Mi otra consulta es simple ¿Como puedo crear un proyecto donde mi
página indice se HTML por ejemplo "index.html" como principal y no
".jsp" o ".php"? ... no sé si me comprendés o sea quiero que mi
proyecto tenga una página de inicio como te indiqué.
Respuesta: Si estás haciendo una aplicación java web, revisa el archivo web.xml, en la sección General. Ahí indicas el orden de los archivos de inicio. Es decir, busca primero un index.html, y si no está, busca un index.jsp, etc. como desees.


Pregunta 4 Estube mirando el sitio de NB y hay una solapa donde podés bajar o
descargar los "Plugins"...
Mi consulta (y disculpá mi ignorancia): ¿Para que sirven y que
ventajas tengo si los instalo a estos plugins?... ¿Los mismos son para
la versión de NetBeans 6.1 o eso no importa son compatibles para
cualquiera?
Respuesta: Algunos plugins funcionan para todas las versiones o algunas solo para ciertas versiones. Se puede probar si funciona o no. Eso yo haría. Pero lo mejor es usar los plugins que son compatibles con la version que se está usando. Estos plugins lo puedes descargar desde el mismo IDE, entrando al menú Herramientas > Complementos. Lo bueno de usar esta opción, es que si deseas usar un plugin que depende de otro, el IDE te descargará los necesarios.


Bueno, espero haber ayudado a la comunidad con estas respuestas.

jueves, 4 de diciembre de 2008

JavaFX 1.0

NetBeans tiene el orgullo de presentar el NetBeans 6.5 para javaFX.

Se puede descargar el IDE en http://www.netbeans.org/downloads/index.html

O también se puede descargar el componente desde el mismo IDE.


Algún día haré un artículos sobre JavaFX.

sábado, 22 de noviembre de 2008

Documentación de Hibernate en Español

Gonzalo Díaz ha terminado la traducción de la documentación de Hibernate al español
Aquí se encuentra el link

http://hibernar.org/documentacion_es/documentacion.php

Vaya que ha sido un gran trabajo

Felicitaciones a Gonzalo por su gran aporte para la comunidad.

Si seguimos así, podemos hacernos del dominio de la documentación en español :)

miércoles, 19 de noviembre de 2008

NetBeans 6.5 liberado!

Salió a la luz
NetBeans 6.5!

http://www.netbeans.org/community/releases/65/

A la hora de enviar este post, aún no aparece la versión en español.
Seguramente están acabando de preparar el instalador :)

viernes, 14 de noviembre de 2008

Cambiar ícono a un JFrame

Un visitante de mi blog me pidió que le dijera cómo cambiar el ícono de los JFrame. Pero como este tip puede ser útil para toda la comunidad, decidí escribirlo aquí en mi blog.

Paso 1
El ícono debe ser una imagen de extensión PNG. Esto se hace más fácil, ya que conseguir una figura y convertirlo en formato .ico es muy complicado. Los PNG nos ayudan bastante.

Paso 2
La imagen que será el ícono debe estar dentro del paquete de fuentes, como si fuera una clase más. Si estuviera dentro de un paquete, sería mucho mejor.

Paso 3
En el código del JFrame que vamos a poner el ícono, sobreescribimos el método getIconImage() conteniendo el siguiente código: (notar cómo se está llamando a la imagen .png)

@Override
public Image getIconImage() {
   Image retValue = Toolkit.getDefaultToolkit().
         getImage(ClassLoader.getSystemResource("resources/icono.png"));


   return retValue;
}

Paso 4
En la vista de diseño del JFrame, lo seleccionamos y vamos sus propiedades, buscamos la propiedad "iconImagen" y hacemos clic en el botón de puntos suspensivos. Se mostrará una ventana de diálogo como esta:

De la lista desplegable, seleccionamos "Valor de componente existente". Esto hará que cambie la ventana a la siguiente forma:


Seleccionamos la opción "Propiedad" y hacemos clic en el botón de puntos suspendidos. Aparecerá una ventana de diálogo más pequeña, y seleccionamos la propiedad "iconImage" que aparece ahí.


Clic en Aceptar, y se verá así:
y nuevamente clic en "Aceptar" para cerrar la ventana de selección de imagen.

Ahora, veremos que las propiedades del JFrame ya tiene un nuevo valor



Paso 5
Ejecutamos la aplicación con el JFrame, y voila! nuestro JFrame con un ícono diferente

miércoles, 12 de noviembre de 2008

Wavemaker Visual Ajax Studio

No sé si lo habeís visto antes, yo recién lo veo y me he quedado sorprendido con este software

http://wavemaker.com/

Aún no lo he descargado, y tampoco sé si los screencast que se ven utilizan la versión Community. Lo descargaré y veré qué tan bueno es.. y daré mi opinión por esta vía.

miércoles, 5 de noviembre de 2008

Grupo de discusión

Hola a todos!
Debido a las diversas preguntas respecto a artículos que publico en mi blog, he creado un grupo de discusión sobre Google Groups. Este es:

http://groups.google.com/group/diesil-java

Si alguien tiene una pregunta, trataré de responderla.. y si alguien tiene la respuesta, todos estaremos beneficiados.

jueves, 30 de octubre de 2008

NetBeans 6.5 RC 2 (En español)

Gracias al esfuerzo del equipo de traducción de NetBeans al Español, se puede descargar la versión 6.5 RC 2 en nuestro idioma:


http://bits.netbeans.org/netbeans/6.5/community/rc2/ml/

Hay algunos módulos que no hemos acabado de traducir, pero lo seguiremos haciendo y se actualizarán automáticamente desde el Centro de Actualizaciones del IDE.

¡¡Un sincero agradecimiento a todos los miembros del equipo de traducción de NetBeans!!

viernes, 17 de octubre de 2008

Cambiando el Look And Feel de NetBeans

(Versión Wiki:http://wiki.netbeans.org/TaT_CambiandoLookAndFeel)

El look and feel predeterminado desde la versión 6.5 del IDE NetBeans se establece de acuerdo al sistema operativo. Esto hace que el NetBeans parezca una aplicación de Windows con el Look and Feel del Windows que se esté usando, y así en cualquier sistema operativo.

chlaf1.jpg

Para cambiar el look and feel necesitamos editar el archivo netbeans.conf que se encuentra en la subcarpeta etc del directorio de NetBeans. Abriremos ese archivo usando un editor de texto. Lo que necesitamos editar es la línea que dice "netbeans_default_options":

chlaf2.jpg

Lo que debemos es agregar al final de la cadena (como parte de la cadena, es decir, dentro de las comillas dobles) lo siguiente:

--laf javax.swing.plaf.metal.MetalLookAndFeel

al reiniciar el IDE, veremos los cambios

chlaf3.jpg


jueves, 16 de octubre de 2008

Certificación en especialista de NetBeans IDE

Sun Learning Services ha desarrollado un Examen de Certificación del IDE NetBeans, el cual prueba el conocimiento que tenga uno en el desarrollo de aplicaciones web y desktop usando el IDE NetBeans.

Ahora ellos necesitan probadores de la versión beta (beta testers) del examen. Hasta el 5 de noviembre podemos rendir la versión beta de este examen totalmente gratis.

Si pasas el examen, consigues el estado de Sun Certified Specialist NetBeans IDE, el cual puede ser bueno para agregarlo a tu currículum.


Para más información y registrarse, visitar http://www.sun.com/training/certification/netbeans.html.

Internacionalización (i18n) con Visual JSF

(Versión Wiki: http://wiki.netbeans.org/TaT_I18nVisualJSF)

Todos sabemos que escribir un texto rígido (hard-code) en nuestras aplicaciones no es una buena práctica. Esto cubre también a los textos de los formularios. Todo debemos pasarlo a variables, y si modificamos el contenido de la variable, toda la aplicación donde usa esa variable, se actualizarán automáticamente. Bueno, eso lo sabemos todo.

Los mensajes de la interfaz de usuario - ya sea web o desktop - deben estar almacenados en un archivo de recurso llamado .properties. Además, estos tipos de archivos permiten la internacionalización (i18n)

En la web de Sun existe un tutorial sobre la i18n, y esta es Trail: Internationalization

Aquí veremos como usar el archivo .properties para Visual JSF.

Para comenzar, diseñaremos un formulario simple como este:

i18n-vjsf-01.jpg

Ahora, en el panel del proyecto, dentro del paquete del código fuente, buscamos el archivo Bundle.properties.

i18n-vjsf-02.jpg

Editamos este archivo de tal manera que tengan los textos necesarios para nuestro formulario. Si es necesario, también usamos su texto localizado.

i18n-vjsf-03.jpg

Bundle.properties:

app_upload_title=Load files package
app_upload_file=Select package
app_upload_submit=Submit

Bundle_es.properties:

app_upload_title=Cargar paquete de archivos
app_upload_file=Indique paquete de archivos
app_upload_submit=Cargar

Regresamos al editor visual de nuestra aplicación. De la paleta de componentes, en la categoría Advanced buscamos el elemento Load Bundle

i18n-vjsf-04.jpg

Lo seleccionamos, lo arrastramos y lo soltamos sobre la ventana de editor visual. No pasará nada visual, pero si vemos en el panel Navegador veremos que existe el elemento loadBundle

i18n-vjsf-05.jpg

Ahora, volvemos a enfocarnos en el editor visual. Seleccionamos un elemento, por ejemplo el Static text que está en la parte superior. a este elemento escribimos en la propiedad text lo siguiente: #{messages1.app_upload_title}, para el componente label colocamos: #{messages1.app_upload_file}, y para el botton colocamos: #{messages1.app_upload_submit}

Al final del diseño, el editor mostrará lo siguiente

i18n-vjsf-06.jpg

Ahora, cuando desplegamos la aplicación, veremos que lucirá así:

i18n-vjsf-07.jpg

Ahora, en adelante, si necesitamos modificar un texto, solo modificamos el archivo Bundle.properties

viernes, 3 de octubre de 2008

NetBeans 6.5 en Español como Plugin

Ahora podemos descargar un plugin de NetBeans 6.5 para visualizar el IDE en español.

Para ello, entramos a Tools > Plugins, y en la ficha 'Settings', hacer clic en el botón 'Add'.
Aparecerá la ventana 'Update Center Customizer'. Escribimos los siguientes valores

Name: Localization UC
URL: http://deadlock.netbeans.org/hudson/job/nb6.5-community-ml/lastSuccessfulBuild/artifact/l10n/nbms/community/catalog_all.xml.gz

Después de hacer clic en 'OK', regresamos a la ficha 'Avaible plugins', hacemos clic en 'Reload', y veremos que aparecerán algunos plugins nuevos. Activamos para descarga el 'NetBeans 6.5 es localization kit' como se muestra en la siguente imagen.


Clic en 'Install'. Se procederá a la descarga de los plugins.


Habrá un mensaje de advertencia respecto a lo que se va a instalar. Estos plugins aún no tienen firmas de seguridad. Pero como sabemos que lo hemos descargado de NetBeans, continuamos


Y listo,
Después de reiniciar el IDE considerando la nueva instalación, podremos ver el IDE en español.

Todos los textos traducidos son colaboraciones de los traductores de la comunidad hispana.
Si quieres colaborar en este noble proyecto :), visita http://wiki.netbeans.org/SpanishTranslationNB65

jueves, 11 de septiembre de 2008

NetBeans 6.5 en español al 21%

He abandonado un rato mi blog porque he estado abocado en la traducción de NetBeans 6.5

Ya vamos en 21% de la traducción, una cifra bastante significativa para el objetivo que nos hemos trazado.

Aquí podemos ver algunas pantallas del NetBeans 6.5 Beta con el paquete de traducciones obtenido de http://translatedfiles.netbeans.org/servlets/ProjectDocumentList?folderID=283.








viernes, 29 de agosto de 2008

Tú puedes hacer que NetBeans 6.5 salga en español

Si te gusta Java, hablas español/castellano, y quieres que haya más gente hispana que programe en Java.. ¡este post es para ti!

¡Estamos buscando gente entusiasta como tú!

Parece un anuncio que busca gente para que venda algún producto. Pues algo así es este post.

Como lo mencioné en mi anterior post NetBeans 6.5 en Español, deseamos que el NetBeans 6.5 - el único IDE que necesitas - salga en nuestro idioma.

Quizás te preguntes ¿Por qué traducirlo?. Bueno, piensa: tu sistema operativo, tu suite de ofimática, tu correo electrónico, los software que usas en tu trabajo ¿están en español? Y si no estuvieran, ¿no te gustaría que lo estén?

Pues es la misma razón por la que varios desarrolladores nos caería bien que el NetBeans estuviera en español: es más cómodo usar un producto en nuestro idioma que en inglés.

Tienes la oportunidad de participar en este gran proyecto: Traducción del NetBeans 6.5 al Español

Somos varios países que hablamos español/castellano ¡Qué grandioso sería que tengamos un IDE traducido por nosotros mismos! ¿No te parece?

El lanzamiento oficial del NetBeans 6.5 está programado para el 15 de Octubre.

Y estamos trabajando duro para lanzar el producto en español en la misma fecha.

En este cuadro se puede apreciar cuánto estamos avanzado (columna es)
http://translatedfiles.netbeans.org/6.5/status.html

La traducción es fácil, aunque un poco laboriosa. Pero si entre todos ponemos el hombro, llegaremos a la meta sin ningún problema.

Arístides Villarreal de Panamá, miembro del NetBeans Dream Team, es el líder y coordinador del Equipo de Traducción al Español de NetBeans.

Para que sepas cómo participar, visita nuestra web: http://wiki.netbeans.org/SpanishTranslation

También te puedes suscribir a la lista: http://groups.google.com/group/traduccionnetbeans

¡Te esperamos!

martes, 26 de agosto de 2008

¿Para que los EJB?

Si hacemos una aplicación Web ¿para qué necesitamos los EJB, si todo lo podemos programar en los Servlets y los JSP?... y si programos una aplicación Desktop ¿para qué los EJB si todo lo podemos programar en las clases Swing? Pero si queremos una aplicación que sea funcional tanto en Web como en Desktop, donde la lógica de negocio debe ser la misma, y si se cambia la forma de realizar alguna rutina debe ser reflejada en en las dos aplicaciones. ¿qué hacemos?
¿Aún no está claro lo que hablo? Bueno, vayamos directo a la aplicación.

Haciendo una aplicación Web que calcula áreas

Supongamos que queremos una aplicación web llamada AreasWeb que haga cálculos de área geométricas: el área del círculo, del pentágono regular, del triángulo y del trapecio. Los parámetros que necesitamos son los siguientes:
  • Para calcular el círculo necesitamos el radio.
  • Para el pentágono, la altura
  • Para el triángulo, la base y la altura
  • Y para el trapecio, la base menor, la base mayor y la altura.

La solución usando un JSP

Haremos cuatro formularios en un solo .jsp y en ese mismo .jsp mostraremos el resultado. Este es el JSP para nuestra solución:
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
  <meta equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>JSP Page</title>
</head>
<body>
<h1>Calculando áreas</h1>
<form action="index.jsp?area=circulo" method="post">
  <fieldset>
      <legend>Área del círculo</legend>
      Radio: <input type="text" name="radio" value="${param.radio}">
      <input type="submit" value="Calcular">
      <%if ("circulo".equals(request.getParameter("area"))) {
      double radio=Double.parseDouble(request.getParameter("radio"));
      double area=Math.PI*Math.pow( radio,2.0);
      %><br/>
      El área es: <%=area%>
      <%}%>
  </fieldset>
</form>

<form action="index.jsp?area=pentagono" method="post">
  <fieldset>
      <legend>Área del pentágono</legend>
      Altura: <input type="text" name="altura" value="${param.altura}">
      <input type="submit" value="Calcular">
      <%if ("pentagono".equals(request.getParameter("area"))) {
      double altura=Double.parseDouble(request.getParameter("altura"));
      double area=((5.0*Math.pow(altura, 2))/4.0)*(1.0/Math.tan(Math.PI/5.0));
      %><br/>
      El área es: <%=area%>
      <%}%>
  </fieldset>
</form>
<form action="index.jsp?area=triangulo" method="post">
  <fieldset>
      <legend>Área del Triángulo</legend>
      Altura: <input type="text" name="altura" value="${param.altura}"><br/>
      Base: <input type="text" name="base" value="${param.base}"><br/>
      <input type="submit" value="Calcular">
      <%if ("triangulo".equals(request.getParameter("area"))) {
      double altura=Double.parseDouble(request.getParameter("altura"));
      double base=Double.parseDouble(request.getParameter("base"));
      double area=(base*altura)/2.0;
      %><br/>
      El área es: <%=area%>
      <%}%>
  </fieldset>
</form>

<form action="index.jsp?area=trapecio" method="post">
  <fieldset>
      <legend>Área del Trapecio</legend>
      Altura: <input type="text" name="altura" value="${param.altura}"><br/>
      Base 1: <input type="text" name="base1" value="${param.base1}"><br/>
      Base 2: <input type="text" name="base2" value="${param.base2}"><br/>
      <input type="submit" value="Calcular">
      <%if ("trapecio".equals(request.getParameter("area"))) {
      double altura=Double.parseDouble(request.getParameter("altura"));
      double base1=Double.parseDouble(request.getParameter("base1"));
      double base2=Double.parseDouble(request.getParameter("base2"));
      double area=(altura*(base1+base2))/2.0;
      %><br/>
      El área es: <%=area%>
      <%}%>
  </fieldset>
</form>


</body>
</html>
Toda la lógica de negocio está aquí. Ahorramos bastante código, ahorramos esfuerzo. Nada más hemos logrado.
Problemas:
  1. Si queremos otra página en nuestra aplicación que querramos usar alguna de esas fórmulas, tendremos que volver a pegar las fórmulas en esa nueva página.
  2. Si hay que hacer alguna modificación o corrección en una de las fórmulas, tendremos que revisar en todas las páginas que lo utilizan. De hecho, uno se nos podría escapar a nuestra revisión.
Bueno, podriamos hacer un servlet que siempre reciba los parámetros y guardar el resultado del área en una variable de sesión y mostrarlo en la página resultante.

La solución usando Servlet

Pues aquí está el servlet, la clase se llama web.AreaServlet y su URL es /AreaServlet:
      String tipoArea = request.getParameter("area");
    double area = 0.0;
    if ("circulo".equals(tipoArea)) {
        double radio = Double.parseDouble(request.getParameter("radio"));
        area = Math.PI * Math.pow(radio, 2.0);

    } else if ("pentagono".equals(tipoArea)) {
        double altura = Double.parseDouble(request.getParameter("altura"));
        area = ((5.0 * Math.pow(altura, 2)) / 4.0) * (1.0 / Math.tan(Math.PI / 5.0));
    } else if ("triangulo".equals(tipoArea)) {
        double altura = Double.parseDouble(request.getParameter("altura"));
        double base = Double.parseDouble(request.getParameter("base"));
        area = (base * altura) / 2.0;
    } else if ("trapecio".equals(tipoArea)) {
        double altura = Double.parseDouble(request.getParameter("altura"));
        double base1 = Double.parseDouble(request.getParameter("base1"));
        double base2 = Double.parseDouble(request.getParameter("base2"));
        area = (altura * (base1 + base2)) / 2.0;
    }
    request.setAttribute("area", area);
    request.setAttribute("formula", tipoArea);
    RequestDispatcher rd = request.getRequestDispatcher("respuesta.jsp");
    rd.forward(request, response);
El index.jsp ahora tiene menos código:
<%@page contentType="text/html"%>
<%@page pageEncoding="UTF-8"%>


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>JSP Page</title>
</head>
<body>
<h1>Calculando áreas</h1>
<form action="AreaServlet?area=circulo" method="post">
    <fieldset>
        <legend>Área del círculo</legend>
        Radio: <input type="text" name="radio" value="${param.radio}">
        <input type="submit" value="Calcular">
  
    </fieldset>
</form>

 <form action="AreaServlet?area=pentagono" method="post">
    <fieldset>
        <legend>Área del pentágono</legend>
        Altura: <input type="text" name="altura" value="${param.altura}">
        <input type="submit" value="Calcular">
    
    </fieldset>
</form>
<form action="AreaServlet?area=triangulo" method="post">
    <fieldset>
        <legend>Área del Triángulo</legend>
        Altura: <input type="text" name="altura" value="${param.altura}"><br/>
        Base: <input type="text" name="base" value="${param.base}"><br/>
        <input type="submit" value="Calcular">
   
    </fieldset>
</form>

<form action="AreaServlet?area=trapecio" method="post">
    <fieldset>
        <legend>Área del Trapecio</legend>
        Altura: <input type="text" name="altura" value="${param.altura}"><br/>
        Base 1: <input type="text" name="base1" value="${param.base1}"><br/>
        Base 2: <input type="text" name="base2" value="${param.base2}"><br/>
        <input type="submit" value="Calcular">
   
    </fieldset>
</form>


</body>
</html> 
Funciona, ahora cualquier página que llamemos a ese Servlet utilizando los respectivos parámetros, nos mostrará el resultado. Es más, puede ser llamado desde cualquier aplicación web, así no sea del mismo servidor.
Problemas:
  1. Si queremos usar la misma lógica para calcular las áreas para una aplicación Desktop con Swing, no podremos, ya que un Swing no soporta servlets y nada web.
  2. El resultado siempre se mostrará en respuesta.jsp, si queremos utilizar el mismo resultado en otra página, dependeríamos del formato utilizado en respuesta.jsp.

Creando una biblioteca que contenga la lógica del cálculo

Trataremos de solucionar el primer problema cuestionado en el anterior párrafo.
Crearemos una nueva biblioteca Java desde NetBeans:
Y la llamaremos BibliotecaAreas
Dentro crearemos una clase llamada areas.CalculaAreas la cual tendrá el siguiente código:
package areas;

public class CalculaAreas {

  public static double circulo(double radio) {
      return Math.PI * Math.pow(radio, 2.0);
  }

  public static double pentagono(double altura) {
      return ((5.0 * Math.pow(altura, 2)) / 4.0) * (1.0 / Math.tan(Math.PI / 5.0));
  }

  public static double trapecio(double altura, double base1, double base2) {
      return (altura * (base1 + base2)) / 2.0;
  }

  public static double triangulo(double altura, double base) {
      return (base * altura) / 2.0;
  }
}
Agregamos este proyecto como biblioteca del proyecto Web:
Y el método de nuestro servlet cambiará un poco así:
 protected void processRequest(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
      String tipoArea = request.getParameter("area");
      double area = 0.0;
      if ("circulo".equals(tipoArea)) {
          double radio = Double.parseDouble(request.getParameter("radio"));
          area = CalculaAreas.circulo(radio);

      } else if ("pentagono".equals(tipoArea)) {
          double altura = Double.parseDouble(request.getParameter("altura"));
          area = CalculaAreas.pentagono(altura);
      } else if ("triangulo".equals(tipoArea)) {
          double altura = Double.parseDouble(request.getParameter("altura"));
          double base = Double.parseDouble(request.getParameter("base"));
          area = CalculaAreas.triangulo(altura, base);
      } else if ("trapecio".equals(tipoArea)) {
          double altura = Double.parseDouble(request.getParameter("altura"));
          double base1 = Double.parseDouble(request.getParameter("base1"));
          double base2 = Double.parseDouble(request.getParameter("base2"));
          area = CalculaAreas.trapecio(altura, base1, base2);
      }
      request.setAttribute("area", area);
      request.setAttribute("formula", tipoArea);
      RequestDispatcher rd = request.getRequestDispatcher("respuesta.jsp");
      rd.forward(request, response);

  }
¿Qué ganamos? Pues que ahora la lógica que calcula las áreas está en fuera de nuestra aplicación principal, y tenemos las siguientes ventajas:
  1. Podemos agregar esta biblioteca a otros proyectos, de la misma manera cómo la agregamos a la aplicación web.
  2. Si deseamos modificar la fórmula de alguna área, lo haremos en la biblioteca, y los demás proyectos que utilizan nuestra biblioteca no sufrirán cambios.
Problema:
Si hacemos cambios en esta biblioteca, habría que actualizar todas las aplicaciones con el nuevo .jar de nuestra biblioteca.

La solución usando EJB

Usando una analogía: podemos decir que es mucho más eficiente y económico tener una impresora en red para N equipos, que una impresora por cada computador. Es más fácil dar mantenimiento a un solo recurso, que a varios sabiendo que están todos sobre una red.
De la misma manera funcionan los EJB. Los EJB tienen la lógica de negocio para una determinada tarea. Es muy similar a la biblioteca que hemos creado, pero se aloja sobre un Contenedor de EJB, de tal manera que cualquier aplicación Java EE pueda utilizarlo. Si se hace alguna modificación en el EJB, no tendremos que actualizar las aplicaciones que lo utiliza, ya que estas siempre obtendrán el EJB que está en el Contenedor EJB.
Crearemos un nuevo proyecto (Mayúscula+Ctrl+N) que consistirá en un módulo EJB:
y llamaremos AreasEJBModule.
Luego creamos un nuevo archivo (Ctrl+N) que será un Session bean
Tendrá las siguientes propiedades:
  • Nombre: Calculadora
  • Paquete: ejb
  • Tipo de sesión: Stateless
  • Create Interface: remote
Nuestra interfaz CalculadoraRemote debe tener las siguientes declaraciones:
package ejb;

import javax.ejb.Remote;

@Remote
public interface CalculadoraRemote {

  double pentagono(double altura);

  double circulo(double radio);

  double trapecio(double altura, double base1, double base2);

  double triangulo(double altura, double base);
}
Y nuestra clase CalculadoraBean debe estar implementado de la siguiente manera:
package ejb;

import javax.ejb.Stateless;

@Stateless
public class CalculadoraBean implements CalculadoraRemote  {

 public  double circulo(double radio) {
      return Math.PI * Math.pow(radio, 2.0);
  }

  public  double pentagono(double altura) {
      return ((5.0 * Math.pow(altura, 2)) / 4.0) * (1.0 / Math.tan(Math.PI / 5.0));
  }

  public  double trapecio(double altura, double base1, double base2) {
      return (altura * (base1 + base2)) / 2.0;
  }

  public  double triangulo(double altura, double base) {
      return (base * altura) / 2.0;
  }
}
Sugerencia: También se pudo haber agregado el proyecto BibliotecaAreas a nuestro EJB para reutilizar los métodos.
Seleccionamos clic derecho sobre el nodo del proyecto EJB, y seleccionamos Undeploy and Deploy para desplegar el módulo en nuestro contenedor EJB (por ejemplo, Glassfish). deploy.jpg
Después de haber desplegado el EJB, vayamos a nuestro proyecto web, y quitamos la referencia al proyecto BibliotecaAreas de la sección Libraries de las propiedades del proyecto Web.
Ahora, abrimos el Servlet, hagamos clic derecho sobre el fondo del editor del código fuente y seleccionemos Enterprise Resources > Call Enterprise Bean. En la ventana que aparece, seleccionamos CalculadoraBean call-bean.jpg
Vemos que se agregado una nueva propiedad con una anotación en nuestro servlet:
 @EJB
  private CalculadoraRemote calculadoraBean;
Con esta anotación, la aplicación obtendrá las referencia a nuestra lógica de cálculos. Así, nuestro servlet tendrá este nuevo código:
package web;


import ejb.CalculadoraRemote;
import java.io.IOException;
import javax.ejb.EJB;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AreaServlet extends HttpServlet {

  @EJB
  private CalculadoraRemote calculadoraBean;

  /**
   * Processes requests for both HTTP GET and POST methods.
   * @param request servlet request
   * @param response servlet response
   */
  protected void processRequest(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
      String tipoArea = request.getParameter("area");
      double area = 0.0;
      if ("circulo".equals(tipoArea)) {
          double radio = Double.parseDouble(request.getParameter("radio"));
          area = calculadoraBean.circulo(radio);

      } else if ("pentagono".equals(tipoArea)) {
          double altura = Double.parseDouble(request.getParameter("altura"));
          area = calculadoraBean.pentagono(altura);
      } else if ("triangulo".equals(tipoArea)) {
          double altura = Double.parseDouble(request.getParameter("altura"));
          double base = Double.parseDouble(request.getParameter("base"));
          area = calculadoraBean.triangulo(altura, base);
      } else if ("trapecio".equals(tipoArea)) {
          double altura = Double.parseDouble(request.getParameter("altura"));
          double base1 = Double.parseDouble(request.getParameter("base1"));
          double base2 = Double.parseDouble(request.getParameter("base2"));
          area = calculadoraBean.trapecio(altura, base1, base2);
      }
      request.setAttribute("area", area);
      request.setAttribute("formula", tipoArea);
      RequestDispatcher rd = request.getRequestDispatcher("respuesta.jsp");
      rd.forward(request, response);

  }
//.... sigue
Ejecutamos la aplicación y Voila!

Un paso más adelante... con Web Services

Pero, si queremos usar la lógica de negocio en una aplicación que no sea web, y más aún, que no sea Java. Aquí entran los Web Services
No entraremos en detalle sobre la historia de esta tecnología.
Hacemos clic derecho sobre el nodo del proyecto AreasEJBModule y seleccionamos New > Other. Seleccionamos Web Services | Web Service
Y tendrá las siguientes propiedades:
  • Web Service Name: Calculadora
  • Package: ws
  • Create Web Service from Session Bean: Enterprise Beans#CalculadoraBean (hacemos clic en el botón Browse para seleccionar CalculadoraBean)
Hacemos nuevamente clic derecho sobre el ícono del proyecto AreasEJBModule y seleccionamos Undeploy and deploy para desplegar el módulo en Glassfish.
Para probar si funciona bien nuestro Web Service, hacemos clic derecho sobre el ícono de nuestro Servicio Web y seleccionamos Test Web Service: test-ws.jpg
Se abrirá nuestro navegador web mostrando una página donde se muestran todos nuestros métodos de nuestro Servicio Web, con entradas de texto que podemos escribir para enviar parámetros:
Podemos escribir algunos valores para probar si funcionan correctamente nuestros métodos.
En la misma página de prueba hay un enlace (http://localhost:8080/CalculadoraService/Calculadora?WSDL) al WSDL (Lenguaje descriptor del Servicio web) de nuestro servicio web. Este WSDL es el que se utilizará en otras aplicaciones (como .Net, Delphi, etc) que desean consumir nuestro servicio web.

Los proyectos

A continuación se listan los proyectos utilizados en este artículo:

jueves, 14 de agosto de 2008

NetBeans 6.5 Beta

La versión Beta de NetBeans IDE 6.5 ya está disponible.
Dentro de sus principales características, están las siguientes:
  • PHP



    • Autocompletado de código
    • Corrección rápida y verificación de semántica
    • Generador de código
    • Compatibilidad con FRP
    • Depuración con Xdebug
    • Compatibilidad con Servicios Web populares
  • Ajax/JavaScript
    • Depuración en Firefox e IE
    • Monitoreo HTTP del cliente
    • Contiene bibliotecas populares de JavaScript
  • Java
    • Compatibilidad con Groovy / Grails
    • Compilación en la grabación
    • Sincronizador e importador de proyectos de Eclipse
    • Creación de proyectos utilizando Hibernate
    • Generador CRUD (Create/Read/Update/Delete) de JSF ahora con Ajax
  • Base de datos
    • Nueva ventana de diálogo para conección a la base de datos
    • Editor de SQL mejorado
  • C/C++
    • Completación de código mejorado y resaltado de errores
    • Desarrollo remoto
    • Compatibilidad para empaquetado
  • Ruby
    • Nuevo paquete de Ruby/Glassfish ve
    • Compatibilidad para pruebas Ruby
    • Rails actualizado a 2.1.0

Ver más sobre la nueva versión, aquí: http://www.netbeans.org/community/releases/65/

viernes, 8 de agosto de 2008

SDK Preliminar de JavaFX

Sun ha lanzado la versión preliminar del SDK de JavaFX.

Nandini Ramani, directora ingeniera, presenta este vídeo, además de cómo se puede usar desde NetBeans 6.1

http://www.netbeans.tv/screencasts/Nandini-Ramani-Introduces-the-JavaFX-Preview-SDK-372/

Reportes en NetBeans 6.1 con iReport/JasperReports y Visual Web JavaServer Faces

[Este tutorial también se encuentra en los tutoriales en Español de NetBeans. Ya que es un Wiki, se puede tener el tutorial actualizado]

Introducción

Microsoft tiene su Visual Studio, Java tiene a NetBeans.


Microsoft tiene su Crystal Reports, Java tiene JasperReports.

Java no tiene nada qué envidiar a Visual Studio. Ni menos en los reportes.

JasperReports es un framework bastante completo para desarrollar reportes tanto web como desktop en Java.

Aunque el formato fuente de un reporte en JasperReports es un archivo XML, existe una herramienta que permite crear un reporte de manera visual. Su nombre: iReport.

Pero como estamos usando como IDE a NetBeans, podemos elaborar nuestro reporte sin salir del IDE. Para ello, existe un plugin (archivo .nbm) para NetBeans que muestra el iReport dentro del mismo IDE.

http://downloads.sourceforge.net/ireport/iReport-nb-0.9.2.nbm



Instalando el plugin

Después de descargar el archivo .nbm, abrimos el IDE NetBeans. Entramos al menú Tools > Plugins, y en la ficha Downloaded, hacemos clic en el botón Add plugins...

Seleccionamos el archivo .nbm que previamente hemos descargado. Después de esto se mostrará la ventana lista para instalarse el plugin:

Image:Pantallazo-Plugins_ReportesEnNetBeansConIReport.png

Y hacemos clic en el botón Install. Se nos mostrará la siguiente ventana:

File:Pantallazo-NetBeans IDE Installer.png


Clic en Next. Aceptamos los términos de la licencia, y hacemos clic en Install. Nos mostrará la ventana de advertencia ya que el plugin es posible que no sea confiable:

File:Pantallazo-Verify Certificate.png

Pero como sabemos de dónde lo hemos descargado, hacemos clic en Continue.

Al finalizar la instalación del plugin, veremos que hay una opción nueva en la barra de herramientas,

Image:ireportnb1_ReportesEnNetBeansConIReport.jpg

y se muestra un panel nuevo de salida llamado "iReport output"

Image:ireportnb2_ReportesEnNetBeansConIReport.jpg


Verificando la biblioteca instalada.


Entremos a Tools > Libraries y seleccionemos la biblioteca JasperReports 2.0.5-snapshot. Revisemos el panel del classpath y veremos que hay una referencia marcada de rojo.



Pues bien, significa que según la ubicación donde se instaló el módulo no encuentra la ubicación del .jar que necesitamos para nuestra aplicación. Por tanto, lo configuraremos manualmente.

Hacemos clic en el botón Add Jar/Folder.. y buscamos la carpeta donde está instalada el NetBeans. Veremos que dentro hay una carpeta llamada ireport



Entramos a esa carpeta, luego a modules > ext.

Buscamos el archivo jasperreports-3.0.1.jar,lo seleccionamos



y hacemos clic en Add JAR/Folder.

Como podemos deducir, el problema que no encontraba el archivo jasperreports-2.0.5.jar era porque no existía.





Creando un proyecto

Lo que haremos en esta aplicación es mostrar en una lista todas las personas registradas en la base de datos TRAVEL. El usuario seleccionará uno de ellos, y hará clic en un botón llamado Mostrar Viajes para mostrar en un reporte todos los viajes relacionados a esta persona. Además, habrá un botón de opción (Radio Button) que permitirá escoger el formato del reporte: en PDF o en HTML.

Crearemos un proyecto web llamado TravelReport el cual utilizará el framework Visual Web JavaServer Faces.


Además, agregamos la biblioteca 'JasperReports 2.0.5-snapshot'

File:Pantallazo-Project Properties - TravelReport.png


La página con la lista de personas

De la paleta de componentes seleccionamos un Label y lo soltamos en el Page1.jsp. El texto que tendrá el componente label será "Seleccione una persona:".

Además, de la paleta de componentes arrastramos un Listbox y lo soltamos debajo del label que acabamos de pegar. En el panel de propiedades escribimos como id de este componente el valor personasLB.


También pegaremos un Radio button group al costado de la lista. Pondremos formatoCG como valor de la propiedad id.




Luego le damos clic derecho sobre el Radio button group que acabamos de pegar y seleccionamos la opción Configure Default Options... Editamos las opciones para que tengan como en la siguiente imagen:


File:Pantallazo-Options Customizer - formatoCG.png

Le damos nuevamente clic derecho y seleccionamos Add Binding attribute. Hacemos lo mismo con el componente personasLB.

Para finalizar con el diseño de esta página, pegaremos un componente button y tendrá como texto "Mostrar Reporte".

El diseño de la página debe quedar así:

File:Pantallazo-TravelReport - Page1.png


Accediendo a la base de datos


Entramos al panel de Services del panel izquierdo, o presionando Ctrl+5. Abrimos el nodo Databases, hacemos clic derecho sobre la conexión a la base de datos travel y seleccionamos Connect...

Seleccionamos el nodo Tables >> PERSON, lo arrastramos y lo soltamos sobre el componente personasLB. Sabremos que se realizó ya que las opciones que se mostrarán en el diseño serán "abc" tres veces.


Hacemos clic derecho sobre personasLB y seleccionamos Bind to data... Debe lucir así:

File:Pantallazo-Bind to Data - personasLB.png


Diseñando el reporte

Lo que necesitamos antes de programar cómo debe mostrarse el reporte, es, justamente, diseñar el reporte.

Presionamos Ctrl+N para mostrar el asistente para crear un nuevo archivo. Seleccionamos la categoría Report y el tipo de archivo Report.


File:Pantallazo-New File.png

Clic en el botón Next.

Escribimos viajes.jrxml como nombre del archivo, y en el campo Folder seleccionamos a través del botón Browse la carpeta src/java/travelreport


File:Pantallazo-New Report.png

Clic en el botón Next.

En la ventana donde se selecciona el Datasource, hacemos clic en el botón New.., y en la ventana de diálogo que se muestra, seleccionamos NetBeans Database JDBC Connection

Image:Pantallazo-nbjdbconn_ReportesEnNetBeansConIReport.png

Clic en el botón Next.

Escribimos 'travelDB como nombre, y de la lista desplegable seleccionamos la conexión para la base de datos travel.


Image:Pantallazo-nbjdbconn1_ReportesEnNetBeansConIReport.png

Podemos hacer clic en el botón Test para comprobar que esté correcta la conexión.

Clic en el botón Save.

Clic en el botón Design query para diseñar la consulta del reporte.

En este diseñador de consultas, desplegamos la lista que se encuentra en la parte media izquierda y seleccionamos la base de datos TRAVEL. Con esto se mostrarán las tablas de la base de datos.

File:Pantallazo- query1.png


Hacemos doble clic en la tabla TRIP. Un ícono que representa a la tabla TRIP se mostrará en el panel derecho de la ventana. Hacemos doble clic también en la tabla TRIPTYPE. Veremos que se mostró la asociación existente entre ambas tablas.

Activamos las casillas de verificación de los campos DEPDATE, DEPCITY y DESTCITY de la TRIP, y DESCRIPTION de la tabla TRIPTYPE.




Clic en el botón Ok

El diseño de la consulta va a quedar así:

File:Pantallazo- query3.png

Clic en el botón Ok

Ahora vemos el comando SQL generada por el diseñador.

File:Pantallazo-New File-2.png

Clic en el botón Next.

En la selección de campos, hacemos clic en el botón ">>" para agregar todos los campos en el reporte.


File:Pantallazo-New File-3.png

Clic en el botón Next.

En la selección de grupos, hacemos clic en el botón Next, ya que no haremos alguna agrupación en el reporte.

En la selección de diseño ("Layout") del reporte, seleccionamos Tabular Layout.

File:Pantallazo-New File-4.png

Clic en el botón Next. Finalmente, clic en el botón Finish.


El IDE nos mostrará el diseño del reporte que acabamos de crear utilizando el asistente. Podemos editarlo para que luzca como en la siguiente imagen:

File:Pantallazo-NetBeans IDE 6.1-reporte1.png


Modificando el reporte para que permita parámetros.

Entramos a la opción Window > Navigating > Report Inspector. Se abrirá un panel llamado Report Inspector en la parte lateral izquierda inferior.


Hacemos clic derecho sobre el nodo Parameters y Add parameter. Con esto se agregará un nuevo nodo llamado parameter1.

Lo seleccionamos y modificamos las propiedades colocando lo siguiente:

  • name: personId
  • Default value expresion: "1"
  • use as a prompt: (sin seleccionar)

File:Pantallazo-NetBeans IDE 6.1-parameterPersonId.png

Hacemos clic derecho en una zona en blanco del diseñador de reportes, y seleccionamos Edit query. Se nos presentará el diseñador de consultas para el reporte actual.

File:Pantallazo-Report query.png

Tenemos dos caminos para agregar el parámetro personId en la consulta

  1. Agregando el valor WHERE TRIP.PERSONID = $P{personId} desde la misma ventana de edición del comando SQL.

  2. Utilizando el diseñador de reporte, haciendo clic en el botón Query designer. Para ello, desde el diseñador de consulta, damos clic derecho sobre el nodo WHERE y seleccionamos add condition
Image:Pantallazo-condition_ReportesEnNetBeansConIReport.edit-1.png

De cualquier manera, el query debe ser similar a este:

SELECT
     TRIP."DEPDATE" AS TRIP_DEPDATE,
     TRIP."DEPCITY" AS TRIP_DEPCITY,
     TRIP."DESTCITY" AS TRIP_DESTCITY,
     TRIPTYPE."DESCRIPTION" AS TRIPTYPE_DESCRIPTION
FROM
     "TRAVEL"."TRIPTYPE" TRIPTYPE INNER JOIN "TRAVEL"."TRIP" TRIP ON TRIPTYPE."TRIPTYPEID" = TRIP."TRIPTYPEID"

WHERE
     TRIP.PERSONID = $P{personId}
Hacemos clic en el botón Ok para cerrar la ventana Report query

Podemos hacer clic en el botón Preview de la barra de herramientas del diseño del reporte para ver una muestra de cómo se visualizaría el reporte.


Adicionando ImageServlet a la aplicación

Los reportes HTML de JasperReports utilizan algunos recursos propios como ciertas imágenes que ayudan a mostrarse un reporte correctamente. Para ello, debemos agregar un Servlet de JasperReports para que interprete las peticiones de imágenes usando sus propios recursos.


Abrimos el archivo web.xml, seleccionamos la sección Servlets, y hacemos clic en el botón Add Servlet Element que se encuentra en la parte superior derecha. En la ventana de diálogo que se muestra, escribimos los siguientes valores:

Image:AddImageServlet_ReportesEnNetBeansConIReport.jpg

Clic en el botón OK


Programando el lanzamiento del reporte.

Hasta ahora hemos hecho todo el diseño visual. Ahora haremos la parte de la programación del botón Mostrar reporte.


Regresamos a la ventana Page1.jsp y estando en el modo "Design" vamos a la ventana Navigator. Examinamos los nodos y le damos doble clic en el nodo ApplicationBean1. El código fuente de ApplicationBean1.java se abrirá en el editor.

sugerencia: podemos escribir las siguientes líneas de código presionando Ctrl+Espacio cuando se desea escribir una clase o un método de tal manera que el IDE nos pueda sugerir cuáles son las clases que se utilizará y agregará los imports necesarios. También se puede copiar estas líneas de código y pegarlas en el editor del IDE, y luego presionar Ctrl+Mayúscula+I para importar las clases que se utilizan en la clase

.



Agregemos el siguiente método:

public void jasperReport(String tipo, String dataSourceName, Map<String, String> params) throws ClassNotFoundException {
        ExternalContext econtext = getExternalContext();
        InputStream inputStream = ApplicationBean1.class.getResourceAsStream("/travelreport/viajes.jasper");
        if (inputStream == null) {
            throw new ClassNotFoundException("Archivo viajes.jasper no se encontró");
        }
        FacesContext fcontext = FacesContext.getCurrentInstance();
        try {
            JRExporter exporter = null;
            Context  ctx=new InitialContext();
            DataSource ds=(DataSource) ctx.lookup(dataSourceName);
            Connection conn=ds.getConnection();
            
            JasperPrint jasperPrint = JasperFillManager.fillReport(inputStream, params, conn);
            HttpServletResponse response = (HttpServletResponse) econtext.getResponse();

            HttpServletRequest request = (HttpServletRequest) econtext.getRequest();

            response.setContentType(tipo);
            if ("application/pdf".equals(tipo)) {
                exporter = new JRPdfExporter();
                exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
                exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, response.getOutputStream());
            } else if ("text/html".equals(tipo)) {
                exporter = new JRHtmlExporter();
                exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
                exporter.setParameter(JRExporterParameter.OUTPUT_WRITER, response.getWriter());
                exporter.setParameter(JRHtmlExporterParameter.IMAGES_URI, request.getContextPath() + "/image?image=");
            }
            if (exporter != null) {
                exporter.exportReport();
            }
        } catch (Exception ex) {
            Logger.getLogger(ApplicationBean1.class.getName()).log(Level.SEVERE, null, ex);
            throw new FacesException(ex);
        }
        fcontext.responseComplete();


    }

Ahora, desde la ventana Page1.jsp hacemos doble clic en el botón Mostrar reporte. Con esto se mostrará el método button1_action(). Editemos el método para que luzca así:

public String button1_action() {
        try {
            Map<String, String> params = new HashMap<String, String>();
            params.put("personId", getPersonasLB().getSelected().toString());
            String dataSourceName = getSessionBean1().getPersonRowSet().getDataSourceName();

            String tipo = (String) formatoCG.getSelected();
            getApplicationBean1().jasperReport(tipo, dataSourceName, params);

        } catch (Exception ex) {
            Logger.getLogger(Page1.class.getName()).log(Level.SEVERE, null, ex);
            error(ex.toString());
        }
        return null;
    }



Ejecutando la aplicación

Ejecutamos el proyecto con la tecla F6.

Image:Pantallazo-ProjectRunning_ReportesEnNetBeansConIReport.png

Seleccionemos una persona de la lista, seleccionamos una opción del tipo de reporte (html o pdf) y hacemos clic en el botón "Mostrar reporte".

Reporte en HTML:

Image:reporte-html1_ReportesEnNetBeansConIReport.jpg

Reporte en PDF:

Image:reporte-pdf1_ReportesEnNetBeansConIReport.jpg


Recursos

El código fuente del proyecto utilizado en este tutorial se encuentra aquí http://diesil-java.googlecode.com/files/TravelReport.tar.gz






Ver también