Java BsonDocument.get方法代码示例

import org.bson.BsonDocument; //导入方法依赖的package包/类
@Test
    public void testPatchAppliedCleanly() throws Exception {
        for (int i = 0; i < jsonNode.size(); i++) {
        	BsonDocument node = jsonNode.get(i).asDocument();
        	
            BsonValue first = node.get("first");
            BsonValue second = node.get("second");
            BsonArray patch = node.getArray("patch");
            String message = node.containsKey("message") ? node.getString("message").getValue() : "";

//            System.out.println("Test # " + i);
//            System.out.println(first);
//            System.out.println(second);
//            System.out.println(patch);

            BsonValue secondPrime = BsonPatch.apply(patch, first);
//            System.out.println(secondPrime);
            Assert.assertThat(message, secondPrime, equalTo(second));
        }

    }
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
/**
 * Converts a binary uuid to a standard uuid
 *
 * @param json The json string (should contain "$binary" and "$type" or something like that)
 * @return The uuid
 */
private UUID convertBinaryUUID(String key, String json) {
    BsonDocument document = BsonDocument.parse(json);

    BsonValue value = document.get(key);
    if(!(value instanceof BsonBinary)) {
        return null;
    }
    byte[] bytes = ((BsonBinary) value).getData();
    ByteBuffer bb = ByteBuffer.wrap(bytes);
    bb.order(ByteOrder.LITTLE_ENDIAN);
    long l1 = bb.getLong();
    long l2 = bb.getLong();

    return new UUID(l1, l2);
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public <T> BsonValue toBson(Object value, Class<T> clazz) {
	if(value == null) {
		return new BsonNull();
	}
	if(value instanceof BsonValue) {
		return (BsonValue) value;
	}
	final Codec<T> codec = registry.get(clazz);
	final String key = "value";
	final BsonDocument document = new BsonDocument();
	final BsonWriter writer = new BsonDocumentWriter(document);
	writer.writeStartDocument();
	writer.writeName(key);
	codec.encode(writer, (T) value, EncoderContext.builder().build());
	writer.writeEndDocument();
	return document.get(key);
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
BsonValue toBson() {
  @SuppressWarnings("unchecked")
  Encoder<T> encoder = BsonEncoding.encoderFor((Class<T>) value.getClass(), adapter);
  BsonDocument bson = new BsonDocument();
  org.bson.BsonWriter writer = new BsonDocumentWriter(bson);
  // Bson doesn't allow to write directly scalars / primitives, they have to be embedded in a document.
  writer.writeStartDocument();
  writer.writeName("$");
  encoder.encode(writer, value, EncoderContext.builder().build());
  writer.writeEndDocument();
  writer.flush();
  return bson.get("$");
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
private void testOperation() throws Exception {
    BsonDocument node = p.getNode();

    BsonValue doc = node.get("node");
    BsonValue expected = node.get("expected");
    BsonArray patch = node.getArray("op");
    String message = node.containsKey("message") ? node.getString("message").getValue() : "";

    BsonValue result = BsonPatch.apply(patch, doc);
    String failMessage = "The following test failed: \n" +
         "message: " + message + '\n' +
         "at: " + p.getSourceFile();
    assertEquals(failMessage, expected, result);
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
private void testError() throws  ClassNotFoundException {
    BsonDocument node = p.getNode();
    BsonValue first = node.get("node");
    BsonArray patch = node.getArray("op");
    String message = node.containsKey("message") ? node.getString("message").getValue() : "";
    Class<?> type =
            node.containsKey("type") ? exceptionType(node.getString("type").getValue()) : BsonPatchApplicationException.class;

    try {
        BsonPatch.apply(patch, first);

        fail(errorMessage("Failure expected: " + message));
    } catch (Exception e) {
        if (matchOnErrors()) {
            StringWriter fullError = new StringWriter();
            e.printStackTrace(new PrintWriter(fullError));

            assertThat(
                    errorMessage("Operation failed but with wrong exception type", e),
                    e,
                    instanceOf(type));
            if (message != null) {
                assertThat(
                        errorMessage("Operation failed but with wrong message", e),
                        e.getMessage(),
                        containsString(message));    // equalTo would be better, but fail existing tests
            }
        }
    }
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
/**
 * 反序列化BsonDocument到POJO/decode BsonDocument->POJO
 *
 * @param bsonDocument
 * @param targetClazz
 * @param bsonMapperConfig
 * @param <T>
 * @return
 */
<T> T decode(BsonDocument bsonDocument, Class<T> targetClazz, BsonMapperConfig bsonMapperConfig) {
    MAPPER_LAYER_COUNTER.addCount(bsonMapperConfig);
    try {
        List<Field> allField = Utils.getAllField(targetClazz);
        T target = Utils.newInstanceByClazz(targetClazz);
        for (Field field : allField) {
            if (isIgnored(field)) {
                continue;
            }
            String bsonName = getBsonName(field);
            BsonValue bsonValue = bsonDocument.get(bsonName);
            if (bsonValue == null || bsonValue.isNull()) {
                continue;
            }
            Object javaValue;
            try {
                javaValue = getJavaValueFromBsonValue(bsonValue, field, bsonMapperConfig);
            } catch (BsonMapperConverterException e) {
                throw new BsonMapperConverterException("error when try to get java value from Bson.BsonName:" + bsonName, e);
            }
            setJavaValueToField(targetClazz, target, field, javaValue);
        }
        return target;
    } finally {
        MAPPER_LAYER_COUNTER.reduceCount();
    }
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
private Map<?, ?> toMap(BsonDocument document, PrimaryField fieldOpts) {
	final Map<Object, Object> map = new LinkedHashMap<>();
	final Pair<SecondaryField, SecondaryField> mapClass = getMapFields(fieldOpts);

	for(String bsonKey : document.keySet()) {
		final BsonValue bsonValue = document.get(bsonKey);
		final Object key = toMapKey(bsonKey, mapClass.getKey());
		final Object value = toMapValue(bsonValue, mapClass.getValue());
		map.put(key, value);
	}

	return map;
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
private <T> void handleField(BsonDocument document, BsonBuilder<T> builder, PrimaryField field) {
	final BsonValue fieldValue = document.get(field.getName());
	final Object parsedObj;
	if(fieldValue != null) {
		if(fieldValue.isObjectId()) {
			builder.append2LazyElements(field, fieldValue.asObjectId().getValue());
		}
		else {
			parsedObj = topParser.fromBson(fieldValue, field);
			builder.append2AdditionalFields(field.getRawField(), parsedObj);
		}
	}
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
protected final <T> BsonValue serializeWithCodec(Codec<T> codec, Object value) {
	checkArgument(codec != null, "Cannot find a valid codec to serialize: " + value);
	final BsonDocument document = new BsonDocument();
	final String name = "result";
	final BsonDocumentWriter writer = new BsonDocumentWriter(document);
	writer.writeStartDocument();
	writer.writeName(name);
	codec.encode(writer, (T) value, EncoderContext.builder().build());
	writer.writeEndDocument();
	return document.get(name);
}
 

import org.bson.BsonDocument; //导入方法依赖的package包/类
private BsonValue getFromDocument(BsonDocument document, String field) {
	final BsonValue value = document.get(field);
	return value == null ? new BsonNull() : value;
}