Archivo de la categoría ‘Java’

Paginación en Java

Sábado, 20 de Marzo de 2010

Muchas veces lo que se necesita es implementar la paginación en Java. Tengo una forma genérica en implementar cualquier tipo de paginación en cualquier sitio. Sin cargar mucho la base de datos, ni utilizar mucha memoria una vez que se devuelven los datos. Supongamos que tenemos una tabla con muchos registros (100 000, por ejemplo) y queremos mostrarle a los usuarios 1 000 páginas con 100 registros por página.

Pongo un ejemplo genérico para un Servlet, pero en los demás casos la situación sería parecida.


public class PaginacionServlet extends HttpServlet {

private static final int REGISTROS_POR_PAGINA = 100;

private SqlMapClient SQL;

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

// para simplificar todo va dentro de bloque try..catch

// calculo la cantidad de contactos en todas las páginas

try {

// calculo el total de las entradas que tenemos

int total = (Integer)SQL.queryForObject(“”);

// calculo la cantidad de páginas total que vamos a mostrar al usuario

int mod = total % REGISTROS_POR_PAGINA;

int diff = total - mod;

int totalPaginas = diff / REGISTROS_POR_PAGINA;

if(mod != 0) // si la división no es exacta habrá una página más

totalPaginas++;

// obtengo la página actual en la que estamos

String sPage = request.getParameter(“p”);

int page = 0;

// si no está presente el parámetro asumo que estamos en la página cero (la primera)

if(sPage != null) {

page = Integer.parseInt(sPage);

page–;

}

// calculo el límite y el offset que pasaremos a la BBDD en la consulta

int offset = page * REGISTROS_POR_PAGINA;

int limit = REGISTROS_POR_PAGINA;

// la página actual ”de cara al usuario”

int paginaActual = page + 1; // el usuario empieza a contar de 1, no de 0

int paginaAnterior = page; // aquí se debería de controlar el valor de 0

int paginaSiguiente = page + 2; // la misma razón

// en la lista objects estará lo que queremos

List objects = SQL.queryForList(“queryConElLimitYElOffsetPuestos”);

}catch(Exception e){}

}

}

Publicado en Java, Soluciones | 2 comentarios »

Codificaciones en los servlets

Jueves, 18 de Marzo de 2010

Muchas veces, cuando trabajamos con caractéres que no están en la tabla ASCII (castellano incluído) pueden surgir problemas a la hora de tratar las cadenas en los servlets. Por ejemplo, muchas veces aparecen caractéres extraños en vez de las eñes, letras acentuadas, etc. La forma más sencilla de evitar esto es trabajar con UTF-8 (Unicode) a todos los niveles. Para lograrlo basta con seguir unas simples reglas a la hora de enviar los formularios:

  1. En la página HTML desde la que se envía el formulario hay que poner el meta, exactamente: <meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″>
  2. En el servlet que trata la página enviada, la primera (esto es super-importante) llamada tiene que ser: request.setCharacterEncoding(“UTF-8″);
  3. No estaría demás (pero no es obligatorio) incluir en la página HTML el tipo de documento que es, por ejemplo: <!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” “http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>.

Siguiendo estas sencillas reglas se puede evitar muchos quebraderos de cabeza.

Publicado en Java, Soluciones | 1 comentario »

Java2HTML — una utilidad para colorear Java

Lunes, 17 de Agosto de 2009

Ya que siempre estoy poniendo el código en estas páginas voy a pensar más en los usuarios que lean esto. He encontrado una utilidad muy buena llamada Java2HTML. Se puede instalar o bien como una aplicación aparte o bien como un plugin de Eclipse. Colorea el código bastante bien (podeis ver ejemplos en este mismo blog) y es muy sencilla de instalar, aquí dejo los enlaces:

Java2HTML — aplicación standalone.
Java2HTML — plugin para Eclipse (probado con Ganymede).

Publicado en Descargas, Java, Soluciones | No hay comentarios »

Ejecutar comandos Linux desde Java (II)

Lunes, 17 de Agosto de 2009

La primera parte se encuentra aquí.

En la entrada anterior vimos un ejemplo sencillo sobre cómo podíamos ejecutar un comando externo desde el código Java. Voy a intentar construir algo más complejo que esto, concretamente me interesa hacer una clase que pueda lanzar un comando Linux sin bloquear el hilo que lo origina. Es decir, lanzar un comando como si fuera un Thread más de la máquina virtual.

La forma más sencilla que conozco para hacerlo sin ningún tipo de bloqueos es mediante un Listener. A mi me interesa ver en tiempo real la STDOUT y STDERR del comando externo. También quiero saber cuando acaba y cuál es el código de salida. Construyo una interfaz:



public interface ProcessListener {
  // se llama cuando se actualiza la salida estándar
  public void updateStdOut(byte[] b);
  
  // se llama cuando se actualiza StdErr
  public void updateStdErr(byte[] b);
  
  // se llama cuando el proceso termina
  public void processFinish(int exitCode, byte[] stdOut, byte[] stdErr);
}

