domingo, noviembre 30, 2008

Ley contra el SPAM

Leo en el periodo la Nación (http://www.nacion.com/ln_ee/2008/noviembre/28/pais1788837.html) la divulgación acerca de una ley para castigar a las entidades o personas que realicen SPAM, ya sea mediante llamadas telefónicas, mensajes de texto (SMS), etc.

Una buena practica, cuando recibimos un correo electrónico basura, es rastrear la IP y enviársela a Racsa detallando el delito, en el caso de mensajes de texto o llamadas no deseadas, se puede notificar al ICE.

Por otro lado, sería interesante crear un "black list", para denunciar y exponer a los sitios, números de teléfono o personas que se dedican a este tipo de actividades.

miércoles, noviembre 26, 2008

Impensando acerca de las referencias en Java

Fue hace ya algún tiempo que pase un rato discutiendo con algunos compañeros acerca de si existe o no el paso por referencia; el discurso fue mucho hacia que en Java el comportamiento, en el supuestamente pasamos por referencia un objeto y por valor los objetos primitivos creo mucha polémica.

Para ubicarnos en contexto veamos el siguiente ejemplo.

public static void main(String[] args) {

int value = 10;

changeValue(value);

System.out.println("value = " + value);

User user = new User();
Name name = new Name();

user.setName(name);
name.setName("jsanca");
name.setLastName("XXX");

user.setPassword("123queso");

System.out.println("user: " + user.getName().getName() + ", "
+ user.getName().getLastName() + ", " + user.getPassword());

changeValue1(user);

System.out.println("user: " + user.getName().getName() + ", "
+ user.getName().getLastName() + ", " + user.getPassword());

changeValue2(user);

System.out.println("user: " + user.getName().getName() + ", "
+ user.getName().getLastName() + ", " + user.getPassword());

changeValue3(user);

System.out.println("user: " + user.getName().getName() + ", "
+ user.getName().getLastName() + ", " + user.getPassword());
}


// lost the reference
private static void changeValue3(User user) {

Name name = new Name ();
name.setName("anotheruser");
name.setLastName("somelastname");
user = new User (); // here lost the reference.
user.setPassword("xxxxxx");
}

// change the password, used reference for user object.
private static void changeValue2(User user) {

user.setPassword("654321");
}

// change the name for new name object, used reference for user object.
private static void changeValue1(User user) {
Name name = new Name ();
name.setName("hackuser");
name.setLastName("trocker");

user.setName(name);
}

private static void changeValue(int value) {

value *= 20;
}

Resultado:

value = 10
user: jsanca, XXX, 123queso
user: hackuser, trocker, 123queso
user: hackuser, trocker, 654321
user: hackuser, trocker, 654321

Como se puede notar, cuando pasamos un valor primitivo (llamese entero, carácter, etc) y el valor se modifica en el método, el resultado no se refleja al salir del "scope" del método, de aquí le recomiendo pasar los valores primitivos como final y así se asegura que los programadores no van a tener confusiones.

El segundo y tercero método, consiste en la supuesta referencia y la misma es modificada, la tercera pierde la referencia, pues cuando se realiza un "new" el compilador otorga una nueva casilla de memoria, perdiendo totalmente la referencia pasada por parámetro.

Si analizamos, por ejemplo C++, cuando una variable inclusive nula, se le pasa &miVar en un parámetro, realmente pasamos un referencia, pero esto sucede porque en C++ la memoria es gestionada por los programadores, al contrario de Java, donde es tarea del Garbage Collector; en C++ existen los punteros, así como las instrucciones new y delete o free y malloc en el caso de C, pero en Java no existen los punteros, por lo que discutir acerca si el paso por referencia es estrictamente igual que el que esperamos en C++ no tiene sentido, pues la referencias pueden solo existir en un lenguaje con soporte de punteros, al no tener Java esta característica, en realidad no existe el paso por referencia, solo podemos concluir que Java no cambia los datos primitivos en una función, pero puede cambiar las propiedades de un objeto siempre y cuando el objeto en si, no sea cambiado, es decir que no suceda como en el método "changeValue3()" donde se le realiza un "new" al objeto pasado por parámetro.

La unica excepción a esta regla, la podemos encontrar en el contexto de RMI, donde todos los objetos así como los primitivos son pasados por valor (por razones obvias de perfomance), aunque extendiendo una interface se le puede indicar que esta variable debe ser sincronizada entre el cliente y el server, es decir que se pase una referencia al estilo de Java.

martes, noviembre 25, 2008

Labor de mantenimiento

Como parte mi labor de mantenimiento, se han adherido nuevos elementos al blog;

  1. Se agrego un icono para el usuario de debugmodeon y mi perfil de linkedin.

  2. Se cambio el "look & feel" y la estrategia adSense.

  3. Se agrego un nuevo elemento llamado: Que hay de nuevo en blogger, el mismo tiene las actualizaciones mis blogs.

  4. La sección de visitalos fue actualizada y refactorizada.

  5. La sección de foto fue eliminada, por no contar con ninguna hasta el momento.



Del primer punto, solo decir que ambos iconos los tome del sitio debugmodeon y los agregue como un nuevo elemento HTML/JavaScript.

El segundo punto fue cambiado después de leer algunos artículos en adsense en español; este sitio además fue agregado a que hay de nuevo y les recomiendo visitarlo regularmente, pues contiene información y artículos muy interesantes acerca de Google AdSense.

El tercer elemento me gusta bastante y muestra de una manera muy agradable los blog con las entradas mas recientes.

Mi ultimo y cuarto elemento, he insertado y removido algunos links, ahí seguiré agregando links de interés común.

Espero les guste, ciao!

lunes, noviembre 24, 2008

Utilizando expresiones regulares en Java

A continuación muestro un ejemplo de como utilizar expresiones, no se pretende cubrir extensivamente ni mucho menos, el uso de expresiones regulares. Nuestro ejemplo, simplemente muestra como buscar los matches, de una cadena dentro de otra.

Nota: Tanto el objeto Pattern como Matcher, se encuentra alojados en el paquete java.util.regex del SDK Java Standard.

public static int countMatches (String string, String patternToFind) {

Pattern pattern = null;
Matcher matcher = null;
int countMatches = 0;

pattern = Pattern.compile(patternToFind);
matcher = pattern.matcher(string);

while (matcher.find()) {

countMatches +=1;
}

matcher = null;
pattern = null;

return countMatches;
} // countMatches

System.out.println(countMatches("hola ?,?,?,?,?)", "\\?"));
System.out.println(countMatches("hola)", "\\?"));

Resultado:

5
0

El ejemplo simplemente compila una cadena, una vez compilado y siendo valido, solicitamos los matches e invocamos a find, para ir buscando los matches de la cadena ahí.

Bastante simple, disfrutenlo!

Open CSV

http://opencsv.sourceforge.net/ trata de un framework muy simple y sin mas dependencias de acople que el mismo SDK, a continuación muestro como encapsular mediante Spring, la librería y a su vez leer un archivo csv.


import java.io.Closeable;
import java.io.IOException;

/**
* Common interface to read CSV file extension.
* @author jsanca
*
*/
public interface CsvReaderGenericDAO extends Closeable {

/**
* Return the next row in the CSV file,
* null if not has next.
* @return String []
*/
String [] next () throws IOException;
} // E:O:F:CsvReaderGenericDAO.

Esta clase será nuestra interface común para el lector de Csv. Como puedes ver, simplemente lee la siguiente fila y retorna un vector de cadenas, null en caso que ya no existan mas filas.

import java.io.IOException;

import au.com.bytecode.opencsv.CSVReader;

/**
* http://opencsv.sourceforge.net/ implementation wrapper.
* @author jsanca
*
*/
public class OpenCsvReaderGenericDAOImpl implements CsvReaderGenericDAO {

private CSVReader csvReader = null;

/**
* Constructor.
*/
public OpenCsvReaderGenericDAOImpl(CSVReader csvReader) {

this.csvReader = csvReader;
} // OpenCsvReaderGenericDAOImpl.

/* (non-Javadoc)
* @see cr.smartframework.geo.locator.dao.CsvReaderGenericDAO#next()
*/
@Override
public String[] next() throws IOException {

return this.csvReader.readNext();
} // next.

/* (non-Javadoc)
* @see java.io.Closeable#close()
*/
@Override
public void close() throws IOException {

if (null != this.csvReader) {

this.csvReader.close();
}
} // close.

} // E:O:F:OpenCsvReaderGenericDAOImpl.

Esta sería nuestra implementación, por defecto, implementa la interface antes dicha, junto con la interface closeable.
La implementación simplemente envuelve (wrappea) un CSVReader e invoca al método readNext, para ir obteniendo la siguiente fila.

import java.io.File;
import java.io.FileReader;

import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;

import au.com.bytecode.opencsv.CSVReader;

/**
* Factory to build the OpenCsvReader...
* Lee y parsea a objetos un archivo csv.
* @author jsanca
*
*/
public class OpenCsvReaderGenericDAOFactoryBean implements FactoryBean,
InitializingBean {

private OpenCsvReaderGenericDAOImpl object = null;

private String pathFile = null;

/**
* Obtiene el path del archivo csv.
* @return String
*/
public String getPathFile() {
return pathFile;
} // getPathFile.

/**
* Obtiene el path del archivo csv.
* @param pathFile String
*/
public void setPathFile(String pathFile) {
this.pathFile = pathFile;
} // setPathFile.

/**
* Constructor.
*/
public OpenCsvReaderGenericDAOFactoryBean() {

super ();
} // OpenCsvReaderGenericDAOFactoryBean.

/* (non-Javadoc)
* @see org.springframework.beans.factory.FactoryBean#getObject()
*/
@Override
public Object getObject() throws Exception {

return this.object;
} // getObject.

/* (non-Javadoc)
* @see org.springframework.beans.factory.FactoryBean#getObjectType()
*/
@SuppressWarnings("unchecked")
@Override
public Class getObjectType() {

return OpenCsvReaderGenericDAOImpl.class;
} // getObjectType.

/* (non-Javadoc)
* @see org.springframework.beans.factory.FactoryBean#isSingleton()
*/
@Override
public boolean isSingleton() {

return false;
} // isSingleton.

/* (non-Javadoc)
* @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
*/
@Override
public void afterPropertiesSet() throws Exception {

CSVReader csvReader = null;

csvReader = new CSVReader (new FileReader(new File (this.pathFile)));
this.object =
new OpenCsvReaderGenericDAOImpl (csvReader);
} // afterPropertiesSet.

} // E:O:F:OpenCsvReaderGenericDAOFactoryBean.

Ahora realizamos un acomple intrusivo para crear un factorybean de String, el mismo posse la propiedad "pathFile", donde se asigna (comunmente mediante inyección) la locación del archivo. Si hechas un ojo en "afterPropertiesSet"; este método simplemente crea un CSVReader.


<bean id="cvsReaderDAO" class="cr.smartframework.geo.locator.dao.OpenCsvReaderGenericDAOFactoryBean">
<property name="pathFile" value="${csvFilePath}">
</property>



<bean id="algunBean" class="AlgunBean">
<property name="cvsReaderDAO" ref="cvsReaderDAO">
</property>

Por ultimo mostramos el código necesario para asignar nuestro cvsReaderDAO a algún bean.

viernes, noviembre 21, 2008

Revisa tu ortografía

En los últimos días y como todos los blogueros se darán cuenta, el corrector ortográfico de blogger, no esta funcionando de la manera correcta, encontré este otro sitio donde puedes checar en línea tu ortografía; http://revisor.com.ar/, funciona bastante bien y es mejor que tener que abrir el open office o el Abi.

http://portableapps.com/

http://portableapps.com/ es un sitio Web, donde puedes conseguir gran cantidad de software en principio portable (i.e no ocupa instalarse) y entre sus filas milita mucho software free o open, yo lo estoy evaluando el sitio y hasta el momento me parece muy completo.

My Cow parade


http://www.mycowparade.net Full recomendado, este sitio conserva una de las más grandes colecciones de las vaquitas que se formaron parte de la muestra de arte, del cowparade, San José y que si mas no me equivoco, ahora se encuentran en las ruinas de Cartago.
Excelente recopilación y sin mas, mis sinceras felicitaciones al creador!

miércoles, noviembre 19, 2008

Algunas cosas acerca de Herencia, sobre escritura y métodos estaticos

A continuación vamos a realizar un pequeño estudio, acerca de dos cosas, la primera de ellas es probar que pasa cuando ponemos los keywords, final y static al mismo tiempo en una clase, la segunda es determinar el comportamiento de las clases cuando se sobre escribe un método estático.

1) Tomando en cuenta que una clase final no puede ser extendida y una clase abstract debe ser extendida, cuando intentamos hacer:

