Una de las cosas que más se repiten en un proyecto de desarrollo, es el tema de log y excepciones. Lo tengo super trillado ya pero creo que vendría bien el tener a mano una guía con unas clases ya predefinidas que me abstrayeran de hacerlas siempre.
Comenzaré con una clase de excepciones propia que básicamente sea una extensión de la clase Exception y que la única particularidad, sea que mediante el código de error genere un mensaje u otro.
Esto lo haré así ya que en todos los proyectos que he trabajado, o bien necesitaban localización o mucho mensaje personalizado y siempre acabo haciendo lo mismo. Os dejo un ejemplo de clase personalizada y de un fichero de códigos de error.
La manera más eficiente que tengo de implementar esto es asociando códigos de error mediante constantes y luego mediante claves en un archivo de texto:
Archivo errorCodes.txt
#Errores Generales
0000=Error de tipo general
0001=Ha ocurrido un error inesperado
#Errores de configuración
0101=No se encuentra el archivo de la configuración
0102=No se encuentra la propiedad
Así que ahora nos metemos en harina y os pongo mi propuesta de clase de excepciones personales. Incluye aparte un lector de properties muy muy básico para “ilustrar” cómo sería el obtener de un archivo de propiedades un mensaje asociado a un código de error.
package es.snippetea;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
/**
* Clase de excepciones personales con código numérico de error y
* mensaje genérico.
* @author icendrero
*/
@SuppressWarnings("serial") //Molesto al extender de Exception
public class ExcepcionPersonal extends Exception{
private String errorCode;
private String aditionalInfo;
/**
* Constructor por defecto
*/
public ExcepcionPersonal(){
//Constructor por defecto
super();
}
/**
* Constructor que contendrá un mensaje que no está incluido en el
* archivo de errores
* @param infoMsg
*/
public ExcepcionPersonal(String infoMsg){
super(infoMsg);
this.aditionalInfo = infoMsg;
}
/**
* Constructor que contendrá un mensaje que no está incluido
* en el archivo de errores y viene de una excepción anterior
* @param aditionalInfo
* @param t
*/
public ExcepcionPersonal(String infoMsg, Throwable t){
super(infoMsg,t);
this.aditionalInfo=infoMsg;
}
/**
* Constructor que simplemente envuelve a la excepción y la
* lanza hacia arriba
* @param t
*/
public ExcepcionPersonal(Throwable t){
super(t);
}
/**
* Constructor que coge un código de error y obtiene el mensaje
* asociado a ese código.
* @param code
*/
public ExcepcionPersonal(String code, String aditionalInfo){
super(obtenerMsgAsociado(code));
this.errorCode = code;
this.aditionalInfo = aditionalInfo;
}
/**
* Constructor que coge un código de error, obtiene el mensaje
* asociado a ese código, e incluye una excepcion anterior.
* @param code
* @param t
*/
public ExcepcionPersonal(String code, String aditionalInfo, Throwable t){
super(obtenerMsgAsociado(code),t);
this.errorCode = code;
this.aditionalInfo = aditionalInfo;
}
/**
* Metodo que devuelve del properties de errores el mensaje asociado
* a ese código.
* @param code Codigo del mensaje
* @return El mensaje
*/
private static String obtenerMsgAsociado(String code){
return MisProperties.getInstance().getMsgAsociado(code);
}
/**
* @return the errorCode
*/
public String getErrorCode() {
return errorCode;
}
/**
* @param errorCode the errorCode to set
*/
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
/**
* @return the aditionalInfo
*/
public String getAditionalInfo() {
return aditionalInfo;
}
/**
* @param aditionalInfo the aditionalInfo to set
*/
public void setAditionalInfo(String aditionalInfo) {
this.aditionalInfo = aditionalInfo;
}
/**
* Metodo main para probar las excepciones personalizadas
* */
public static void main(String args[])
throws FileNotFoundException, IOException, InterruptedException{
MisProperties.init("C:\\errorCodes.txt");
try{
throw new ExcepcionPersonal();
}catch(ExcepcionPersonal ep){
System.out.println("Constructor por defecto:");
ep.printStackTrace();
}
//Esperamos un segundín para que no se haga un lío con los catch
Thread.sleep(1000);
try{
throw new ExcepcionPersonal("Hemos lanzado una excepción");
}catch(ExcepcionPersonal ep){
System.out.println("Constructor
ep.printStackTrace();
}
Thread.sleep(1000);
try{
throw new ExcepcionPersonal("Hemos lanzado una excepción",
new Throwable("Excepcion recogida y pasada hacia arriba"));
}catch(ExcepcionPersonal ep){
System.out.println("Constructor
ep.printStackTrace();
}
Thread.sleep(1000);
try{
throw new ExcepcionPersonal("0000","Mensaje de apoyo");
}catch(ExcepcionPersonal ep){
System.out.println("Constructor
ep.printStackTrace();
System.out.println("Informacion adicional:" + ep.getAditionalInfo());
}
Thread.sleep(1000);
try{
throw new ExcepcionPersonal("0201","Más información adicional",
new Throwable("Excepcion recogida y pasada hacia arriba"));
}catch(ExcepcionPersonal ep){
System.out.println("Constructor
ep.printStackTrace();
System.out.println("Informacion adicional:" + ep.getAditionalInfo());
}
}
}
/**
* Clase lectora de properties muy básica.
* @author icendrero
*/
class MisProperties{
//Instancias
private static MisProperties instance;
private Properties misProp;
/**
* @return Instancia del objeto
*/
public static MisProperties getInstance(){
return instance;
}
/**
* Inicio del Singleton
* @param path Ruta al fichero de propiedades
* @throws FileNotFoundException Si no encuentra el fichero
* @throws IOException Al hacer el load.
*/
public static void init(String path)
throws FileNotFoundException, IOException{
if(instance == null){
instance = new MisProperties();
instance.misProp = new Properties();
instance.misProp.load(new FileInputStream(path));
}else{
getInstance();
}
}
/**
* Metodo que simula el obtener de un fichero de properties
* el mensaje asociado a un código.
* @param code El código del mensaje
* @return El mensaje asociado a ese código
*/
public String getMsgAsociado(String code){
return misProp.getProperty(code);
}
}
El resultado es este:
Constructor por defecto:
es.snippetea.ExcepcionPersonal
at es.snippetea.ExcepcionPersonal.main(ExcepcionPersonal.java:127)
Constructor
es.snippetea.ExcepcionPersonal: Hemos lanzado una excepción
at es.snippetea.ExcepcionPersonal.main(ExcepcionPersonal.java:136)
Constructor
es.snippetea.ExcepcionPersonal: Hemos lanzado una excepción
at es.snippetea.ExcepcionPersonal.main(ExcepcionPersonal.java:145)
Caused by: java.lang.Throwable: Excepcion recogida y pasada hacia arriba
at es.snippetea.ExcepcionPersonal.main(ExcepcionPersonal.java:146)
Constructor
es.snippetea.ExcepcionPersonal: Error de tipo general
at es.snippetea.ExcepcionPersonal.main(ExcepcionPersonal.java:155)
Informacion adicional:Mensaje de apoyo
Constructor
es.snippetea.ExcepcionPersonal: Usuario no identificado
at es.snippetea.ExcepcionPersonal.main(ExcepcionPersonal.java:165)
Caused by: java.lang.Throwable: Excepcion recogida y pasada hacia arriba
at es.snippetea.ExcepcionPersonal.main(ExcepcionPersonal.java:166)
Informacion adicional:Más información adicional
No hay comentarios:
Publicar un comentario