web-dev-qa-db-fra.com

Stockage de plusieurs objets imbriqués dans redis

Je voudrais stocker plusieurs données complexes JSON dans Redis mais je ne sais pas comment

C'est ma structure json

"users":{

        "user01":{username:"ally", email:"[email protected]"},
         "user02":{username:"user2".....}
        },

 "trucks":{
         "truck01":{reg_no:"azn102", make:"subaru" .......},
         "truck02":{reg_no:"kcaher3".....}
       }

J'ai vérifié Cette question qui fournit un moyen de stocker les utilisateurs mais je voudrais stocker les utilisateurs (01, 02) à l'intérieur des utilisateurs, puis les camions (01, 02) dans des camions afin que si récupérer des utilisateurs que je peux simplement faire 

hmget users

et cas similaire pour les camions

Plus tard, je voudrais aussi obtenir user01 dans les utilisateurs, mais je ne comprends pas comment stocker ces données dans Redis.

jsonredis
13
GEOFFREY MWANGI

Vous pouvez utiliser le module ReJSON Redis et stocker les objets directement. http://rejson.io/

7
Not_a_Golfer

Vous pouvez enregistrer des données dans les fichiers redis comme dans les images jointes . In this images i have made a structure for you

for user data

MODIFIER

Le code exemple est:

public void saveInRedis(Jedis jedis) throws JSONException{

        JSONObject jsonObject=new JSONObject();
        JSONObject jsonObject1=new JSONObject();
        JSONObject jsonObject2=new JSONObject();
        JSONObject jsonObject3=new JSONObject();


        jsonObject2.put("username", "ally");
        jsonObject2.put("email", "[email protected]");
        jsonObject3.put("username", "xyz");
        jsonObject3.put("email", "[email protected]");
        jsonObject1.put("user01", jsonObject2);
        jsonObject1.put("user02", jsonObject3);
        jsonObject.put("users", jsonObject1);


    // json is -- >  {"users":{"user02":{"email":"[email protected]","username":"xyz"},"user01":{"email":"[email protected]","username":"ally"}}}

        System.out.println("json is ---  >  "+jsonObject);

        JSONObject parse=new JSONObject(jsonObject.toString());
        JSONObject parseJson=parse.getJSONObject("users");
        JSONObject parseJson2=parseJson.getJSONObject("user02");
        JSONObject parseJson3=parseJson.getJSONObject("user01");

        Map<String, String> map=new HashMap<>();
        Map<String, String> map1=new HashMap<>();

        map.put("email", parseJson2.getString("email"));
        map.put("username", parseJson2.getString("username"));
        map1.put("email", parseJson3.getString("email"));
        map1.put("username", parseJson3.getString("username"));
        jedis.hmset("users:user01", map);
        jedis.hmset("users:user02", map1);



    }

vous pouvez faire hmget et hmgetAll sur ces clés.

5
Abhijeet Behare

Option 1

Je pense que si vous recherchez une méthode indépendante du langage d’implémentation, c’est-à-dire que les mêmes opérations et résultats sont attendus dans différentes parties du système écrites dans différents langages de programmation, la recommandation @Not_a_Golfer convient le mieux à votre cas.

Option 2

Toutefois, si vous utilisiez uniquement Java et que vous n'exécutiez pas encore Redis 4.0, je vous recommanderais d'utiliser Redisson en tant que bibliothèque côté client afin de vous faciliter grandement la tâche. 

Avertissement, je suis membre du projet Redisson , mon point de vue ci-dessous est biaisé. Il est également écrit dans l'espoir qu'il peut atteindre d'autres personnes qui se trouvent dans cette situation précise.

Redisson est une bibliothèque Java côté client qui vous permet d’utiliser Redis en tant que grille de données en mémoire. Les objets complexes multidimensionnels sont naturellement pris en charge.

Redisson fournit des types de données Redis avec des interfaces Java standard, c’est-à-dire que Redis hash est fourni sous la forme Java.util.Map et Java.util.concurrent.ConcurrentMap, de sorte que dans votre cas, l’utilisation serait simplement:

//lets imagine you have a builder that creates users 
User user01 = new User();
user01.setUsername("ally");
user01.setEmail("[email protected]");

User user02 = new User();
user02.setUsername("user2");
user02.setEmail("...");

//You get a Redis hash handler that works as a standard Java map
Map<String, User> users = redisson.getMap("users");
//This is how you put your data in Redis
//Redisson serialize the data into JSON format by default
users.put("user01", user01);
users.put("user02", user02);

//the same works for trucks
Truck truck01 = new Truck();
truck01.setRegNo("azn102");
truck01.setMake("subaru");

Truck truck02 = new Truck();
truck02.setRegNo("kcaher3");
truck02.setMake("...");

//The same as above
Map<String, Truck> trucks = redisson.getMap("trucks");
trucks.put("truck01", truck01);
trucks.put("truck02", truck02);