public final abstract class ImposibleAbstractClass {

public abstract void doSomething ();
}

El compilador nos muestra el siguiente error de compilación:

"The class ImposibleAbstractClass can be either abstract or final, not both"

Osea, no se puede hacer.

2) Que pasa cuando sobre cargamos un método estático:

Veamos el siguiente código:
public class A {

public static void a () {

System.out.println("A");
}

public void b () {

System.out.println("a");
}
}

public class B extends A {

public static void a () {

System.out.println("B");
}

@Override
public void b() {

System.out.println("b");
}

}

public class Main {

@SuppressWarnings("static-access")
public static void main(String[] args) {

A a = new A ();
A b = new B ();

a.a(); // funciona x tipo
b.a();

System.out.println("***********");

a.b(); // funciona x polimorfismo, osea por implementación.
b.b();

System.out.println("***********");

A.a(); // Llamado directo a la clase, no hay quite.
B.a();

}
}

Resultado:
A
A
***********
a
b
***********
A
B

Como pueden ver y a diferencia del comportamiento polimorfico, la implementación del método la otorga el tipo y no la implementación.
Si cambiamos;
A a = new A ();
A b = new B ();

Por

A a = new A ();
B b = new B ();

El resultado cambia a:
A
B

Por que el tipo de la variable "b" paso de A a B, y por esta razón utiliza esta sobrecarga.

lunes, noviembre 17, 2008

Test de eficiencia en concatenación de Java String.

