Persistencia 4

Para trabajar de forma correcta con el modelo de tres capas, el DISC ha desarrollado una herramienta denominada "Persistencia", la cual nos sirve para conectarse a una base de datos y trabajar con los datos contenidos en ella. Fue escrita en lenguaje java y ha ido evolucionando con el tiempo, es por este motivo que revisaremos la versión 4.

Los objetos que necesitamos sean persistentes dentro de nuestro programa, deben implementar la interface "Persistente".
Como ejemplo desarrollaremos la clase "Formulario" y algunos métodos necesarios.

La clase formulario tiene como atributos básicos: nombre, apellido paterno, apellido materno, rut, email, título de grado, universidad del grado, ciudad, país, año titulación, teléfonos (casa, trabajo y celular), código de acceso, fecha de creación del formulario, folio y una descripción.
Al asignar los tipos de estos atributos hay que tener en cuenta que no deben corresponder a tipos básicos, tales como: int, long, etc. Deben ser de tipo "objetos", por ejemplo: Integer en vez de int, Long en vez de long, etc.
De forma adicional toda clase persistente debe añadir el atributo id, que corresponderá a su identificador en la base de datos. En este caso particular debemos agregar de forma adicional los id correspondientes a las referencias realizadas a las tablas de "estado" y "tipo magister".
De esta forma la cabecera de nuestra clase formulario queda así:

public class Formulario implements Persistente {

private Long id_tipo_magister;
private Long id_estado;

private Long id;

private String nombre;
private String apellidoPaterno;
private String apellidoMaterno;
private Long rut;
private String mail;
private String tituloGrado;
private String universidadGrado;
private String ciudad;
private String pais;
private Integer anioTitulacion;
private String telefonoCasa;
private String telefonoTrabajo;
private String telefonoCelular;
private String codigoAcceso;
private Calendario fechaCreacion;
private Long folio;
private String observacion;
.
.
.
}

Además, es necesario que nuestra clase implemente tres constructores:

1) Un constuctor vacío.

public Formulario(){

}

2) Un constructor que recibe el identificador del objeto en la base de datos.

public Formulario(Long _id) throws PersistenciaException{
this.id = _id;
this.cargar();
}

3) Un constructor que recibe un "objeto genérico" el cual es de tipo "ObjectBD"

public Formulario(ObjectBD _obj) throws PersistenciaException{
this.inicializar(_obj);
}

Al ser una implementación de la interface "Persistente", es necesario implementar los métodos: nuevo, guardar, eliminar, cargar, inicializar, getObjectBD, esPersistente.

A continuación se explican los métodos: getObjectBD, nuevo e inicializar.

1) El método "getObjectBD( )" crea un objeto genérico (ObjectBD) y lo rellena con los datos asociados al objeto lógico (Formulario). Hay que notar que establece la relación entre los atributos lógicos y los correspondientes a los atributos de la tabla. Finalmente retorna un ObjectBD con toda la información del objeto Formulario.

public ObjectBD getObjectBD() throws PersistenciaException {

FachadaPersistencia fachada = PersistenciaFormulario.FACTORY.crear();

ObjectBD obj = fachada.crear("formulario");
obj.set("id", id);

obj.set("id_estado", this.id_estado);
obj.set("id_tipo_magister", this.id_tipo_magister);
obj.set("nombre", this.nombre);
obj.set("apellido_paterno", this.apellidoPaterno);
obj.set("apellido_materno", this.apellidoMaterno);
obj.set("rut", this.rut);
obj.set("email", this.mail);
obj.set("titulo_grado", this.tituloGrado);
obj.set("universidad_grado", this.universidadGrado);
obj.set("ciudad", this.ciudad);
obj.set("pais", this.pais);
obj.set("anho_titulacion", this.anioTitulacion);
obj.set("telefono_casa", this.telefonoCasa);
obj.set("telefono_trabajo", this.telefonoTrabajo);
obj.set("telefono_celular", this.telefonoCelular);
obj.set("codigo_acceso", this.codigoAcceso);
obj.set("fecha_creacion", this.fechaCreacion.getTimestamp());
obj.set("folio", this.folio);
obj.set("observacion", this.observacion);

return obj;
}

2) El método "inicializar(ObjectBD)" recibe un objeto con toda la información (contenido) de los atributos, la cual es vaciada en los atributos lógicos correspondientes. Debido a que el ObjectBD almacena los datos de forma general (asociando el tipo Object), es necesario realizar un casting con los tipos correctos.

public void inicializar(ObjectBD _obj) throws PersistenciaException {

this.id = (Long)_obj.get("id");
this.nombre  = (String)_obj.get("nombre");
this.apellidoPaterno = (String)_obj.get("apellido_paterno");
this.apellidoMaterno = (String)_obj.get("apellido_materno");
this.rut = (Long)_obj.get("rut");
this.mail = (String)_obj.get("email");
this.tituloGrado = (String)_obj.get("titulo_grado");
this.universidadGrado = (String)_obj.get("universidad_grado");
this.ciudad = (String)_obj.get("ciudad");
this.pais = (String)_obj.get("pais");
this.anioTitulacion = (Integer)_obj.get("anho_titulacion");
this.telefonoCasa = (String)_obj.get("telefono_casa");
this.telefonoTrabajo = (String)_obj.get("telefono_trabajo");
this.telefonoCelular = (String)_obj.get("telefono_celular");
this.codigoAcceso = (String)_obj.get("codigo_acceso");

this.observacion = (String)_obj.get("observacion");

Timestamp objFecha = (Timestamp)_obj.get("fecha_creacion");
if (objFecha != null)
this.fechaCreacion = new Calendario(((Timestamp)objFecha).toString());

}

3) El método "nuevo( )" es el encargado de crear un nuevo objeto dentro de la base de datos. La forma de realizar esto es creando un ObjectBD con la información actual del objeto lógico, la cual será entregada al objeto "fachada", éste creará un nuevo identificador y lo asociará con el ObjectBD. Finalmente se actualiza el id del objeto lógico con el correspondiente en la base de datos.

public void nuevo() throws PersistenciaException {
try {
ObjectBD obj = this.getObjectBD();
FachadaPersistencia fachada = PersistenciaFormulario.FACTORY.crear();
fachada.nuevo(obj);
this.inicializar(obj);
} catch (PersistenciaException e) {
LOG.error("Error:",e);
}
}

Además de implementar los métodos de la interfaz, se deben agregar los métodos "get" y "set" de todos los atributos.
Con tan sólo estos métodos ya es posible probar el funcionamiento de la clase, instanciando un objeto y solicitando información a nuestra base de datos.

Para mayor información, revisar la documentación que se encuentra en el sitio del profesor Bekios acá.