Obtenir vos données est tout aussi facile

User user01 = users.get("user01");
Truck truck02 = trucks.get("truck02");

Dans Redis, vous obtenez deux hachages, l'un appelé users et l'autre appelé trucks, vous verrez que les chaînes JSON sont stockées en fonction des noms de champs spécifiés dans ces objets de hachage.

Vous pouvez maintenant affirmer qu'il ne s'agit pas vraiment d'un objet imbriqué, mais simplement d'une sérialisation de données. 

Bien, prenons l'exemple un peu plus complexe pour voir la différence: si vous souhaitez conserver une liste de tous les utilisateurs qui ont conduit un camion particulier, vous pouvez également rechercher facilement le camion qu'un utilisateur conduit actuellement.

Je dirais que ce sont des cas d'utilisation assez typiques.

Cela ajoute vraiment plus de dimensions et de complexité aux structures de données. Normalement, vous devez les diviser en plusieurs morceaux: 

  • Vous auriez besoin que les variables Truck et User soient mappées sur un hachage différent pour éviter les problèmes de duplication et de cohérence des données; 

  • Vous devez également gérer une liste distincte pour que chaque camion stocke le journal d'utilisation.

À Redisson, ces tâches sont gérées de manière plus naturelle et sans tenir compte des préoccupations susmentionnées.

Vous feriez simplement, comme vous le feriez normalement, en Java comme ceci:

  • Annotez votre classe User et votre classe Truck avec l'annotation @REntity, puis choisissez un générateur d'identificateur ou un spécificateur personnel, ce qui pourrait être la valeur d'un champ.

  • Ajoutez un champ de liste (usageLog) à la classe Truck.

  • Ajoutez un champ Camion (en cours de conduite) à la classe d'utilisateurs.

C'est tout ce dont vous avez besoin. Donc, l’utilisation n’est pas beaucoup plus importante qu’en Java:

//prepare the service and register your class.
RLiveObjectService service = redisson.getLiveObjectService();
service.registerClass(User.class);
service.registerClass(Truck.class);

Truck truck01 = new Truck();
truck01.setRegNo("azn102");
truck01.setMake("subaru");
//stores this record as a Redis hash
service.persist(truck01);

User user02 = new User();
user02.setUsername("user2");
user02.setEmail("...");
//stores this record as a Redis hash
service.persist(user02);

//assuming you have invoked setUsageLog elsewhere.
truck01.getUsageLog().add(user02);
user02.setCurrentlyDriving(truck01);

//under normal circumstance keeping a Redis hash registry is not necessary.
//the service object can be used for this type of look up.
//this is only for demonstration.
Map<String, Truck> trucks = redisson.getMap("trucks");
trucks.put("truck01", truck01);

Map<String, User> users = redisson.getMap("users");
users.put("user02", user02);

Donc, ce que vous obtenez en définitive est que chaque enregistrement est stocké dans Redis et un hachage, et chaque enregistrement de camion conserve une liste indépendante des enregistrements d'utilisateur qui l'ont utilisé. L'enregistrement d'utilisateur contient maintenant des informations sur le camion qu'il conduit actuellement. Toutes ces opérations sont effectuées à l'aide de références d'objet au lieu de dupliquer les enregistrements de domaine.

Comme vous pouvez le constater, Redisson fournit une solution qui répond à tous les besoins et élimine les maux de tête au cours du processus.

Pour plus d'informations sur la manière dont Redisson gère les objets complexes multidimensionnels dans Redis via le mappage de hachage d'objet et le référencement d'objet: 

4
Redisson_RuiGu

Je pense qu'il vaut mieux utiliser _HMSET pour enregistrer les clés. 

Comme dans votre cas, vous pouvez créer une HMSET avec le nom "users" & "trucks". Dans cette HMSET, vous pouvez créer des clés (des champs) telles que "user01" et "user02". Comme ces clés (comme "user01", "user02" etc.) sont capables de stocker une valeur, vous pouvez donc stocker votre reste (c'est-à-dire {username:"ally", email:"[email protected]"}) d'objet JSON dans stringified form.

Par exemple: HMSET users user01 "{\"username\":\"ally\",\"email\":\"[email protected]\"}"

Ensuite, vous pouvez obtenir votre liste users par HGETALL (comme avec HGETALL users) . De même, si vous devez récupérer les détails de l'utilisateur "user01", vous pouvez utiliser . HGET like HGET users user01. Après avoir récupéré la valeur de "user01", vous pouvez analyser cette valeur et l'utiliser en fonction de vos besoins.

3
Mayank Jain

Redis est un magasin de valeur clé. Vous ne pouvez pas lier deux structures de données à l'aide de Redis. Mieux utiliser Mongo DB ou Couch DB qui sont des bases de documents permettant de lier des structures de données

0
Srini Sydney