algo de todo NO todo de algo: julio 2008

jueves, 24 de julio de 2008

1000 Visitas!!

jueves, 17 de julio de 2008

Agregar gráficas a paginas JSP usando JFreeCharts

JFreeCharts es una librería (open source) para java, para generar gráficas de forma practica y sencilla. La librería JFreeCharts fue diseñada para poderse usar tanto en aplicaciones web como de escritorio.

A continuación presentamos una forma de utilizar JFreeCharts para generar gráficas que serán incluidas en páginas JSP.

Para poder mostrar las gráficas en la página es necesario que se realicen dos HTTP Request esto es debido a la forma en que los Browsers parsean los HTML. El primer HTTP Request es el que genera el contenido de la página y el segundo es el que genera la imagen.

Ahora JSP solo puede enviar texto, así que es necesario crear un servlet para poder enviar la imagen.

Consideremos el siguiente flujo:

- Primero tenemos una clase java (En el caso de struts un action) que se encarga de cargar todos los datos necesarios para la generación de la JSP. En esta clase se cargan en session los datos que serán mostrados en las gráficas.

- Una vez cargados los datos, se genera la JSP. la cual instancia un constructor de gráficas.

- Por ultimo la JSP invoca al servlet para obtener la imagen.

Codigo:

Action: Graficar.java
En esta clase se cargan en session los datos que serán gráficados.


package com.ui.actions;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.ActionMapping;

import org.jfree.data.category.DefaultCategoryDataset;

import org.jfree.data.general.DefaultPieDataset;

import com.ui.actions.BaseAction;



public class Graficar extends BaseAction {



public ActionForward execute(ActionMapping mapping, ActionForm form,

        HttpServletRequest request, HttpServletResponse response) throws Exception {

     ActionForward forward=null;

     crearImagenes(request);

     forward = mapping.findForward("success");

     return forward;

}

private void crearImagenes(HttpServletRequest request) {

    DefaultPieDataset pieDataset = new DefaultPieDataset();

    pieDataset.setValue( "US 44.3%", 44.3 );

    pieDataset.setValue( "France", 12.1 );

    pieDataset.setValue( "Japan", 10.0 );

    pieDataset.setValue( "UK", 8.4 );

    pieDataset.setValue( "Spain", 3.4 );

    pieDataset.setValue( "Germany", 8.6 );

    pieDataset.setValue( "Australia", 3.2 );

    pieDataset.setValue( "China", 5.4 );

    pieDataset.setValue( "Other", 1.4 );

    request.getSession().setAttribute("imagenData3",pieDataset);

}

}

JSP: graficar.jsp
Esta es la página que mostrara las gráficas, es donde se invoca al constructor de graficas y al servlet.

