DAO

Pasemos ahora a ver cómo implementar el patrón DAO usando Hibernate y de forma que sea fácilmente reutilizable.

El mayor problema del patrón DAO es la repetición de código para cada una de las entidades. Para evitar dicha repetición y obtener una gran flexibilidad en la implementación del objeto DAO se va a usar un modelo de clases e interfaces un poco complejo, pero una vez entendido cómo funciona será muy sencillo crear nuevos objetos DAO o cambiar su implementación.

Los interfaces

El siguiente diagrama UML explica los interfaces ProfesorDAO y UsuarioDAO.

PlantUML Graph

Como podemos ver, los objetos DAO de Profesor y Usuario son realmente los interfaces ProfesorDAO y UsuarioDAO ya que de esa forma podremos fácilmente tener varias implementaciones para cada interfaz DAO. Para evitar definir los mismos métodos en cada interfaz DAO se ha creado un interfaz padre llamado GenericDAO del que heredan ProfesorDAO y UsuarioDAO.

El código Java relativo a los 3 interfaces es el siguiente:

1: public interface GenericDAO<T,ID extends Serializable> {
2:     T create() throws BussinessException;
3:     void saveOrUpdate(T entity) throws BussinessException;
4:     T get(ID id) throws BussinessException;
5:     void delete(ID id) throws BussinessException;
6:     List<T> findAll() throws BussinessException;
7: }

GenericDAO.java

1: public interface ProfesorDAO extends GenericDAO<Profesor,Integer> {
2:
3: }

ProfesorDAO.java

1: public interface UsuarioDAO extends GenericDAO<Usuario,Integer>  {
2:
3: }

UsuarioDAO.java

Pasemos ahora a explicar cada uno de los métodos de GenericDAO:

  • T create(): Crea un nuevo objeto de la entidad.
  • void saveOrUpdate(T entity) : Inserta o actualiza un objeto de una entidad en la base de datos.
  • T get(ID id) : Obtiene un objeto de una entidad desde la base de datos en función de la clave primaria.
  • void delete(ID id) : Borra un objeto de una entidad de la base de datos en función de la clave primaria.
  • List<T> findAll() : Obtiene una lista con todos los objetos de una entidad de la base de datos.

Los métodos que tiene el interfaz GenericDAO son un posible ejemplo de métodos para un objeto DAO. El programador puede diseñar el objeto DAO de la forma que más le interese,como por ejemplo:

  • Separando el método void saveOrUpdate(T entity) en dos distintos, uno para la inserción y otro para la actualización.
  • Haciendo que el método T get(ID id) permita bloquear el objeto para que nadie lo pueda modificar.
  • Etc.

Un GenericDAO con muchos mas métodos lo podemos encontrar en Spring Framework: El patrón DAO

En los interfaces ProfesorDAO y UsuarioDAO será normal añadir, entre otros, más métodos find para personalizar los métodos de búsqueda de entidades.

Por ejemplo en UsuarioDAO sería útil añadir el método Usuario findByLogin(String login) que nos permitiría obtener un usuario en función de su login en vez de en función de su idUsuario tal y como hace T get(ID id).

Tambien en ProfesorDAO sería útil añadir el método List<Profesor> findByNombreAndApe1AndApe2(String nombre,String ape1,String ape2) que nos permitiría obtener los usuarios que tengan el nombre y el 1º apellido y el 2º apellido en vez de obtener todos los profesores como hace List<T> findAll()

La implementación

Como ya hemos comentado la ventaja de usar el patrón DAO es poder tener varias implementaciones del mismo interfaz DAO de forma que podamos cambiar la funcionalidad de una forma sencilla pero también es necesario que no se repita el código entre las distintas implementaciones.

Para reutilizar el código se ha creado la clase GenericDAOImplHibernate que implementa de forma genérica el acceso a la base de datos mediante Hibernate. De esta clase heredarán las implementaciones de cada interfaz DAO.

Veamos un diagrama UML con las relaciones:

PlantUML Graph

