架构设计 - JAVA端的错误码和错误信息，该设计成全局常量还是枚举值？

Question

Map<String,String> responseInfo = new HashTable<String,String>();
responseInfo.set("FE_PRC_BACK_001","TargetUri is not exist");
//responseInfo.set("FE_XREQ_002","Target Uri of XRequest is Empty.");
//responseInfo.set("FE_REQ_003","The processor flag is incorrect or the BusinessContext time out.");

FE_PRC_BACK_001这样的是错误码，TargetUri is not exist是错误信息，需要以键值对(JSON)的形式响应给浏览器
这时，JAVA端是应该以什么方式来罗列这些错误码和错误信息呢？常量？还是枚举类型？

String FE_PRC_BACK_001 = "TargetUri is not exist";

请教一下各位大神，你们的项目中都是怎么设计的？

Answer 1

Il existe les 2 solutions suivantes :
1. L'encapsuler dans un objet, par exemple :

public final class Result {
    private Result(String code, String msg){
        this.code = code;
        this.msg = msg;
    }
    
    // ignore setter and getter
    private String code;
    private String msg;
    
    public static final FE_PRC_BACK_001 = new Result("FE_PRC_BACK_001", "TargetUri is not exist");
    
    public static final ...
}

2. Utilisez l'énumération pour l'implémenter, comme suit :

public enum Result {
    FE_PRC_BACK_001("FE_PRC_BACK_001", "TargetUri is not exist"), 
    ...;

    // ignore setter and getter and constructor
    private String code;
    private String msg;
}

Les idées d'implémentation de 1 et 2 sont en fait similaires (les idées de code données par le sujet sont également similaires, la différence est seulement de savoir s'il faut utiliser spécifique DTO ou général Map), mais lors de l'utilisation d'énumérations, il y a les suivants Plusieurs endroits à noter :
Supposons que le résultat de l'énumération existe dans base-api, version 1.0.0, il y a respectivement les projets A et B, le projet A dépend du projet B, et les projets A et B tous les deux dépend de base-api
1. Si le projet B met à niveau base-api vers 1.0.1 et qu'une nouvelle énumération est ajoutée au résultat, et qu'une interface du projet B renvoie la nouvelle énumération, mais pas le projet A. Lors de la mise à niveau de base-api, si l'interface est appelée et qu'une nouvelle énumération est renvoyée, une exception de désérialisation sera signalée car la nouvelle énumération n'existe pas dans l'ancienne version de base-api
2. La valeur par défaut consiste à sérialiser l'énumération dans le nom de la variable d'énumération. Si vous souhaitez la sérialiser dans un format personnalisé (par exemple, incluant msg), vous devez personnaliser un sérialiseur.

Answer 2

Si tous les messages d'erreur ont été déterminés, ils peuvent être écrits dans le programme. Il est plus facile d'utiliser des énumérations que des constantes globales. Il est encore assez pénible d'avoir des constantes globales correspondant aux codes d'erreur et aux messages.

J'aime le plus les énumérations de Java, principalement parce que les types d'énumération de Java peuvent être étendus, construits et réécritstoString... Parce que l'énumération de Java elle-même est un objet et que le type d'énumération lui-même est une classe assez spéciale.

Si votre message d'erreur ne peut pas être corrigé, il peut être ajouté pendant le processus de candidature et enregistré dans la base de données. Ensuite, vous devez écrire un ensemble spécial de classes de gestion pour le gérer et utiliser HashTable ou HashMap pour l'implémenter. Mais je suppose que votre problème n'est pas si compliqué.

Answer 3

Mettez la mauvaise clé dans l'énumération Java, puis placez le mappage entre la mauvaise clé et les mauvaises informations dans un fichier externe, tel que le fichier de propriétés. Au moment de l'exécution, récupérez simplement le texte d'erreur du fichier en temps réel en fonction de la clé d'énumération des erreurs. Étant donné que les erreurs ne se produisent pas souvent, il ne devrait y avoir aucun problème à lire les informations d'erreur en temps réel. Bien sûr, vous pouvez également lire toutes les erreurs. le programme démarre. Les informations sont lues et mises en cache pour améliorer les performances.