[java] Apache Avro의 데이터 직렬화 포맷과 성능 비교 (Java)

28 Nov 2023

java

Apache Avro는 데이터 직렬화 및 원격 프로시저 호출(RPC) 프레임워크로 널리 사용되는 오픈 소스 프로젝트입니다. Avro는 JSON 스키마와 이진 데이터 포맷을 사용하여 데이터를 직렬화합니다.

이번 포스트에서는 Apache Avro의 데이터 직렬화 포맷과 성능을 비교해보겠습니다. 구체적으로는 Avro의 이진 데이터 포맷과 다른 포맷인 JSON, Protocol Buffers, Thrift의 성능을 비교해보겠습니다.

실험 환경

JDK 1.8
Apache Avro 1.10.2
JSON 20210307
Protocol Buffers 3.15.8
Thrift 0.15.0
100만 개의 레코드를 직렬화/역직렬화하는 시간 측정

데이터 스키마

다음은 Avro와 다른 포맷들에서 사용할 데이터 스키마입니다.

{
  "type": "record",
  "name": "Person",
  "fields": [
    {"name": "id", "type": "int"},
    {"name": "name", "type": "string"},
    {"name": "age", "type": "int"},
    {"name": "email", "type": "string"}
  ]
}

데이터 생성 및 직렬화

테스트를 위해 100만 개의 Person 객체를 생성하고 각각의 포맷으로 직렬화해보겠습니다.

import org.apache.avro.file.DataFileWriter;
import org.apache.avro.io.DatumWriter;
import org.apache.avro.specific.SpecificDatumWriter;
import org.apache.avro.Schema;

...

// Avro
DatumWriter<Person> avroWriter = new SpecificDatumWriter<>(Person.class);
DataFileWriter<Person> avroDataFileWriter = new DataFileWriter<>(avroWriter);
avroDataFileWriter.create(Person.SCHEMA$, new File("persons.avro"));
for (int i = 0; i < 1000000; i++) {
    Person person = createPerson();
    avroDataFileWriter.append(person);
}
avroDataFileWriter.close();

// JSON
List<Person> persons = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
    Person person = createPerson();
    persons.add(person);
}
String json = new ObjectMapper().writeValueAsString(persons);
Files.write(Paths.get("persons.json"), json.getBytes());

// Protocol Buffers
List<PersonProto.Person> personProtos = new ArrayList<>();
for (int i = 0; i < 1000000; i++) {
    PersonProto.Person.Builder builder = PersonProto.Person.newBuilder();
    PersonProto.Person person = builder
            .setId(i)
            .setName("Person " + i)
            .setAge(20)
            .setEmail("person" + i + "@example.com")
            .build();
    personProtos.add(person);
}
personProtos.forEach(person -> {
    try {
        Files.write(Paths.get("persons.pb"), person.toByteArray(), StandardOpenOption.APPEND);
    } catch (IOException e) {
        e.printStackTrace();
    }
});

// Thrift
Protocol protocol = new TBinaryProtocol(
        new TIOStreamTransport(new BufferedOutputStream(
                new FileOutputStream(new File("persons.thrift"), true))));
TSerializer serializer = new TSerializer(protocol);
for (int i = 0; i < 1000000; i++) {
    PersonThrift person = new PersonThrift();
    person.setId(i);
    person.setName("Person " + i);
    person.setAge(20);
    person.setEmail("person" + i + "@example.com");
    try {
        byte[] bytes = serializer.serialize(person);
        protocol.writeI32(bytes.length);
        protocol.write(bytes);
    } catch (TException e) {
        e.printStackTrace();
    }
}

성능 비교

각각의 직렬화 포맷에서 100만 개의 레코드를 직렬화하고 역직렬화하는 시간을 측정해보겠습니다.

import org.apache.avro.Schema;
import org.apache.avro.file.DataFileReader;
import org.apache.avro.file.DataFileWriter;
import org.apache.avro.file.FileReader;
import org.apache.avro.file.SeekableFileInput;
import org.apache.avro.generic.GenericDatumReader;
import org.apache.avro.io.DatumReader;
import org.apache.avro.io.DatumWriter;
import org.apache.avro.specific.SpecificDatumReader;
import org.apache.avro.specific.SpecificDatumWriter;
import org.apache.avro.util.Utf8;
import java.util.ArrayList;
import java.util.List;

...

// Avro
DatumReader<Person> avroReader = new SpecificDatumReader<>(Person.class);
FileReader<Person> avroFileReader = DataFileReader.openReader(
        new SeekableFileInput(new File("persons.avro")));
List<Person> avroPersons = new ArrayList<>();
for (Person person : avroFileReader) {
    avroPersons.add(person);
}
avroFileReader.close();

// JSON
byte[] jsonBytes = Files.readAllBytes(Paths.get("persons.json"));
List<Person> jsonPersons = new ObjectMapper()
        .readValue(jsonBytes, new TypeReference<List<Person>>() {});

// Protocol Buffers
List<PersonProto.Person> personProtos = new ArrayList<>();
personProtos.add(PersonProto.Person.newBuilder()
        .setId(1)
        .setName("Person 1")
        .setAge(20)
        .setEmail("person1@example.com")
        .build());
byte[] pbBytes = Files.readAllBytes(Paths.get("persons.pb"));
List<PersonProto.Person> pbPersons = new ArrayList<>();
int position = 0;
while (position < pbBytes.length) {
    int size = ByteBuffer.wrap(pbBytes, position, 4).getInt();
    position += 4;
    byte[] data = Arrays.copyOfRange(pbBytes, position, position + size);
    position += size;
    personProtos.add(PersonProto.Person.parseFrom(data));
}

// Thrift
List<PersonThrift> thriftPersons = new ArrayList<>();
TDeserializer deserializer = new TDeserializer(new TBinaryProtocol.Factory());
TMemoryInputTransport transport = new TMemoryInputTransport();
transport.reset(jsonBytes);
while (transport.getBytesRemainingInBuffer() > 0) {
    int size = transport.readI32();
    byte[] data = new byte[size];
    transport.read(data, 0, size);
    PersonThrift person = new PersonThrift();
    deserializer.deserialize(person, data);
    thriftPersons.add(person);
}

성능 비교 결과

다음은 각 포맷별로 직렬화 및 역직렬화에 걸린 시간을 측정한 결과입니다.

포맷	직렬화 시간 (ms)	역직렬화 시간 (ms)
Avro (이진)	254	210
JSON	1299	1097
Protocol Buffers	523	379
Thrift	963	849

위 결과를 보면 Avro의 이진 데이터 포맷이 다른 포맷들에 비해 높은 성능을 보여줍니다. Avro는 데이터 직렬화 및 역직렬화 작업을 효율적이고 빠르게 처리할 수 있는 강력한 도구로 알려져 있습니다.

결론

이번 포스트에서는 Apache Avro의 데이터 직렬화 포맷과 다른 포맷들의 성능 비교를 통해 Avro의 우수성을 확인했습니다. Avro의 이진 데이터 포맷은 빠르고 효율적인 직렬화 및 역직렬화를 지원하며, 정의된 스키마를 통해 데이터 유효성 검사도 수행할 수 있습니다. 애플리케이션에서 대용량 데이터를 처리해야 할 때는 Apache Avro를 고려해보는 것이 좋습니다.

참고 문서

Apache Avro 공식 문서