Ahora tenemos las 2 clases ProfesorDAOImplHibernate y UsuarioDAOImplHibernate que reutilizan todo el código de GenericDAOImplHibernate ya que heredan de GenericDAOImplHibernate y de esa forma evitaremos duplicar el código de Hibernate en cada entidad.

En el siguiente diagrama UML puede verse los interfaces que implementa cada clase.

PlantUML Graph

El código Java correspondiente a las 3 clases es el siguiente:

  1: public class GenericDAOImplHibernate<T, ID extends Serializable> implements GenericDAO<T, ID> {
  2:
  3:
  4:     SessionFactory sessionFactory;
  5:
  6:     private final static Logger LOGGER = Logger.getLogger(GenericDAOImplHibernate.class.getName());
  7:
  8:     public GenericDAOImplHibernate() {
  9:         sessionFactory=HibernateUtil.getSessionFactory();
 10:     }
 11:
 12:
 13:
 14:     @Override
 15:     public T create() throws BussinessException {
 16:         try {
 17:             return getEntityClass().newInstance();
 18:         } catch (InstantiationException | IllegalAccessException ex) {
 19:             throw new RuntimeException(ex);
 20:         } catch (RuntimeException ex) {
 21:             throw ex;
 22:         } catch (Exception ex) {
 23:             throw new RuntimeException(ex);
 24:         }
 25:     }
 26:
 27:     @Override
 28:     public void saveOrUpdate(T entity) throws BussinessException {
 29:         Session session = sessionFactory.getCurrentSession();
 30:         try {
 31:             session.beginTransaction();
 32:             session.saveOrUpdate(entity);
 33:             session.getTransaction().commit();
 34:         } catch (javax.validation.ConstraintViolationException cve) {
 35:             try {
 36:                 if (session.getTransaction().isActive()) {
 37:                     session.getTransaction().rollback();
 38:                 }
 39:             } catch (Exception exc) {
 40:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
 41:             }
 42:             throw new BussinessException(cve);
 43:         } catch (org.hibernate.exception.ConstraintViolationException cve) {
 44:             try {
 45:                 if (session.getTransaction().isActive()) {
 46:                     session.getTransaction().rollback();
 47:                 }
 48:             } catch (Exception exc) {
 49:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
 50:             }
 51:             throw new BussinessException(cve);
 52:         } catch (RuntimeException ex) {
 53:             try {
 54:                 if (session.getTransaction().isActive()) {
 55:                     session.getTransaction().rollback();
 56:                 }
 57:             } catch (Exception exc) {
 58:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
 59:             }
 60:             throw ex;
 61:         } catch (Exception ex) {
 62:             try {
 63:                 if (session.getTransaction().isActive()) {
 64:                     session.getTransaction().rollback();
 65:                 }
 66:             } catch (Exception exc) {
 67:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
 68:             }
 69:             throw new RuntimeException(ex);
 70:         }
 71:     }
 72:
 73:     @Override
 74:     public T get(ID id) throws BussinessException {
 75:         Session session = sessionFactory.getCurrentSession();
 76:         try {
 77:             session.beginTransaction();
 78:             T entity = (T) session.get(getEntityClass(), id);
 79:             session.getTransaction().commit();
 80:
 81:             return entity;
 82:         } catch (javax.validation.ConstraintViolationException cve) {
 83:             try {
 84:                 if (session.getTransaction().isActive()) {
 85:                     session.getTransaction().rollback();
 86:                 }
 87:             } catch (Exception exc) {
 88:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
 89:             }
 90:             throw new BussinessException(cve);
 91:         } catch (org.hibernate.exception.ConstraintViolationException cve) {
 92:             try {
 93:                 if (session.getTransaction().isActive()) {
 94:                     session.getTransaction().rollback();
 95:                 }
 96:             } catch (Exception exc) {
 97:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
 98:             }
 99:             throw new BussinessException(cve);
100:         } catch (RuntimeException ex) {
101:             try {
102:                 if (session.getTransaction().isActive()) {
103:                     session.getTransaction().rollback();
104:                 }
105:             } catch (Exception exc) {
106:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
107:             }
108:             throw ex;
109:         } catch (Exception ex) {
110:             try {
111:                 if (session.getTransaction().isActive()) {
112:                     session.getTransaction().rollback();
113:                 }
114:             } catch (Exception exc) {
115:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
116:             }
117:             throw new RuntimeException(ex);
118:         }
119:     }
120:
121:     @Override
122:     public void delete(ID id) throws BussinessException {
123:         Session session = sessionFactory.getCurrentSession();
124:         try {
125:             session.beginTransaction();
126:             T entity = (T) session.get(getEntityClass(), id);
127:             if (entity == null) {
128:                 throw new BussinessException(new BussinessMessage(null, "Los datos a borrar ya no existen"));
129:             }
130:             session.delete(entity);
131:             session.getTransaction().commit();
132:         } catch (javax.validation.ConstraintViolationException cve) {
133:             try {
134:                 if (session.getTransaction().isActive()) {
135:                     session.getTransaction().rollback();
136:                 }
137:             } catch (Exception exc) {
138:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
139:             }
140:             throw new BussinessException(cve);
141:         } catch (org.hibernate.exception.ConstraintViolationException cve) {
142:             try {
143:                 if (session.getTransaction().isActive()) {
144:                     session.getTransaction().rollback();
145:                 }
146:             } catch (Exception exc) {
147:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
148:             }
149:             throw new BussinessException(cve);
150:         } catch (BussinessException ex) {
151:             try {
152:                 if (session.getTransaction().isActive()) {
153:                     session.getTransaction().rollback();
154:                 }
155:             } catch (Exception exc) {
156:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
157:             }
158:             throw ex;
159:         } catch (RuntimeException ex) {
160:             try {
161:                 if (session.getTransaction().isActive()) {
162:                     session.getTransaction().rollback();
163:                 }
164:             } catch (Exception exc) {
165:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
166:             }
167:             throw ex;
168:         } catch (Exception ex) {
169:             try {
170:                 if (session.getTransaction().isActive()) {
171:                     session.getTransaction().rollback();
172:                 }
173:             } catch (Exception exc) {
174:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
175:             }
176:             throw new RuntimeException(ex);
177:         }
178:     }
179:
180:     @Override
181:     public List<T> findAll() throws BussinessException {
182:         Session session = sessionFactory.getCurrentSession();
183:         try {
184:
185:             Query query = session.createQuery("SELECT e FROM " + getEntityClass().getName() + " e");
186:             List<T> entities = query.list();
187:
188:             return entities;
189:         } catch (javax.validation.ConstraintViolationException cve) {
190:             try {
191:                 if (session.getTransaction().isActive()) {
192:                     session.getTransaction().rollback();
193:                 }
194:             } catch (Exception exc) {
195:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
196:             }
197:             throw new BussinessException(cve);
198:         } catch (org.hibernate.exception.ConstraintViolationException cve) {
199:             try {
200:                 if (session.getTransaction().isActive()) {
201:                     session.getTransaction().rollback();
202:                 }
203:             } catch (Exception exc) {
204:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
205:             }
206:             throw new BussinessException(cve);
207:         } catch (RuntimeException ex) {
208:             try {
209:                 if (session.getTransaction().isActive()) {
210:                     session.getTransaction().rollback();
211:                 }
212:             } catch (Exception exc) {
213:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
214:             }
215:             throw ex;
216:         } catch (Exception ex) {
217:             try {
218:                 if (session.getTransaction().isActive()) {
219:                     session.getTransaction().rollback();
220:                 }
221:             } catch (Exception exc) {
222:                 LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
223:             }
224:             throw new RuntimeException(ex);
225:         }
226:     }
227:
228:     private Class<T> getEntityClass() {
229:         return (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
230:     }
231: }

GenericDAOImplHibernate.java

1: public class ProfesorDAOImplHibernate extends GenericDAOImplHibernate<Profesor,Integer> implements  ProfesorDAO {
2:
3: }

ProfesorDAOImplHibernate.java

1: public class UsuarioDAOImplHibernate extends GenericDAOImplHibernate<Usuario,Integer> implements  UsuarioDAO {
2:
3: }

UsuarioDAOImplHibernate .java

El código de GenericDAOImplHibernate ha quedado un poco largo ya que se ha incluido la gestión de excepciones que hemos visto en el tema anterior.

Destacar la línea 9 de GenericDAOImplHibernate en la que se ve cómo usamos la clase HibernateUtil para acceder al objeto SessionFactory. Ésto es importante ya que en la siguiente lección explicaremos cómo hacer que no sea necesaria esa línea y evitar la dependencia de GenericDAOImplHibernate con HibernateUtil.

También destacar la simplicidad de las implementaciones para los interfaces ProfesorDAO y UsuarioDAO. Sólo es necesario crear las clases ProfesorDAOImplHibernate y UsuarioDAOImplHibernate y que hereden de GenericDAOImplHibernate no habiendo ni una sola línea de código.

La clase GenericDAOImplHibernate hace uso de los Generics de Java. Está mas allá del alcance de este curso explicar cómo funcionan los Generics de Java, pero en Internet existen gran cantidad de tutoriales explicando su funcionamiento.

Ahora en un único diagrama UML se ven todas las relaciones entre los interfaces y las clases.

PlantUML Graph

Este diagrama UML contiene todos los intefaces y clases que se necesitan para implementar el patrón DAO en hibernate de una forma correcta.

Creando un nuevo objeto DAO

Para finalizar explicar los pasos necesarios para crear un objeto DAO de una nueva entidad. Para ello, lo haremos con el ejemplo de la entidad Municipio.

  • Crear un nuevo interfaz llamado MunicipioDAO que herede de GenericDAO. El código Java es el siguiente:
public interface MunicipioDAO extends GenericDAO<Municipio,Integer> {
 
}
  • Crear una nueva implementación llamada MunicipioDAOImplHibernate para Hibernate que herede de GenericDAOImplHibernate e implemente MunicipioDAO
public class MunicipioDAOImplHibernate extends GenericDAOImplHibernate<Municipio,Integer> implements  MunicipioDAO {
 
}

Como vemos es sencillísimo crear un nuevo objeto DAO para una nueva entidad y sin nada de código repetido.

Creando objetos DAO

Ya sabemos cómo programar nuestros objetos DAO, pero ahora hay que añadirle el problema de crearlos desde nuestra aplicación. Aparentemente es tan sencillo como el siguiente código:

UsuarioDAO usuarioDAO = new UsuarioDAOImplHibernate();
ProfesorDAO profesorDAO = new ProfesorDAOImplHibernate();

Con esas dos simples líneas hemos creado 2 objetos DAO para las entidades Profesor y Usuario. Estas líneas se repetirán a lo largo del código cada vez que quedamos acceder a las entidades Profesor y Usuario.

¿Cuál es el problema?

Que si queremos cambiar la implementación de UsuarioDAO o de ProfesorDAO deberemos cambiar el código en todos los sitios en los que se use. Supongamos que ahora queremos usar implementaciones basadas en JDBC, se debería cambiar el código a:

UsuarioDAO usuarioDAO = new UsuarioDAOImplJDBC();
ProfesorDAO profesorDAO = new ProfesorDAOImplJDBC();

Podríamos pensar que hacer un simple buscar/reemplazar en nuestro IDE sería suficiente, pero podríamos tener código ya compilado en JARs con lo que no se cambiaría a no ser que buscáramos el fuente de los JARs y además habría que volver a recompilarlos.Una aplicación pueden ser miles y miles de líneas de código y decenas de JARs, así que el trabajo puede ser un poco largo y tedioso.

Hay varias soluciones a ésto pero hablaremos de la solución elegida en el siguiente tema sobre Spring.

unidades/07_arquitectura/03_dao.txt · Última modificación: 2016/07/03 20:35 (editor externo)
Ir hasta arriba
CC Attribution-Noncommercial-Share Alike 3.0 Unported
chimeric.de = chi`s home Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0