com.fasterxml.jackson.core.util.BufferRecycler#org.bson.BsonWriter源码实例Demo

@Override
protected void encodeStage(final BsonWriter writer, final Group group, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    GroupId id = group.getId();
    if (id != null) {
        writer.writeName("_id");
        if(id.getDocument() != null) {
            id.getDocument().encode(getMapper(), writer, encoderContext);
        } else {
            id.getField().encode(getMapper(), writer, encoderContext);
        }
    } else {
        writer.writeNull("_id");
    }

    Fields<Group> fields = group.getFields();
    if(fields != null) {
        fields.encode(getMapper(), writer, encoderContext);
    }

    writer.writeEndDocument();
}
 

@Override
public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writer.writeName(getOperation());
    writer.writeStartDocument();

    ExpressionCodec.writeNamedExpression(mapper, writer, "year", year, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "month", month, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "day", day, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "hour", hour, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "minute", minute, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "second", second, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "millisecond", millisecond, encoderContext);

    ExpressionCodec.writeNamedExpression(mapper, writer, "isoWeekYear", isoWeekYear, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "isoWeek", isoWeek, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "isoDayOfWeek", isoDayOfWeek, encoderContext);

    ExpressionCodec.writeNamedExpression(mapper, writer, "timezone", timezone, encoderContext);

    writer.writeEndDocument();
    writer.writeEndDocument();
}
 

@Override
protected void encodeStage(final BsonWriter writer, final GeoNear value, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writeNamedValue(writer, "near", value.getPoint(), encoderContext);
    writeNamedValue(writer, "near", value.getCoordinates(), encoderContext);
    writeNamedValue(writer, "key", value.getKey(), encoderContext);
    writeNamedValue(writer, "distanceField", value.getDistanceField(), encoderContext);
    writeNamedValue(writer, "spherical", value.getSpherical(), encoderContext);
    writeNamedValue(writer, "maxDistance", value.getMaxDistance(), encoderContext);
    writeNamedValue(writer, "minDistance", value.getMinDistance(), encoderContext);
    Filter[] filters = value.getFilters();
    if (filters != null) {
        writer.writeStartDocument("query");
        for (final Filter filter : filters) {
            filter.encode(getMapper(), writer, encoderContext);
        }
        writer.writeEndDocument();
    }
    writeNamedValue(writer, "distanceMultiplier", value.getDistanceMultiplier(), encoderContext);
    writeNamedValue(writer, "includeLocs", value.getIncludeLocs(), encoderContext);
    writer.writeEndDocument();
}
 

@Override
public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writer.writeStartDocument(getOperation());
    writer.writeStartArray("branches");
    for (final Pair branch : branches) {
        writer.writeStartDocument();
        writer.writeName("case");
        branch.caseExpression.encode(mapper, writer, encoderContext);
        writer.writeName("then");
        branch.then.encode(mapper, writer, encoderContext);
        writer.writeEndDocument();
    }
    writer.writeEndArray();
    writeNamedExpression(mapper, writer, "default", defaultCase, encoderContext);
    writer.writeEndDocument();
    writer.writeEndDocument();
}
 

@Override
public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext context) {
    writer.writeStartDocument(field(mapper));
    writer.writeStartDocument("$geoWithin");

    writer.writeStartArray(getFilterName());
    Point center = getValue();
    writer.writeStartArray();
    for (final Double value : center.getPosition().getValues()) {
        writer.writeDouble(value);
    }
    writer.writeEndArray();
    writer.writeDouble(radius);
    writer.writeEndArray();

    writer.writeEndDocument();
    writer.writeEndDocument();
}
 

@Override
protected void encodeStage(final BsonWriter writer, final CollectionStats value, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    if (value.getHistogram()) {
        writer.writeStartDocument("latencyStats");
        writer.writeBoolean("histograms", true);
        writer.writeEndDocument();
    }
    if (value.getScale() != null) {
        writer.writeStartDocument("storageStats");
        writer.writeInt32("scale", value.getScale());
        writer.writeEndDocument();
    }
    if (value.getCount()) {
        writer.writeStartDocument("count");
        writer.writeEndDocument();
    }
    writer.writeEndDocument();
}
 

/**
 * write with BSON read with jackson.
 * inverse of {@link #jacksonThenBson(String)}
 */
private void bsonThenJackson(String json) throws IOException {
  ObjectNode toWrite = maybeWrap(mapper.readTree(json));

  BasicOutputBuffer buffer = new BasicOutputBuffer();
  BsonWriter writer = new BsonBinaryWriter(buffer);

  // write with BSON
  BsonDocument expected = BsonDocument.parse(toWrite.toString());
  MongoClientSettings.getDefaultCodecRegistry().get(BsonDocument.class)
          .encode(writer, expected, EncoderContext.builder().build());

  BsonBinaryReader reader = new BsonBinaryReader(ByteBuffer.wrap(buffer.toByteArray()));
  IOContext ioContext = new IOContext(new BufferRecycler(), null, false);
  BsonParser parser = new BsonParser(ioContext, 0, reader);

  // read with jackson
  BsonDocument actual = BsonDocument.parse(mapper.readValue(parser, JsonNode.class).toString());

  if (!actual.equals(expected)) {
     check(maybeUnwrap(actual)).is(maybeUnwrap(expected));
     Assertions.fail("Should have failed before");
  }
}
 