<html>
<head>
<title>Gráficas</title>
</head>
<jsp:useBean id="myChartPie" scope="session" class="com.ui.servlets.graficas.PieChartGraphic" />
<body>
<h2>Gráficas
<!--String getChartViewer(HttpServletRequest request, HttpServletResponse response, String databean, int width, int height, String valueAxisLabel, String title, String categoryAxisLabel, boolean urls, boolean legend, boolean tooltips, boolean orientacionHorizonal, float R, float G,float B) { -->

<%String chartViewer3 = myChartPie.getChartViewer(request, response, "imagenData3",350,250,"value axis label2","Lu","categoria axis label",false,true,false,true,200,200,255);%>

<img src="<%=chartViewer3%>" border=0 usemap="#imageMap">
</body>
</html>

En el código de la página hay que prestar atención sobretodo a estas lineas:


Se crea un bean en session, AreaChartGrafic que es el encargado de generar la gráfica.

<jsp:useBean id="myChart" scope="session" class="com.servlets.graficas.AreaChartGraphic" />

Se define una variable string con el resultado de la invocación al bean antes definido, en esta invocación se pueden especificar ciertos parámetros que serán usados en la creación de la página el mas importante es el correspondiente a "databean" (3ro)que contiene el nombre de la variable en session, correspondiente los datos cargados en el action.

<!--String getChartViewer(HttpServletRequest request, HttpServletResponse response, String databean, int width, int height, String valueAxisLabel, String title, String categoryAxisLabel, boolean urls, boolean legend, boolean tooltips, boolean orientacionHorizonal, float R, float G,float B) { -->

<%String chartViewer3 = myChartPie.getChartViewer(request, response, "imagenData3",350,250,"value axis label2","Lu","categoria axis label",false,true,false,true,200,200,255);%>

Imprime la imagen de la gráfica en la pantalla
<img src="<%=chartViewer3%>" border=0 usemap="#imageMap">

Clase básica de graficadores: BasicGraphic.java
Esta clase abstracta permite abstraer toda la lógica necesaria para la invocación a los graficadores y su comunicación con el Servlet.

import java.awt.Color;
import java.awt.image.BufferedImage;
import java.io.PrintWriter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.jfree.chart.ChartRenderingInfo;
import org.jfree.chart.ChartUtilities;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.entity.StandardEntityCollection;
import org.jfree.chart.plot.PlotOrientation;

/***
*
* @author Ricardo
*
*/
public abstract class BasicGraphic {

protected HttpServletRequest request;
protected HttpServletResponse response;
protected String databean;
protected int width;
protected int height;
protected String valueAxisLabel;
protected String title;
protected String categoryAxisLabel;
protected boolean urls;
protected boolean legend;
protected boolean tooltips;
protected boolean orientacionHorizonal;
protected int R;
protected int G;
protected int B;
protected Object dataset;
protected PlotOrientation orientacion;
protected Color backgroundcolor;
  /***
   *
   * @param request
   * @param response
   * @param databean Nombre de la variable en session que contiene los datos a graficar
   * @param width Ancho que tendra la imagen
   * @param height Alto de la imagen
   * @param valueAxisLabel Etiqueta del eje de valores
   * @param title Titulo de la grafica
   * @param categoryAxisLabel Etiqueta del eje de categorias
   * @param urls
   * @param legend
   * @param tooltips
   * @param orientacionHorizonal Grafica horizontal o vertical
   * @param R Componente RED del color de fondo
   * @param G Componente GREEN del color de fondo
   * @param B Componente BLUE del color de fondo
   * @return Ruta al servlet que generara el mapping de la grafica notar que se le pasa como parametro el nombre de la variable en session que contiene el chart.
   */
  public String getChartViewer(HttpServletRequest request, HttpServletResponse response, String databean, int width, int height, String valueAxisLabel, String title, String categoryAxisLabel, boolean urls, boolean legend, boolean tooltips, boolean orientacionHorizonal, int R, int G,int B) {
   this.request=request;
   this.response=response;
   this.databean=databean;
   this.width=width;
   this.height=height;
   this.valueAxisLabel=valueAxisLabel;
   this.title=title;
   this.categoryAxisLabel=categoryAxisLabel;
   this.urls=urls;
   this.legend=legend;
   this.tooltips=tooltips;
   this.orientacionHorizonal=orientacionHorizonal;
   this.R=R;
   this.G=G;
   this.B=B;
   this.backgroundcolor = new Color(R,G,B);
   HttpSession session = request.getSession();
   dataset = session.getAttribute(databean);
   orientacion=null;
  if (orientacionHorizonal ==true){
   orientacion = PlotOrientation.HORIZONTAL;
  }else{
   orientacion = PlotOrientation.VERTICAL;
  }
  JFreeChart chart = crearJFreeChart();
     ChartRenderingInfo info = null;
     try {
       //Create RenderingInfo object
       response.setContentType("text/html");
       info = new ChartRenderingInfo(new StandardEntityCollection());
       BufferedImage chartImage = chart.createBufferedImage(width, height, info);//640,400
       // putting chart as BufferedImage in session,
       // thus making it available for the image reading action Action.
       session.setAttribute("chartImage"+databean, chartImage);
       PrintWriter writer = new PrintWriter(response.getWriter());
       ChartUtilities.writeImageMap(writer, "imageMap", info,true);
       writer.flush();
     }
     catch (Exception e) {
        Log.getInstance().write(AreaChartGraphic.class.getName(), "getChartViewer" , e);
     }
     String pathInfo = "http://";
     pathInfo += request.getServerName();
     int port = request.getServerPort();
     pathInfo += ":"+String.valueOf(port);
     pathInfo += request.getContextPath();
     String chartViewer = pathInfo + "/servlet/ChartViewer?sessionChart=chartImage"+databean;
     return chartViewer;
   }
protected abstract JFreeChart crearJFreeChart();
}

Graficadores: PieChartGraphic.java
Los graficadores son clases que extienden a BasicGraphic que implementan la función crearJFreeChart dependiendo del estilo de gráfica que se requiere.

import org.jfree.chart.*;
import org.jfree.data.general.DefaultPieDataset;
/***
*
* @author Ricardo
*
*/
public class PieChartGraphic extends BasicGraphic{

public PieChartGraphic() {
}

protected JFreeChart crearJFreeChart() {
 JFreeChart chart = ChartFactory.createPieChart(title, (DefaultPieDataset)dataset, legend, tooltips, urls);
    chart.setBackgroundPaint(this.backgroundcolor);
 return chart;
}
}



import org.jfree.chart.*;
import org.jfree.data.general.DefaultPieDataset;
/***
*
* @author Ricardo
*
*/
public class PieChartGraphic extends BasicGraphic{
public PieChartGraphic() {
}

protected JFreeChart crearJFreeChart() {
 JFreeChart chart = ChartFactory.createPieChart(title, (DefaultPieDataset)dataset, legend, tooltips, urls);
    chart.setBackgroundPaint(this.backgroundcolor);
 return chart;
}
}

Servlet: ChartViewer.java
Por ultimo esta el servlet el encargado de generar el maping de la imagen.

package com.ui.servlets.graficas;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.logging.Level;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import com.keypoint.PngEncoder;

/***
*
* @author Ricardo
*
*/
public class ChartViewer extends HttpServlet  {

private static final long serialVersionUID = 1L;

  public void init() throws ServletException {
  }

  //Process the HTTP Get request
  public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    System.out.println("ChartViewer");
    Log.getInstance().write(ChartViewer.class.getName(), "doGet", Log.ENTER, Level.INFO);
    String sessionChart = request.getParameter("sessionChart");

    // get the chart from session
    HttpSession session = request.getSession();
    BufferedImage chartImage = (BufferedImage) session.getAttribute(sessionChart);
   // set the content type so the browser can see this as a picture
    response.setContentType("image/png");

    // send the picture
    PngEncoder encoder = new PngEncoder(chartImage, false, 0, 9);

    response.getOutputStream().write(encoder.pngEncode());
    Log.getInstance().write(ChartViewer.class.getName(), "doGet", Log.EXIT, Level.INFO);
  }

  //Process the HTTP Post request
  public void doPost(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException {
    doGet(request, response);
  }

  //Process the HTTP Put request
  public void doPut(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException {
  }

  //Clean up resources
  public void destroy() {
  }
}

tener en cuenta que para que el Servlet funcione hay que acoplarlo al sistema para esto hay que agregar al Web.xml las siguientes lineas:

<servlet>
       <servlet-name>ChartViewer
    <servlet-class>com.servlets.graficas.ChartViewer
</servlet>

<servlet-mapping>
   <servlet-name>ChartViewer
   <url-pattern>/servlet/ChartViewer
</servlet-mapping>

Una ves realizado todos los pasos descriptos podemos generar gráficas dinámicas fácilmente desde nuestras paginas JSP.

miércoles, 16 de julio de 2008

Como utilizar una DLL desde codigo java

En el desarrollo de un sistema que requeria el cargado dinamico de una dll, me surgio la necesidad de mover el proyecto. Consecuencia de esto fue que el sistema dejo de funcionar sin razon aparente. Investigando un poco encontre que el problema era que no se cargaba la dll correctamente, a continuación les dejo el resultado de la investigacion. Espero les sirva ^_^

Existe dos formas diferentes de cargar una libereria nativa desde un programa java en ejecucion:

System.loadLibrary(String)

System.load(String).

El metodo System.loadLibrary permite cargar una libreria desde la ruta por defecto, en cambio System.loadLibrary permite cargar una libreria desde cualquier lado utilizando la ruta absoluta a la DLL.

Cuando usamos System.loadLibrary, lo único que hace falta especificar el nombre del archivo DLL que queremos cargar. La JVM buscará la DLL especificada en "Java library path". Este camino esta dado por la propiedad: java.library.path system property (Y puede alterarce al utilizar el comando java.exe usando la opcion -D). Por defecto este valor esta relacionado con el Windows path.

Tener en cuenta que el directorio actual es agregado automaticamente al path, por esta razon no es necesario configurar nada siempre y cuando la DLL se encuentre en el directorio de trabajo actual.

Para poder hacer que la JVM cargue la libreria, necesitamos modificar nuestro código Java de la siguiente forma (El nombre de la DLL a cargar es "HelloWorld" y se encuentra en el path):


package example.jni;

public class HelloWorld {
      private static native void writeHelloWorldToStdout();

     public static void main(String[] args) {
         System.loadLibrary("HelloWorld");
          writeHelloWorldToStdout();
     }
}

La JVM se encarga de resolver la extension dependiendo del sistema operativo.

Una vez realizados los pasos anteriores ya habremos cargado la DLL y seremos capas de usarla.

jueves, 3 de julio de 2008

Liga Deportiva Universitaria de Quito Campeón de la Copa Libertadores de América 2008

La Liga Deportiva Universitaria de Quito se coronó por primera vez como campeón de la Copa Libertadores luego de derrotar por penales a Fluminense en el estadio Maracaná.

En el partido de ida Liga había ganado 4 a 2. En el partido de vuelta Fluminense se impuso por 3 a 1.

Los goles del partido de vuelta fueron convertidos por Luis Bolaños (min 5) y Thiago Neves (min 11, min 27, min 57).

Los jugadores de Liga se hicieron grandes en la serie de penales. José Cevallos demoró cada uno de los penales que le lanzaron y comenzó atajando el de Darío Conca. Cícero fue el único que anotó para Fluminense, recién en el tercer lanzamiento. Ni siquiera la figura del partido, Thiago Neves, acertó su penal.

Y en el cuarto penal, Washington remató muy mal y Cevallos desató la fiesta ecuatoriana en un desolado Maracaná.

Equipos ecuatorianos en la copa libertadores:

1975 - Liga de quito: semifinalista

1976 - Liga de quito: semifinalista

1985 - El Nacional: semifinalista

1986 - Barcelona: semifinalista

1987 - Barcelona: semifinalista

1990 - Bacelona: Finalista cayo ante el Olimpia

1992 - Barcelona: semifinalista

1995 - Emelec: semifinalista

1998 - Barcelona: Finalista cayo ante el Vasco da Gama

2008 - Liga de Quito: campeón derrontando al Fluminense

Ultimos campeones de la libertadores:

2004 - Once Caldas (COL)

2005 - Sao Pablo (BRA)

2006 - Internacional (BRA)

2007 -Boca Juniors (ARG)

2008 - Liga de Quito (ECU)

Historia de la liga de Quito:

Liga Deportiva Universitaria, nace en octubre de 1918 , cuando el equipo de los "doctorcitos", marca el inicio de una gran etapa con el nombre de 'Universitario' . Un club de fútbol para colmar la satisfacción y las necesidades de los universitarios de ese tiempo, pero con grandes y positivos resultados.

A continuación les dejo un video con un resumen de la final:

¿Cómo validar números enteros por JavaScript?

La páginas web están formadas por múltiples elementos pero el principal para la interacción con el usuario son los formularios, donde el usuario ingresa datos que luego serán enviados al servidor. Para evitar que se envíen datos incorrectos al servidor siempre es recomendable validarlos antes.
Una forma de validar los datos es por medio de funciones javascript que se ejecutan en el evento "onsubmit" del formulario.

A continuación les dejo una función javascript para validar que se ingrese un entero en un campo de texto.


 //valida que el elemento con identificador (id)
 //y de nombre (nombre) tenga un valor entero
 function validarInt(id, nombre) {
     var error = '';
     elemento = document.getElementById(id);
     var re = /^(-)?[0-9]*$/;
     if (!re.test(elemento.value)) {
         error = 'El campo '+nombre+' debe ser un número entero';
     }
     return error;
 }

miércoles, 2 de julio de 2008

Cuidado señores a bordo!!

Es cierto que hay algunas personas que no deben acercarse a los botes por ejemplo las que aparecen en este videito, jaja. ^_^

España campeón de la Euro Copa 2008

De forma merecida tras desplegar el mejor fútbol del campeonato España se consagró campeón de la Euro Copa 2008 tras derrotar a Alemania 1 a 0 con gol de Fernando Torres.
Gracias a este título por fin la selección española fue capaz de demostrar un favoritismo (injustificado hasta la fecha) que se le otorgaba cada vez que iniciaba una competencia internacional y que hacia 44 años que no ganaba. Sin duda el triunfo da esperanzas de conseguir mayores logros en el futuro cercano.

El plantel de españa en la Euro:

Arqueros

Defensas

Centrocampistas

6 Andrés Iniesta »
8 Xavi Hernández » votado como Mejor Jugador
10 Cesc Fàbregas »
12 Santi Cazorla »
14 Xabi Alonso »
19 Marcos Senna »
22 Rubén de la Red »

Delanteros

7 David Villa » goleador del Torneo con 4 goles
9 Fernando Torres »

16 Sergio García »

17 Daniel Güiza »
21 David Silva »

Los campeones de la UEFA:

1960 - URSS

1964 - España

1968 - Italia

1972 - Alemania

1980 - Alemania

1984 - Francia

1988 - Holanda

1992 - Dinamarca

1996 - Alemania

2000 - Francia

2004 - Grecia

2008 - España

A continuación les dejo todos los goles de España en la Euro Copa 2008:

algo de todo NO todo de algo