El siguiente código resulta muy interesante, en el grado que nos permite experimentar con diferentes implementaciones de CharSequence, para concatenar caracteres (string con +, string utilizando el método concat, StringBuilder, StringBuffer y una biblioteca de terceros que implementa un nuevo objeto llamado Ropes, el cual asegura ser mas rápido y eficiente que el StringBuffer y el simple String (+ info: http://ahmadsoft.org/ropes/).

Los resultados a la vista son muy interesantes, el StringBuilder gana la lucha en eficiencia y eficacia. Y la razón del resultado recae en la estrategia de bufereo y que el objeto no sea sincronizado, muy cerca le sigue el StringBuffer el cual utiliza la misma estrategia de buffering, sin embargo es un objeto sincronizado, seguido por la biblioteca propietaria Ropes, la utilizaron del método String.concat() se encuentra de penúltima, la ultima y altamente no recomendable es la utilización del operador + para concatenar; esta operación no solo es lenta, también utiliza mucha memoria y hace que nuestra aplicación ocupe mas tiempo de proceso, practicamente mas de 250 veces mas lento en el manejo intensivo de concatenación que utilizar StringBuilder.

Aquí los resultados:

47 = StringBuilder
52 = StringBuffer
286 = Ropes
61079 = String.concat().
137514 = string = string1 + string2;
Este resultado se encuentra en milli segundos.



import java.util.Map;
import java.util.TreeMap;

import org.ahmadsoft.ropes.Rope;


public class ConcatenationStringExample {

public void concat() {

Map resultTimeMap = new TreeMap ();
Map resultMenMap = new TreeMap ();
final CharSequence s = "Hello classmate, this is the concatening example, [email protected]#$%^&*()_+, @@@###@@@ 1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111======================blauppee";
final int repeat = 6000;


long totalTime = 0;
long totalMem = 0;

long iniMem = Runtime.getRuntime().freeMemory();
long initTime = System.currentTimeMillis();

this.simpleConcatString(s, repeat);

totalTime = System.currentTimeMillis() - initTime;
totalMem = iniMem - Runtime.getRuntime().freeMemory();

System.out.println("Total time in millis: " + totalTime
+ ", total memory used: " + totalMem);

resultTimeMap.put(totalTime, "simpleConcatString");
resultMenMap.put(totalMem, "simpleConcatString");
System.gc();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
/**/
}
// //////////////////////////////////////////////////////////////
iniMem = Runtime.getRuntime().freeMemory();
initTime = System.currentTimeMillis();

this.concatString(s, repeat);

totalTime = System.currentTimeMillis() - initTime;
totalMem = iniMem - Runtime.getRuntime().freeMemory();

System.out.println("Total time in millis: " + totalTime
+ ", total memory used: " + totalMem);

resultTimeMap.put(totalTime, "concatString");
resultMenMap.put(totalMem, "concatString");
System.gc();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
/**/
}
// //////////////////////////////////////////////////////////////
iniMem = Runtime.getRuntime().freeMemory();
initTime = System.currentTimeMillis();

this.concatStringBuffer(s, repeat);

totalTime = System.currentTimeMillis() - initTime;
totalMem = iniMem - Runtime.getRuntime().freeMemory();

System.out.println("Total time in millis: " + totalTime
+ ", total memory used: " + totalMem);

resultTimeMap.put(totalTime, "concatStringBuffer");
resultMenMap.put(totalMem, "concatStringBuffer");
System.gc();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
/**/
}
// //////////////////////////////////////////////////////////////
iniMem = Runtime.getRuntime().freeMemory();
initTime = System.currentTimeMillis();

this.concatStringBuilder(s, repeat);

totalTime = System.currentTimeMillis() - initTime;
totalMem = iniMem - Runtime.getRuntime().freeMemory();

System.out.println("Total time in millis: " + totalTime
+ ", total memory used: " + totalMem);

resultTimeMap.put(totalTime, "concatStringBuilder");
resultMenMap.put(totalMem, "concatStringBuilder");
System.gc();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
/**/
}
// //////////////////////////////////////////////////////////////
iniMem = Runtime.getRuntime().freeMemory();
initTime = System.currentTimeMillis();

this.concatRopes(s, repeat);

totalTime = System.currentTimeMillis() - initTime;
totalMem = iniMem - Runtime.getRuntime().freeMemory();

System.out.println("Total time in millis: " + totalTime
+ ", total memory used: " + totalMem);

resultTimeMap.put(totalTime, "concatRopes");
resultMenMap.put(totalMem, "concatRopes");

System.out.println("***************-*******************");
System.out.println("time results with " + (repeat) + " repeat :" + resultTimeMap.toString().replaceAll(",","\n"));
System.out.println("Memory results with " + (repeat) + " repeat :" + resultMenMap.toString().replaceAll(",","\n"));

} // concat.

private void concatRopes(final CharSequence sequence, final int repeat) {

Rope string = null;

string = Rope.BUILDER.build(sequence);
for (int i = 0; i < Math.abs(repeat); ++i) {

string = string.append(sequence.toString());
}
System.out.println("concatRopes length: " + string.length());
} // concatRopes.


private void concatStringBuilder(final CharSequence sequence, final int repeat) {

StringBuilder string = null;

string = new StringBuilder(sequence);
for (int i = 0; i < Math.abs(repeat); ++i) {

string.append(sequence);
}
System.out.println("concatStringBuilder length: " + string.length());
} // concatStringBuilder.


private void concatStringBuffer(final CharSequence sequence, final int repeat) {

StringBuffer string = null;

string = new StringBuffer(sequence);
for (int i = 0; i < Math.abs(repeat); ++i) {

string.append(sequence);
}
System.out.println("concatStringBuffer length: " + string.length());
} // concatStringBuffer.


private void concatString(final CharSequence sequence, final int repeat) {

String string = null;

string = new String(sequence.toString());
for (int i = 0; i < Math.abs(repeat); ++i) {

string = string.concat(sequence.toString());
}

System.out.println("concatString length: " + string.length());
} // concatString.

private void simpleConcatString(final CharSequence sequence,
final int repeat) {

String string = null;

string = new String(sequence.toString());
for (int i = 0; i < Math.abs(repeat); ++i) {

string = string + sequence;
}

System.out.println("simpleConcatString length: " + string.length());
} // concatString.

public static void main(String[] args) {

ConcatenationStringExample example = new ConcatenationStringExample();
example.concat();
}
} // ConcatenationStringExample.

Comparación de cadenas en Java

El siguiente código nos muestra diferentes formas y métodos para realizar comparaciones de cadenas.
La primera comparación con el operador (==), se realiza simplemente a nivel de referencia de memoria. El método (equals) permite realizar una comparación carácter a carácter de dos strings. (equalsIgnoreCase) funciona igual que (equals) descartando las diferencias entre mayúsculas y minúsculas. (CompareTo) permite comparar dos cadenas, con la diferencias que si la clase es igual retorna 0, si la primera cadena es mayor retorna la diferencia (un numero positivo), si la cadena es menor retorna también la diferencia (un numero negativo).
Por ultimo se utilizan métodos para realizar comparaciones de pre y pos cadenas, obtener un índice, etc.