/**
 * Read and Write in Jackson API but using BSON reader/writer adapters
 */
private void jacksonThenJackson(String json) throws IOException {
  ObjectNode expected = maybeWrap(mapper.readTree(json));

  BasicOutputBuffer buffer = new BasicOutputBuffer();
  BsonWriter writer = new BsonBinaryWriter(buffer);

  BsonGenerator generator = new BsonGenerator(0, writer);
  // write with Jackson
  mapper.writeValue(generator, expected);

  BsonBinaryReader reader = new BsonBinaryReader(ByteBuffer.wrap(buffer.toByteArray()));
  IOContext ioContext = new IOContext(new BufferRecycler(), null, false);
  BsonParser parser = new BsonParser(ioContext, 0, reader);

  // read with Jackson
  JsonNode actual = mapper.readValue(parser, JsonNode.class);
  check(actual).is(expected);
}
 

private <S> void encodeValue(final BsonWriter writer, final EncoderContext encoderContext, final FieldModel<S> model,
                             final S propertyValue) {
    if (model.shouldSerialize(propertyValue)) {
        writer.writeName(model.getMappedName());
        if (propertyValue == null) {
            writer.writeNull();
        } else {
            try {
                encoderContext.encodeWithChildContext(model.getCachedCodec(), writer, propertyValue);
            } catch (CodecConfigurationException e) {
                throw new CodecConfigurationException(String.format("Failed to encode '%s'. Encoding '%s' errored with: %s",
                    morphiaCodec.getEntityModel().getName(), model.getMappedName(), e.getMessage()), e);
            }
        }
    }
}
 

@Override
public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writer.writeName(getOperation());
    Codec codec = mapper.getCodecRegistry().get(getValue().getClass());
    encoderContext.encodeWithChildContext(codec, writer, getValue());
    writer.writeEndDocument();
}
 

/**
 * Matches documents that satisfy a JavaScript expression.
 *
 * @param val the value to check
 * @return the filter
 * @query.filter $where
 */
public static Filter where(final String val) {
    return new Filter("$where", null, val) {
        @Override
        public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext context) {
            writer.writeName(getFilterName());
            String value = getValue(mapper).toString().trim();
            if (!value.startsWith("function()")) {
                value = format("function() { %s }", value);
            }
            writer.writeString(value);
        }
    };
}
 

@Override
protected void encodeStage(final BsonWriter writer, final Facet value, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    for (final Entry<String, List<Stage>> entry : value.getFields().entrySet()) {
      writeNamedValue(writer, entry.getKey(), entry.getValue(), encoderContext);
    }
    writer.writeEndDocument();
}
 

/**
 * Matches documents that have the specified field.
 *
 * @param field the field to check
 * @return the filter
 * @query.filter $exists
 */
public static Filter exists(final String field) {
    return new Filter("$exists", field, null) {
        @Override
        public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext context) {
            writer.writeStartDocument(field(mapper));
            writer.writeName(getFilterName());
            writer.writeBoolean(!isNot());
            writer.writeEndDocument();
        }
    };
}
 

@Override
public void encode(BsonWriter writer, IamBean value, EncoderContext encoderContext) {
    writer.writeStartDocument();
    writer.writeString("message_id", value.getMessageId());
    writer.writeString("role_id", value.getRoleId());
    writer.writeEndDocument();
}
 

@Override
protected void encodeStage(final BsonWriter writer, final Bucket value, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writeNamedExpression(getMapper(), writer, "groupBy", value.getGroupBy(), encoderContext);
    writeNamedValue(writer, "boundaries", value.getBoundaries(), encoderContext);
    writeNamedValue(writer, "default", value.getDefaultValue(), encoderContext);
    DocumentExpression output = value.getOutput();
    if (output != null) {
        output.encode("output", getMapper(), writer, encoderContext);
    }
    writer.writeEndDocument();
}
 

@Override
protected void encodeStage(final BsonWriter writer, final ReplaceRoot replace, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writer.writeName("newRoot");
    if(replace.getValue() != null) {
        replace.getValue().encode(getMapper(), writer, encoderContext);
    } else {
        replace.getDocument().encode(getMapper(), writer, encoderContext);
    }
    writer.writeEndDocument();
}
 

@Override
protected void encodeStage(final BsonWriter writer, final Unwind value, final EncoderContext encoderContext) {
    if(!value.optionsPresent()) {
        value.getPath().encode(getMapper(), writer, encoderContext);
    } else {
        writer.writeStartDocument();
        writeNamedExpression(getMapper(), writer, "path", value.getPath(), encoderContext);
        writeNamedValue(writer, "includeArrayIndex", value.getIncludeArrayIndex(), encoderContext);
        writeNamedValue(writer, "preserveNullAndEmptyArrays", value.getPreserveNullAndEmptyArrays(), encoderContext);
        writer.writeEndDocument();
    }
}
 

