Récupérer un sous-document dans un tableau en tant que DBObject (s)

Je suis très nouveau pour MongoDB, et je l'utilise avec le pilote Java. J'ai cette structure du document:

{ "_id" : ObjectId("4f7d2ba6fd5a306d82687d48"), "room" : "Den" }
{ "_id" : ObjectId("4f7d2baafd5a306d82687d49"), "room" : "Foyer" }
{ "_id" : ObjectId("4f7d2fdcfd5a306d82687d4a"), "room" : "Master Bedroom" }
{ "_id" : ObjectId("4f7d301afd5a306d82687d4b"), "room" : "Guest Bedroom" }
{ "_id" : ObjectId("4f7d2b98fd5a306d82687d47"), "code" : "A", "lights" : [ { "name" : "Overhead", "code" : "1" } ], "room" : "Kitchen" }

Où la dernière ligne est d'un intérêt particulier pour illustrer ce que je veux faire. Chaque document est une chambre et peut avoir un "lumières" touche correspondant à une valeur qui est un tableau de sous-documents. À partir d'un point de vue de modélisation, j'ai une maison, qui a 0-n chambres, dont chacune a 0-n lumières. Ce que je veux faire en Java, c'est de prendre le nom de la salle en tant que paramètre et retourner une collection de DBObject correspondant à la sous-documents dans les lumières de tableau -- "donnez-moi toutes les lumières pour la pièce "cuisine"", par exemple.

Jusqu'à présent, de procéder progressivement en TDD style, j'ai construit cette requête:

public static final String ROOM_KEY = "room";

public static final String EQUALS_KEY = "$eq";

private BasicDBObject buildRoomNameQuery(String roomName) {

    BasicDBObject myQuery = new BasicDBObject();
    myQuery.put(ROOM_KEY, new BasicDBObject(EQUALS_KEY, roomName));

    return myQuery;
}

Je me rends compte que cela va me faire la totalité de la salle de document pour le nom de la salle je passe. Je suis un peu coincé sur ce la meilleure façon de procéder à partir d'ici est d'obtenir ce que je veux. Est ce que je fais même possible avec une simple requête, ou devrai-je récupérer le tableau et itérer dans le code, de la fonte des éléments comme DBObject? Je suis aussi ouvert à des suggestions pour une meilleure structure du document pour mon objectif -- je ne suis pas marié à cette structure par tous les moyens.

Pour un peu de point de vue, je suis tout à fait bien versé dans SQL et traditionnelles de bases de données relationnelles, si ça peut aider dans les termes de l'exposé des analogies. Aussi, si je suis le dépeçage de la MongoDB terminologie, merci de me corriger. Merci à l'avance.

source d'informationauteur Erik Dietrich

  1. 19

    Vous pouvez faire quelque chose comme ceci:

    DBCollection coll = db.getCollection("test");
BasicDBObject query = new BasicDBObject("room", "Kitchen"); 

//optional, limit the fields to only have the lights field
BasicDBObject fields = new BasicDBObject("lights",1).append("_id",false);
DBCursor curs = coll.find(query, fields);
while(curs.hasNext()) {
  DBObject o = curs.next();

  //shows the whole result document
  System.out.println(o.toString());
  BasicDBList lights = (BasicDBList) o.get("lights");

  //shows the lights array -- this is actually a collection of DBObjects
  System.out.println(lights.toString());

  //optional: break it into a native java array
  BasicDBObject[] lightArr = lights.toArray(new BasicDBObject[0]);
  for(BasicDBObject dbObj : lightArr) {
    //shows each item from the lights array
    System.out.println(dbObj);
  }
}

    Aussi, je recommande d'utiliser le QueryBuilder dans le pilote Java--c'est un peu plus concis que la création de Requêtes à partir de DBObjects. Mieux encore, découvrez Morphia, qui est un objet mappeur qui utilise le pilote Java. Il prend nativement en charge de l'entité des modèles qui ont des listes en eux, et sérialise/désérialise à Mongo sans avoir à traiter avec le DBObject choses.

  2. 1

    Regardez printemps mongo paquet. Une très bonne façon de travailler avec mongo utilisation de POJO documents

    http://www.springsource.org/spring-data/mongodb

    Vous n'aurez pas besoin d'effectuer de moulage et de travailler avec des chaînes de

  3. 1

    Vous pouvez utiliser un itérateur pour les champs

    Iterator<DBObject> fields = curs.iterator();
          while(fields.hasNext()){
              DBObject field = (DBObject) fields.next().get("lights");
              System.out.println(field.get("name"));
            }
  4. 0

    Pour les versions plus récentes, l'utilisation de la Document. Pour éviter décoché jette et linter mises en garde, ainsi que l'écriture de votre propre boucle, utilisez la bibliothèque de l' get(final Object key, final Class<T> clazz) méthode:

    List<Document> comments = posts.get("comments", docClazz)

    où docClazz est quelque chose que vous créez en une fois:

    final static Class<? extends List> docClazz = new ArrayList<Document().getClass();