import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Override
public void update(List<Provider> entityList) throws DBException {
    for (Provider provider : entityList) {
        List<Provider> providers = fetchById(new ArrayList<String>() {{
            add(provider.getCloudProvider());
        }});
        Provider existingProvider = null;
        if (providers != null && !providers.isEmpty()) {
            existingProvider = providers.get(0);
        }
        if (existingProvider != null) {
            UpdateOperations<Provider> ops = this.createUpdateOperations();
            if (provider.getCommands() != null) {
                ops.set("commands", provider.getCommands());
            }
            if (provider.getDockerImage() != null) {
                ops.set("dockerImage", provider.getDockerImage());
            }

            Query<Provider> updateQuery = this.createQuery().field(Mapper.ID_KEY).equal(provider.getCloudProvider());
            UpdateResults results = this.update(updateQuery, ops);
        }
    }
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
protected MoManager createManager() throws NotFoundException {
	 MongoDataSource ds = getMongoDataSource();
	 MongoClient client = ds.getConnection();
	 MoSchema schema = doCreateSchema();
	 
	 BundleContext bundleContext = FrameworkUtil.getBundle(this.getClass()).getBundleContext();
	 MoManager manager = new MoManager(client,schema) {
			@Override
			protected Mapper createMapper() {
				Mapper m = super.createMapper();
				m.getOptions().setObjectFactory(new BundleObjectFactory(bundleContext));
				return m;
			}

	 };

	return manager;
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Override
public void prePersist(final Object entity, final DBObject dbObj, final Mapper mapper) {
  MappedClass mclass = mapper.getMappedClass(entity);
  Field id = mclass.getIdField();
  if (id != null && id.getAnnotation(GeneratedValue.class) != null) {
    try {
      id.setAccessible(true);
      final String collName = gen.value(mclass.getClazz());
      final Query<StoredId> q = db.find(StoredId.class, "_id", collName);
      final UpdateOperations<StoredId> uOps = db.createUpdateOperations(StoredId.class)
          .inc("value");
      StoredId newId = db.findAndModify(q, uOps);
      if (newId == null) {
        newId = new StoredId(collName);
        db.save(newId);
      }
      id.set(entity, newId.value);
    } catch (Exception ex) {
      throw new IllegalStateException("Can't generate ID on " + mclass, ex);
    }
  }
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createInstanceFromClazz() throws Exception {
  Injectable injectable = new Injectable();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class)
      .expect(boot)
      .expect(unit -> {
        Registry injector = unit.get(Registry.class);
        expect(injector.require(Injectable.class)).andReturn(injectable);
      })
      .run(unit -> {
        assertEquals(injectable,
            new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                .createInstance(Injectable.class));

      });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createInstanceFromClazzNoInjectable() throws Exception {
  GuiceObjectFactoryTest expected = new GuiceObjectFactoryTest();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class)
      .expect(boot)
      .expect(unit -> {
        ObjectFactory injector = unit.get(ObjectFactory.class);
        expect(injector.createInstance(GuiceObjectFactoryTest.class)).andReturn(expected);
      })
      .run(unit -> {
        assertEquals(expected,
            new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                .createInstance(GuiceObjectFactoryTest.class));

      });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createInstanceFromClazzWithDBObject() throws Exception {
  Injectable injectable = new Injectable();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class, DBObject.class)
      .expect(boot)
      .expect(unit -> {
        Registry injector = unit.get(Registry.class);
        expect(injector.require(Injectable.class)).andReturn(injectable);
      })
      .run(unit -> {
        assertEquals(injectable,
            new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                .createInstance(Injectable.class, unit.get(DBObject.class)));

      });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createInstanceFromClazzWithDBObjectNoInjectable() throws Exception {
  GuiceObjectFactoryTest expected = new GuiceObjectFactoryTest();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class, DBObject.class)
      .expect(boot)
      .expect(unit -> {
        ObjectFactory factory = unit.get(ObjectFactory.class);
        expect(factory.createInstance(GuiceObjectFactoryTest.class, unit.get(DBObject.class)))
            .andReturn(expected);
      })
      .run(unit -> {
        assertEquals(expected,
            new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                .createInstance(GuiceObjectFactoryTest.class, unit.get(DBObject.class)));

      });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createInstanceFully() throws Exception {
  Injectable injectable = new Injectable();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class, DBObject.class,
      MappedField.class)
      .expect(boot)
      .expect(unit -> {
        MappedField mf = unit.get(MappedField.class);
        expect(mf.getType()).andReturn(Injectable.class);

        Registry injector = unit.get(Registry.class);
        expect(injector.require(Injectable.class)).andReturn(injectable);
      })
      .run(
          unit -> {
            assertEquals(
                injectable,
                new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                    .createInstance(unit.get(Mapper.class), unit.get(MappedField.class),
                        unit.get(DBObject.class)));

          });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createInstanceFullyNoInjectable() throws Exception {
  GuiceObjectFactoryTest expected = new GuiceObjectFactoryTest();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class, DBObject.class,
      MappedField.class)
      .expect(boot)
      .expect(unit -> {
        MappedField mf = unit.get(MappedField.class);
        expect(mf.getType()).andReturn(GuiceObjectFactoryTest.class);

        ObjectFactory factory = unit.get(ObjectFactory.class);
        expect(factory.createInstance(unit.get(Mapper.class), mf, unit.get(DBObject.class)))
            .andReturn(expected);
      })
      .run(unit -> {
        assertEquals(
            expected,
            new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                .createInstance(unit.get(Mapper.class), unit.get(MappedField.class),
                    unit.get(DBObject.class)));

      });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createMap() throws Exception {
  Map<String, Object> expected = Collections.emptyMap();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class,
      MappedField.class)
      .expect(boot)
      .expect(unit -> {
        ObjectFactory factory = unit.get(ObjectFactory.class);
        expect(factory.createMap(unit.get(MappedField.class))).andReturn(expected);
      })
      .run(unit -> {
        assertEquals(
            expected,
            new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                .createMap(unit.get(MappedField.class)));

      });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createSet() throws Exception {
  Set<String> expected = Collections.emptySet();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class,
      MappedField.class)
      .expect(boot)
      .expect(unit -> {
        ObjectFactory factory = unit.get(ObjectFactory.class);
        expect(factory.createSet(unit.get(MappedField.class))).andReturn(expected);
      })
      .run(unit -> {
        assertEquals(
            expected,
            new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                .createSet(unit.get(MappedField.class)));

      });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void createList() throws Exception {
  List<String> expected = Collections.emptyList();

  new MockUnit(Registry.class, Morphia.class, Mapper.class, ObjectFactory.class,
      MappedField.class)
      .expect(boot)
      .expect(unit -> {
        ObjectFactory factory = unit.get(ObjectFactory.class);
        expect(factory.createList(unit.get(MappedField.class))).andReturn(expected);
      })
      .run(unit -> {
        assertEquals(
            expected,
            new GuiceObjectFactory(unit.get(Registry.class), unit.get(Morphia.class))
                .createList(unit.get(MappedField.class)));

      });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void shouldSkipNullID() throws Exception {
  Object entity = new Object();
  new MockUnit(Datastore.class, DBObject.class, Mapper.class, MappedClass.class, Field.class,
      GeneratedValue.class)
          .expect(unit -> {

            MappedClass mclass = unit.get(MappedClass.class);
            expect(mclass.getIdField()).andReturn(null);
            Mapper mapper = unit.get(Mapper.class);
            expect(mapper.getMappedClass(entity)).andReturn(mclass);
          })
          .run(unit -> {
            new AutoIncID(unit.get(Datastore.class), IdGen.LOCAL)
                .prePersist(entity, unit.get(DBObject.class), unit.get(Mapper.class));
          });
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Override
public void fromDBObject(DBObject dbObject, MappedField mf, Object entity, EntityCache cache, Mapper mapper) {
    BasicDBList cowlist = (BasicDBList) dbObject.get(mf.getNameToStore());

    if (cowlist == null)
        throw new IllegalArgumentException("Improperly formatted DBObject for CopyOnWriteList");

    List core = new ArrayList();
    for (Object obj : cowlist) {
        DBObject listEntryDbObj = (DBObject) obj;

        // Hack until we can coax MappedField to understand what CopyOnWriteList is. Eliminate as soon as possible.
        // Currently mf.getSubType() is null because MappedField does not use Iterable to determine a list and thus
        // does not check for subtypes.
        Class clazz = mapper.getOptions().getObjectFactory().createInstance(mapper, mf, listEntryDbObj).getClass();

        core.add(mapper.fromDBObject(clazz, listEntryDbObj, cache));
    }
    mf.setFieldValue(entity, new CopyOnWriteList(core));
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Override
public void fromDBObject(final DBObject dbObject, final MappedField mf, final Object entity, final EntityCache cache, final Mapper mapper) {

    final Key key = extractKey(mapper, mf, (DBObject) dbObject.get(mf.getNameToStore()));
    if (key != null && cache.getEntity(key) != null) {
        final Object object = cache.getEntity(key);
        mf.setFieldValue(entity, object);
    } else if (this.customMappers.containsKey(mf.getType())) {
        this.customMappers.get(mf.getType()).fromDBObject(dbObject, mf, entity, cache, mapper);
    } else if (isAwkwardMap(mf)) {
        this.awkwardMapper.fromDBObject(dbObject, mf, entity, cache, mapper);
    } else {
        // the first two conditions (isMap and isMultipleValues) are part of the hack to fix handling primitives
        if (mf.isMap()) {
            readMap(dbObject, mf, entity, cache, mapper);
        } else if (mf.isMultipleValues()) {
            readCollection(dbObject, mf, entity, cache, mapper);
        } else {
            mapper.getOptions().getEmbeddedMapper().fromDBObject(dbObject, mf, entity, cache, mapper);
        }

        this.serializationMethodInvoker.callReadResolve(mf.getFieldValue(entity));
    }


}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void should_get_cause_from_dbObject() throws Exception {
    BasicDBObject cause1DbObject = new BasicDBObject("cause1", "cause1");
    DBObject causes = new BasicDBObjectBuilder().add("causes", Arrays.asList(cause1DbObject)).get();

    Mapper mapper = Mockito.mock(Mapper.class);
    Cause cause1 = new NullBuildCause();
    when(mapper.fromDBObject(null, cause1DbObject, null)).thenReturn(cause1);

    CauseActionConverter converter = new CauseActionConverter();
    converter.setMapper(mapper);
    CauseAction action = converter.decode(CauseAction.class, causes, Mockito.mock(MappedField.class));

    Assert.assertEquals(1, action.getCauses().size());
    Assert.assertEquals(cause1, action.getCauses().get(0));

}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@Test
public void should_convert_cause_action_to_old_format() throws Exception {
    Cause cause1 = new NullBuildCause();
    Mapper mapper = Mockito.mock(Mapper.class);
    when(mapper.toDBObject(cause1)).thenReturn(new BasicDBObject("cause1", "cause1"));

    CauseAction causeAction = new CauseAction(cause1);
    CauseActionConverter converter = new CauseActionConverter();
    converter.setMapper(mapper);

    DBObject dbObject = (DBObject) converter.encode(causeAction, null);

    Assert.assertEquals(dbObject.get("className"), CauseAction.class.getName());
    Assert.assertNotNull(dbObject.get("causes"));
    List dbCauses = ((List) dbObject.get("causes"));
    Assert.assertEquals(1, dbCauses.size());
    Assert.assertEquals("cause1", ((BasicDBObject) dbCauses.get(0)).get("cause1"));
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@SuppressWarnings("unchecked")
protected <T> Iterable<T> deref(Class<T> clazz, List<Key<T>> keys) {
    if (keys == null || keys.isEmpty()) {
        return Collections.emptyList();
    }
    ListMultimap<String, Key<T>> kindMap = getKindMap(clazz, keys);
    List<Iterable<T>> fetched = Lists.newLinkedList();
    for (String kind : kindMap.keySet()) {
        List<Key<T>> kindKeys = kindMap.get(kind);
        List<Object> objIds = new ArrayList<>(kindKeys.size());
        Class<T> kindClass = clazz == null
                             ? (Class<T>) kindKeys.get(0).getType()
                             : clazz;
        kindKeys.stream().map(Key::getId).forEach(objIds::add);
        fetched.add(getDatastore()
                .find(kindClass)
                .disableValidation()
                .field(Mapper.ID_KEY)
                .in(objIds)
                .fetch());
    }
    return Iterables.concat(fetched);
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
private void setupDatabase(MongoClient mongoCl, String dbName) {
	// Initialize Morphia
	Morphia morphia = new Morphia();
	morphia.map(Company.class).map(LinkedChest.class);

	// Setup datastore
	MapperOptions opts = new MapperOptions();
	opts.objectFactory = new CustomCreator(this.getClassLoader());
	Mapper mapper = new Mapper(opts);
	Datastore ds = new DatastoreImpl(mapper, mongoCl, dbName);

	// Setup DAOs
	companyDAO = new CompanyDAO(ds);
	companyDAO.ensureIndexes();
	linkedChestDAO = new LinkedChestDAO(ds);
	linkedChestDAO.ensureIndexes();
}
 

import org.mongodb.morphia.mapping.Mapper; //导入依赖的package包/类
@SuppressWarnings("deprecation")
MapReduceCommand toCommand(final Mapper mapper) {
    if (query.getOffset() != 0 || query.getFieldsObject() != null) {
        throw new QueryException("mapReduce does not allow the offset/retrievedFields query ");
    }

    final DBCollection dbColl = inputCollection != null ? getQuery().getCollection().getDB().getCollection(inputCollection)
                                                        : query.getCollection();
    final String target = outputCollection != null ? outputCollection : mapper.getMappedClass(resultType).getCollectionName();

    final MapReduceCommand command = new MapReduceCommand(dbColl, map, reduce, target, outputType, query.getQueryObject());
    command.setBypassDocumentValidation(bypassDocumentValidation);
    command.setCollation(collation);
    command.setFinalize(finalize);
    command.setJsMode(jsMode);
    command.setLimit(limit);
    command.setMaxTime(maxTimeMS, TimeUnit.MILLISECONDS);
    command.setOutputDB(outputDB);
    command.setReadPreference(readPreference);
    command.setScope(scope);
    command.setSort(query.getSortObject());
    command.setVerbose(verbose);

    return command;
}