JavaNullPointerException y otros petardazos.

Configuración de TileCache en Windows

2010-08-01T13:26:00.000+02:00

Una de las cosas en la que estoy dedicando mi tiempo laboral, es a trabajar con servidores de mapas y visores en Javascript, como OpenLayers y Google Maps, enfocados como no, al desarrollo web con J2EE.

Para poder usar nuestras propias capas, pues estoy usando MapServer, y para mejorar el rendimiento, he decidido usar TileCache. El problema de usar TileCache, es que, básicamente, es un cristo poder configurarlo (sobre todo con google maps).

Instalarlo es poco intuitivo (según la documentación de su página web). Tras muchos cabezazos, he dado con la tecla. Voy a describir uno a uno los pasos a seguir:

1 - Debemos descomprimir TileCache en una carpeta accesible via web. Yo he optado de instalarlo en la carpeta htdocs del Apache que incorpora mi MapServer (C:\ms4w\Apache\htdocs\tilecache)

2 - Instalar Python en el equipo. Yo he instalado la versión 2.7

3 - Abrimos y editamos el fichero httpd.conf de Apache (C:\ms4w\Apache\conf) y añadimos lo siguiente:

Directory "C:/ms4w/Apache/htdocs/tilecache/"

AddHandler cgi-script .cgi

Options +ExecCGI

/Directory

Esto significa que permitirá la ejecución CGI en la carpeta que le indicamos.

4 - Abrimos y editamos el fichero tilecache.cfg (C:\ms4w\Apache\htdocs\tilecache). Modificamos la opción de caché:

[cache]

type=Disk

base=c:/tmp/tilecache

Esto apunta donde estará la caché de imágenes.

5 - Abrimos y editamos la primera linea del fichero tilecache.cgi. (C:\ms4w\Apache\htdocs\tilecache)

#!C:/Python27/python.exe –u

Lo que hacemos es indicar la ruta de ejecución de Python. Yo también he añadido al path de Windows dicha ruta (C:\Python27\ ). Es muy importante sustituir esta línea por la que viene, si se añade sin eliminar la que viene, no funcionará.

Con esto, ya tenemos configurado TileCache con WMS. Podemos hacer una pequeña prueba para ver si funciona. Abrimos un navegador, y en la barra de dirección escribimos:

http://localhost/tilecache/tilecache.cgi?LAYERS=basic&SERVICE=WMS%20&VERSION=1.1.1&REQUEST=GetMap&SRS=EPSG:4326&BBOX=-180,-90,0,90%20&WIDTH=256&HEIGHT=256

Y debería aparecer una imagén de América. Si vamos a C:\tmp\tilecache, podremos observar que se genera una estructura de carpetas, y dentro de ellas podremos encontrar las imágenes que se descargan.

Ahora, solo nos queda configurar el tilecache.cfg con nuestras propias capas. Ahora estoy investigando esto, así que cuando tenga conclusiones claras ya escribiré otro post que os pueda servir.

Saludos!

Capítulo 2: Metemos el listener del ratón para dibujar

2010-01-30T00:54:00.000+01:00

Vamos a añadir a nuestra ventana principal un listener para controlar las acciones del mouse.

Primero, añadimos a nuestra ventana principal un componenteque nos ervirá para pintar sobre él. Yo he optado por usar un JLabel, pero podríamos usar otro o incluso crearnos nosotros uno propio.

Una vez añadido en nuestra ventana principal dicho componente, vamos a crear una instancia de un listener que controle las acciones del mouse.

Al declarar dicha instancia, deben de aparecer los métodos a implementar (al tratarse de una interfaz, se deben de implementar los métodos declarados en dicha interfaz). De momento nos vamos a centrar solo en uno, en el mouseDragged . Dicho método sirve para detectar cuando tenemos el botón izquierdo del mouse pulsado y movemos el ratón. Con él, podremos implementar nuestra primera versión del "lápiz" de nuestro paint.

Una vez implementado dicho método, solo nos queda añadirle la instancia del listener a nuestro componente JLabel (en mi caso). Para ello, en el constructor de la ventana principal, se hace lo siguiente:

Hecho esto, ya podremos pintar dentro de nuestro componente al estilo paint. Eso sí, de momento, solo pintaremos pixel a pixel, por lo que a simple vista parecerá que pintamos puntitos pequeños. En el próximo capítulo mostraré como pintar al estilo puro del Paint de Windows y también la herramienta borrador.

Saludos!

Capítulo 1: crear una aplicación en SWING

2010-01-08T12:12:00.001+01:00