public void comparisonEqual () {

String s1 = "Hello Word";
String s2 = "Hello Word";
String s3 = s1;

// Equal examples...
System.out.println((s1 == s2)?s1 + " = " + s3: s1 + " != " + s3);
System.out.println((s1 == s3)?s1 + " = " + s3: s1 + " != " + s3);

s3 = "hello word";
System.out.println((s1.equals(s2))?s1 + " equals " + s2: s1 + " !equals " + s2);
System.out.println((s1.equals(s3))?s1 + " equals " + s3: s1 + " !equals " + s3);

System.out.println((s1.equalsIgnoreCase(s2))?s1 + " equalsIgnoreCase " + s2: s1 + " !equalsIgnoreCase " + s2);
System.out.println((s1.equalsIgnoreCase(s3))?s1 + " equalsIgnoreCase " + s3: s1 + " !equalsIgnoreCase " + s3);

System.out.println(this.customEqual(s1, s2)?s1 + " customEqual " + s2: s1 + " !customEqual " + s2);
System.out.println(this.customEqual(s1, s3)?s1 + " customEqual " + s3: s1 + " !customEqual " + s3);

s1 = s1.toLowerCase();
System.out.println(this.customEqual(s1, s3)?s1 + " customEqual " + s3: s1 + " !customEqual " + s3);

// comparison examples....
System.out.println(s1 + " compareTo " + s3 + ":" + s1.compareTo(s3));

s3 = s3.substring(2);
System.out.println(s1 + " compareTo " + s3 + ":" + s1.compareTo(s3));

System.out.println(s3 + " compareTo " + s1 + ":" + s3.compareTo(s1));

// comparison and finding examples...
System.out.println("s1.startsWith(\"hell\"): " + s1.startsWith("hell"));
System.out.println("s1.toUpperCase().startsWith(\"HELL\"): " + s1.toUpperCase().startsWith("HELL"));

System.out.println("s1.endsWith(\"ord\"): " + s1.endsWith("ord"));

System.out.println("s1.indexOf('o'): " + s1.indexOf('o'));
System.out.println("s1.indexOf('o', s1.indexOf('o')): " + s1.indexOf('o', s1.indexOf('o') + 1));

System.out.println("s1.lastIndexOf('o'): " + s1.lastIndexOf('o'));

System.out.println("s1.contains(\"o w\"): " + s1.contains("o w"));
}

public boolean customEqual (String s1, String s2) {

boolean isequal = s1.length() == s2.length();

if (isequal) {

for (int i = 0; i < s1.length(); i++) {

isequal &= (s1.charAt(i) == s2.charAt(i));
}
}

return isequal;
}

String en Java

Ahora nos centraremos en objetos CharSequence, esta interface es implementada por varios objetos, tales como; String, StringBuilder, StringBuffer, CharBuffer. Ahora nos centraremos en los primeros 3 objetos, pero tomando más importancia al objeto String.

String s = "Hello Word";

System.out.println("chartAt: " + s.charAt((s.length() - 1) / 2));
System.out.println("codePointAt: " + s.codePointAt((s.length() - 1) / 2));

System.out.println("isEmpty: " + s.isEmpty());
System.out.println("split: " + java.util.Arrays.toString(s.split("o")));
System.out.println("toCharArray: " + java.util.Arrays.toString(s.toCharArray()));
System.out.println("toCharArray: " + s.replace('o', 'a') );
System.out.println("toCharArray: " + s.replace("Hello", "Good bye") );

El método CharAt, nos permite obtener el carácter en una posición determinada.
El método codePointAt, nos proporciona el ascii correspondiente al carácter en la posición indicada.
El método isEmpty, solo indica si el objeto tiene un tamaño (length() == 0), igual a cero, si desea ver si un objeto es vacio o está lleno de blancos, aplique string.trim().length() == 0.
El método Split, crea un vector, resultado de dividir la cadena por algún token.
El método toCharArray, transforma la cadena en un vector de caracteres que componen la cadena.
El método replace, tiene diferentes sobrecargas para implementar un replace sobre el objeto, tome en cuenta que el string en realidad es un objeto de solo lectura, por lo tanto cualquier modificación al mismo, regularmente retorna la cadena resultante.

jueves, noviembre 13, 2008

Transformando fechas a diferentes zonas horarias (TimeZone)

Ya es sabido por todo programador Java, que uno de los puntos mas bajos, recae en el uso de las fechas, las mismas se encuentran super mal diseñadas y algunos objetos como el caso de Date, practicamente no son usables, pues toda su API esta deprecada (cosa que siento debería de dejar de ponerla deprecada, pues van por la versión 6 y aun la conservan). Recientemente me encontré con el siguiente problema; resulta que al poner un sistema en otro servidor, el cual aparentemente tiene una diferencia horaria configurada, obtenemos como seria de esperar resultados no esperados, cuando realizamos consultas con fechas a la base de datos. La primera solución que se nos ha ocurrido es implementar un convertidor de fechas a diferentes zonas horarias, a continuación coloco el método necesario para realizar la operación:


public static Date convertToTimeZoneDate(Date date, TimeZone timeZone) {

Date newTimeZoneDate = null;
Calendar foreignCalendar = null;
// Create a Calendar object with the local time zone
Calendar localCalendar = new GregorianCalendar();
localCalendar.setTime(date);

// Create an instance using foreign time zone and set it with the local
// UTC
strangerCalendar = new GregorianCalendar(timeZone);
strangerCalendar.set(Calendar.HOUR_OF_DAY, localCalendar
.get(Calendar.HOUR_OF_DAY));
strangerCalendar.set(Calendar.MINUTE, localCalendar
.get(Calendar.MINUTE));
strangerCalendar.set(Calendar.SECOND, localCalendar
.get(Calendar.SECOND));

// Create a Calendar object with the local time zone and set
// the UTC from foreign calendar
newTimeZoneDate = new Date(strangerCalendar.getTimeInMillis());

return newTimeZoneDate;
} // convertToTimeZone.

Este conveniente método, puede usarse de la siguiente forma:


String newTimeZoneId = "Chile/Continental";
Calendar calendar = new GregorianCalendar ();
Date date2 = calendar.getTime();
System.out.println(date2 + ":" + calendar.getTimeZone().getID());
System.out.println(convertToTimeZoneDate(date2, TimeZone
.getTimeZone(newTimeZoneId)) + ":" + newTimeZoneId);


Este código nos permite, obtener convertir nuestra fecha actual a la hora en chile. Para obtener la lista de las zonas horarias disponibles, puede ejecutar el siguiente código:


import java.io.PrintStream;
import java.util.Date;
import java.util.TimeZone;

public class TimeZoneAvailable {

/**
*
*/
public TimeZoneAvailable() {
}

public void execute() {

this.printTimeZones(System.out);
}

public void printTimeZones (PrintStream out) {

Date today = new Date();

// Get all time zone ids
String[] zoneIds = TimeZone.getAvailableIDs();

out.println("zoneIds.length = " + zoneIds.length);
// View every time zone
for (int i = 0; i < zoneIds.length; i++) {
// Get time zone by time zone id
TimeZone tz = TimeZone.getTimeZone(zoneIds[i]);

// Get the display name
String shortName = tz.getDisplayName(tz.inDaylightTime(today),
TimeZone.SHORT);
String longName = tz.getDisplayName(tz.inDaylightTime(today),
TimeZone.LONG);

// Get the number of hours from GMT
int rawOffset = tz.getRawOffset();
int hour = rawOffset / (60 * 60 * 1000);
int min = Math.abs(rawOffset / (60 * 1000)) % 60;

// Does the time zone have a daylight savings time period?
boolean hasDST = tz.useDaylightTime();

// Is the time zone currently in a daylight savings time?
boolean inDST = tz.inDaylightTime(today);

out.println(zoneIds[i] + ", " + shortName + ", " + longName + ", "
+ hour + ", " + min + ", hasDST: " + hasDST
+ ", inDST: " + inDST);
}
}

public static void main(String[] args) {

new TimeZoneAvailable().execute();
}
}







martes, noviembre 11, 2008

Un viaje a través de los Vectores en Java

import java.util.ArrayList;
import java.util.List;

