Dans Morphia, comment puis-je mettre à jour un objet incorporé dans un ArrayList?

Question

Vraiment nouveau pour l'utilisation de Mongodb avec Morphia et voir beaucoup de réponses avancées comment faire ceci.

Je veux faire simple s'il est possible et j'ai ce @Embedded objet appelé
fileObjects qui contient Files objets.

Je ne peux pas mettre à jour les champs à l'intérieur du Files. Je souhaite mettre à jour un seul champ pour le String fileHash.

@Entity 
public class BatchData { 

    @Id private ObjectId id; 
    @Embedded 
    public ArrayList<Files> fileObjects = new ArrayList<Files>(); 
} 

MISE À JOUR .. La lecture du wiki à Morphia Updating dont « vraiment » dire comment faire que lorsque le tableau contient Integer comme ceci:

@Embedded 
    List<Integer> roomNumbers = new ArrayList<Integer>(); 

Voici ce que j'essaie jusqu'à présent :

mongo.createUpdateOperations(BatchData.class).add("fileObjects", Files, false); 

le Files que cet insert de code est déjà dans le mongo. Le false ne détecte pas cela et l'insère à la fin de la matrice. Puis-je ajouter un identifiant unique au Files afin qu'il détecte que l'insertion Files existe dans le tableau, puis le mettre à jour?

@Embedded 
public class Files 
{ 
    public Files() { 

    } 

    public int position; 
    public String fileName = ""; 
    public String fileHash = ""; 

    public Files(int pos, String fileName, String fileHash) { 
     this.position = pos; 
     this.fileName = fileName; 
     this.fileHash = fileHash; 
    } 
} 

Lire d'autres réponses comme morphia-mongodb-accessing, mais il a déjà
@Entity BlogEntry (voir lien) dans un POJO en dehors de mongo. Peut-être que je dois faire la même chose?
Sortez-le, changez-le et enregistrez-le de nouveau?

Answer 1

Répondre à ma propre question pour le plaisir de tous.

Je pense que je l'ai résolu pas sûr.
On dirait que ça marche en test quand les fileObjects ont beaucoup de Files.
Le droit fileHash est mis à jour en effet.

UpdateOperations<BatchData>updateOperations=mongo.createUpdateOperations 
      (BatchData.class) 
      .disableValidation().set("fileObjects.$.fileHash",hash).enableVali..; 

mongo.update(mongo.createQuery(BatchData.class) 
      .filter("uuid",theBatch.uuid) 
      .filter("fileObjects.fileName","theFileName"),updateOperations); 

Answer 2

Dans mon cas, j'ai pu utiliser la méthode removeAll:

UpdateOperations<MyType> ops = ds.createUpdateOperations(
      MyType.class).removeAll("myEmbeddedList", "thevalue"); 
ds.update(ds.find(MyType.class).get(), ops); 

Cette supposer que MyType a la liste des champs myEmbeddedList; et qu'il y a une "valeur" vlue à supprimer de la liste.

Answer 3

Je viens (oui, en ce moment) résolu ce problème, de cette façon: je reçois la classe racine avec une requête

List<Applications> fileList = mDatastore.createQuery(File.class).field("_id").equal(new ObjectId(ID)).asList(); 

Puis, je l'ai mis en œuvre les opérations CRUD à l'intérieur de cette classe racine (I afficherons ma classe racine):

@Entity 
public class Applications extends BaseEntity{ 


    private String name;  
    private String owner; 
    private String version; 

    @Embedded 
    List<Resources> resources = new ArrayList<>(); 

    @Embedded 
    List<Activities> activities = new ArrayList<>(); 

    @Embedded 
    List<Components> components = new ArrayList<>(); 

    public Applications() { 
    } 

    public String getName() { 
     return name; 
    } 

    public void setName(String name) { 
     this.name = name; 
    } 

    public String getOwner() { 
     return owner; 
    } 

    public void setOwner(String owner) { 
     this.owner = owner; 
    } 

    public String getVersion() { 
     return version; 
    } 

    public Applications setVersion(String version) { 
     this.version = version; 
     return this; 
    } 

    public List<Resources> getResources() { 
     return resources; 
    } 

    public Applications setResources(List<Resources> resources) { 
     this.resources = resources; 
     return this; 
    } 

