JAVA - La mejor estructura de datos adecuada

Question

Soy un poco nuevo en Java pero ahora estoy enfrentando un dilema. Tengo una lista de error que se parece a:

"ERROR CODE" "POSITION" "Error description" 
"000" "1" "No error" 
"001" "1" "Connection error" 
"002" "1" "Error sending reversal or batch capture process" 
"003" "1" "Error after authorization – message sent to host and answer received" 
"004" "1" "Error sending message for authorization" 
"005" "1" "Error receiving message from host" 

y mucho más errores.

Ahora estoy trabajando en una biblioteca JAVA lo que realmente tengo que hacer es implementar estos errores (los errores nunca cambian, siempre son los mismos) de alguna manera para que los desarrolladores que usan la biblioteca puedan identificar fácilmente la descripción del error dado ERROR_CODE.

por ejemplo: String getError (ERROR_CODE); y para devolver la cadena de la descripción del error asociada a ERROR_CODE.

Pensé en declarar la estructura de datos ENUM pero parece que no puedo hacer que funcione correctamente.

Muchas gracias.

Answer 1

Usted puede utilizar una enumeración de este modo:

enum Error { 

    ERROR_000("000", 1, "No error"), 
    ERROR_001("001", 1, "Connection error"), 
    ERROR_002("002", 1, "Error sending reversal or batch capture process"), 
    ERROR_003("003", 1, "Error after authorization – message sent" + 
         "to host and answer received"), 
    ERROR_004("004", 1, "Error sending message for authorization"), 
    ERROR_005("005", 1, "Error receiving message from host"); 

    private final String code; 
    private final int position; 
    private final String description; 
    private static final Map<String, Error> errorMap = 
     new HashMap<String, Error>(); 

    static { 
     for (Error error : Error.values()) { 
      errorMap.put(error.code, error); 
     } 
    } 

    Error(final String code, final int position, final String description) { 
     this.code = code; 
     this.position = position; 
     this.description = description; 
    } 

    public static Error getError(String code) { 
     return errorMap.get(code); 
    } 
    // add getters and setters here: 
    public String getCode() { return this.code; } 
    public int getPosition() { return this.position; } 
    public String getDescription() { return this.description; } 
} 

Answer 2

enum ErrorCode{ 
001,002 
} 

y

class ErrorWrapper{ 
private ErrorCode errorCode; 
private String description; 
//setters + getters  
} 

tienen un uso Map<ErrorCode, List<ErrorWrapper>>

Answer 3

una aplicación java.util.Map (HashMap). Use el código de error como la clave y la descripción como el valor.

Answer 4

sólo tiene que utilizar un

HashMap<String, String> 

desde que declaró sus códigos de error son cadenas y la descripción es también una cadena.

Answer 5

Se puede construir una estructura utilizando enumeración:

public enum Error { 

    public final int code; 
    public final String message; 

    e0 (000, "No Error"), 
    e1 (001, "Connection error"); 

    public Error(int code, String message) { 
     this.code = code; 
     this.message = message; 
    } 

    public static Error byCode(int code) { 
     return Error.valueOf("e"+code); // you may add try/catch on IllegalArgumentException, etc. 
    } 
} 

Usted puede añadir tantos descriptores de acceso (fijas o no, se podría utilizar, por ejemplo, un HashMap estática de encontrar a través de mensajes) como sea necesario.

Puede usar valores de enum en instrucciones de conmutación desde java 1.5.

Answer 6

En primer lugar, "errores nunca cambian" será un error en un futuro próximo :)

me gustaría utilizar un archivo de propiedades para almacenar estos códigos de error y descripciones (si es necesario los datos "posición" se pueden analizar)

Properties properties = new Properties(); 
    try { 
     properties.load(new FileInputStream("errors.properties")); 
    } catch (IOException e) {} 

Entonces, el método de getError sería:

public String getError(String errorCode){ 
    return properties.getProperty(errorCode); 
} 

su archivo errors.properties sería como:

001=No error 
002=Connection error 

pienso, esto será más dinámico

Answer 7

escribí algo para usted; código de prueba está incluido. Simplemente haga una clase Principal en el paquete predeterminado, copie y pegue mi código y ejecútelo.Usted puede utilizar el método getError (código de cadena) a partir de los errores de clase para obtener el mensaje de error con el código:

import java.util.*; 
public class Main { 
    public static void main(String[] args) { 
     for(String code : new String[]{"000", "001", "002", "003", "004", "005"}) { 
      System.out.println(Errors.getError(code)); 
     } 
    } 
} 
class Errors { 
    static { 
     Errors.errors = new HashMap<String, Error>(); 
     for(String[] error : new String[][]{ 
       {"000", "1", "No error"}, 
       {"001", "1", "Connection error"}, 
       {"002", "1", "Error sending reversal or batch capture process"}, 
       {"003", "1", "Error after authorization – message sent to host and answer received"}, 
       {"004", "1", "Error sending message for authorization"}, 
       {"005", "1", "Error receiving message from host"} 
     }) { 
      Errors.errors.put(error[0], new Error(error[0], error[1], error[2])); 
     } 

    } 
    private static Map<String, Error> errors; 
    public static String getError(String code) { 
     return Errors.errors.get(code).message; 
    } 
    private static class Error { 
     private String code; 
     private String position; 
     private String message; 
     public Error(String code, String position, String message) { 
      super(); 
      this.code = code; 
      this.position = position; 
      this.message = message; 
     } 
     @Override 
     public String toString() { 
      return this.getClass().getSimpleName() + " | code: " + this.code + " | position: " + this.position + " | message: " + this.message; 
     } 
    } 
} 

Answer 8

Java son enum buen ajuste a su problema. Podría pensar en otro enfoque que sea un poco más flexible en términos de agregar nuevos códigos de error o modificar el código existente.

1. Crear un archivo de propiedades con las entradas como la siguiente
   • 000-1 = ningún fallo
   • 001-1 = Error de conexión
2. Bundle este archivo en el frasco que será distribuido a los desarrolladores.
3. Cree una clase y coloque un código que lea este archivo desde dentro de jar y cree un mapa (o HashMap) de estos pares de nombre y valor.
4. Ponga este código en un bloque estático para que el HashMap se inicialice en el momento en que se carga la clase.
5. El método getError(ERROR_CODE) simplemente añada -1 al código de error de entrada y consultar este mapa y devolver el mensaje de error correspondiente.
6. Para agregar un nuevo mensaje o modificar un mensaje existente, simplemente cambie el contenido del archivo de propiedad. No es necesario cambiar el código.