viernes, 31 de diciembre de 2010

Feliz 2011!!!!!!!!!!

Pues al igual que felicité la Navidad hace una semana, aprovecho para felicitar el Año Nuevo. Podría haber hecho las dos cosas en la misma entrada, pero oye, cada cosa en su momento.

Otro año que se va y otro año que viene. Cosas que dejas atrás y cosas que esperas que lleguen. En lo que a mí respecta este año, y más concretamente  en marzo, se me acaba el chollo del Carnet Joven. ¿Qué quiere decir eso? Pues que ya hago 26 años, que en términos matemáticos si lo divides entre 10 y redondeas a entero te queda 3, y en términos de Ingenieros de la Calle, quiere decir que me acerco peligrosamente a los 30 años. ¡¡Vaya Tela!! Pero sin complejo ninguno. Que yo siempre he dicho que tengo que llegar a los 100 años y a partir de entonces me consideraré viejo. Luego la vida dirá.

¿Qué espero del 2011? Pues lo de siempre salud, dinero y amor, como rezaba la mítica canción de los años 60 de Cristina y los Stop. Más detalladamente, seguir creciendo como persona, aprender cada día un poquito más y que la gente que me quiere siga haciéndolo.

A nivel deportivo, pues seguir disfrutando del deporte, intentar coger la forma de antaño y a corto plazo poder con esos 20 Km Marcha.

Para todos vosotros únicamente deseo lo mejor que puedo desear para mí. Salud que no faltE nunca. Mientras haya salud se puede hacer el resto de cosas. Trabajo, sobre todo en estos tiempos de crisis. Y amor mucho amor, que es lo que más falta hace en este mundo lleno de guerra, odio y rencor.

Así que lo dicho ¡¡¡¡ FELIZ 2011!!!!.... y cuidado con lo que bebemos y la cantidad, que una noche de fiesta tiene que ser eso, de fiesta.

viernes, 24 de diciembre de 2010

Feliz Navidad !!!!!!!!!!!!!

Aprovecho que este año tengo mi espacio en la red para felicitar la Navidad a todo el mundo y en especial a atletas, sobre todo marchadores, e informáticos.

No para todos la Navidad significa lo mismo. Para unos es una época de amor, para otros es sólo consumismo, para algunos simplemente vacaciones e incluso hay gente para la que la Navidad significa tristeza y nostalgia.

A mí la verdad que ha significado un poco de todo. Aún así es un momento para aprovechar estar con la familia y si puede ser con el resto de seres queridos y para recordar que la vida hay que vivirla con ilusión y con alegría, aunque muchas veces tengamos todo de frente y hay que luchar para no venirnos abajo. Si obramos bien siempre tendremos nuestra recompensa.

Un saludo y FELIZ NAVIDAD!!!!!!!

viernes, 10 de diciembre de 2010

Marcha Atlética Espada Toledana 2010

Hola a todos!!! Pues vuelvo con fuerza para añadir al blog mi primera entrada sobre atletismo. Y como no, la primera va a ser de ....(tambores).... MARCHA ATLÉTICA!!! Qué para algo soy Franjo Marchador, jejeje. 

Pues el tema a tratar es mi participación en la marcha atlética Espada Toledana que se celebró el pasado sábado 27 de noviembre. La verdad que en una tarde bastante fresquita, sobre todo a la hora de la competición, tengo que decir que el resultado fue positivo. 30:02, todavía lejos del 25:47 que hice en 2005 y del 24:51 que acredito como mejor marca en 5 km marcha. Pero claro, esos tiempos los hacía con 10 kilos menos que ahora y antes de estar tres años parado para acabar la carrera.

Centrándonos en las condiciones actuales, hay que decir que la marca muestra que estoy en buena progresión para volver a hacer esas marcas (o por lo menos acercarme). Si comparamos con la marca hecha en esta misma carrera el año pasado ( mi primera carrera después de los tres años de parón) he mejorado 1:05 y de no ser porque fui solo desde casi el km 2, podría haber bajado de 30 minutos. Luego tuve un fallo, y es que no miré en ningún momento el cronómetro, que me hubiera dado referencias y con las que hubiera dado el todo por el todo. ¡Qué pardillo!  Parece mentira que lleve 10 años haciendo marcha atlética y 12 haciendo atletismo. De todas maneras quedé contento con la carrera.