    public Resources getResourcesByName(String name) { 
     for(Resources resource : this.resources){ 
      if (resource.getName().equals(name)) 
       return resource; 
     } 
     return null; 
    } 

    public boolean containsResourceByName(String name) { 
     for(Resources resource : this.resources){ 
      if (resource.getName().equals(name)) 
       return true; 
     } 
     return false; 
    } 



    public Applications addResource(Resources newResource) { 
     if (!containsResourceByName(newResource.getName())) { 
      this.resources.add(newResource); 
     } 
     return this; 
     } 

    public Applications removeResource(Resources newResource) { 
     if (containsResourceByName(newResource.getName())) { 
      this.resources.remove(getResourcesByName(newResource.getName())); 
     } 
     return this; 
    } 

    public Applications removeResourceByName(String name) { 
     if (containsResourceByName(name)) { 
      this.resources.remove(getResourcesByName(name)); 
     } 
     return this; 
    } 

    public List<Activities> getActivities() { 
     return activities; 
    } 

    public Applications setActivities(List<Activities> activities) { 
     this.activities = activities; 
     return this; 
    } 

    public Activities getActivityByName(String name) { 
     for(Activities activity : this.activities){ 
      if (activity.getName().equals(name)) 
       return activity; 
     } 
     return null; 
    } 

    public boolean containsActivityByName(String name) { 
     for(Activities activity : this.activities){ 
      if (activity.getName().equals(name)) 
       return true; 
     } 
     return false; 
    } 

    public Applications addActivity(Activities newActivity) { 
     if (!containsActivityByName(newActivity.getName())) { 
      this.activities.add(newActivity); 
     } 
     return this; 
     } 

    public Applications removeActivity(Activities newActivity) { 
     if (containsActivityByName(newActivity.getName())) { 
      this.activities.remove(getActivityByName(newActivity.getName())); 
     } 
     return this; 
    } 

    public Applications removeActivityByName(String name) { 
     if (containsActivityByName(name)) { 
      this.activities.remove(getActivityByName(name)); 
     } 
     return this; 
    } 

    public List<Components> getComponents() { 
     return components; 
    } 

    public Applications setComponents(List<Components> components) { 
     this.components = components; 
     return this; 
    } 

    public Components getComponentByName(String name) { 
     for(Components component : this.components){ 
      if (component.getName().equals(name)) 
       return component; 
     } 
     return null; 
    } 

    public boolean containsComponentByName(String name) { 
     for(Components component : this.components){ 
      if (component.getName().equals(name)) 
       return true; 
     } 
     return false; 
    } 

    public Applications addComponent(Components newComponent) { 
     if (!containsComponentByName(newComponent.getName())) { 
      this.components.add(newComponent); 
     } 
     return this; 
     } 

    public Applications removeComponent(Components newComponent) { 
     if (containsComponentByName(newComponent.getName())) { 
      this.components.remove(getComponentByName(newComponent.getName())); 
     } 
     return this; 
    } 

    public Applications removeComponentByName(String name) { 
     if (containsComponentByName(name)) { 
      this.components.remove(getComponentByName(name)); 
     } 
     return this; 
    } 

    public Applications updateComponentByName(String name, String newName) { 
     if (containsComponentByName(name)) { 
      getComponentByName(name).setName(newName); 
     } 
     return this; 
    } 


    @Override 
    public String toString() { 

     try { 
      JSONObject jsonObject = new JSONObject(); 
      jsonObject.put(DatabaseModel.ApplicationsModel.FIELD_ID, id); 
      jsonObject.put(DatabaseModel.ApplicationsModel.FIELD_NAME, name); 
      jsonObject.put(DatabaseModel.ApplicationsModel.FIELD_OWNER, owner); 
      jsonObject.put(DatabaseModel.ApplicationsModel.FIELD_VERSION, version); 
      jsonObject.put(DatabaseModel.ActivitiesModel.DOCUMENT_NAME, activities); 
      jsonObject.put(DatabaseModel.ResourcesModel.DOCUMENT_NAME, resources); 
      jsonObject.put(DatabaseModel.ComponentsModel.DOCUMENT_NAME, components); 
      return jsonObject.toString(); 
     } catch (JSONException e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
      return "Something went wrong"; 
     } 

    } 

Une fois, je modifié mes données d'application que je viens de l'enregistrer à MongoDB dans le programme principal avec:

mDatastore.save(mApplications); 

J'espère que cela peut vous aider, au revoir!