public class Arrays {

public void example1() {

int i = 0;
// Diferentes formas de declarar un array.
Object[] objectArray = null;
String[] stringArray = new String[10];
int[] intArray = new int[] { i++, i++, i++, i++, i++, i++, i++, i++,
i++, i++ };
Character[] characterArray = { 'a', 'b', 'c' };
char[] charArray = new char[26];

for (int j = 0; j < stringArray.length; j++) {

stringArray[j] = String.valueOf(j);
}

List listString = java.util.Arrays.asList(stringArray);
System.out.println("listString = " + listString);

System.out
.println("java.util.Arrays.binarySearch(characterArray, 'c') = "
+ java.util.Arrays.binarySearch(characterArray, 'c'));

System.out
.println("java.util.Arrays.binarySearch(characterArray, 'd') = "
+ java.util.Arrays.binarySearch(characterArray, 'd'));

System.out
.println("java.util.Arrays.equals(characterArray, new char [] {'a','b','c'}); = "
+ java.util.Arrays.equals(characterArray,
new Character[] { 'a', 'b', 'c' }));

System.out
.println("java.util.Arrays.equals(characterArray, new char [] {'d','f','g'}); = "
+ java.util.Arrays.equals(characterArray,
new Character[] { 'd', 'f', 'g' }));

java.util.Arrays.fill(charArray, 'a');
System.out.println("charArray = "
+ java.util.Arrays.toString(charArray));

System.out.println("java.util.Arrays.hashCode(characterArray) = "
+ java.util.Arrays.hashCode(characterArray));

char[] orderArrayExample = new char[] { 'c', 'a', 'b', 'x', 'z', 'e',
'h' };
java.util.Arrays.sort(orderArrayExample);
System.out.println("orderArrayExample = "
+ java.util.Arrays.toString(orderArrayExample));

System.out.println("buildStringArray = "
+ java.util.Arrays.toString(buildStringArray("one", "two",
"three")));
} // example1.

public String[] buildStringArray(String... strings) {

List listString = new ArrayList();

for (String string : strings) {

listString.add(string);
}

return listString.toArray(new String[] {});
} // buildStringArray.

public static void main(String[] args) {

new Arrays().example1();
}
}

Las primeras líneas de código, encontramos diferentes maneras de inicializar un vector en Java; lo primero que debes notar, es que en Java los vectores representa un tipo de dato (Array) por eso se deben colocar los corchetes (se puede tanto al inicio como al final de la variable), puedes inicializarlo a null, colocarle una cantidad inicial (en donde todos los valores serán nulos o se almacenaran los valores por defecto en el caso de los datos primitivos), sin indicar el tamaño, pero proporcionando un conjunto de datos iníciales entre paréntesis (en este caso no siempre es necesario el uso del operador new).

A continuación podemos apreciar la forma de llenar un vector a través de una instrucción “for”, como crear un objeto List a partir de un Vector, como hacer una búsqueda binaria valiéndonos del objeto, java.util.Array, también el equals para comparar dos vectores, fill para llenar un vector con un idéntico valor, como obtener una representación en String de nuestro vector, como aplicar hashCode a cada elemento dentro del vector, como realizar el ordenamiento de un vector (tome en cuenta que en el caso de los tipos no primitivos, usted deberá asegurar que estos objetos implementan la comparación, a través de la interface Comparable o pasar como argumento un objeto Comparator).

Por último se muestra un método propio para crear un vector, la única observación es la notación parte de Java 5, para obtener “N” parámetros, si observa la implementación del método, el objeto recibido es enumerable, por lo que lo podemos utilizar a través de un “foreach”. En caso que desee utilizar esta funcionalidad en otro método, solo se puede recibir uno de ellos y tiene que ser declarado como el último argumento.

Creando un TLD dinamicamente con tobago apt plugin y Struts

Una de las tareas tediosas en JEE, es la de mantener nuestros TLD (definición de  librerías de Tag), cada vez que se cambia o agrega algo. Hace poco publique un post donde se explicaba como realizar taglibs utilizando el API de componentes de Struts, pues ahora se mostrara un plugin para Maven, mediante el cual podemos generar automáticamente un TLD, como observación interesante, cuando el TLD se almacena bajo el “META-INF”, no hay necesidad de agregarlo al “web.xml”, ni necesidad de tenerlo en bajo la estructura de directorios del WEB-INF.

Lo primero que debemos hacer, es agregar la carpeta “META-INF”, bajo main/resources, una nota al pie; Maven filtra cualquier directorio que no tenga ningún archivo, por lo tanto puedes agregar bajo “META-INF”, un archivo “README.txt”, con un mensaje como este (yo lo copie de Struts 2)

TLD file is generated inside META-INF after compilation.
If META-INF is empty, Maven will not copy it to the "target/classes" folder.
Please do not remove META-INF, or this file.

Esto permite que nuestra carpeta de “META-INF”, sea creada cuando se deploya el sobre la carpeta target, en caso que ya tengas un “META-INF” con al menos un archivo dentro, puedes omitir este paso.

El segundo paso es crear, la carpeta /src/site/resources/tags, en esta nuestro plugin almacena una serie de plantillas que utiliza para crear el TLD.

El siguiente trabajo es ir al pom.xml de Maven; en la sección de plugin e incluiremos el siguiente código:

                org.apache.myfaces.tobago
                maven-apt-plugin
                
                    target
                    false
                    true
                    true
                    true
                    org.apache.struts.annotations.taglib.apt.TLDAnnotationProcessorFactory
                    1.5
                    
                        **/*.java
                    
                
                
                    
                        compile
                        
                            execute
                        
                
                
            

Este plugin nos permite indicarle, los parámetros que deseamos utilizar para nuestro taglib, uri por ejemplo será el nombre de nuestro taglib, etc. El resultado cuando invoques a Maven compile, o algun objetivo que incluya esta fase del ciclo de vida, como packaged o install, seria algo como:

  2.2.3
  1.2
  my
  /my-tags
  "My Tags"
  

Puedes utilizar tanto los parámetros include o exclude al estilo de Ant, para agregar o limitar los paquetes o archivos a analizar.

Si te corres el nuevo pom.xml con tu Maven, te darás cuenta que el mismo crea tus taglib de HelloWord, que se había implementado en el articulo mencionado al inicio de este, sin embargo los atributos que incluye tu no los pusiste y además, en caso que agregues un atributo adicional, el taglib no será actualizado con este. Lo que pasa es que necesitas indicarle al Engine que crear el TLD, que tiene un atributo y deseas que el mismo se agregue al TLD, esto lo realizamos sencillo, anotando nuestro método set, con el siguiente annotation:

 @StrutsTagAttribute(description="Some attribute description", type="String", required=true)
Public void setNewAttribute () { …

Esto le indica, al Engine que este atributo debe ser agregado en nuestro TLD.


Como podrás notar, este proceso nos proporciona gran facilidad de mantenimiento y escalabilidad, pues el proceso de edición y creación de los taglib, se lo relegamos al ciclo de vida gestionado por Maven.

Algunos recursos de interés:

domingo, noviembre 09, 2008

Uso aplicado de la instrucción "For"


A continuación se presenta una pequeña aplicación, donde se utiliza la instrucción de control "For". Este ejemplo muestra como construir un Applet y como dibujar sobre ella (utilizando para ello la instrucción "For"), una seria de rombos, existen dos prototipos (métodos), el primer "paintRomboLine", resulta mas fácil de entender, pero necesita mas código para funcionar (4 instrucciones "for"), el segundo prototipo solo ocupa una instrucción "for", y realiza una serie de cálculos por cuadrantes.

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.HeadlessException;

import javax.swing.JApplet;

/**
 * Simple class to paint a rombo based in lines.
 * 
 * @author jsanca
 * 
 */