Siguiendo con la marcha, una buena noticia. Y es que a pesar de las malas pretensiones de algún que otro responsable del deporte en Campo de Criptana, este año y como se viene haciendo desde hace 22 ediciones y desde 2003 en un circuito urbano homologado, se volverá a celebrar la Marcha Atlética Villa de los Molinos. Este año vuelve a ser también el regional de Castilla La Mancha. Y como novedad, la categoría absoluta se va a disputar sobre la distancia de 20 km. Buen aliciente para la gente de fuera que quiera venir a hacer marca para el nacional de Benicasim y sobre todo para la prueba que creo que le dará algo más de prestigio (prestigio que hemos estado a punto de perder gracias ciertos personajes que parece que quieren cargarse el atletismo en Criptana).

También indicar que la distancia de 20 km es un aliciente para mí. Otra cosa es que consiga acabar la prueba, porque llevo desde el Campeonato de España de León en 2006 sin hacer un 20 y este año aunque estoy entrenando, no estoy haciendo muchos kilómetros. Pero todo se intentará y si tardo 2h 20 o 2h 30, pues bueno será porque habré acabado, y será otro puntito a mi progresión para volver a ser el que era.

Ya os iré contando más cosas sobre la prueba. Mientras tanto os dejo una foto de mi participación en la prueba de Toledo que ha sido cedida por Luis Maroto de aemarcha, al cual le agradezco no solo la foto, si no que también junto al resto de miembros de aemarcha sigan promocionando esta bella especialidad. (Yo soy el de blanco, rojo y negro, para el que no me conozca).


sábado, 27 de noviembre de 2010

Un Agente CRUD para el uso de Hibernate

Buenas de nuevo. Después de tanto tiempo vuelvo a incluir una nueva entrada. Perdón a los que habéis estado esperando tanto tiempo (según mis cuentas solo mi amigo y compañero Longinos), pero ya tengo preparadas una serie de entradas nuevas con las que ir entreteniéndoos. Adelanto que alguna de ellas no será de informática, para los que esperan ansiosos (todavía solo mi novia, jejeje) que les hable de otros temas.

La presente entrada trata sobre Hibernate. Para los que no conozcan lo que es Hibernate, comentar brevemente que es una tecnología de mapeo objeto-relacional implementada para Java. También existe una versión para .NET llamada NHibernate.

En resumidas cuentas, Hibernate es una herramienta que nos permite abstraer la capa de Persistencia de nuestros programas y aplicaciones, de manera que por ejemplo, para guardar la información de un determinado objeto en base de datos no tenemos primero que serializar el objeto en una consulta SQL y después ejecutarla, si no que directamente "guardas el objeto en la base de datos".


Esto se realiza a groso modo relacionando las tablas de la base de datos con las clases persistentes del programa mediante ficheros XML.

Hibernate es muchísimo más complejo de lo que he explicado de manera somera en los anteriores párrafos. Hay por la Web muchos tutoriales sobre esta tecnología que os pueden dar más información teórica. Yo como chico práctico que soy, voy a ir a eso, a enseñaros cosas prácticas que podáis utilizar directamente en vuestros programas.

Por lo tanto, lo primero sobre Hibernate que voy a añadir va a ser un Agente CRUD (Create, Read, Update, Delete), con el cual vais a poder abstraer en una sola clase el acceso a una base de datos utilizando Hibernate.

Este agente está hecho a partir de la clase HibernateUtil, que se crea automáticamente en muchos entornos de desarrollo, y el objetivo es crear las cuatros funciones  básicas de acceso a una base de datos, como son Insertar, Leer, Actualizar y Borrar.

Los que leísteis mi entrada anterior (y los más avanzados en conocimientos de Ingeniería del Software), comprobareis que esta clase implementa el patrón Singleton, lógico, ya que no vamos a querer por seguridad que dos instancias accedan a la vez a la base de datos.

Aquí os muestro el código.
import java.util.ArrayList;
import java.util.List;

import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.hibernate.collection.PersistentSet;



/**
 * Clase Agente que permite el acceso a una base de datos relacional utilizando Hibernate.
 * Incluye las  cuatro funciones básicas de acceso a una base de datos como son Insertar,
 * Consultar, Editar y Borrar.
 * Implementa el patrón Singletón de manera que solo haya una instancia, y no haya conflictos
 * en el acceso a la BBDD.
 * @author Franjo
 *
 */
public class Agente {
 private SessionFactory sessionFactory;
 protected static Agente instancia;
 
 public static Agente getAgente() {
  if (instancia==null) 
   instancia=new Agente();
  
  return instancia;
 }
 