Buenas, vamos a ir aplicando conceptos y vamos a realizar una aplicación en Java (J2SE con SWING). Vamos a comenzar desde 0, paso a paso.
Yo voy a usar NETBEANS versión 6.5, están ya disponibles otras versiones más recientes en la web de NETBEANS, por si os interesa otra versión.
Bien, comencemos.
Primero, debemos crear un nuevo proyecto. Pulsamos en el menú File->New Proyect. Elegimos la carpeta de proyectos JAVA y el tipo de proyecto JAVA APLICATION.

Mi idea de este pequeño tutorial es de hacer un paint, pero con menos funcionalidades que el de Windows (en principio). Vamos a llamar al proyecto JavaPaint. También indicamos que nos cree una clase main en nuestro proyecto.

Una vez hecho esto, tenemos nuestro proyecto creado. En principio, la carpeta de proyecto se situa en la carpeta predeterminada de Netbeans, que se encuentra en “Mis documentos”.
Vamos a crearnos unos cuantos de paquetes en el proyecto, así tendremos nuestras clases y paneles ordenados (el orden en la programación es imprescindible). Me he creado un par de ellos, a uno le he llamado beans (que contendrá las clases) y al otro paneles (contendrá la parte visual del programa).
Lo siguiente, será crearnos nuestra ventana principal de la aplicación. Para ello, sobre el paquete paneles, pulsamos el botón derecho del ratón y seleccionamos la opción New->Other. Ahora, seleccionamos la carpeta Swing GUI Forms y seleccionamos el tipo de fichero JFrame Form. Yo he optado por el nombre de PantallaPrincipal para el frame principal de la aplicación.

Ya tenemos la ventana principal del programa, ahora, vamos a implementar en el main que se lance al arrancar la aplicación. De momento, no tendrá funcionalidad alguna, pero vamos a ir poco a poco.

Pulsando ejecutar (Run Main Proyect) observamos que nuestra ventana principal aparece ya ejecutandose.
En el próximo capítulo añadiremos una barra de menú, una barra de herramientas y la ventana de selección de carga de ficheros de imágenes.

Interfaces en JAVA

2010-01-07T14:18:00.001+01:00

Seguimos con el mini-curso de programación: hoy veremos un patrón de diseño nuevo, en este caso se trata de las interfaces.
Una interfaz en Java es una colección de declaraciones de métodos y contanstes. Así de sencillo y explicado a grosso modo. Nuestras interfaces no tendrán implementaciones ni nada, solo declararciones. Veamos un ejemplo:

Como se ve, se declaran los métodos sin implementarlos. Ahora, cada clase que deseemos que implemente esa interfaz, tenemos que indicarlo en la declaración de clase:

Como se observa, para implementar una interfaz basta con añadir a la declaración el término implements seguido de la clase interfaz y todos los métodos que ésta tiene e implementarlos (o no, según lo que el programador busque), pero deben de aparecer al menos en la declaración de la clase.
Las interfaces son muy útiles para funcionalidades comunes en distintas clases, por ejemplo, en la declaración de beans, la interfaz de acceso a datos con nuestra base de datos.

Clases heredadas.... con ejemplos de animalitos!

2010-01-05T11:55:00.000+01:00

Título más rocambolesco no podría ser. Aprovechando lo bien que esta diseñado el lenguaje JAVA, voy a dar una mini-clase de eso que se suele enseñar en asignaturas claves de programación de las titulaciones universitarias, las cuales muchos alumnos dicen que no sirven pa ná….

Como todos sabréis, JAVA es un lenguaje enfocado a la POO (un teletubbie, pero para nosotroso será la programación orientada a objetos, y a partir de ahora, POO, que lo otro es más largo) por lo que me va a ser muy útil para dar las explicaciones sobre los temas que vamos a abarcar con este lenguaje. Se podría hacer también con C++, pero este me lo reservo para cuando comienze el curso avanzado y os muestre algo de QT

Voy a obviar un poco la teoría, y partiré de la base de que ustedes ya sabeis los principios básicos sobre la POO, el concepto de clase y objeto, atributos o miembros, etc etc. Vamos entonces con la HERENCIA (si voy rápido paradme xD).

Con la explicación burra y sencilla, se podría decir que yo soy un humano (aún por demostrar). Al ser un humano, esto me engloba dentro del grupo de los animales (aquí ya es más demostrable), y más concretamente, dentro de los mamíferos. ¿Qué queremos demostrar? pués que dentro del grupo de los animales, están los mamíferos, y dentro de los mamíferos, los seres humanos. Los animales, no existen en la realidad como entidad, o sea, no son instanciables, por lo que diremos que son una clase abstracta. Los animales también podemos deducir que tienen características y propiedades comunes a todos los animales, por lo que se define la clase animales como una de las clases a heredar a las demás subclases de animales (en este caso, mamíferos). Funcionalidades como comer, descansar, desplazarse, etc las tendran todos los animales, pero cada animal lo hace a su manera. Esto nos dice que cada funcionalidad será propia de cada animal.

