Enregistrer enum pour SharedPreference

Je me demandais, quelle est la méthode couramment utilisée pour sauver des Enum à SharedPrefereces? Actuellement, je suis en utilisant gson pour convertir enum type String, puis l'enregistrer pour le SharedPrefereces.

    Gson gson = new Gson();
    //country is an enum.
    String json_country = gson.toJson(country);
    sharedPreferences.edit().putString(COUNTRY, json_country);

Je me demandais, est-ce une bonne façon? Est-il un meilleur moyen?

InformationsquelleAutor Cheok Yan Cheng | 2013-02-07

android

11

Vous pouvez assotiate votre enums avec des entiers et de les stocker simple int, regardez ceci:

Cast Int enum en Java (deuxième réponse) - également de la même manière que vous pouvez faire enumToInt
- comme une option enum peut être sauvé aussi comme une Chaîne de caractères, si l'utilisation d'Enum.nom() à la place de l'ordinal()
InformationsquelleAutor dilix

Vous pouvez utiliser une simple Chaîne de caractères, puis extraire de la valeur à l'aide de la méthode valueOf. Voici un exemple:

public enum MyEnum {
    ENUM1, ENUM2, ENUM3, ENUM4;

    public static MyEnum toMyEnum (String myEnumString) {
        try {
            return valueOf(myEnumString);
        } catch (Exception ex) {
                //For error cases
            return ENUM1;
        }
    }
}

public void setMyEnum(Context context, MyEnum myEnum) {
    SharedPreferences sp = context.getPreferences(this.MODE_PRIVATE);
    SharedPreferences.Editor editor = sp.edit();
    editor.putString("MyEnum", myEnum.toString());
    editor.commit();
}

public MyEnum getMyEnum(Context context) {
    SharedPreferences sp = context.getPreferences(this.MODE_PRIVATE);
    String myEnumString = sp.getString("MyEnum", MyEnum.ENUM1.toString());
    return MyEnum.toMyEnum(myEnumString);
}

Voici un exemple de code que vous pouvez voir comment cela fonctionne.
https://github.com/jiahaoliuliu/SavingEnumToSharedPreferences

Enum chaîne de valeur peut être modifiée par le ProGuard, même pire, il sera différent dans les versions release.
Je voudrais utiliser myEnum.name() au lieu de .toString() comme il peut être remplacé

InformationsquelleAutor jiahao

34

C'est le même problème que les Enterprise Java développeurs sont confrontés lors de la persistance d'un enum pour une base de données. Le problème avec les questions /réponses, c'est qu'ils sont fragiles et ne pas refactoring de l'environnement. Voici pourquoi (avec une alternative au fond.)

À l'aide d'un enum toString() et valueOf() méthodes signifie qu'une valeur d'énumération ne peut pas être renommé. Supposons que j'ai un VehicleType enum avec des valeurs CAR et TRUCK. Si je stocker la chaîne de caractères "CAMION" comme une valeur de préférence et puis renommez VehicleType.TRUCK à VehicleType.PICKUP_TRUCK dans la prochaine version de mon application, la chaîne stockée n'a plus de sens et valueOf() va jeter un IllegalArgumentException.

À l'aide d'une valeur ordinale signifie que les valeurs enum ne peut pas être re-commandé ou votre stockées les valeurs ne correspondent plus. Ce scénario est sans doute pire parce que votre application va continuer à courir, mais peut se comporter de manière inattendue, ce qui rend la question difficile de la piste vers le bas une fois qu'il est enfin remarqué et probablement impossible à corriger. Le même est vrai pour l'ajout d'une nouvelle valeur n'importe où, mais à la fin. Si j'ai ajouté une nouvelle MOTORCYCLE valeur au sommet, un CAR stockées comme son ordinal (0) dans la version précédente de l'application serait de revenir en tant que MOTORCYCLE après la mise à jour, et un TRUCK (ordinal 1) deviendrait un CAR.

