org.mongodb.morphia.Datastore Java Examples

private <T> Query<T> prepareQuery(Object criteria, Datastore dataStore) {

          Query<T> query = (Query<T>) dataStore.createQuery(criteria.getClass());

          List<Field> fields = this.getAllModelFields(criteria.getClass());
          for (Field field : fields) {
               field.setAccessible(true);
               Object value = null;
               try {
                    value = field.get(criteria);
               } catch (IllegalArgumentException | IllegalAccessException e) {
                    log.error(e.getMessage(), e);
               }
               if (value != null) {
                    query.criteria(field.getName()).equal(value);
               }
          }

          return query;
     }
 

private <T> Query<T> prepareQuery(Object criteria, Datastore dataStore) {

        Query<T> query = (Query<T>) dataStore.createQuery(criteria.getClass());

        List<Field> fields = this.getAllModelFields(criteria.getClass());
        for (Field field : fields) {
            field.setAccessible(true);
            Object value = null;
            try {
                value = field.get(criteria);
            } catch (IllegalArgumentException | IllegalAccessException ignored) {}

            if (value != null) {
                query.criteria(field.getName()).equal(value);
            }
        }

        return query;
    }
 

@Test
@LocalData
public void should_save_mixed_type_lists() {
    MixedTypeListClass mixed = new MixedTypeListClass();
    Serializable[] mixedList = {1, "teststring", new DummySerialiazable()};
    mixed.mixedTypeList = mixedList;
    Datastore ds = SetupConfig.get().getInjector().getInstance(Datastore.class);
    ds.save(mixed);
    MixedTypeListClass restoredMixed = ds.createQuery(MixedTypeListClass.class).get();

    assertEquals(1, restoredMixed.mixedTypeList[0]);
    assertEquals("teststring", restoredMixed.mixedTypeList[1]);
    assertNotNull(restoredMixed.mixedTypeList[2]);
    assertTrue(restoredMixed.mixedTypeList[2] instanceof DummySerialiazable);
    DummySerialiazable dummy = (DummySerialiazable) restoredMixed.mixedTypeList[2];
    assertEquals("test", dummy.test);
}
 

@Override
public <T> T merge(T object) {

    try {
        Datastore ds = this.datastore();
        ds.merge(object);
        return findOne(object);
    } catch (Exception e) {
        return null;
    }

}
 

public static Datastore getDataStore(Config config) {

        String[] addresses = config.getParameter(ExtConfig.MONGO_ADDRESSES, new String[]{"127.0.0.1:27017"});
        String database = config.getParameter(ExtConfig.MONGO_DATABASE, "lts");
        String username = config.getParameter(ExtConfig.MONGO_USERNAME);
        String pwd = config.getParameter(ExtConfig.MONGO_PASSWORD);

        String cachedKey = StringUtils.concat(StringUtils.concat(addresses), database, username, pwd);

        Datastore datastore = DATA_STORE_MAP.get(cachedKey);
        if (datastore == null) {
            try {
                synchronized (lock) {
                    datastore = DATA_STORE_MAP.get(cachedKey);
                    if (datastore != null) {
                        return datastore;
                    }
                    Morphia morphia = new Morphia();
                    MongoFactoryBean mongoFactoryBean = new MongoFactoryBean(addresses, username, database, pwd);
                    MongoClient mongo = mongoFactoryBean.createInstance();
                    datastore = morphia.createDatastore(mongo, database);
                    DATA_STORE_MAP.put(cachedKey, datastore);
                }
            } catch (Exception e) {
                throw new IllegalStateException(
                        StringUtils.format("connect mongo failed! addresses: {}, database: {}",
                                addresses, database), e);
            }
        }
        return datastore;
    }
 

@Provides
@Singleton
Datastore provideDatastore(final Mongo mongo) {
    final String databaseName = SetupConfig.get().getDbName();

    final Mapper mapper = new JenkinsMapper();
    final Morphia morphia = new Morphia(mapper);
    return morphia.createDatastore(mongo, databaseName);

}
 

@Override
protected Datastore createInstance() throws Exception {
	// 这里的username和password可以为null，morphia对象会去处理
	MongoClientURI mongoClientURI = new MongoClientURI(uri);
	Datastore ds = morphia.createDatastore(new MongoClient(mongoClientURI), dbName);
	if (toEnsureIndexes) {
		ds.ensureIndexes();
	}
	if (toEnsureCaps) {
		ds.ensureCaps();
	}
	return ds;
}
 

@Override
public <T> T merge(T object) {

     try {
          Datastore ds = this.datastore();
          ds.merge(object);
          return findOne(object);
     } catch (Exception e) {
          log.error(e.getMessage(), e);
          return null;
     }

}
 

public int assignNextBuildNumber(final DynamicProject project) {
    final Datastore datastore = getDatastore();
    BuildNumberCounter seq = datastore.findAndModify(
        datastore.find(BuildNumberCounter.class, "key = ", project.getFullName()), // query
        datastore.createUpdateOperations(BuildNumberCounter.class).inc("counter") // update
    );
    if (seq == null) {
        seq = new BuildNumberCounter(project.getFullName(), 1);
        datastore.save(seq);
    }

    return seq.getCounter();
}
 

@Provides
@Singleton
Datastore provideDatastore(final Mongo mongo) {
    final String databaseName = SetupConfig.get().getDbName();

    final Mapper mapper = new JenkinsMapper();
    final Morphia morphia = new Morphia(mapper);
    return morphia.createDatastore(mongo, databaseName);

}
 

