Java Codec类代码示例

import org.bson.codecs.Codec; //导入依赖的package包/类
/**
 * Testing if List<String> can be decoded into a
 */
@Test
public void testResilience() {

    Codec<EncodingPojo> encodingPojoCodec = codecRegistry.get(EncodingPojo.class);
    Codec<DecodingPojo> decodingPojoCodec = codecRegistry.get(DecodingPojo.class);

    EncodingPojo encodingPojo = new EncodingPojo();
    encodingPojo.someList = new ArrayList<>();
    encodingPojo.someList.add("string1");
    encodingPojo.someList.add("string2");
    encodingPojo.someList.add("string3");


    StringWriter stringWriter = new StringWriter();
    JsonWriter writer = new JsonWriter(stringWriter, new JsonWriterSettings(true));
    encodingPojoCodec.encode(writer, encodingPojo, EncoderContext.builder().build());
    System.out.println(stringWriter.toString());

    DecodingPojo decodingPojo = decodingPojoCodec.decode(new JsonReader(stringWriter.toString()), DecoderContext.builder().build());
    Assert.assertNotNull(decodingPojo.someList);
    assertThat(decodingPojo.someList, instanceOf(ListOfStrings.class));
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
/**
 * "Smart" registry just for this particular {@code type}. It is typically composed with existing
 * registries using {@link org.bson.codecs.configuration.CodecRegistries#fromRegistries(CodecRegistry...)} method.
 */
public static <T> CodecRegistry registryFor(final Class<T> type, final TypeAdapter<T> adapter) {
  return new CodecRegistry() {
    @SuppressWarnings("unchecked")
    @Override
    public <X> Codec<X> get(Class<X> clazz) {
      // TODO is this a safe assumption with polymorphism (in repositories) ?
      if (type.isAssignableFrom(clazz)) {
        return (Codec<X>) codecFor(type, adapter);
      } else {
        // let other registries decide
        throw new CodecConfigurationException(String.format("Type %s not supported by this registry", type.getName()));
      }
    }
  };
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <T> Codec<T> get(Class<T> clazz, CodecRegistry registry) {
	if (clazz == BigDecimal.class) {
		return (Codec<T>) bigDecimalCodec;
	}
	if (clazz == BigInteger.class) {
		return (Codec<T>) bigIntegerCodec;
	}
	if (clazz == InetAddress.class || clazz == Inet4Address.class || clazz == Inet6Address.class) {
		return (Codec<T>) inetAddressCodec;
	}
	if (clazz.isArray()) {
		return (Codec<T>) arrayCodec;
	}
	return null;
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
@Override
public <T> Codec<T> get(Class<T> clazz, CodecRegistry registry) {
    // if clazz has type parameters, we warn the user that generic class definitions are problematic
    Codec<T> codec = pojoContext.get(clazz, registry);
    if (codec instanceof TypeCodec) {
        if (clazz != null && clazz.getTypeParameters().length > 0) {
            LOGGER.warn("Generic classes will only be encoded/decoded with their upper bounds! " +
                    "We could prohibit handling of the pojo codec for those generic classes, " +
                    "but then user would loose flexibility when subclassing such classes. Class: " + clazz.toGenericString());
        }
        TypeCodec typeCodec = (TypeCodec) codec;
        // generate dynamic proxy to add CollectibleCodec functionality
        if (typeCodec.isCollectible()) {
            LOGGER.debug("Enhancing {} to be collectible codec.", typeCodec);
            Class[] proxyInterfaces = new Class[]{CollectibleCodec.class};
            CollectibleCodec collectibleCodec = (CollectibleCodec) Proxy.newProxyInstance(
                    PojoCodecProvider.class.getClassLoader(),
                    proxyInterfaces,
                    new CollectibleCodecDelegator(typeCodec));

            return collectibleCodec;
        }
    }
    return codec;
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
/**
 * Calculates and returns a codec for the given type, null otherwise
 *
 * @param type              type for which a codec is requested
 * @param typeCodecRegistry codec registry that can handle any type including parameterizd types, generic arrays, etc
 * @param <T>               the value type
 * @return the codec responsible for the given type or null
 */
public synchronized <T> Codec<T> getCodec(Type type, TypeCodecRegistry typeCodecRegistry) {
    Codec codec = codecMap.get(type);
    if (codec != null) {
        return codec;
    }

    // we register within codecMap as LazyCodec for recursion detection
    LazyCodec lazyCodec = new LazyCodec(type, typeCodecRegistry);
    codecMap.put(type, lazyCodec);

    // calculate the codec for given type
    codec = calculateCodec(type, typeCodecRegistry);
    if (codec == null) {
        codecMap.remove(type);
    } else {
        codecMap.put(type, codec);
    }

    return codec;
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
@Test
public void reorderingDocumentTest() {
    Document document = new Document();
    document.stringProperty = "a nice string";
    document.datProperty = new Date();

    MongoCollection<Document> documentMongoCollection = mongoClient.getDatabase("test").getCollection("documents").withDocumentClass(Document.class);

    documentMongoCollection.insertOne(document);

    Document readDocument = documentMongoCollection.find(Filters.eq("_id", document.getMeta().getId())).first();

    Assert.assertEquals(document, readDocument);

    Codec<Document> documentCodec = codecRegistry.get(Document.class);
    StringWriter stringWriter = new StringWriter();
    JsonWriter writer = new JsonWriter(stringWriter, new JsonWriterSettings(true));
    documentCodec.encode(writer, document, EncoderContext.builder().build());
    LOGGER.info("The encoded json looks like: {}", stringWriter);

}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
@Test
public void basicTest() {
    BasePojo basePojo = new BasePojo();
    basePojo.aString = STRING;

    Codec<BasePojo> primitivePojoCodec = codecRegistry.get(BasePojo.class);

    StringWriter stringWriter = new StringWriter();
    JsonWriter writer = new JsonWriter(stringWriter, new JsonWriterSettings(true));
    primitivePojoCodec.encode(writer, basePojo, EncoderContext.builder().build());
    LOGGER.info("The encoded json looks like: {}", stringWriter);

    BasePojo readBasePojo = primitivePojoCodec.decode(new JsonReader(stringWriter.toString()), DecoderContext.builder().build());
    // assert that the modified version was actually written to the database
    Assert.assertEquals(basePojo, readBasePojo);
    Assert.assertEquals(MODIFIED_STRING, readBasePojo.aString);
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
@Test
public void testEnums() {
    Codec<Pojo> pojoCodec = codecRegistry.get(Pojo.class);

    LovelyDisplayable lovelyDisplayable = LovelyDisplayable.builder().identityProperty("foo").build();

    Pojo pojo = Pojo.builder()
            .simpleEnumProperty(EnumA.TYPE1)
            .displayable(Arrays.asList(EnumB.TYPE1, EnumA.TYPE1, EnumA.TYPE3, lovelyDisplayable))
            .build();

    StringWriter stringWriter = new StringWriter();
    JsonWriter writer = new JsonWriter(stringWriter, new JsonWriterSettings(true));
    pojoCodec.encode(writer, pojo, EncoderContext.builder().build());
    System.out.println(stringWriter.toString());

    Pojo decodedPojo = pojoCodec.decode(new JsonReader(stringWriter.toString()), DecoderContext.builder().build());

    MatcherAssert.assertThat(decodedPojo.getDisplayable(),
            IsIterableContainingInOrder.contains(EnumB.TYPE1, EnumA.TYPE1, EnumA.TYPE3, lovelyDisplayable));

}
 

import org.bson.codecs.Codec; //导入依赖的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.codecs.Codec; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public <T> Codec<T> get(Class<T> clazz, CodecRegistry registry) {
    // Optimistic get to avoid using dynamic memory
    Codec<?> ret = codecs.get(clazz);
    if (ret != null) {
        return (Codec<T>) ret;
    }
    if (clazz.isEnum()) {
        return (Codec<T>) codecs.computeIfAbsent(clazz, c -> new EnumCodec<>((Class<? extends Enum>) c));
    }
    if (clazz.isArray()) {
        Class<?> componentType = clazz.getComponentType();
        Codec componentCodec = get(componentType, registry);
        if (componentCodec != null) {
            return (Codec<T>) codecs.computeIfAbsent(clazz, c -> new ArrayCodec(clazz, componentCodec));
        }
    }
    return registry.get(clazz);
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
private CodecRegistry buildCodecRegistries() {
	Codec<Document> defaultDocumentCodec = MongoClient.getDefaultCodecRegistry().get(Document.class);
	
	CodecRegistry codecRegistry = CodecRegistries.fromRegistries(
		MongoClient.getDefaultCodecRegistry(),
		CodecRegistries.fromCodecs(
			new BibleCodec(defaultDocumentCodec),
			new BookCodec(defaultDocumentCodec),
			new ChapterCodec(defaultDocumentCodec),
			new VerseCodec(defaultDocumentCodec),
			new UserCodec(defaultDocumentCodec)
		)
	);
	
	return codecRegistry;
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
/**
 * To be used if and only if it belongs to {@link java.util} package
 * @param writer
 * @param coll
 * @param encoderContext
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
protected void encode(BsonWriter writer, Collection<?> coll, EncoderContext encoderContext) {
	writer.writeStartArray();
	Iterator<?> iterator = coll.iterator();
	while(iterator.hasNext()) {
		Object next = iterator.next();
		if (next == null) {
			writer.writeNull();
		} else {
			Codec codec = registry.get(next.getClass());
			encoderContext.encodeWithChildContext(codec, writer, next);
		}
	}
	writer.writeEndArray();
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
@Override
public void encode(BsonWriter writer, List value, EncoderContext encoderContext) {
	if (value != null && !value.isEmpty()) {
		writer.writeStartArray();
		for (Object a : value) {
			if (a != null) {
				Codec codec = this.codecRegistry.get(a.getClass());
				encoderContext.encodeWithChildContext(codec, writer, a);
			}
			else {
				writer.writeNull();
			}
		}
		writer.writeEndArray();
	}
	else {
		writer.writeNull();
	}
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
@SuppressWarnings("resource")
protected <T> void writeReadCompare(T source, Codec<T> codec) {
	BasicOutputBuffer bsonOutput = new BasicOutputBuffer();
	BsonBinaryWriter writer = new BsonBinaryWriter(bsonOutput);
	writer.writeStartDocument();
	writer.writeName("name");
	codec.encode(writer, source, EncoderContext.builder().build());
	writer.writeEndDocument();
	writer.close();

	BsonBinaryReader reader = new BsonBinaryReader(
			ByteBuffer.wrap(bsonOutput.toByteArray()));
	reader.readStartDocument();
	assertThat(reader.readName()).isEqualTo("name");
	T readNow = codec.decode(reader, DecoderContext.builder().build());

	assertThat(readNow).isEqualTo(source);
}
 

import org.bson.codecs.Codec; //导入依赖的package包/类
@Test
public void testCodec() throws IOException {
    Codec<DefaultDomain> codec = DefaultDomainCodec.INSTANCE;
    DefaultDomain domain = new DefaultDomain();
    domain.addPlayer(UUID.randomUUID());
    domain.addGroup("test_group");

    DefaultDomain other;
    try (StringWriter sw = new StringWriter()) {
        codec.encode(new JsonWriter(sw), domain, EncoderContext.builder().build());
        other = codec.decode(new JsonReader(sw.toString()), DecoderContext.builder().build());
    }

    Assert.assertEquals(domain.getPlayers(), other.getPlayers());
    Assert.assertEquals(domain.getUniqueIds(), other.getUniqueIds());
    Assert.assertEquals(domain.getGroups(), other.getGroups());
}