Manejo de fechas Java

Un poco sobre el manejo de fechas en Java de una manera muy práctica :

Algunos comandos interesantes

Esta entrada deriva de una práctica del Máster de Software Libre de la UOC de la asignatura Administración de sistemas Linux. 

En ella voy a escribir algunos comandos de linux que aparecían en esta práctica, no pretenden ser la manera mas sencilla de hacer las cosas, simplemente los menciono porque algunos de ellos me parecen interesantes.

Spring. Primeros Pasos

Spring Framework
Vamos a ver la creación de un sencillo "hola mundo" con el framework Spring, pero antes vamos a ver, un poco por encima de que trata esto de Spring.

Spring es un framework  open source que tiene como objetivo facilitar el desarrollo de aplicaciones Java, está formado por diversos módulos que se pueden agregar a las aplicaciones. El único obligatorio es Spring Core (para la inyección de dependencias), a partir de aquí se pueden agregar mas módulos según las necesidades del programador, algunos ejemplos típicos son MVC (modelo vista controlador), AOP (trabajo con aspectos), DAO (data acces object)...

Sus características, a grandes rasgos, son:

• Simplicidad y acoplamiento débil basándose en el concepto de inyección de dependencias.
• Es un contenedor que gestiona el ciclo de vida de los objetos y su relación entre ellos facilitando que nos centremos en la lógica de la aplicación
• Es ligero y poco intrusivo
• Soporta la programación orientada a aspectos. Mas información

Inyección de dependencias

También conocido como inversión del control, es el mecanismo en que se basa Spring y lo que nos proporciona un acoplamiento débil entre sus clases. 

Básicamente se trata de que un objeto conozca sus dependencias a partir de una interficie y no por su implementación, lo que desemboca en que la implementación puede variar sin que el objeto dependiente se de cuenta, algo que será de extrema utilidad a la hora de mantener aplicaciones muy grandes.

Ejemplo

Vamos a ver un ejemplo muy básico, en primer lugar necesitaremos bajarnos las librerías para agregarlas a nuestro proyecto. Aquí podemos encontrarnos con el primer problema.

Inexplicablemente, des de la pagina de Spring no existe ningún link de descarga, tenemos que dirigirnos directamente al repositorio para descargarlo:
http://maven.springframework.org/release/org/springframework/spring/

Una vez agregados a nuestro classpath del proyecto, también deberemos agregar los jars de Apache Commons. Los podremos descargar de este enlace.

Para este ejemplo no hará falta descargarlos todos, a continuación listo los que yo tengo añadidos a mi classpath para este ejemplo, con el link a su página de descarga:

• BeanUtils
• Digester
• FileUpload
• Logging
• Validator

Primero vamos a crear el proyecto, lo haremos funcionar, y al final explicaré que es lo que está pasando.

La estructura final con el proyecto de ejemplo terminado tendrá este aspecto :

Crearemos un archivo que llamaremos spring.xml que tendrá el siguiente contenido :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

<bean id="saludoImpl" class="com.repocodigo.SaludoImpl">
      <property name="val" value="Hola repocódigo!!!!!"/>
</bean>

<bean id="persona" class="com.repocodigo.Persona" >
      <property name="saludo" ref="saludoImpl"/>
</bean>

</beans>

Creamos una clase encargada de cargar nuestro archivo spring.xml, la llamaremos ContextFactory.java

package com.repocodigo;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;


public class ContextFactory {

private static ApplicationContext respuesta;
    
    
    public static ApplicationContext getInstance(){
        if (respuesta != null) {
            return respuesta;
        }
        respuesta = new FileSystemXmlApplicationContext("C:/wrkspcPruebas/SPRING_1/spring.xml"); //Ruta de nuestro xml
        return respuesta;
    }
}
 

Listo, ahora creamos una clase llamada Persona, esta clase tendrá un atributo que será una interfície llamada Saludo, este es el código para Persona.java

package com.repocodigo;

import com.repocodigo.interfaces.Saludo;

public class Persona {

 private Saludo saludo;
 
 public Saludo getSaludo(){
  return saludo;
 }
 
 public void setSaludo(Saludo saludo){
  this.saludo = saludo;
 }
}

Ahora vamos con la interficie Saludo.java

package com.repocodigo.interfaces;

public interface Saludo {
 public String saluda();
}

A continuación realizaremos una implementación de la clase saludo llamada SaludoImpl.java

package com.repocodigo;

import com.repocodigo.interfaces.Saludo;

public class SaludoImpl implements Saludo{
 
 private String val;
 
 public String saluda() {
  return val;
 }
 
 public String getVal(){
  return val;
 }
 
 public void setVal(String val){
  this.val = val;
 }

}

Una vez ya lo tenemos todo, yo creo una clase llamada Principal.java que lo único que contendrá será un metodo main que tendrá el aspecto siguiente :

package com.repocodigo;

import org.springframework.context.ApplicationContext;

public class Principal {

 public static void main(String[] args) {
  
  ApplicationContext factory = ContextFactory.getInstance();
  
  Persona persona = (Persona) factory.getBean("persona");
  System.out.println(persona.getSaludo().saluda());
 }
}

Ejecutamos y vemos el resultado siguiente :