@Inject
public MongoRepository(final Datastore datastore) {
    this.datastore = datastore;
}
 

@Inject
public DynamicProjectRepository(final Datastore datastore, final DynamicBuildRepository buildRepository) {
    this(datastore, new OrganizationContainerRepository(), buildRepository);
}
 

public MongoExperimentsCache(Datastore ds, RevisionManager revisionManager) {
    this.ds = ds;
    this.revisionManager = revisionManager;
}
 

protected AbstractMongoRepository(Class<T> entity, Datastore datastore) {
    super(entity, datastore);
    collection = getCollection();
}
 

public Datastore datastore() {
    return datastore;
}
 

public static PluginTypeRepository create(Datastore ds) {
    return new PluginTypeRepository(ds);
}
 

private PluginTypeRepository(Datastore ds) {
    super(PluginType.class, ds);
}
 

public static ServerTypeRepository create(Datastore datastore) {
    return new ServerTypeRepository(datastore);
}
 

public Datastore getDatastore() {
    return this.datastore;
}
 

@Inject
public GithubDeployKeyRepository(final Datastore datastore) {
    super(datastore);
    this.encryptionService = new EncryptionService();
}
 

@Inject
public GithubAccessTokenRepository(final Datastore datastore) {
    super(datastore);
}
 

private ServerRepository(Datastore datastore) {
    super(Server.class, datastore);
}
 

protected DynamicProjectRepository(final Datastore datastore, final OrganizationContainerRepository organizationRepository, final DynamicBuildRepository dynamicBuildRepository) {
    super(datastore);
    this.organizationRepository = organizationRepository;
    this.dynamicBuildRepository = dynamicBuildRepository;
}
 

@Inject
public DynamicBuildRepository(final Datastore datastore) {
    super(datastore);
}
 

@Override
public Statement apply(final Statement base, final Description description) {
    return new Statement() {
        @Override
        public void evaluate() throws Throwable {
            if (Jenkins.getInstance() == null
                || SetupConfig.get().getInjector() == null
                || SetupConfig.get().getInjector().getInstance(Datastore.class) == null) {
                throw new IllegalStateException("Requires configured Jenkins and Mongo configurations");
            }

            DB db = SetupConfig.get().getInjector().getInstance(Datastore.class).getDB();

            //Load mongo data
            File homedir = Jenkins.getInstance().getRootDir();

            for (File fileOfData : homedir.listFiles()) {
                if (!fileOfData.getName().endsWith(".json")) continue;

                String collectionName = fileOfData.getName().replaceAll("\\.json$", "");
                DBCollection collection = db.createCollection(collectionName, new BasicDBObject());

                String data = FileUtils.readFileToString(fileOfData);
                Object bsonObject = JSON.parse(data);
                if (bsonObject instanceof BasicDBList) {
                    BasicDBList basicDBList = (BasicDBList) bsonObject;
                    collection.insert(basicDBList.toArray(new DBObject[0]));
                } else {
                    collection.insert((DBObject) bsonObject);
                }

            }

            for (OrganizationContainer container : Jenkins.getInstance().getAllItems(OrganizationContainer.class)) {
                container.reloadItems();
            }

            base.evaluate();

            // Clean up mongo data
            for (String collectioName : db.getCollectionNames()) {
                db.getCollection(collectioName).drop();
            }
        }
    };
}
 

public static Datastore getDatastore(Datastore ds)
{
	Datastore result =ds;
	
	if (mongourl!=null)
	{
		try{
			Properties prop = new Properties();
			prop.load(DatastoreFactory.class.getResource("/acmeair-mongo.properties").openStream());
			boolean fsync = new Boolean(prop.getProperty("mongo.fsync"));
			int w = new Integer(prop.getProperty("mongo.w"));
			int connectionsPerHost = new Integer(prop.getProperty("mongo.connectionsPerHost"));
			int threadsAllowedToBlockForConnectionMultiplier = new Integer(prop.getProperty("mongo.threadsAllowedToBlockForConnectionMultiplier"));
			
			// To match the local options
			MongoClientOptions.Builder builder = new MongoClientOptions.Builder()
				.writeConcern(new WriteConcern(w, 0, fsync))
				.connectionsPerHost(connectionsPerHost)
				.threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier);
		
			MongoClientURI mongoURI = new MongoClientURI(mongourl, builder);
			MongoClient mongo = new MongoClient(mongoURI);
			Morphia morphia = new Morphia();				
			result = morphia.createDatastore( mongo ,mongoURI.getDatabase());
			System.out.println("create mongo datastore with options:"+result.getMongo().getMongoClientOptions());
		}catch (Exception e)
		{
			e.printStackTrace();
		}
	}
   	// The converter is added for handing JDK 7 issue
//	result.getMapper().getConverters().addConverter(new BigDecimalConverter());		
   //	result.getMapper().getConverters().addConverter(new BigIntegerConverter());
   	
	// Enable index
	result.ensureIndex(Booking.class, "pkey.customerId");
	result.ensureIndex(Flight.class, "pkey.flightSegmentId,scheduledDepartureTime");
	result.ensureIndex(FlightSegment.class, "originPort,destPort");

   	return result;
}
 

public Datastore getDatastore(){
	return datastore;
}
 

public static ServerRepository create(Datastore datastore) {
    return new ServerRepository(datastore);
}
 

public Datastore getDatastore() {
	return baseDao.getDatastore();
}
 

@Override
public Class<?> getObjectType() {
	return Datastore.class;
}