public class DrawRombo extends JApplet {

private static final long serialVersionUID = 7677516509658561962L;

public DrawRombo() throws HeadlessException {

super();
setSize(new Dimension(1200, 1200));
} // DrawCircularLine.

@Override
public void paint(Graphics g) {

int y = 180;
int x = 180;
int intensity = 4;

super.paint(g);
this.paintRomboLine(g);
this.paintRomboLine(g, x, y, intensity);

y = 270;
x = 90;
intensity = 2;
this.paintRomboLine(g, x, y, intensity);

y = 270;
x = 270;
intensity = 1;
this.paintRomboLine(g, x, y, intensity);

y = 360;
x = 180;
intensity = 8;
this.paintRomboLine(g, x, y, intensity);

y = 540;
x = 180;
intensity = 16;
this.paintRomboLine(g, x, y, intensity);

y = 450;
x = 90;
intensity = 90;
this.paintRomboLine(g, x, y, intensity);

y = 450;
x = 270;
intensity = 45;
this.paintRomboLine(g, x, y, intensity);
} // paint.

private void paintRomboLine(Graphics graphics) {

int x1 = 90;
int y1 = 90;
int x2 = x1;
int y2 = y1 - 90;

for (int i = 0; i <= 90; ++i) {

graphics.drawLine(x1, y1, x2++, y2++);
}

for (int i = 0; i <= 90; ++i) {

graphics.drawLine(x1, y1, x2--, y2++);
}

for (int i = 0; i <= 90; ++i) {

graphics.drawLine(x1, y1, x2--, y2--);
}

for (int i = 0; i <= 90; ++i) {

graphics.drawLine(x1, y1, x2++, y2--);
}

} // paintRomboLine.

private void paintRomboLine(Graphics graphics, final int x, final int y,
final int intensity) {

int x1 = Math.abs(x); // 180; // 90;
int y1 = Math.abs(y); // 180; // 90;
int x2 = x1;
int y2 = y1 - 90;
int cuadrante = 0;
int div = Math.abs(intensity);
div = (div == 0) ? 1 : div;
int iteration = 360 / div;

for (int i = 0; i <= iteration; ++i) {

if (i % (iteration / 4) == 0) {

cuadrante += 1;
}

x2 += (1 * intensity)
* ((cuadrante == 2 || cuadrante == 3) ? -1 : 1);
y2 += (1 * intensity)
* ((cuadrante == 3 || cuadrante == 4) ? -1 : 1);

graphics.drawLine(x1, y1, x2, y2);
}
} // paintCircularLine.

} // E:O:F:DrawCircularLine.


sábado, noviembre 08, 2008

Al fin MTV reconoce el potencial de la Internet

Después de mucha lucha y denuncias públicas y demás pleitos para llamar la atención, la cadena mundial de música por televisión mas grande el mundo MTV, abren toda su biblioteca (bueno casi toda, el material en ingles por el momento), al publico. Aseguran tener conciertos, espectáculos acústicos, más todos sus vídeos y a diferencia de YouTube (que es mantenida por una comunidad en buena parte), esta es soportada por MTV, lo que le proporciona idéntica calidad a cada uno de sus temas (vídeos), el sitio en donde han publicado el contenido le llaman MTV Music, y yo debo reconocer que estoy como chiquito con juguete nuevo, jejeje.
El sitio ofrece una gran cantidad de música, como señale anteriormente y además realiza sugerencias acerca de música o vídeos relacionados, en las búsquedas, te de la oportunidad de ir a un perfil del artista o directamente a los vídeos. Buena noticia y supongo que a MTV le paso como dicta el viejo adajio, "si no puedes vencerlos, uneteles".

Para los que les encanta Tori Amos, les dejo el link a una de sus mas melancólicas canciones, China, disfruten del tema, tanto como yo!

miércoles, noviembre 05, 2008

Creando e integrando "custom taglibs" con Struts 2.x, Spring y FreeMarker




Creando un taglib, extendido de los componentes de Struts.


Recientemente surgió la necesidad de crear un “taglib”, para un proyecto en el cual estoy trabajando, hasta ahí todo bien. El problema inicia cuando deseamos reutilizar los componentes de Struts (utilizamos la versión 2.x). Después de investigar un poco, nos encontramos con el “tag” (“<s:component />”), este permite pasarle un nombre de plantilla (de Velocity o FreeMaker) y renderizar el resultado en nuestro Html, por ejemplo, si tenemos:


<component template="/my/custom/component.vm”>

    <s:param name="key1" value="value1"/>

    <s:param name="key2" value="value2"/>

</s:component>


Esto invocará una plantilla de Velocity e introduce al contexto de Velocity, un Mapa llamado “parameters”, del cual podemos obtener los parámetros que anteriormente insertamos en el JSP.

Más o menos, algo así:


${parameters.key1}


Este enfoque esta bastante bien, sin embargo tiene algunos problemas; la implementación queda totalmente expuesta a los WebDev. En caso que deseemos utilizar alguna clase nuestra o solicitar a Spring algún componente del contexto, la tarea se dificulta.


La solución mas adecuada sería extender este funcionamiento, para encapsular y reutilizar la funcionalidad del componente de Struts y proporcionar componentes fáciles de utilizar a los WebDev.


Investigando un poco, tuvimos la sensación que la documentación necesaria para implementar este tipo de extensiones al Framework, al momento no se encuentra muy documentado (por no decir que no existe) o nadie ha necesitado hacerlo. Sin más opción, ni guía, nos consumimos en el código fuente de Struts 2 y del estudio de ciertas partes del código, encontramos una solución, la misma se detalla a continuación:


Nuestra prueba de concepto consiste en crear un “taglib”, llamado HelloWord, el cual recibirá mediante un atributo llamado “name”, el nombre de la persona a saludar.


Lo primero que tenemos que hacer, es crear un componente el cual implemente la interfase “org.apache.struts2.views.TagLibrary”, esta interfase permite a Struts conocer los componentes y “taglibs” que deseamos utilizar, así pues creamos la siguiente clase:


public class MyTagLibrary implements TagLibrary {

       @Override

       public Object getFreemarkerModels(ValueStack stack, HttpServletRequest req,

            HttpServletResponse res) {

             

              return new MyModels(stack, req, res);

       } // getFreemarkerModels.

       @Override

       public List<Class> getVelocityDirectiveClasses() {

              return null;

       } // getVelocityDirectiveClasses.

}


Como podrá ver, esta clase tiene dos métodos, mediante los cuales le damos a conocer a Struts tanto, los componentes de Velocity (ninguno en nuestro caso) y los componentes de FreeMaker (para este caso se utiliza un Objeto, se trata de MyModels ya lo vemos en mas detalle).


Adicionalmente, este objeto debe ser agregado en nuestro archivo de configuración:


<struts>

<bean type="org.apache.struts2.views.TagLibrary" name="my" class="com.mypackage.web.views.MyTagLibrary" />


Esto permite al Struts, conocer que existe una fábrica para los componentes “taglib”, importante colocarle el atributo (type), pues mediante este, Struts se percata de que existe y debe ser procesado como una fabrica de TagLibrary. Importante saber, que el valor de “name”, en nuestro caso “my” es algo así como el nombre del “namespace” del taglib, ósea que al final debe utilizarse el “taglib”, mas o menos así: <my:nombreTagLib.


El siguiente paso, es crear nuestra fábrica de modelos; en el caso que desees utilizar Freemaker, debes crear un objeto el cual supongo que Struts analizará por reflexión, pues no implementa nada, simplemente utiliza la nomenclatura que a continuación te muestro:


public class MyModels {


    protected ValueStack stack;

    protected HttpServletRequest req;

    protected HttpServletResponse res;    

    protected HelloWordModel helloWord;

   

