Sprin AOP

Programación Orientada a Aspectos.

La Programación Orientada a Aspectos (POA) es un paradigma de programación relativamente reciente cuya intención es permitir una adecuada modularización de las aplicaciones y posibilitar una mejor separación de incumbencias. Gracias a la POA se pueden encapsular los diferentes conceptos que componen una aplicación en entidades bien definidas, eliminando las dependencias entre cada uno de los módulos. De esta forma se consigue razonar mejor sobre los conceptos, se elimina la dispersión del código y las implementaciones resultan más comprensibles, adaptables y reusables.
Objetivo
El principal objetivo de la POA es la separación de las funcionalidades dentro del sistema:
• Por un lado funcionalidades comunes utilizadas a lo largo de la aplicación.
• Por otro lado, las funcionalidades propias de cada módulo.

Conceptos

• Aspect (Aspecto) es una funcionalidad transversal (cross-cutting) que se va a implementar de forma modular y separada del resto del sistema. El ejemplo más común y simple de un aspecto es el logging (registro de sucesos) dentro del sistema, ya que necesariamente afecta a todas las partes del sistema que generan un suceso.
• Join point (Punto de Cruce o de Unión) es un punto de ejecución dentro del sistema donde un aspecto puede ser conectado, como una llamada a un método, el lanzamiento de una excepción o la modificación de un campo. El código del aspecto será insertado en el flujo de ejecución de la aplicación para añadir su funcionalidad.
• Advice (Consejo) es la implementación del aspecto, es decir, contiene el código que implementa la nueva funcionalidad. Se insertan en la aplicación en los Puntos de Cruce.
• Pointcut (Puntos de Corte) define los Consejos que se aplicarán a cada Punto de Cruce. Se especifica mediante Expresiones Regulares o mediante patrones de nombres (de clases, métodos o campos), e incluso dinámicamente en tiempo de ejecución según el valor de ciertos parámetros.
• Introduction (Introducción) permite añadir métodos o atributos a clases ya existentes. Un ejemplo en el que resultaría útil es la creación de un Consejo de Auditoría que mantenga la fecha de la última modificación de un objeto, mediante una variable y un método setUltimaModificacion(fecha), que podrían ser introducidos en todas las clases (o sólo en algunas) para proporcionarles esta nueva funcionalidad.
• Target (Destinatario) es la clase aconsejada, la clase que es objeto de un consejo. Sin AOP, esta clase debería contener su lógica, además de la lógica del aspecto.
• Proxy (Resultante) es el objeto creado después de aplicar el Consejo al Objeto Destinatario. El resto de la aplicación únicamente tendrá que soportar al Objeto Destinatario (pre-AOP) y no al Objeto Resultante (post-AOP).
• Weaving (Tejido) es el proceso de aplicar Aspectos a los Objetos Destinatarios para crear los nuevos Objetos Resultantes en los especificados Puntos de Cruce. Este proceso puede ocurrir a lo largo del ciclo de vida del Objeto Destinatario:
o Aspectos en Tiempo de Compilación, que necesita un compilador especial.
o Aspectos en Tiempo de Carga, los Aspectos se implementan cuando el Objeto Destinatario es cargado. Requiere un ClassLoader especial.
o Aspectos en Tiempo de Ejecución.

Spring AOP

