@Deprecated static Schema<GenericRecord> AUTO() { return AUTO_CONSUME(); }
/** * Check if the message is a valid object for this schema. * * <p>The implementation can choose what its most efficient approach to validate the schema. * If the implementation doesn't provide it, it will attempt to use {@link #decode(byte[])} * to see if this schema can decode this message or not as a validation mechanism to verify * the bytes. * * @param message the messages to verify * @return true if it is a valid message * @throws SchemaSerializationException if it is not a valid message */ default void validate(byte[] message) { decode(message); }
public void setSchema(Schema<T> schema) { this.schema = schema; this.requireSchemaValidation = schema.getSchemaInfo() != null && SchemaType.BYTES != schema.getSchemaInfo().getType() && SchemaType.NONE != schema.getSchemaInfo().getType(); }
public static String getJsonSchemaInfo(Class clazz) { return new String(Schema.JSON(clazz).getSchemaInfo().getSchema(), StandardCharsets.UTF_8); }
public static String getAvroSchemaInfo(Class clazz) { return new String(Schema.AVRO(clazz).getSchemaInfo().getSchema(), StandardCharsets.UTF_8); }
@Override public void validate(byte[] message) { ensureSchemaInitialized(); schema.validate(message); }
@Override public TypedMessageBuilder<T> value(T value) { checkArgument(value != null, "Need Non-Null content value"); this.content = ByteBuffer.wrap(schema.encode(value)); return this; }
.thenCompose(schemaInfoOptional -> { if (schemaInfoOptional.isPresent()) { autoProduceBytesSchema.setSchema(Schema.getSchema(schemaInfoOptional.get())); } else { autoProduceBytesSchema.setSchema(Schema.BYTES);
@Override public void validate(byte[] message) { ensureSchemaInitialized(); schema.validate(message); }
@Override public byte[] encode(GenericRecord message) { ensureSchemaInitialized(); return schema.encode(message); }
.thenCompose(schemaInfoOptional -> { if (schemaInfoOptional.isPresent()) { autoProduceBytesSchema.setSchema(Schema.getSchema(schemaInfoOptional.get())); } else { autoProduceBytesSchema.setSchema(Schema.BYTES);
@Override public SchemaInfo getSchemaInfo() { ensureSchemaInitialized(); return schema.getSchemaInfo(); } }
public KeyValue<K, V> decode(byte[] bytes) { ByteBuffer byteBuffer = ByteBuffer.wrap(bytes); int keyLength = byteBuffer.getInt(); byte[] keyBytes = new byte[keyLength]; byteBuffer.get(keyBytes); int valueLength = byteBuffer.getInt(); byte[] valueBytes = new byte[valueLength]; byteBuffer.get(valueBytes); return new KeyValue<>(keySchema.decode(keyBytes), valueSchema.decode(valueBytes)); }
@Deprecated static Schema<GenericRecord> AUTO() { return AUTO_CONSUME(); }
@Override public byte[] encode(byte[] message) { ensureSchemaInitialized(); if (requireSchemaValidation) { // verify if the message can be decoded by the underlying schema schema.validate(message); } return message; }
public byte[] encode(KeyValue<K, V> message) { byte[] keyBytes = keySchema.encode(message.getKey()); byte[] valueBytes = valueSchema.encode(message.getValue()); ByteBuffer byteBuffer = ByteBuffer.allocate(4 + keyBytes.length + 4 + valueBytes.length); byteBuffer.putInt(keyBytes.length).put(keyBytes).putInt(valueBytes.length).put(valueBytes); return byteBuffer.array(); }
@Override public SchemaInfo getSchemaInfo() { ensureSchemaInitialized(); return schema.getSchemaInfo(); }
@Override public byte[] decode(byte[] bytes) { ensureSchemaInitialized(); if (requireSchemaValidation) { // verify the message can be detected by the underlying schema schema.decode(bytes); } return bytes; }
@SuppressWarnings("unchecked") private static <T> Schema<T> newSchemaInstance(Class<T> clazz, SchemaType type) { switch (type) { case NONE: return (Schema<T>) Schema.BYTES; case AUTO_CONSUME: case AUTO: return (Schema<T>) Schema.AUTO_CONSUME(); case STRING: return (Schema<T>) Schema.STRING; case AVRO: return AvroSchema.of(clazz); case JSON: return JSONSchema.of(clazz); case PROTOBUF: return ProtobufSchema.ofGenericClass(clazz, Collections.emptyMap()); default: throw new RuntimeException("Unsupported schema type" + type); } }
@Override public byte[] encode(byte[] message) { ensureSchemaInitialized(); if (requireSchemaValidation) { // verify if the message can be decoded by the underlying schema schema.validate(message); } return message; }