L'alternative que j'utilise consiste à ajouter un final champ enum et utiliser sa valeur, comme suit:
```
public enum VehicleType {
    CAR("C"),
    TRUCK("T");

    private final String code;
    private static final Map<String,VehicleType> valuesByCode;

    static {
        valuesByCode = new HashMap<>(values().length);
        for(VehicleType value : values()) {
            valuesByCode.put(value.code, value);
        }
    }

    VehicleType(String code) {
        this.code = code;
    }

    public static VehicleType lookupByCode(String code) { 
        return valuesByCode.get(code); 
    }

    public String getCode() {
        return code;
    }
}
```
De stocker une valeur en utilisant quelque chose comme preferences.putString("vehicle_type", vehicleType.getCode()) et de les récupérer en utilisant quelque chose comme vehicleType = VehicleType.lookupByCode(preferences.getString("vehicle_type", null)).

Cette approche nécessite un peu plus de code, mais à mon avis, c'est le plus robuste de la solution.
- Je ne vois pas comment l'exemple précédent est "fragile". Il n'a pas de "fuite" de la Chaîne utilisée par les préférences. Pourquoi pas la version plus simple d'être convertis à ce plus compliqué que la version si/lorsque l'énumération des noms de besoin d'être changé? Je suis assez nouveau à Java, suis-je raté quelque chose? Je suppose que le seul inconvénient est que vous ne avez plus à vous rappeler que le refactoring est nécessaire en utilisant le premier exemple...
- Si un enum nom ou ordinale n'était pas écrit à la persistance de la mémoire et de la mort avec votre VM, je serais d'accord. Mais lorsque votre application stocke une préférence, les "fuites" de la valeur dans le sens que la version de votre application qui a écrit la valeur peut ne pas être la version de votre application qui lit à une date ultérieure. Vous avez certainement pu restructurer le code pour utiliser cette approche, plus tard, mais comme vous l'avez dit, alors que vous auriez à vous rappeler de le faire... et d'autres développeurs auraient à connaître pour refactoriser le code... et rappelez-vous aussi. C'est une préférence personnelle, mais je préfère suivre ce modèle simple dès le départ.
- Je préfère utiliser le protocole Enum.nom() et ajouter un bon commentaire dans ma déclaration d'enum ne pas changer les valeurs de chaîne.
- Que diriez-ProGuard? Son travail est de renommer vos identifiants. 🙂
- Jusqu'à présent, il n'a pas, j'ai ProGuard off. Je suis en train d'écrire à un partage de la Préf enum.nom() et de la lecture enum.valueOf() et les deux chaînes sont identiques. Mais merci pour la sortir.
InformationsquelleAutor spaaarky21
2

Compte tenu de toutes les options ci-dessus, j'ai décidé d'utiliser une autre solution pour le problème.

J'ai besoin seulement d'un ensemble de valeurs, sans aucune logique sur eux. Dans ce cas, il est possible d'utiliser des outils tels que l' @IntDef et @StringDef au lieu d'utiliser enum.

La solution est sûr de revoir à la fois en termes de noms de variables et les variables de commande. La seule chose qui ne devrait pas être modifié - valeurs réelles. Cependant, par défaut le refactoring ne vous demandons pas de les changer en cas de modification du nom, de sorte qu'il n'est pas si facile à faire juste automatiquement (et @IntDef est mieux de ce point de vue que @StringDef).
```
  @Retention(SOURCE)
  @IntDef({NOT_REQUESTED, GIVEN, PROHIBITED})
  public @interface CustomPermission {}

  public static final int NOT_REQUESTED = -1;
  public static final int PROHIBITED = 0;
  public static final int GIVEN = 1;

  @CustomPermission
  public int getPermission() {
    return getSharedPreferences(SHARED_PREFS_FILE)
          .getInt(STATISTICS_COLLECTION_PERMISSION, NOT_REQUESTED);
  }

  public void setPermission(@CustomPermission int flag) {
    getSharedPreferences(SHARED_PREFS_FILE)
      .edit()
      .putInt(STATISTICS_COLLECTION_PERMISSION, flag)
      .apply();
  }
```
Et voici le officiel doc

InformationsquelleAutor Gaket

Vous devez vous connecter pour publier un commentaire.