Java Bson类代码示例

import org.bson.conversions.Bson; //导入依赖的package包/类
/**
 * This is deleted delete all document(s), which is matched
 */
@Override
public void deleteManyDocument() {
	MongoDatabase db = null;
	MongoCollection collection = null;
	Bson query = null;
	try {
		db = client.getDatabase(mongo.getDataBase());
		collection = db.getCollection(mongo.getSampleCollection());
		query = lt("age", 20);
		DeleteResult result = collection.deleteMany(query);
		if (result.wasAcknowledged()) {
			log.info("Document deleted successfully \nNo of Document(s) Deleted : "
					+ result.getDeletedCount());
		}
	} catch (MongoException e) {
		log.error("Exception occurred while delete Many Document : " + e, e);
	}
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
public static Bson getFilterBson(MatchOperator operator , String attributeName , Object value){
	Bson filter = null;
	switch(operator){
	case GT : 
		filter=Filters.gt(attributeName, value);
		break;
	case LT : 
		filter=Filters.lt(attributeName, value);
		break;
	case GTE : 
		filter=Filters.gte(attributeName, value);
		break;
	case LTE : 
		filter=Filters.lte(attributeName, value);
		break;
	case EQ :
		filter=Filters.eq(attributeName, value);
		break;
	case NE : 
		filter=Filters.ne(attributeName, value);
		break;
	default :
		filter=Filters.eq(attributeName, value);
		break;
	}
	return filter;
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
/**
 * 删除记录
 * 
 * @param collectionName
 *            表名
 * @param mongoObj
 *            记录
 * @return
 */
public static boolean deleteById(String collectionName, MongoObj mongoObj) {
	MongoCollection<Document> collection = getCollection(collectionName);
	try {
		Bson filter = Filters.eq(MongoConfig.MONGO_ID, mongoObj.getDocument().getObjectId(MongoConfig.MONGO_ID));
		DeleteResult result = collection.deleteOne(filter);
		if (result.getDeletedCount() == 1) {
			return true;
		} else {
			return false;
		}
	} catch (Exception e) {
		if (log != null) {
			log.error("删除记录失败", e);
		}
		return false;
	}

}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
/**
 * Converting User-defined constaints to Bson constraints.
 *
 * @param featureConstraint
 * @return
 */
public Bson generateBson(FeatureConstraint featureConstraint) {
    List<TargetAthenaValue> dataRequestObjectValueList = featureConstraint.getDataRequestObjectValueList();
    FeatureConstraintOperatorType featureConstraintOperatorType =
            featureConstraint.getFeatureConstraintOperatorType();
    Bson query = null;

    if (!(dataRequestObjectValueList.size() > 0)) {
        return null;
    }

    if (featureConstraintOperatorType == FeatureConstraintOperatorType.COMPARABLE) {
        query = getBsonFromRequestOperatorComparison(featureConstraint);

    } else if (featureConstraintOperatorType == FeatureConstraintOperatorType.LOGICAL) {
        query = getBsonFromRequestOperatorLogical(featureConstraint);

    } else {
        log.warn("not supported FeatureConstraintOperatorType");
    }

    return query;

}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
@GET @Produces(MediaType.APPLICATION_JSON)
public Response readAll(
    @NotEmptyButNull @QueryParam("last_id") String lastId,
    @Range(min = 1, max = Globals.MAX_SIZE) @DefaultValue("20") @QueryParam("size") int size) {

    RebaseAsserts.existCategory(category);
    List<Document> feeds = new ArrayList<>();
    List<Bson> filters = new ArrayList<>();
    if (lastId != null) {
        filters.add(lt(Feed._ID, objectId(lastId)));
    }
    filters.add(eq(Feed.CATEGORY, category));
    filters.add(eq(Feed.OWNER, owner));
    MongoDBs.feeds().find().sort(descending(Feed._ID))
        .filter(and(filters))
        .limit(size)
        .into(feeds);
    return Response.ok(feeds).build();
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
@PATCH @Path("{_id}")
public Response editFeed(@PathParam("_id") String _id, @NotNull Feed input) {
    Authorizations.verify(owner, auth);
    if (!isNullOrEmpty(input.category)) {
        RebaseAsserts.existCategory(input.category);
    }
    final Bson target = eq(Feed._ID, objectId(_id));
    MongoDBs.feeds().updateOne(target,
        combine(filterNotNull(
            optionalSet(Feed.TITLE, input.title),
            optionalSet(Feed.CONTENT, input.content),
            optionalSet(Feed.URL, input.url),
            optionalSet(Feed.CATEGORY, input.category),
            optionalSet(Feed.COVER_URL, input.coverUrl),
            currentDate(Feed.UPDATED_AT))
        )
    );
    Document feed = MongoDBs.feeds().find(target).first();
    RebaseAsserts.notNull(feed, "feed");
    return Response.ok(feed).build();
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
@GET @Path("{username}")
@Produces(MediaType.APPLICATION_JSON)
public Response authorize(
    @Username @PathParam("username") String username,
    @NotEmpty @QueryParam("password") String password) {

    Bson filter = and(eq(User.USERNAME, username), eq(User.PASSWORD, Hashes.sha1(password)));
    Document newAuth = Authorizations.newInstance(username);
    Document user = MongoDBs.users().findOneAndUpdate(filter, set(User.AUTHORIZATION, newAuth));
    if (user == null) {
        return Response.status(FORBIDDEN)
            .entity(new Failure("The username or password is incorrect"))
            .build();
    } else {
        return Response.ok(newAuth).build();
    }
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
/**
 * 校验激活码是否有效。如果激活码存在，并且设备 ID 没变，则返回原 License 对象。如果不存在，返回错误信息。
 * 如果存在，但设备变了，则根据 override 覆盖使用新的设备 ID。
 *
 * @param id 激活码 key
 * @param deviceId 设备 ID
 * @param override 是否覆盖设备 ID
 * @return 如果激活码有效，返回最新 License，否则返回错误
 */
@GET @Path("{_id}")
@Produces(MediaType.APPLICATION_JSON)
public Response verify(
    @PathParam("_id") String id,
    @QueryParam("device_id") String deviceId,
    @QueryParam("override") boolean override) {

    if (override && isEmpty(deviceId)) {
        return Responses.badRequest("device_id required");
    }
    Document license = MongoDBs.licenses().find(eq(License._ID, objectId(id))).first();
    RebaseAsserts.notNull(license, "license");
    if (override && !Objects.equals(deviceId, license.getString(License.DEVICE_ID))) {
        final Bson target = eq(License._ID, objectId(id));
        MongoDBs.licenses().updateOne(target, set(License.DEVICE_ID, deviceId));
        license.put(License.DEVICE_ID, deviceId);
    }
    return Response.ok(license).build();
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
private Bson getRangeBson(MatchOperation matchOperation , String attributeName){
	Object literalValue=null;
	Bson filter =null;
	if(matchOperation!=null){
		MatchAble rightExpression =matchOperation.getRightExpression();
		if(rightExpression instanceof Literal){
			literalValue = ((Literal)rightExpression).getLiteralValue();
		}else{
			Literal leftExpression =(Literal) matchOperation.getLeftExpression();
			literalValue = leftExpression.getLiteralValue();
		}
		MatchOperator matchOperator = matchOperation.getOperator();
		filter = MongoDbUtilities.getFilterBson(matchOperator, attributeName, literalValue);			
	}
	return filter;
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
@Override
public void concretProcessor(Object key, Map elemData, List<Bson> list) {

    if (null == key && null == elemData) {
        list.add(new BasicDBObject("$project",
                new BasicDBObject("_id", 0).append(DataStoreProtocol.RESULT, "$" + DataStoreProtocol.RESULT)));
    }
    else {
        Document filterBson = new Document();
        filterBson.append("_id", 0);
        String fileds = (String) elemData.get(DataStoreProtocol.FIELDS);
        if (!StringHelper.isEmpty(fileds)) {
            String[] filters = fileds.split(";");
            for (String filter : filters) {
                filterBson.append(filter, 1);
            }
        }

        list.add(new BasicDBObject("$project", filterBson));
    }
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
@Override
public Optional<T> peek() {
    final Bson peekQuery = QueryUtil.generatePeekQuery(defaultHeartbeatExpirationMillis);

    final Document update = new Document();
    update.put("heartbeat", new Date());
    update.put("status", OkraStatus.PROCESSING.name());

    final FindOneAndUpdateOptions options = new FindOneAndUpdateOptions();
    options.returnDocument(ReturnDocument.AFTER);

    final Document document = client
            .getDatabase(getDatabase())
            .getCollection(getCollection())
            .findOneAndUpdate(peekQuery, new Document("$set", update), options);

    if (document == null) {
        return Optional.empty();
    }

    return Optional.ofNullable(serializer.fromDocument(scheduleItemClass, document));
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
public static <T extends OkraItem> void ensureIndexes(final Okra<T> okra,
                                                      final MongoClient mongo,
                                                      final String database,
                                                      final String collection) {
    okra.getIndexDefs()
            .stream()
            .map(indexDef -> {
                final boolean ascending = indexDef.getOrdering() == null
                        || indexDef.getOrdering().equals(Ordering.ASC);

                final Bson ordering = ascending
                        ? Indexes.ascending(indexDef.getAttrs()) : Indexes.descending(indexDef.getAttrs());

                return mongo
                        .getDatabase(database)
                        .getCollection(collection)
                        .createIndex(ordering);
            })
            .forEach(indexName -> LOGGER.info("Done. Index name: {}", indexName));
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
/**
 * Get last statuses for particular environment and defined resources
 * @param environmentName environment to fetch statuses for
 * @param resourceIds resources to fetch statuses for
 * @return
 */
public List<ResourceStatus> find(String environmentName, Set<String> resourceIds) {
  Bson query = and(
      eq("environmentName", environmentName),
      in("resource.resourceId", resourceIds)
  );

  List<ResourceStatus> resources = thisCollection.find(query)
      .map(DocumentMapper::resourceStatusFromDocument)
      .into(new ArrayList<>());

  return resources;
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
/**
 * Given a query / ordering clause will convert it to Bson representation.
 */
public static Bson convertToBson(final Constraints.ConstraintHost fields) {
  if (fields instanceof JsonQuery) {
    return Document.parse(((JsonQuery) fields).value);
  }
  return fields.accept(new ConstraintBuilder("")).asDocument();
}
 

import org.bson.conversions.Bson; //导入依赖的package包/类
/**
 * 查询列表
 * 
 * @param collectionName
 *            表名
 * @param filter
 *            过滤条件
 * @param clazz
 *            类名
 * @param start
 *            开始条数
 * @param pageSize
 *            多少条
 * @return
 */
public static <T> List<T> find(String collectionName, Bson filter, Class<T> clazz, int start, int pageSize) {
	MongoCollection<Document> collection = getCollection(collectionName);
	try {
		MongoCursor<Document> iterator = null;
		if (pageSize == 0) {
			if (filter == null) {
				iterator = collection.find().iterator();
			} else {
				iterator = collection.find(filter).iterator();
			}
		} else {
			if (filter == null) {
				iterator = collection.find().skip(start).limit(pageSize).iterator();
			} else {
				iterator = collection.find(filter).skip(start).limit(pageSize).iterator();
			}
		}
		ArrayList<T> list = new ArrayList<>();
		while (iterator.hasNext()) {
			Document document = iterator.next();
			T obj = documentToObject(document, clazz);
			MongoObj mongoObj = (MongoObj) obj;
			mongoObj.setDocument(document);
			list.add(obj);
		}
		return list;
	} catch (Exception e) {
		if (log != null) {
			log.error("查询documentList失败", e);
		}
		return null;
	}
}