Sigámos profundizando. Siguiendo la cadena, tenemos que los seres humanos somos mamíferos… nuestra siguiente clase será esa misma: mamíferos.
Mamíferos hereda directamente de la clase animal, así que contendrá las mismas propiedades que dicha clase. Como los mamíferos tampoco son instanciables (en la realidad no existen mamíferos como tales), también lo definiremos como clase abstracta:

Las propiedades de animal, aunque no sean visibles en la clase mamífero, están ahí.
La última clase a implementar , sería la de ser humano. Le llamaremos clase Persona. Como una persona si es instanciable (por ejemplo, Manuel Sillín Ventanuco -nombre para evitar casualidades con personas reales- ) es una persona física, existe como tal. Decímos que Manuel Sillín Ventanuco (clase persona) es una instancia de la clase Persona. Implementando quedaría algo así:

Vemos que Persona hereda de la clase Mamiferos, y esta hereda de la clase Animal. La conclusión que se obtiene es que Persona tiene todas las caracteristicas de la clase Animal y Mamifero. Como Persona es una clase final, también podemos decir que Persona debe implementar todos los métodos abstractos de las clases superiores. Los métodos heredados de las clases superiores se denotan con el @Override delante de cada función. Notar que no podemos acceder a los atributos como numeroPelos de la clase Mamifero o edad de la clase Animal. Se debe a que hemos definido los atributos como privados. Si quisieramos acceder a dichos atributos desde persona se recomienda que se declaren como protected en vez de privados, o dejarlos privados e implementar métodos no abstractos en las clases padres para acceder a dicho atributo desde Persona.
Se puede observar que Persona implementa los métodos de las clases padre y también implementa los suyos propios.
Veamos en código un pequeño ejemplo con todo esto que se ha explicado:

Muy bien, pues esta ha sido la lección rápida pero efectiva sobre la herencia de clases, el próximo post seguramente lo haga sobre interfaces de clases, que molan mucho y además son también muy útiles. Cuidense!

Patrón de diseño: SINGLETON

2010-01-05T11:52:00.000+01:00

Muy buenas,

volvemos al blog, y vamos bien, a post por año…. hoy voy a comentar un patrón de diseño bastante eficaz: singleton.

El patrón de diseño singleton (o para los de aquí, instancia única) trata de mantener un acceso único a un objeto que solo tendrá una instancia, es decir, es un objeto global y único en nuestra aplicación.

¿Pará que es útil este patrón de diseño? Pués tiene muchas utilidades… por ejemplo, para el acceso a recursos únicos o para tener “a mano” unos datos o funcionalidades para todos los objetos. Para ello, se debe garantizar que el construcctor de nuestra clase singleton sea privada, de esa forma nos aseguramos que solo pueda haber una instancia de la clase:

public class Singleton {
private static Singleton miObjeto = null;
private Singleton() {
}
}

Ahora, solo nos queda el acceso restringido a nuestro objeto. Para ello, solo añadir a la clase un método de recogida de la instancia:

public class Singleton {
private static Singleton miObjeto = null;
private Singleton() {
}
public static Singleton getInstancia() {
if (miObjeto == null) {
miObjeto = new Singleton();
}
return miObjeto;
}
}

Con esto ya tenemos el patrón implementado con lo básico, ahora, solo añadir los métodos que se quieran para hacerlo totalmente funcional.

Para llamar desde nuestro código:

Singleton objetoSingleton = Singleton.getInstancia();

Veamos un pequeño ejemplo. Vamos a tener una clase que se encarga de tener almacenana la conexión con una base de datos MySQL. Para ello, usaremos el patrón Singleton para el acceso a dicha conexión.

public class ConexionSingleton {
private static ConexionSingleton instancia = null;
private java.sql.Connection conexion = null;
private ConexionSingleton() {
}
public static ConexionSingleton getInstancia() {
if (instancia == null) {
instancia = new ConexionSingleton();
}
return instancia;
}
/* devuelve true si se ha creado correctamente */
public boolean crearConexion() {
try {
Class.forName(“com.mysql.jdbc.Driver”);
conexion = DriverManager.getConnection(“urlBaseDatos”, “usuarioBaseDatos”, “passwordBaseDatos”);
} catch (Exception e) {
return false;
}
return true;
}
public java.sql.Connection getConexion() {
if (conexion == null) {
crearConexion();
}
return conexion;
}
}

Llamando desde nuestro código principal:

ConexionSingleton.getInstancia().crearConexion();
java.sql.Connection conexion = ConexionSingleton.getInstancia().getConexion();

Espero que os sea útil. Saludos!

PD: a ver si aprendo a manejar mejor el blog, así no me sale el código tan feote como me ha salido :mrgreen: