Excepciones

Nuestro siguiente tema a tratar con la arquitectura de Hibernate es el tratamiento de las excepciones.Antes de ver este tema es recomendable la lectura de Tratamiento de Excepciones.

Tratamiento de Excepciones

Al realizar una operación con Hibernate se pueden lanzar cualquiera de las siguiente 4 excepciones:

Hemos indicado únicamente estas 4 excepciones ya que vamos a tratar cada una de ellas de forma distinta , no siendo necesario tratar ninguna otra ya que siempre caerán dentro de alguna de las cuatro.

Veamos cómo vamos a tratarlas. El siguiente código dentro del catch deberá ponerse siempre que usemos Hibernate:

 1: try {
 2:     session.beginTransaction();
 3:     session.saveOrUpdate(entity);
 4:     session.getTransaction().commit();
 5: } catch (javax.validation.ConstraintViolationException cve) {
 6:     try {
 7:         if (session.getTransaction().isActive()) {
 8:             session.getTransaction().rollback();
 9:         }
10:     } catch (Exception exc) {
11:         LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
12:     }
13:     throw new BussinessException(cve);
14: } catch (org.hibernate.exception.ConstraintViolationException cve) {
15:     try {
16:         if (session.getTransaction().isActive()) {
17:             session.getTransaction().rollback();
18:         }
19:     } catch (Exception exc) {
20:         LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
21:     }
22:     throw new BussinessException(cve);
23: } catch (BussinessException ex) {
24:     try {
25:         if (session.getTransaction().isActive()) {
26:             session.getTransaction().rollback();
27:         }
28:     } catch (Exception exc) {
29:         LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
30:     }
31:     throw ex;
32: } catch (RuntimeException ex) {
33:     try {
34:         if (session.getTransaction().isActive()) {
35:             session.getTransaction().rollback();
36:         }
37:     } catch (Exception exc) {
38:         LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
39:     }
40:     throw ex;
41: } catch (Exception ex) {
42:     try {
43:         if (session.getTransaction().isActive()) {
44:             session.getTransaction().rollback();
45:         }
46:     } catch (Exception exc) {
47:         LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
48:     }
49:     throw new RuntimeException(ex);
50: }

Lo que debemos hacer siempre en las 4 excepciones es ver si hay una transacción activa y en ese caso hacer un rollback. Si al hacer un rollback se produce un error , simplemente generaremos un mensaje en el log.

try {
    if (session.getTransaction().isActive()) {
        session.getTransaction().rollback();
    }
} catch (Exception exc) {
    LOGGER.log(Level.WARNING,"Falló al hacer un rollback", exc);
}

La propiedad estática LOGGER la definiremos como una propiedad a nivel de clase usando Java Logging APIs de la siguiente forma:

private final static Logger LOGGER = Logger.getLogger(ProfesorController.class .getName());

Veamos ahora el tratamiento individualizado para cada una de ellas:

RuntimeException

Si la excepción es de tipo RuntimeException lo único que hacemos es volver a relanzar la misma excepción mediante:

throw ex;

Exception

Si la excepción es de tipo Exception lo único que hacemos es relanzar la excepción envuelta en una RuntimeException:

throw new RuntimeException(ex);

De esa forma evitamos la obligación de tratar las Checked Exceptions de Java cuando no sabemos que hacer con ella.

javax.validation.ConstraintViolationException

Esta excepción la vamos a reconvertir en una BussinessException. En el siguiente apartado se explica en qué consiste BussinessException.

throw new BussinessException(cve);

org.hibernate.exception.ConstraintViolationException

Esta excepción la vamos a reconvertir en una BussinessException. En el siguiente apartado se explica en qué consiste BussinessException.

throw new BussinessException(cve);

BussinessException

Si se produce ésta excepción simplemente la volveremos a relanzar sin modificar nada ya que queremos que se vea tal y como es.

throw ex;

Al poner todos los catch en un trozo de código de Hibernate, puede que el compilador dé un error ya que alguna de las excepciones no se lanza nunca. En ese caso simplemente eliminaremos el catch que está dando el error.

Mejoras con BusinessException

En el apartado anterior hemos visto cómo tratamos las siguientes excepciones transformándolas en BussinessException:

El significado de la nueva excepción es avisarnos de que los datos de las entidades contienen algún tipo de error y que el usuario debe modificarlo. Por ello la excepción hereda de java.lang.Exception ya que el error sí que es recuperable y el código debería estar preparado para avisar de ello al usuario y que éste corrija los datos.

Además de éso, el usar BussinessException tiene las siguientes ventajas:

Unificar el tratamiento de las excepciones

Desde otras clases de la aplicación , ahora al llamar a los métodos que tratan con Hibernate sólo deberemos preocuparnos de tratar la nueva excepción BussinessException. Con ello simplificamos el resto del código de la aplicación. De lo contrario, habríamos tenido que arrastrar siempre el tratar con las 2 excepciones javax.validation.ConstraintViolationException y org.hibernate.exception.ConstraintViolationException.

Otra ventaja de la unificación de excepciones es que si nuestra aplicación dejará de usar Hibernate para volver a JDBC podríamos seguir usando la nueva BussinessException sin necesidad de cambiar nada del manejo del excepciones del resto de la aplicación. Es decir que es mejor independizar de excepciones específicas del Hibernate.

Simplificar el uso de javax.validation.ConstraintViolationException

El uso de javax.validation.ConstraintViolationException puede ser un poco raro de usar debido a las propiedades de la clase javax.validation.ConstraintViolation.

¿Qué hace el método getPropertyPath()? ¿Y getLeafBean()? Etc. Si la mayoría de estos métodos no los vamos a usar , mejor será crear una clase que contenga sólo la información importante ya que ayudará a los programadores a usarla mas rápidamente y sin errores.

Por ello BussinessExceptioncontendrá una lista de objetos de BussinessMessage. Esta estructura es similar a la que encontramos entre javax.validation.ConstraintViolationException y javax.validation.ConstraintViolation

En el siguiente diagrama UML podemos ver las similitudes y diferencias:

PlantUML Graph

Como podemos ver , aunque hayamos perdido cierta funcionalidad que debe encontrase en javax.validation.ConstraintViolation, si ésta no pensábamos usarla, es mejor simplificar el código.

Mejorar los mensajes de error

Al mostrar los mensajes de error que se incluyen en javax.validation.ConstraintViolation hay dos problemas principales:

  • El nombre de los campos es el de las propiedades Java y no un nombre amigable para el usuario.
  • Los mensajes empiezan en minúscula.

Un ejemplo de mensaje de error es el siguiente:

ape1 - el tamaño tiene que estar entre 3 y 50

¿Qué es “ape1”? ¿No debería indicarse “1º Apellido”?. Y luego el artículo “el” del mensaje debería debería empezar en mayúsculas.

Así que el mensaje correcto debería ser:

1º Apellido - El tamaño tiene que estar entre 3 y 50

Se podría argumentar que esos dos problemas deben ser de la capa de presentación y no de la capa de negocio. Pero ya que javax.validation.ConstraintViolation nos está ofreciendo los mensajes de error como un texto, deberíamos hacer todo lo posible por mejorar la calidad de los mismos y no hacer que cada presentación que realicemos tenga que preocuparse de estos mismos problemas.

El código de BussinessException

Ya hemos visto las ventajas y el diseño de BussinessException, veamos ahora el código que los implementa.

 1: public class BussinessException extends Exception {
 2:
 3:     private Set<BussinessMessage> bussinessMessages = new TreeSet<>();
 4:
 5:     public BussinessException(List<BussinessMessage> bussinessMessages) {
 6:         this.bussinessMessages.addAll(bussinessMessages);
 7:     }
 8:
 9:     public BussinessException(BussinessMessage bussinessMessage) {
10:         this.bussinessMessages.add(bussinessMessage);
11:     }
12:
13:     public BussinessException(Exception ex) {
14:         bussinessMessages.add(new BussinessMessage(null, ex.toString()));
15:     }
16:
17:     public BussinessException(javax.validation.ConstraintViolationException cve) {
18:         for (ConstraintViolation constraintViolation : cve.getConstraintViolations()) {
19:             String fieldName;
20:             String message;
21:
22:             fieldName = getCaptions(constraintViolation.getRootBeanClass(), constraintViolation.getPropertyPath());
23:             message = constraintViolation.getMessage();
24:
25:             bussinessMessages.add(new BussinessMessage(fieldName, message));
26:         }
27:     }
28:
29:     public BussinessException(org.hibernate.exception.ConstraintViolationException cve) {
30:         bussinessMessages.add(new BussinessMessage(null, cve.getLocalizedMessage()));
31:     }
32:
33:     public Set<BussinessMessage> getBussinessMessages() {
34:         return bussinessMessages;
35:     }
36: }

BussinessException.java

Podemos ver que el código es bastante sencillo. Consta principalmente de varios constructores y el método getBussinessMessages().

  • Línea 3: Un java.util.TreeSet donde guardar todos los BussinessMessage. Se usa un TreeSet para que los mensajes salgan ordenados por orden alfabético.
  • Líneas 5-7: Constructor al que directamente se le pasa una lista de BussinessMessage.Ësto permitirá generar mensajes al usuario aunque no haya habido ninguna excepción.
  • Líneas 9-11: Constructor al que directamente se le pasa un único BussinessMessage.Esto permitirá generar mensajes al usuario aunque no haya habido ninguna excepción.
  • Líneas 13-15: Constructor al que se le pasa una Exception. Eso permite mostrar al usuario un mensaje aunque sea un Exception.
  • Líneas 13-15: Constructor al que se le pasa una javax.validation.ConstraintViolationException.Este constructor creará un BussinessMessage por cada uno de los javax.validation.ConstraintViolation.
  • Líneas 29-31: Constructor al que se le pasa una org.hibernate.exception.ConstraintViolationException. Creará un único BussinessMessage en función del mensaje de la excepción.
  • Línea 33-35: Retorna la lista de todos los BussinessMessage.

El código de BussinessMessage es el siguiente:

 1: public class BussinessMessage implements Comparable<BussinessMessage> {
 2:     private final String fieldName;
 3:     private final String message;
 4:
 5:     public BussinessMessage(String fieldName, String message) {
 6:         if (message==null) {
 7:             throw new IllegalArgumentException("message no puede ser null");
 8:         }
 9:
10:         if ((fieldName!=null) && (fieldName.trim().equals(""))) {
11:             this.fieldName =null;
12:         } else {
13:             this.fieldName = StringUtils.capitalize(fieldName);
14:         }
15:         this.message = StringUtils.capitalize(message);
16:     }
17:
18:     @Override
19:     public String toString() {
20:         if (fieldName!=null) {
21:             return "'"+fieldName+ "'-"+message;
22:         } else {
23:             return message;
24:         }
25:     }
26:
27:     /**
28:      * @return the fieldName
29:      */
30:     public String getFieldName() {
31:         return fieldName;
32:     }
33:
34:     /**
35:      * @return the message
36:      */
37:     public String getMessage() {
38:         return message;
39:     }
40:
41:
42:     @Override
43:     public int compareTo(BussinessMessage o) {
44:         if ((getFieldName()==null) && (o.getFieldName()==null)) {
45:             return getMessage().compareTo(o.getMessage());
46:         } else if ((getFieldName()==null) && (o.getFieldName()!=null)) {
47:             return 1;
48:         } else if ((getFieldName()!=null) && (o.getFieldName()==null)) {
49:             return -1;
50:         } else if ((getFieldName()!=null) && (o.getFieldName()!=null)) {
51:             if (getFieldName().equals(o.getFieldName())) {
52:                 return getMessage().compareTo(o.getMessage());
53:             } else {
54:                 return getFieldName().compareTo(o.getFieldName());
55:             }
56:         } else {
57:            throw new RuntimeException("Error de lógica");
58:         }
59:     }
60:
61:
62: }

BussinessMessage.java

La clase BussinessMessage es también sencilla pero tiene la particularidad de implementar el interfaz java.lang.Comparable.

  • Línea 1: Implementar el interfaz Comparable. Se implementa este interfaz para que se pueda usar dentro de la clase java.util.TreeSet y que los mensajes salga ordenados.
  • Líneas 13 y 15 : Se pone en mayúsculas el primer carácter del campo y el mensaje para que quede mas amigable al usuario.
  • Línea de la 43 a la 59: Método compareTo(T) del interfaz Comparable. Este método ordena las BussinessMessage de forma que primero van los mensajes que incluyen el nombre del campo y luego los que no.

Nombres de las columnas

La última parte que nos queda por tratar es el tema del nombre de las columnas. En el texto que muestra BussinessMessage se sigue viendo como nombre de una columna el nombre de la propiedad Java. Ya hemos explicado que esto debería ser solucionado.

Una sencilla solución es añadir una nueva anotación a cada propiedad que incluya un nombre amigable de dicha propiedad. La nueva anotación se llamará @Caption. Su código Java es el siguiente:

1: @Target({ElementType.FIELD,ElementType.METHOD,ElementType.TYPE})
2: @Retention(RetentionPolicy.RUNTIME)
3: public @interface Caption {
4:     String value();
5: }

Caption.java

Ahora nuestras clase de dominio pueden quedar de la siguiente forma:

 1: public class Profesor implements Serializable  {
 2:
 3:     private int id;
 4:     @NotBlank
 5:     @Caption("Nombre")
 6:     private String nombre;
 7:
 8:     @NotBlank
 9:     @Caption("1º Apellido")
10:     private String ape1;
11:
12:     @Caption("2º Apellido")
13:     private String ape2;
14:
15:     public Profesor(){
16:     }
17: }

Usuario.java

Vemos en las líneas 5, 9 y 12 como se ha añadido la nueva anotación @Caption para incluir un nombre de la columna válido para el usuario.

Vuelvo a insistir que ciertos frameworks de la capa de presentación hacen este mismo trabajo y se puede pensar que dicha anotación no debería estar en la capa de negocio.

Ahora debemos crear el código Java que en función de una clase de dominio y el nombre de la columna nos retorna el caption. El código Java es el siguiente:

  1: private String getCaptions(Class clazz, Path path) {
  2:     StringBuilder sb = new StringBuilder();
  3:     if (path != null) {
  4:         Class currentClazz = clazz;
  5:         for (Path.Node node : path) {
  6:             ClassAndCaption clazzAndCaption = getSingleCaption(currentClazz, node.getName());
  7:             if (clazzAndCaption.caption != null) {
  8:                 if (sb.length() != 0) {
  9:                     sb.append(".");
 10:                 }
 11:                 if (node.isInIterable()) {
 12:                     if (node.getIndex() != null) {
 13:                         sb.append(node.getIndex());
 14:                         sb.append("º ");
 15:                         sb.append(clazzAndCaption.caption);
 16:                     } else if (node.getKey() != null) {
 17:                         sb.append(clazzAndCaption.caption);
 18:                         sb.append(" de ");
 19:                         sb.append(node.getKey());
 20:                     } else {
 21:                         sb.append(clazzAndCaption.caption);
 22:                     }
 23:                 } else {
 24:                     sb.append(clazzAndCaption.caption);
 25:                 }
 26:             } else {
 27:                 sb.append("");
 28:             }
 29:             currentClazz = clazzAndCaption.clazz;
 30:         }
 31:
 32:         return sb.toString();
 33:
 34:     } else {
 35:         return null;
 36:     }
 37:
 38: }
 39:
 40: private ClassAndCaption getSingleCaption(Class clazz, String fieldName) {
 41:     ClassAndCaption clazzAndCaptionField;
 42:     ClassAndCaption clazzAndCaptionMethod;
 43:
 44:     if ((fieldName == null) || (fieldName.trim().equals(""))) {
 45:         return new ClassAndCaption(clazz, null);
 46:     }
 47:
 48:     clazzAndCaptionField = getFieldCaption(clazz, fieldName);
 49:     if ((clazzAndCaptionField != null) && (clazzAndCaptionField.caption != null)) {
 50:         return clazzAndCaptionField;
 51:     }
 52:
 53:     clazzAndCaptionMethod = getMethodCaption(clazz, fieldName);
 54:     if ((clazzAndCaptionMethod != null) && (clazzAndCaptionMethod.caption != null)) {
 55:         return clazzAndCaptionMethod;
 56:     }
 57:
 58:     if (clazzAndCaptionField != null) {
 59:         return new ClassAndCaption(clazzAndCaptionField.clazz,fieldName);
 60:     } else if (clazzAndCaptionMethod != null) {
 61:         return new ClassAndCaption(clazzAndCaptionMethod.clazz,fieldName);
 62:     } else {
 63:         return new ClassAndCaption(clazz, fieldName);
 64:     }
 65: }
 66:
 67: private ClassAndCaption getFieldCaption(Class clazz, String fieldName) {
 68:     Field field = ReflectionUtils.findField(clazz, fieldName);
 69:     if (field == null) {
 70:         return null;
 71:     }
 72:
 73:     Caption caption = field.getAnnotation(Caption.class);
 74:     if (caption != null) {
 75:         return new ClassAndCaption(field.getType(), caption.value());
 76:     } else {
 77:         return new ClassAndCaption(field.getType(), null);
 78:     }
 79:
 80:
 81: }
 82:
 83: private ClassAndCaption getMethodCaption(Class clazz, String methodName) {
 84:     String suffixMethodName = StringUtils.capitalize(methodName);
 85:     Method method = ReflectionUtils.findMethod(clazz, "get" + suffixMethodName);
 86:     if (method == null) {
 87:         method = ReflectionUtils.findMethod(clazz, "is" + suffixMethodName);
 88:         if (method == null) {
 89:             return null;
 90:         }
 91:     }
 92:
 93:     Caption caption = method.getAnnotation(Caption.class);
 94:     if (caption != null) {
 95:         return new ClassAndCaption(method.getReturnType(), caption.value());
 96:     } else {
 97:         return new ClassAndCaption(method.getReturnType(), null);
 98:     }
 99:
100:
101: }
102:
103: private class ClassAndCaption {
104:
105:     Class clazz;
106:     String caption;
107:
108:     public ClassAndCaption(Class clazz, String caption) {
109:         this.clazz = clazz;
110:         this.caption = caption;
111:     }
112: }

Este código lo deberemos incluir en la clase BussinessException.java. No voy a entrar en detalles de como funciona dicho código ya que tiene cierta complejidad. Pero si que se va a explicar que hace cada función.

  • ClassAndCaption getMethodCaption(Class clazz, String methodName) (Líneas 59-74):Si un método tiene la anotación @Caption retorna el tipo y el valor del caption y sino retornará el tipo y null.
  • ClassAndCaption getFieldCaption(Class clazz, String fieldName) (Líneas 44-57): Si una propiedad tiene la anotación @Caption retorna el tipo y el valor del caption y sino retornará el tipo y null.
  • ClassAndCaption getSingleCaption(Class clazz, String fieldName) (Líneas 24-42): Retorna el tipo y el caption de un campo tanto si dicha anotación está propiedad Java o en un método Java.
  • String getCaptions(Class clazz, Path path) (Líneas 1-22): Dado que el nombre de los campos está en un objeto javax.validation.Path que puede contener varios nombres de campos. Se obtienen todos ellos separados por puntos.

Por último debemos modificar la línea 22 de BussinessException:

fieldName=constraintViolation.getPropertyPath().toString();

para que quede de la siguiente forma:

fieldName=getCaptions(constraintViolation.getRootBeanClass(), constraintViolation.getPropertyPath());

Para la realización de éste código se han usado las clases org.springframework.util.ReflectionUtils y org.springframework.util.StringUtils del framework Spring. Estas clases son simple clases de utilidad con funciones sencillas. Para poder usarlas se ha incluido el jar org.springframework.core-3.1.2.RELEASE.jar. En la siguiente sesión trataremos en profundidad el framework de Spring y explicaremos como instalarlo adecuadamente.Por ahora simplemente recordar el incluir el jar org.springframework.core-3.1.2.RELEASE.jar en los ejercicios que se realicen.

1) Realmente Hibernate lanza excepciones del tipo org.hibernate.HibernateException pero como hereda de RuntimeException podemos tratar únicamente ésta última
unidades/07_arquitectura/02_excepciones.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