 /**
  * Constructor que configura hibernate para que la comunicación sea correcta
  */
    protected Agente(){
        try {
            sessionFactory = new Configuration().configure().buildSessionFactory();            
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }
    
    
    /**
     * El método insertar, añade el objeto que tiene por parámetros mediante el método
     * save de hibernate
     * @param obj, el objeto que se desea insertar
     */
    public void insertar(Object obj) {
        try {
            Session session = sessionFactory.openSession();
            Transaction tx = session.beginTransaction();
            session.save(obj);
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    
    /**
     * El método select, realiza la consulta que hay por parámetros como String mediante
     * el método find de hibernate 
     * @param sql, es la sentencia SQL que debe ejecutar el agente
     * @return Lista de objetos que da como resultado la consulta
     */
    public List select(String sql) {
        try {
            Session session = sessionFactory.openSession();
            Transaction tx = session.beginTransaction();
            List result = session.find(sql);
            tx.commit();
            session.close();
            return result;
        } catch (HibernateException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    /**
     * El método editar, modifica el objeto que tiene por parámetros mediante el método
     * update de hibernate
     * @param obj, el objeto que se desea editar
     */
    public void editar(Object obj) {
        try {
            Session session = sessionFactory.openSession();
            Transaction tx = session.beginTransaction();
            session.update(obj);
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            throw new RuntimeException(e.getMessage());
        }
    }
    
    
    /**
     * El método borrar, elimina el objeto que tiene por parámetros mediante el método
     * delete de hibernate
     * @param obj, el objeto que se desea eliminar
     */
    public void borrar(Object obj) {
        try {
            Session session = sessionFactory.openSession();
            Transaction tx = session.beginTransaction();
            session.delete(obj);
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            throw new RuntimeException(e.getMessage());
        }
    }

}
  
Espero que os sirva esta clase para vuestras prácticas (pensando en los pobres estudiantes de Ingeniería Informática, como yo era antes de acabar la carrera). Si os sirve para sacar buena nota gracias al código que  os pongo lo único que espero es que insertéis un comentario en el blog para que os pueda felicitar, jejeje.

En futuras entradas tengo previsto seguir hablando sobre Hibernate. Para la próxima entrada sobre Hibernate estoy preparando una mini-aplicación sobre el uso de Hibernate con bases de datos SQLite

Así que un saludo, y hasta la próxima entrada que será bastante pronto. Ciaoooooo!!!!!!!!

miércoles, 10 de noviembre de 2010

El patrón Singleton

Buenas de nuevo estimados amigos!!!!!! Una vez creado el blog y habiendo hecho la entrada  de bienvenida, ha llegado el momento de editar la primera entrada sobre informática (comprendo que a mis queridos lectores que no les guste la informática les puede resultar aburrida, pero oye, que un poco de culturilla general no viene mal a nadie, ya se hablará de otros temas).

El tema de esta entrada va a ser sobre un patrón de diseño en programación orientada a objetos llamado Singleton. 

Por motivos de seguridad o simplemente de diseño, en muchas ocasiones, se hace necesario tener una sola instancia de una determinada clase, instancia la cual será utilizada por el resto de las clases. Ejemplos de estas clases pueden ser un Agente de base de datos o una clase Proxy (otro patrón de diseño que ya explicaré en su momento) que acceda a otro sistema externo. Esta problemática la resuelve el patrón Singleton. En el siguiente código fuente muestro la cabecera de una clase Singleton en C++.

class Singleton
{
 protected:
  static Singleton * instancia;
  Singleton();
 public:
  static Singleton * getInstancia();
  void Metodo1();
  void Metodo2();

};

Se pueden ver una serie de particularidades que diferencian a este tipo de clases. 
  1. La primera es que el constructor es protegido. Lógico puesto que lo que se pretende es que ninguna otra clase pueda crear instancias de la clase Singleton. 
  2. La segunda es que existe un puntero a una instancia de la misma clase (instancia) que será la única que se pueda utilizar en toda la aplicación.
  3. La tercera es que existe un método de acceso a esa instancia (getInstancia). Gracias a este método se podrá acceder a los otros métodos públicos de la clase. 
En el siguiente código se puede ver el fichero de implementación de la clase Singleton:
#include "Singleton.h"

/* INICIALMENTE LA INSTANCIA ES NULA PARA NO OCUPAR ESPACIO EN MEMORIA 
 SI NO FUERA ACCEDIDA EN TODA LA EJECUCIÓN DE MEMORIA */
Singleton * Singleton::instancia = NULL;

/* CONSTRUCTOR DE LA CLASE */
Singleton::Singleton()
{
 
}

/* MÉTODO A TRAVES DEL CUAL SE ACCEDERÁ A LA ÚNICA INSTANCIA */
Singleton * Singleton::getInstancia()
{
 if(this->instancia == NULL)
 {
  this->instancia = new Singleton();
 }
 return this->instancia;
}

/* MÉTODO 1 AL CUAL SOLO SE PODRÁ ACCEDER POR LA ÚNICA INSTANCIA */
void Singleton::Metodo1()
{
 printf("Estamos en metodo 1");
}

/* MÉTODO 2 AL CUAL SOLO SE PODRÁ ACCEDER POR LA ÚNICA INSTANCIA */
void Singleton::Metodo2()
{
 printf("Estamos en metodo 2");
}
  
Vemos que la variable instancia se inicializa por defecto a NULL, para que en el caso de que no se haga uso de la clase en toda la aplicación, no ocupe lugar en memoria principal.

Cuando se llama la primera vez al método getInstancia se reserva memoria a la instancia de la clase y se retorna el puntero. Las siguientes veces que se llame al método simplemente se retornará dicho puntero de la instancia recién creada.

A continuación, añado un fragmento de como  se llamaría a esta clase para acceder a sus funciones o métodos:

#include "Singleton.h"

int main()
{
 /* LLAMADA DESDE LA ÚNICA INSTANCIA DEL SINGLETON A SU MÉTODO 1 */
 Singleton::getInstancia()->Metodo1();
 /* LLAMADA DESDE LA ÚNICA INSTANCIA DEL SINGLETON A SU MÉTODO 2 */
 Singleton::getInstancia()->Metodo2();

 return 0;
}

Por último, dejo un ejemplo de como se implementaría la misma clase en java.

public class Singleton{

 /* INSTANCIA DE ACCESO A LA CLASE */
 protected static Singleton instancia;
 
 /* CONSTRUCTOR DE LA CLASE */
    protected Singleton(){

    }
 
 /* MÉTODO DE ACCESO A LA INSTANCIA */
 public static Singleton getSingleton() {
  if (instancia==null) 
   instancia = new Singleton();
  
  return instancia;
 }
 /**********************/
 /* MÉTODOS DE LA CLASE */
 /**********************/
 public void Metodo1(){
  System.out.println("Estamos en Método 1");
 }
 
 public void Metodo2(){
  System.out.println("Estamos en Método 2");
 }
}


Con este último fragmento finalizo la entrada sobre el patrón Singleton, esperando que pueda ser de ayuda. 
Como ser humano que soy y por lo tanto bastante imperfecto (todo sea dicho), os invito a que cualquier fallo que encontréis o cualquier apunte que queráis añadir lo hagáis público. Por eso os invito a ir dejando vuestros comentarios.

Un saludo y hasta la próxima.


sábado, 6 de noviembre de 2010

A sus puestos, listos, ya!!!!!!!!!!!!!

Era inminente y ya ha llegado. Por fin me he unido a la moda de tener un blog. Hoy si no tienes blog, tuenti, facebook y  twitter no existes (no es que lo diga yo, es que se dice por ahí). Puesto que ya tengo tuenti y ahora tengo blog, puedo considerar que "medio existo". Y la verdad que no estoy muy orgulloso de mi dirección de tuenti, por lo que habría que decir que tengo un "cuarto y mitad de existencia". (Sí, es un chiste muy malo, pero ya advierto que va a haber muchos así, disculpen las molestias :-) ).

De lo que si espero estar orgulloso es de este recién creado blog. El nombre que he elegido para la URL tiene que ver en parte con el contenido que se podrá ver en él. Unos y ceros por que soy informático, ingeniero informático para ser más exacto, es decir, de los que saben algo más que instalar programas y grabar CDs (a ver si se entera un día el mundo de las competencias de un ingeniero informático). Quiero por lo tanto, utilizar este blog para ofrecer a quien le pueda servir de ayuda, mis conocimientos sobre informática, sean de programación, analisis y diseño software, nuevas tecnologías o cualquier otro tema relacionado. También iré colgando prácticas mías de la universidad que considere que puedan servir a la gente.

Lo de metros y millas viene por mi afición al atletismo. Y como fondista y marchador que soy, el objetivo es siempre devorar metros para llegar a meta (o a algún sitio en concreto). Es por ello que en este blog también se tratarán temas relacionados con el atletismo.

Eso si, como no solo de informática y atletismo vivo, también aprovecharé este blog para hablar de diferentes temas e inquietudes que pudiera tener y que muchas veces siento la necesidad de compartir. También daré mis opiniones (vivimos en un país libre) sobre asuntos que pudieran generar debate o temas de actualidad. Eso sí, siempre desde el respeto y sin faltar a nadie.

Antes de acabar la entrada, solo me queda invitar a aquel que lea este blog a introducir sus comentarios y a opinar en todas las entradas que vaya registrando.

Así que BIENVENIDOS y hasta la próxima entrada!!!!!!!!!!