       public MyModels (ValueStack stack, HttpServletRequest req,

                     HttpServletResponse res) {

              super();

              this.stack = stack;

              this.req = req;

              this.res = res;

       }


       public HelloWordModel getHelloWord() {

             

              if (null == this.helloWord) {

                    

                      this.helloWord = new HelloWordModel (this.stack, this.req, this.res);

              }

             

              return helloWord;

       }   

}


Pronto explicaremos en detalle de que se trata este “HelloWordModel”, ahora lo importante es saber, que para que Struts descubra nuestro “taglib” ocupa un objeto “TagModel”, observe que la convension es:


Public XXXModel getXXX(), donde XXX es el nombre del componente, en el ejemplo anterior “HelloWord”, usted puede colocar los componentes que ocupe guardar bajo este “namespace”.


Por cada “TagLib” que ocupemos debemos crear al menos 3 objetos, el primero será el modelo, este le sirve al Struts para describir tanto el TagLib, como el “bean” que será introducido en el contexto del motor de plantillas.

Así pues, veamos el modelo:


public class HelloWordModel extends TagModel {

      

       public HelloWordModel(ValueStack stack, HttpServletRequest req,

                     HttpServletResponse res) {

              super(stack, req, res);

       }

      

       @Override

       protected Component getBean() {

             

              return new HelloWord(this.stack, this.req, this.res);

       }

}


Esta clase extiende de “TagModel”, clase la cual, según el contrato de la misma nos exige devolver un “Component”, al invocar al método “getBean”, Aquí vamos a devolver el objeto que necesitamos sea leído por el motor de plantillas, podemos ver analógicamente este objeto “Model”, como una fabrica “Home” en el contexto de los E.J.B.


A continuación creamos nuestro, Java Bean, HelloWord:


@StrutsTag(name="helloWord", tldTagClass="com.mypackage.web.ui.HelloWordTag", description="Hello word example!")

public class HelloWord extends GenericUIBean {


       final public static String TEMPLATE = "helloword";

      

       private String name = null;


       @Override

       protected String getDefaultTemplate() {

      

              return TEMPLATE;

       }

      

       public String getName() {

              return name;

       }


       public void setName(String name) {

              this.name = name;

       }


      

       public HelloWord(ValueStack stack, HttpServletRequest request,

                     HttpServletResponse response) {

              super(stack, request, response);

                     }


}


Puntos importantes de ver; primero nuestra clase extiende de “GenericUIBean”, existen otras clases en la jerarquía, las cuales podemos utilizar como clase base, algunas proporcionan menos o mas funcionalidad, al parecer. El segundo punto a tomar en cuenta, es sobre escribir el método “getDefaultTemplate”, este método permite indicarle al “Engine” de FreeMaker, al menos estilo del patrón template, que la plantilla de FreeMaker, que deseamos utilizar es tal (ojo que la extensión se omite, solo se coloca el nombre). Por ultimo, cualquier atributo al estilo Java Bean (i.e: atributos con sus respectivos set’s y get’s), podrán ser accedidos desde la plantilla de FreeMaker. El constructor es necesario, así como la invocación al súper. Lo ultimo que debemos prestar atención, es la inclusión de una anotación, la cual relaciona nuestro Java Bean, con un “TagLib”, supongo que el “Engine” de FreeMaker toma nuestro objeto “model”, de ellos el JavaBean y de las anotaciones de estos, el taglib asociado.


Por ultimo implementaremos nuestro componente de vista, o lo que es lo mismo nuestro “taglib” propiamente, el mismo debe extender de la clase “ComponentTag”, la cual tiene el soporte necesario para renderizar la plantilla de FreeMaker, con el componente incluido. A continuación el código:


public class HelloWordTag extends ComponentTag {


       private String name = null;


       public String getName() {

              return name;

       }


       public void setName(String name) {

              this.name = name;

       }


       /**

        *

        */

       public HelloWordTag() {


              super();

       }


       @Override

       public Component getBean(ValueStack stack, HttpServletRequest req,

                     HttpServletResponse res) {


             

              return new HelloWord(stack, req, res);

       }


       @Override

       protected void populateParams() {


              HelloWord helloWord = null;

              super.populateParams();

              helloWord = HelloWord.class.cast(this.getComponent());

              helloWord.setName((null != this.getName()) ? this.getName() : "Fulano de tal");

       }


}


 


Note que la implementación del método; “getBean” al funciona al estilo del patrón plantilla y nos permite obtener el Java Bean que deseamos. También tenemos la sobre escritura del método populateParams, el cual nos permite setear parámetros en el componente, este método para los que conocen la interfase “InitializeBean” de Spring, es análogo al método “afterSetProperties”. Note que este Java Bean, tiene propiedades “bean”, las cuales deben ser expuestas mediante un “tld”.


Como lo indicamos en nuestro Java Bean, HelloWord, necesitamos crear nuestra plantilla de FreeMaker y situarla bajo el paquete Java: “template.simple”, el cual por supuesto debe estar en nuestro “classpath”. A continuación nuestro código para helloword.ftl:


<#assign helloword = tag/>


<p>

   Hello ${helloword.name}

</p>


Majestuoso no es cierto, nuestro bean es introducido con el nombre de “tag”, lo asignamos a “helloword” y solicitamos el nombre para saludar.


 


Una vez codificadas las clases y editados los archivos de configuración y FreeMaker, necesitamos integrar nuestro “Taglib”, con nuestro contexto Web, para ello realizamos los pasos de siempre; creamos un “TLD” con la descripción del “HelloWordTag” e incluimos este “TLD” en nuestro Web.xml.


A continuación el código del my-tags.tld:


<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">

<taglib>

  <tlib-version>2.2.3</tlib-version>

  <jsp-version>1.2</jsp-version>

  <short-name>my</short-name>

  <uri>/my-tags</uri>

  <display-name>"My Tags"</display-name>

  <description><![CDATA["My Specific Tag."]]></description>

  <tag>

    <name>helloWord</name>

    <tag-class>com.mypackage.web.ui.HelloWordTag</tag-class>

    <body-content>JSP</body-content>

    <description><![CDATA[Hello word]]></description>

    <attribute>

      <name>name</name>

      <required>false</required>

      <rtexprvalue>false</rtexprvalue>

      <description><![CDATA[Name of the action to be executed (without the extension suffix eg. .action)]]></description>

    </attribute>   

  </tag>

 </taglib>


 


Ahora el código necesario para el web.xml:


<jsp-config>

   

      <taglib id="MyTLD">

         <taglib-uri>/my-tags</taglib-uri>

         <taglib-location>/WEB-INF/my-tags.tld</taglib-location>        

      </taglib>

    </jsp-config>


Por ultimo para utilizar nuestro “taglib”, declaramos el mismo en nuestro JSP y simplemente lo utilizamos:


<%@ taglib prefix="my" uri="/my-tags"%>


<my:helloWord name="Jsanca"></my:helloWord>


// <p>Hello Jsanca</p>


<my:helloWord ></my:helloWord>


// <p>Hello Fulano de tal</p>


Hasta aquí ya tenemos nuestro “taglib”, totalmente integrado con Struts y FreeMaker. En la mayoría de los casos y particularmente si utilizamos Spring, será muy probable que surja la necesidad de utilizar alguna clase declarada en nuestro contexto de Spring, a continuación el código que utilice para realizar la tarea:


HelloWordModel.java:


@Override

       protected Component getBean() {

              ApplicationContext applicationContext = WebApplicationContextUtils

                           .getWebApplicationContext(req.getSession().getServletContext());


              SaludadorService saludador = SaludadorService.class.cast(applicationContext

                           .getBean("saludador"));


              return new HelloWord(this.stack, this.req, this.res, saludador);

       }


HelloWord.java:


@StrutsTag(name="helloWord", tldTagClass="com.mypackage.web.ui.HelloWordTag", description="Hello word example!")

public class HelloWord extends GenericUIBean {


       final public static String TEMPLATE = "helloword";

      

       private String name = null;

      

       private SaludadorService saludador = null;

      


       @Override

       protected String getDefaultTemplate() {

      

              return TEMPLATE;

       }

      

       public String getName() {

              return this. saludador.buildSaludo(this.name);

       }


       public void setName(String name) {

              this.name = name;

       }


       /**

        * @param stack

        * @param request

        * @param response

        */

       public HelloWord(ValueStack stack, HttpServletRequest request,

                     HttpServletResponse response, SaludadorService saludador) {

              super(stack, request, response);

              this. saludador = saludador;

       }


}


HelloWordTag.java:


@Override

       public Component getBean(ValueStack stack, HttpServletRequest req,

                     HttpServletResponse res) {


              ApplicationContext applicationContext = WebApplicationContextUtils

                           .getWebApplicationContext(req.getSession().getServletContext());


              SaludadorService saludador = SaludadorService.class.cast(applicationContext

                           .getBean("saludador"));


              return new HelloWord(this.stack, this.req, this.res, saludador);


       }


 


Aquí el truco recae en utilizar la clase “WebApplicationContextUtils” y tener el acceso al objeto “Request”, pues como supondran la instancia del ApplicationContext de Spring, se encuentra almacenado en el ‘scope’ del ServletContext y mediante este método, podemos obtenerlo.


Espero les haya sido útil!


martes, noviembre 04, 2008

Nuevo libro (JSF)


Un nuevo recurso para mi biblioteca personal, se trata del libro Core Java Server Faces, apenas lo recibí esta semana y ya estoy avanzando por el primer capitulo, la lectura hasta el momento resulta simple y muy facíl de entender, espero terminarlo tan pronto sea posible e ir colocando aquí, en el blog, las diferentes impresiones acerca del mismo.
En cuanto a Faces, en realidad mi experiencia con esta especificación, a pesar de ser el estándar propuesto por Sun, nunca ha sido mas allá de algunos artículos. Conozco su utilidad y el concepto detrás del mismo, sin embargo espero que al final de la lectura, pueda contar con los recursos tecnicos necesarios para poder enfrentar una aplicación con JSF. Personalmente siempre me ha gustado el enfoque de Struts o SpringMVC, actualmente me encuentro trabajando con Struts 2 y fuera de algunos bugs y la poca documentación, comparandola con su predecesor (Struts 1), la potencia e integración tanto con Spring, como con bibliotecas para la capa de vista, tales como tiles, SiteMesh, Freemaker, Velocity y claro esta JSP, le otorgan una elegancia y potencia, poco comparable con su predecesor, el enfoque orientado a Pojos no esta nada mal y la componentización de la configuración, entre otras muchas características que apenas voy conociendo, lo hacen una poderosa y ambiciosa alternativa.

Ejecución de varios select con JDBC

Buenas lectores,

Días atrás, me estuvo dando lata un problema, que describo a continuación; resulta que deseaba enviar una serie de consultas, tipo "select" a una base de datos MySQL, para ahorrar tiempo y conexión de red.

Mi primera idea, al checkar el API de JDBC era utilizar el método, java.sql.Statement.addBatch(String sql), para agrupar un conjunto de instrucciones "select" y después invocar al método executeBatch, de esa misma clase.
Una vez ejecutados los "selects", podría obtener el primer resultSet, recorrerlo y solicitar el siguiente resultSet, utilizando para ello el método getMoreResult (siempre en la misma clase), el cual itera sobre el siguiente ResultSet (resultado del siguiente select), en caso de que este exista, de lo contrario, retorna un "false".

A la luz de los resultados, surgieron los siguientes problemas: El primer problema fue el MySQL en si, resulta que la conexión por defecto no tiene soporte para ejecutar múltiples queries, por lo que debes pasarle el parámetro allowMultiQueries en true. Una vez solucionado el anterior inconveniente, me di por enterado, que el executeBatch, solo funciona en el caso que la consulta sea de tipo "update", es decir: delete, update, insert.

Así pues, improvisando un poco, realice otra prueba de concepto, esta vez concatene en un StringBuilder, todas las consultas divididas por ';', que es el divisor para MySQL (por cierto que este parámetro debe estar parametrizado, en caso que se desee cambiar por otro), creo un Statement y ejecuto la iteración de los resultSet como antes lo había descrito, funciona y bastante bien :)

Instrucciones de control

A continuación se presenta un ejemplo, con los diferentes usos para estructuras condicionales y de iteración.
El ejemplo es totalmente funcional y nos muestra en el método "ifCondicionalStatement()" las  instrucciones condicionales, las diferentes formas de utilizar la sentencia, if, else, switch y una forma opcional de implementar un switch con un mapa, con la ventaja de poder switchear valores mas alla de los primitivos. El método "iterateStatement()" contiene diferentes ejemplo para utilizar, while, for, además de instrucciones como; continue, break, etc.

package com.avventa.training.java.class4;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class ControlStatements {

public static void main(String[] args) {
System.out.println("** ifCondicionalStatement **");
ifCondicionalStatement();
System.out.println("** iterateStatement **");
iterateStatement();
}
/**
* Some examples of conditional statement: 
* Basic statement:
* if ([conditional]) {
*   
*   // do something
* }
*/
public static void ifCondicionalStatement () {
int i = 10;
int j = 20;
// Basic statement
if (i == 10) {
System.out.println("i is 10!");
}
// Two conditional statements and else.
if ( (i != 10) || 
(j == 20)) {
System.out.println("i != 10 or j == 10");
} else {
if (i == 10) {
System.out.println("i is 10 in the else statement");
}
}
// setting and conditional comparation.
if ((i = i + j) == 30) {
System.out.println(" i == 30 ");
}
switch (i) {
case 1:
System.out.println(" case 1 ");
break;
case 10:
System.out.println(" case 10 ");
break;
default:
System.out.println(" Default ");
break;
}
// Map instead of switch.
Map switchMap = new HashMap ();
i = 0;
switchMap.put(i++, " case 1 ");
switchMap.put(i++, " case 2 ");
i = 1;
System.out.println("switchMap.get(i) = " + switchMap.get(i));
} // ifCondicionalStatement.
public static void iterateStatement () {
String [] stringArray = new String [] {"one", "two", "three", "four"};
int index = 0;
System.out.println("while statement\n");
// while statement.
while (index <= stringArray.length) {
System.out.println("index = " + index);
if (index % 2 == 0) {
System.out.println("Doing continue with index = " + index);
index += 1;
continue;
}
index += 1;
}
System.out.println("do ... while\n");
// do ... while.
index = 0;
do {
System.out.println("index = " + index);
if (index > (stringArray.length / 2)) {
break;
}
index += 1;
} while (index <= stringArray.length);
System.out.println("for statement\n");
// for statement.
for (int i = 0; i <>
System.out.println("i = " + i);
}
System.out.println("foreach\n");
// for each.
for (String string : stringArray) {
System.out.println(string);
}
System.out.println("foreach with ArrayList\n");
// for each.
for (String string : Arrays.asList(stringArray)) {
System.out.println(string);
}
} // iterateStatement.
} // E:O:F:ControlStatements.