public void encode(
    final BsonWriter writer,
    final CoreDocumentSynchronizationConfig value,
    final EncoderContext encoderContext
) {
  new BsonDocumentCodec().encode(writer, value.toBsonDocument(), encoderContext);
}
 

@Override
public void encode(final BsonWriter writer, final Collection<T> collection, final EncoderContext encoderContext) {
    writer.writeStartArray();
    for (final T value : collection) {
        if (value == null) {
            writer.writeNull();
        } else {
            codec.encode(writer, value, encoderContext);
        }
    }
    writer.writeEndArray();
}
 

@Override
public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writer.writeStartArray(getOperation());
    writeUnnamedExpression(mapper, writer, array, encoderContext);
    if (position != null) {
        writer.writeInt32(position);
    }
    writer.writeInt32(size);
    writer.writeEndArray();
    writer.writeEndDocument();
}
 

/**
 * @param mapper  the mapper
 * @param writer  the writer
 * @param context the context
 * @morphia.internal
 */
public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext context) {
    writer.writeStartDocument(field(mapper));
    if (not) {
        writer.writeStartDocument("$not");
    }
    writer.writeName(filterName);
    writeUnnamedValue(getValue(mapper), mapper, writer, context);
    if (not) {
        writer.writeEndDocument();
    }
    writer.writeEndDocument();
}
 

/**
 * Specifies equality condition. The $eq operator matches documents where the value of a field equals the specified value.
 *
 * @param field the field to check
 * @param val   the value to check
 * @return the filter
 * @query.filter $eq
 */
public static Filter eq(final String field, final Object val) {
    return new Filter("$eq", field, val) {
        @Override
        public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext context) {
            writer.writeName(field(mapper));
            writeUnnamedValue(getValue(mapper), mapper, writer, context);
        }
    };
}
 

@Override
public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writer.writeStartArray(getOperation());
    writer.writeInt32(start);
    writer.writeInt32(end);
    if (step != null) {
        writer.writeInt32(step);
    }
    writer.writeEndArray();
    writer.writeEndDocument();
}
 

@Override
protected void encodeStage(final BsonWriter writer, final CurrentOp value, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writeBoolean(writer, "allUsers", value.isAllUsers(), encoderContext);
    writeBoolean(writer, "idleConnections", value.isIdleConnections(), encoderContext);
    writeBoolean(writer, "idleCursors", value.isIdleCursors(), encoderContext);
    writeBoolean(writer, "idleSessions", value.isIdleSessions(), encoderContext);
    writeBoolean(writer, "localOps", value.isLocalOps(), encoderContext);
    writer.writeEndDocument();
}
 

@Override
public void encode(BsonWriter writer, T value, EncoderContext context) {
    if (value == null) {
        writer.writeNull();
    } else {
        writer.writeString(encodingMappings.get(value));
    }
}
 

@Override
@SuppressWarnings({"unchecked", "rawtypes"})
protected void encodeStage(final BsonWriter writer, final Match value, final EncoderContext encoderContext) {
    Filter[] filters = value.getFilters();
    writer.writeStartDocument();
    for (final Filter filter : filters) {
        filter.encode(getMapper(), writer, encoderContext);
    }
    writer.writeEndDocument();
}
 

@Override
public void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext encoderContext) {
    writer.writeStartDocument();
    writer.writeStartDocument(getOperation());
    ExpressionCodec.writeNamedExpression(mapper, writer, "input", array, encoderContext);
    ExpressionCodec.writeNamedExpression(mapper, writer, "cond", conditional, encoderContext);
    ExpressionCodec.writeNamedValue(mapper, writer, "as", as, encoderContext);
    writer.writeEndDocument();
    writer.writeEndDocument();
}
 

protected void writeInt64(BsonWriter writer, String name, Object value, EncoderContext ctx) {
  if (value instanceof JsonObject) {
    writeNumberLong(writer, name, value, ctx);
  } else {
    writer.writeInt64((long)value);
  }
}
 

@Override
public final void encode(final Mapper mapper, final BsonWriter writer, final EncoderContext context) {
    writer.writeStartDocument(field(mapper));
    writer.writeStartDocument(getFilterName());
    writer.writeName("$geometry");

    Object shape = getValue();
    Codec codec = mapper.getCodecRegistry().get(shape.getClass());
    codec.encode(writer, shape, context);

    writer.writeEndDocument();
    writer.writeEndDocument();
}
 

protected void writeArray(BsonWriter writer, String name, Object value, EncoderContext ctx) {
  @SuppressWarnings("unchecked")
  A array = (A) value;

  writer.writeStartArray();
  forEach(array, o -> writeValue(writer, null, o, ctx));
  writer.writeEndArray();
}