El funcionamiento lo marca el archivo de configuración spring.xml.
Todo lo que se encuentre dentro de la etiqueta es configuración de Spring.
El tag indica a Spring que ese objeto en cuestión va a ser utilizado dentro del contenedor de Spring.
Dentro de este tag hemos definido dos atributos en nuestro ejemplo:

id = que es obligatorio, se trata de un identificador único para cada bean
class = indica la clase a la cual pertenece el bean

Cada bean puede tener subelementos que representan los atributos de la clase.
Los atributos para properties son :

name = nombre del atributo que tenga la clase
value = valor que le damos a la variable
ref = indicamos que el atributo es un objeto, de manera que configuraremos este objeto de manera independiente, siento el valor de ref el id de este objeto

Como se traduce esto a la práctica?
Tradicionalmente cada objeto es el responsable de obtener sus propias dependencias, como consecuencia nos encontraremos con un código muy acoplado porque cada objeto debe conocer como se construyen otros.
Al aplicar la inyección de dependencias un objeto conoce sus dependencias mediante su interfaz, esto se traduce en un acoplamiento débil ya que podemos variar la implementación ese objeto sin que el objeto dependiente se entere.

Actualización del Kernel de Linux

Vamos a actualizar el núcleo de Linux a una versión mas reciente, el proceso es realmente sencillo pero muchas veces puede provocarnos algun que otro dolor de cabeza.

El ejemplo se realiza en una distro Ubuntu pero el proceso es válido para cualquier distribución existente en el mercado con algunas pequeñas modificaciones.

Hibernate: Inserts en la clase DAO

Vamos a realizar un insert des de una clase DAO.

En primer lugar es una buena idea crear un pequeño método que nos devuelva el objeto en caso de tenerlo previamente en la base de datos. De esta manera podemos decidir si en vez de hacer un insert le hacemos un update.

Vamos a ver como hacer este método con un ejemplo :

public Umbrales getUmbrales(int idUser){  

 Umbrales umbrales = null;  
 try{   
  iniciaOperacion();   
  Criteria criteria = sesion.createCriteria(Umbrales.class);   
  criteria.add(Restrictions.eq("idUsuari", idUser));   
  umbrales = (Umbrales)criteria.uniqueResult();
} catch(HibernateException he){   
    manejaExcepcion(he);
    throw he;  
}finally{   
    sesion.close();}   
return umbrales;
}

Vamos a comentarlo de un modo rápido. Añadimos un criteria con el id de usuario que contiene este objeto llamado Umbrales (es un ejemplo, extrapolar a lo que cada uno necesite, no importa que es exactamente Umbrales). Una vez hecho esto se devuelve un único objeto de la BD  con criteria.uniqueResult(); (entendamos que un usuario solo puede tener un objeto Umbrales en nuestra BD y por tanto idUsuario funciona como identificador único). El modificador del método puede ser public o private según nuestras necesidades de llamar a este método fuera de la clase.

Una vez hecho esto, implementamos el método guardar de la siguiente manera:

public boolean guardarUmbrales(int idUsuari,float dispOptima,float dispWaring,float dispCritical){

  boolean rc=false;
  Umbrales umbralNuevo = 
  new Umbrales(idUsuari,dispOptima,dispWaring,dispCritical);
  Umbrales umbralGuardado = getUmbrales(idUsuari);
  if(umbralGuardado == null){
    rc = insertUmbral(umbralNuevo);
  }else{
    rc = updateUmbrales(umbralNuevo);
  }
 return rc;
}

Este método es público ya que puede ser llamado des de cualquier lado. Vamos a comentar este método : por parámetros recibiremos un seguido de variables que utilizaremos para montarnos el objeto nuevo Umbrales, esto no es del todo necesario ya que podríamos recibir por parámetro directamente el objeto ya instanciado. A continuación realizamos una llamada al método getUmbrales() que hemos creado anteriormente, este nos devolverá un objeto en casa de existir previamente o un null en caso de que no existe ningún objeto en la BD con ese id de usuario, en base a esto decidimos, si es null crearemos una nueva entrada y si ya existe realizaremos un update. Los métodos que haran estas tareas son implementados con modificadores de acceso private ya que no deben ser llamados nunca des de fuera de esta clase, y si debe ser llamado guardarUmbrales() (que contiene la lógica de decisión de que hacer), los métodos son los siguientes:

private boolean insertUmbral(Umbrales umbral){
  boolean rc=false;
  try{
   iniciaOperacion(); 
   sesion.save(umbral);
   tx.commit();
   rc=true;
  }catch(HibernateException he){
   manejaExcepcion(he); 
   throw he; 
  }finally{
   sesion.close(); 
  }
 return rc;
}

private boolean updateUmbrales(Umbrales umbral){
  boolean rc=false;
  try{
    iniciaOperacion(); 
    sesion.update(umbral); 
    tx.commit(); 
    rc=true;
  }catch(HibernateException he){
    manejaExcepcion(he); 
    throw he; 
  }finally{
    sesion.close(); 
  }
  return rc;

}

Cada uno de los métodos retornan una variable rc para verificar que las operaciones han ido correctamente o no, a modo que podamos tener un control de los resultados.