JAVA - Najlepsza odpowiednia struktura danych

Question

Jestem trochę nowa w Javie, ale teraz mam przed sobą dylemat. Mam listę błędów, która wygląda tak:

"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" 

i wiele więcej błędów.

Teraz pracuję nad biblioteką JAVA, co naprawdę muszę zrobić, aby wdrożyć te błędy (błędy nigdy się nie zmieniają, są zawsze takie same), tak aby programiści korzystający z biblioteki mogli łatwo zidentyfikować opis błędu przez podano ERROR_CODE.

np .: String getError (ERROR_CODE); i zwraca ciąg opisu błędu związanego z ERROR_CODE.

Myślałem o zadeklarowaniu struktury danych ENUM, ale wydaje mi się, że nie działa poprawnie.

Dziękuję bardzo.

Answer 1

Można użyć enum tak:

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 
} 

i

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

mają Map<ErrorCode, List<ErrorWrapper>>

Answer 3

Użyj do java.util.Map wdrożenia (HashMap). Użyj kodu błędu jako klucza i opisu jako wartości.

Answer 4

Wystarczy użyć

HashMap<String, String> 

ponieważ stwierdził, kody błędów są struny, a opis jest ciągiem.

Answer 5

można zbudować strukturę przy użyciu ENUM:

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. 
    } 
} 

Można dodać dowolną liczbę akcesorów (statyczny lub nie, mogą na przykład używać statycznego HashMap znaleźć wiadomością), jak trzeba.

Możesz używać wartości wyliczeniowych w instrukcjach przełączników, ponieważ java 1.5.

Answer 6

Przede wszystkim, „błędy nigdy nie zmieni” będzie źle w najbliższej przyszłości :)

chciałbym użyć właściwości pliku, aby zapisać te kod i opis błędu (jeśli konieczne „position” dane mogą być przetwarzane)

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

Następnie metoda getError byłoby:

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

plik errors.properties byłoby jak:

001=No error 
002=Connection error 

myślę, że to będzie bardziej dynamiczny

Answer 7

napisałem coś dla ciebie; kod testowy jest dołączony. Po prostu utwórz klasę główną w domyślnym pakiecie, skopiuj wklej mój kod i uruchom go.Można użyć metody getError (kod String) z błędów klasy dostać komunikat o błędzie o kodzie:

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 enum są dobrze dopasowane do Twojego problemu. Mogłem wymyślić inne podejście, które jest nieco bardziej elastyczne pod względem dodawania nowych kodów błędów lub modyfikowania istniejącego kodu.

1. Utwórz plik działce z wpisami jak po
   • 000-1 = brak błędu
   • 001-1 = Connection error
2. Bundle ten plik w słoiku, które będą dystrybuowane dla programistów.
3. Utwórz klasę i umieść kod, który odczyta ten plik z poziomu słoika i utworzy mapę (lub HashMap) pary tych nazw.
4. Umieść ten kod w bloku statycznym, aby zainicjować HashMap, wczytano klasę momentu.
5. Metoda po prostu dołącza -1 do kodu błędu wejścia i wysyła zapytanie do tej mapy i zwraca odpowiedni komunikat o błędzie.
6. Aby dodać nową wiadomość lub zmodyfikować istniejącą wiadomość, po prostu zmień zawartość pliku właściwości. Nie jest wymagana zmiana kodu.