AOP es útil para realizar tareas puntuales que no encajan de forma natural en nuestras entidades ni en nuestra lógica de negocio; estas tareas podríamos implementarlas en la lógica de negocio por ejemplo, pero estaríamos ensuciando nuestras clases con código que no les corresponde controlar. Imagínemos por ejemplo el envío de un mail al administrador cuando un usuario nuevo ha sido dado de alta. La función de enviar un mail no está relacionada en lo absoluto con las funciones que debería de hacer una clase encargada de administrar usuarios. Para no mezclar estas funciones podríamos utilizar perfectamente AOP y definir fuera de nuestro código que cuando se dé de alta un usuario nuevo se envíe un mail a una dirección determinada. Hay varios campos para los que AOP se puede emplear de forma satisfactoria, como puede ser para realizar Transacciones, para Depurar un programa registrando lo que está sucediendo en los métodos, o para implementar unas políticas de seguridad. Spring tiene implementadas clases para controlar el tema de las Transacciones y el de registro de acciones. También existe un framework de seguridad ( Acegi ) que va a formar parte de Spring. Pero si queremos implementar otro tipo de aspectos personalizados debemos definirlos nosotros mismos implementando unas interfaces creadas para tal efecto, y precisamente éste va a ser el objetivo de este artículo, la definición de aspectos personalizados en Spring.

Job Con Oracle

DECLARE
X NUMBER;
BEGIN
SYS.DBMS_JOB.SUBMIT
( job => X
,what => 'SYNCRONIZA_TIENDAS;'
,next_date => to_date('18/05/2011 06:00:00','dd/mm/yyyy hh24:mi:ss')
,interval => 'TRUNC(SYSDATE+1)+6/24'
,no_parse => TRUE
);
SYS.DBMS_OUTPUT.PUT_LINE('Job Number is: ' || to_char(x));
END;
commit;

este es un job que ejecuta un sp "SYNCRONIZA_TIENDAS" todos los dias a las 6 de la mañana

Ejecutar un jar con ShellScript

#!/bin/sh

#########################################################
#Ejecutar un jar con shell script.
#Juan Antonio Ramirez

######################################################

echo "Ejecutando jar."
$JAVA_HOME/bin/java -jar test.jar Test
echo "jar ejecutado."

Generic DAO with Hibernate

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.Collection;
import java.util.List;

import org.apache.log4j.Logger;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.classic.Session;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