Esta será la interfaz que implementaremos en una clase que será la responsable de realizar ciertas operaciones en función de las distintas salidas del comando exterior. Ahora necesitamos una clase que será la encargada de lanzar el proceso propiamente dicho:



public class ProcessLauncher implements Runnable {
  private String Command;
  
  private int ExitCode = Integer.MIN_VALUE;
  
  private Thread MyThread;
  
  private Vector StdOut;
  private Vector StdErr;
  
  private ProcessListener MyProcessListener;
  
  private Object Lock = new Object();
  
  private Process MyProcess;
  
  public ProcessLauncher(String command, ProcessListener pl) {
    Command = command;
    MyProcessListener = pl;
    
    StdOut = new Vector();
    StdErr = new Vector();
    
    MyThread = new Thread(this);
    MyThread.start();
  }
  
  public boolean isFinished() {
    return ExitCode != Integer.MIN_VALUE;
  }
  
  public void run() {
    try {
      // arranco el proceso
      MyProcess = startProcess();
      // creo un controlador del proceso
      ProcessController pc = new ProcessController(MyProcess, this);
      
      // ahora hasta que no finalice el método voy leyendo la salida
      while(ExitCode == Integer.MIN_VALUE) {
        synchronized(Lock) {
          // de esta forma me aseguro que nadie más está leyendo la salida
          readStreams();
        }
        
        Thread.sleep(500); // duermo un poco para liberar los recursos
      }
    }catch(Exception e){
      e.printStackTrace();
    }
  }
  
  private void readStreams() throws Exception {
    InputStream stdout = MyProcess.getInputStream();
    InputStream stderr = MyProcess.getErrorStream();
    
    byte[] b;
    int size;
    
    size = stdout.available();
    if(size != 0) {
      b = new byte[size];
      stdout.read(b);
      
      MyProcessListener.updateStdOut(b);
      for(int i = 0; i < b.length; i++) {
        StdOut.add(b[i]);
      }
    }
    
    size = stderr.available();
    if(size != 0) {
      b = new byte[size];
      stderr.read(b);
      
      MyProcessListener.updateStdErr(b);
      for(int i = 0; i < b.length; i++) {
        StdErr.add(b[i]);
      }
    }
  }
  
  private Process startProcess() throws Exception {
    Process proc = Runtime.getRuntime().exec(Command);
    return proc;
  }
  
  public void notifyExit(int exitCode) throws Exception {
    // me notifican que se el proceso se ha terminado
    ExitCode = exitCode;
    
    // leo por última vez las salidas, por si se ha quedado algo
    synchronized (Lock) {
      readStreams();
    }
    
    // notifico al listener
    byte[] stdOut = new byte[StdOut.size()];
    for(int i = 0; i < stdOut.length; i++) {
      stdOut[i] = ((Byte)StdOut.get(i)).byteValue();
    }
    
    byte[] stdErr = new byte[StdErr.size()];
    for(int i = 0; i < stdErr.length; i++) {
      stdErr[i] = ((Byte)StdErr.get(i)).byteValue();
    }
    
    MyProcessListener.processFinish(exitCode, stdOut, stdErr);
  }
}

Esta clase se encargará de leer periodicamente los flujos de salida del proceso e ir tanto guardándolo en memoria como pasándolo al Listener en tiempo real. Pero claro, aquí nos encontramos con otra dificultad y es que resulta que queremos saber a ciencia cierta y en el momento exacto cuando termina nuestro proceso, para ello definimos un controlador de proceso (ProcessController):



public class ProcessController implements Runnable {
  private Process MyProcess;
  
  private Thread MyThread;
  
  private ProcessLauncher MyProcessLauncher;
  
  public ProcessController(Process proc, ProcessLauncher pl) {
    MyProcess = proc;
    MyProcessLauncher = pl;
    
    MyThread = new Thread(this);
    MyThread.start();
  }
  
  public void run() {
    try {
      int code = MyProcess.waitFor();
      
      // notificar al padre
      MyProcessLauncher.notifyExit(code);
    }catch(Exception e){
      e.printStackTrace();
    }
  }
}

El objeto de esta clase se ejecutará en un hilo aparte que se quedará bloqueado hasta que el proceso termine. En cuanto termina el proceso el código de salida es comunicado a ProcessLauncher para que este pueda tomar las acciones oportunas. Para la próxima vez pondré ejemplos de utilización y si me da tiempo prepararé un JAR para que se pueda bajar y usar tranquilamente como si fuera una librería.

Publicado en Java, Soluciones | 3 comentarios »

Ejecutar comandos Linux desde Java (I)

Domingo, 16 de Agosto de 2009

Muchas veces hay una necesidad de ejecutar un comando Linux (o Windows) desde Java. Las razones pueden ser varias, a veces conviene usar una cosa que ya está disponible en forma de comando (imaginaros el prototipo de un programa con el presupuesto aún sin aprobar) o a lo mejor simplemente porque una utilidad de consola consume mucho menos recursos que Java (supongamos que tenemos que recodificar avi -> fla muchos videos que nos han subido). El caso es que Java sirve perfectamente para ello, teniendo en cuenta ciertas consideraciones.

Veamos el código:


Process proc = Runtime.getRuntime().exec("ls -la");
InputStream is = proc.getInputStream();
int size;
String s;
int exCode = proc.waitFor();
StringBuffer ret = new StringBuffer();
while((size = is.available()) != 0) {
byte[] b = new byte[size];
is.read(b);
s = new String(b);
ret.append(s);
}
System.out.println(ret.toString());

La primera línea nos crea un proceso dentro de nuestro Runtime, con el comando ls -la dentro. Acto seguido obtenemos un InputStream para poder ver la salida estándar del programa. Y aquí viene la primera consideración, en el momento de lanzar el proceso con Runtime.getRuntime().exec() arranca un subproceso que sigue a su ritmo completamente. Quiero decir, si nada más arrancar el proceso intentamos leer lo que ha devuelto tendremos un String vacío, ya que de momento el processo no ha sacado nada por la salida estándar.

La solución para eso es esperar hasta que el proceso termine. Esto lo hacemos con la siguiente línea: proc.waitFor(); Lo que hace es que detiene el Thread dentro del cual hemos lanzado el proceso y espera hasta que termine el proceso (cuidado con los bloqueos). Como resultado devuelve un número entero con el código de terminación del proceso lanzado. Normalmente el código 0 significa OK, en caso de que se haya producido algún error lo normal es que devuelva otro valor.

Las siguientes líneas simplemente leen lo que el proceso ha enviado por la salida estándar y sacan el resultado por pantalla.

Otra consideración de la que no debemos olvidarnos es que un proceso tiene los siguientes flujos (dos de ellos para leer y uno para escribir):

  1. STDIN – flujo de entrada estándar. Mediante este flujo podemos enviarle datos al comando. Se obtiene mediante Process.getOutputStream().
  2. STDOUT – flujo de salida estándar. Es el que hemos usado en nuestro ejemplo.
  3. STDERR – flujo para la salida de errores. Se obtiene mediante Process.getErrorStream().

Segunda parte — como hacer lo mismo pero sin bloquear el Thread.

Publicado en Java, Linux/Unix, Soluciones | 2 comentarios »

Conectarse desde Java a MySQL mediante JDBC

Viernes, 14 de Agosto de 2009

Este post es una microchuleta sobre como uno puede conectarse a MySQL desde Java mediante JDBC. Existe infinidad de métodos y librerías para realizar esta tarea, pero aquí vamos a ver el más directo.

Supongamos que tenemos una tabla llamada test en la base de datos llamada prueba. Lo primero que tenemos que hacer es cargar el controlador (también llamado Driver).

Class.forName("com.mysql.jdbc.Driver");

Ahora componemos la URL de conexión a la BBDD y conectamos:


String urlDDBB = "jdbc:mysql://localhost:3306/prueba?user=root&password=contrasenya";
Connection conn = DriverManager.getConnection(urlDDBB);

Con esto le indicamos al controlador que nuestro servidor de MySQL se encuentra en localhost, escucha en el puerto 3306 (estándar), la base de datos se llama prueba, el usuario con el que conectamos es root y su contraseña es contrasenya. Una vez realizado podemos empezar a lanzar consultas a la tabla. Vamos a ver como podemos obtener los distintos valores que pueden guardarse en la tabla a asignarlos a las variables nuestras.


String consulta = "SELECT * FROM test";
String s;
int i;
Date d;
long l;
double dd;
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(consulta);
while(rs.next()){
s = rs.getString("columna_string");
i = rs.getInt("columna_int");
d = rs.getDate("columna_date");
l = rs.getLong("columna_long");
dd = rs.getDouble("columna_double");
}

Una cosa muy importante que debemos de hacer una vez hemos terminado de trabajar con los datos de la tabla es cerrar todos los componentes:


rs.close();
stmt.close();
conn.close();

Espero que sirva de ayuda.

Publicado en Java, Soluciones | No hay comentarios »

Cambiar una palabra por otra en Java

Viernes, 14 de Agosto de 2009

Mucha gente pregunta sobre cómo se puede cambiar una palabra por otra en Java. Es decir, lo que pretende el usuario normalmente es sustituir una cadena de caracteres por otra.

Por suerte, Java es bastante flexible y nos da dos opciones para hacerlo. La primera opción va a resulta más sencilla para toda aquella gente que no conoce expresiones regulares (RegExp) y consiste básicamente en separar la cadena en cadenas más pequeñas usando como separador la palabra buscada. Luego se concatena todo y se mete entre medias la cadena que queramos poner. Este es el algoritmo:

static String replace(String str, String pattern, String replace) {
int s = 0;
int e = 0;
StringBuffer result = new StringBuffer();
while ((e = str.indexOf(pattern, s)) >= 0) {
result.append(str.substring(s, e));
result.append(replace);
s = e+pattern.length();
}
result.append(str.substring(s));
return result.toString()
}

Otra forma mucho más sencilla de hacerlo es mediante las expresiones regulares:

String s = "Cadena1 larga muy muy larga";
s = s.replaceAll("\\{Cadena1\\}", "Cadena2")

En este ejemplo la cadena Cadena1 va a ser sustituida por Cadena2.

Publicado en Java, Soluciones | No hay comentarios »