/**
* Dao generico que contiene las operasiones basicas y que regula el
* comportamiento de los metodos.
*
* @author Juan Antonio Ramirez Orduna
* @version 1.0
* @T Es la clase que mapea ORM.
* @ID Es el ID de la tabla mapeada.
*
*/
@SuppressWarnings("unchecked")
public class GenericDAO extends
HibernateDaoSupport {
private static final Logger log = Logger
.getLogger(SevenBaseHibernateDao.class);
private Class persistentClass = getDomainClass();

public void setSessionFactoryHibernate(SessionFactory sessionFactory) {
super.setSessionFactory(sessionFactory);
}

/**
* Constructor de la clase
*/
public GenericDAO() {
/*
* ParameterizedType thisType = (ParameterizedType) getClass()
* .getGenericSuperclass(); setPersistentClass((Class)
* thisType.getActualTypeArguments()[0]);
*/

}

/**
* Realiza una busqueda en la base de datos por ID.
*
* @param id
* ID de la tabla en la que se va a realizar la busqueda.
* @return Regresa un objeto encontrado del tipo T.
*/
public T findById(ID id) {
if (log.isDebugEnabled()) {
log.debug("getting " + getClassName() + " instance with id: " + id);
}
T entity;
entity = (T) getHibernateTemplate().get(getPersistentClass(), id);
return entity;
}

/**
* Busqueda que regresa todos los registros de la T.
*
* @return Regresa una lista con todos los tegistros de la tabla T.
*/
public List findAll() {
if (log.isDebugEnabled()) {
log.debug("finding " + getClassName() + " instance by example");
}
return getHibernateTemplate().find("from " + getClassName());
}


public List getByListId(String lista) {
if (log.isDebugEnabled()) {
log.debug("finding " + getClassName() + " instance by example");
}





if(lista==""||lista==null){
//return getHibernateTemplate().find("from " + getClassName());
return null;
}else{
return getHibernateTemplate().find("from " + getClassName() + " where id in ("+lista+"))");
}

}



public List getByListIdNotIn(String lista) {
if (log.isDebugEnabled()) {
log.debug("finding " + getClassName() + " instance by example");
}

if(lista==""||lista==null){
//return getHibernateTemplate().find("from " + getClassName());
return null;
}else{
return getHibernateTemplate().find("from " + getClassName() + " where id not in ("+lista+"))");
}

}



/**
* Obtiene el valor de la variable referencia persistenClass.
*
* @return Regresa la referencia a la que apunta persistenClass.
*/
public Class getPersistentClass() {
return persistentClass;
}

protected Class getDomainClass() {
if (persistentClass == null) {
ParameterizedType thisType = (ParameterizedType) getClass()
.getGenericSuperclass();
persistentClass = (Class) thisType.getActualTypeArguments()[0];
}
return persistentClass;
}

/**
* Aigna la referencia a la variable referencia persistenClass.
*
* @param persistentClass
* Referencia que se le va a asignar a la variable
* persistenClass.
*/
public void setPersistentClass(Class persistentClass) {
this.persistentClass = persistentClass;
}

/**
* Obtiene el nombre del tipo de la variable persistentClass.
*
* @return Regresa una cadena con el nombre del tipo de la variable
* persistentClass.
*/
private String getClassName() {
return persistentClass.getName();
}

/**
* Guarda el objeto pasado como parametro en la tabla que coincide con T.
*
* @param transientInstance
* Objeto que contiene los valores.
*/
public void save(T transientInstance) {
if (log.isDebugEnabled()) {
log.debug("saving " + getClassName() + " instance");
}
getHibernateTemplate().save(transientInstance);

if (log.isDebugEnabled()) {
log.debug("save successful");
}
}

/**
* Guarda o actualiza el objeto pasado como parametro en la tabla que
* coincide con T.
*
* @param transientInstance
* Objeto que contiene los valores.
*/
public void saveOrUpdate(T transientInstance) {
if (log.isDebugEnabled()) {
log.debug("saving " + getClassName() + " instance");
}

getHibernateTemplate().saveOrUpdate(transientInstance);
if (log.isDebugEnabled()) {
log.debug("save successful");
}
}

/**
* Elimina el objeto pasado como parametro de la tabla que coincide con T.
*
* @param persistentInstance
* Objeto que contiene el registro a ser eliminado.
*/
public void delete(T persistentInstance) {
if (log.isDebugEnabled()) {
log.debug("deleting " + getClassName() + " instance");
}
getHibernateTemplate().delete(persistentInstance);
if (log.isDebugEnabled()) {
log.debug("delete successful");
}
}

/**
* Actualiza el objeto pasado como parametro en la tabla que coincide con T.
*
* @param transientInstance
* Objeto que contiene los valores.
*/
public void update(T transientInstance) {
if (log.isDebugEnabled()) {
log.debug("updating " + getClassName() + " instance");
}
getHibernateTemplate().update(transientInstance);

if (log.isDebugEnabled()) {
log.debug("update successful");
}
}

/**
* Perzonalizado Guarda o actualiza las entidades pasado como parametro en
* la tabla que coincide con T. Todas las entidades son persistidas dentro
* de una misma transaccion.
*
* @param transientInstances
* Objetos que contienen los valores.
*/
public boolean insertBachTransac(Collection transientInstances) {
Session session = getSessionFactory().openSession();
Transaction tx = session.beginTransaction();
System.out.println("Size bach >>" + transientInstances.size());
boolean transac = Boolean.TRUE;
int i = 0;
for (T persistEntity: transientInstances) {
try {
session.saveOrUpdate(persistEntity);

} catch (Exception e) {
e.printStackTrace();
transac = Boolean.FALSE;
tx.rollback();
}
i++;

}
if (transac) {
tx.commit();
}
return transac;

}
public void merge(T transientEntity) {
getHibernateTemplate().merge(transientEntity);
}




}

Java

Decimales Con Java

public static double getDecimal(double value, int numeroDecimales) { return Math.round(value*Math.pow(10,numeroDecimales))/Math.pow(10,numeroDecimales); }