본문으로 건너뛰기
Folly Code Review · 49/89

folly::dynamic — JSON-like dynamic type 분석

· Hawk · 4분 읽기
cpp folly dynamic json type

#한 줄 요약

folly::dynamic은 JSON과 1

대응되는 동적 타입 컨테이너다. null, bool, int, double, string, array, object 여섯 가지를 한 타입에 담는다. std::any나 std::variant와는 목적이 다르다 — JSON serialization과 schema-less 데이터를 직접 다루는 것이 출발점이다.

#동기 — std::any로는 부족하다

C++에서 “타입을 모르는 값을 담는 통”이 필요할 때 std는 세 가지를 제공한다.

  • std::any: 어떤 타입이든. 그러나 꺼낼 때 타입을 정확히 알아야 한다(any_cast<T>).
  • std::variant<Ts...>: 미리 정해진 타입 집합 중 하나.
  • std::optional<T>: T 또는 없음.

JSON 데이터를 다룰 때 셋 다 어색하다.

  • any는 동적 검색이 불가능 — obj["user"]["name"] 같은 path 접근을 못 함.
  • variant는 타입 집합을 미리 정해야 함 — JSON의 6가지 타입을 매번 variant로 적기 번거롭다.
  • recursive 정의(JSON array가 또 JSON object를 담음) 표현이 까다롭다.

folly::dynamic은 이 6가지 타입을 hard-code하고, operator[], at, keys 같은 path 접근 API를 직접 제공한다.

#API

#include <folly/dynamic.h>


// 생성
folly::dynamic obj = folly::dynamic::object;
obj["name"] = "Alice";
obj["age"] = 30;
obj["scores"] = folly::dynamic::array(95, 87, 92);
obj["address"] = folly::dynamic::object("city", "Seoul");


// 접근
auto name = obj["name"].asString();    // "Alice"
auto age  = obj["age"].asInt();        // 30
auto firstScore = obj["scores"][0].asInt();  // 95


// 타입 검사
if (obj["age"].isInt()) {
  // ...
}


// 순회
for (auto& [k, v] : obj.items()) {
  LOG(INFO) << k << " = " << v;
}


// JSON 변환
auto json = folly::toJson(obj);
auto parsed = folly::parseJson(json);

CamelCase의 obj["scores"]가 array를, obj["address"]가 object를 가지면서도 type erasure 비용은 한 번의 enum check다.

#내부 구현

class dynamic {
  enum Type : uint8_t {
    NULLT, BOOL, INT64, DOUBLE, STRING, ARRAY, OBJECT
  };


  Type type_;
  union Data {
    bool b;
    int64_t i;
    double d;
    std::string s;
    std::vector<dynamic> arr;
    folly::F14NodeMap<dynamic, dynamic> obj;
  } u_;
};

핵심은 tagged union이다.

  • type_이 현재 어느 variant인지 명시.
  • u_에 실제 데이터.
  • string, array, object는 heap에 보관(union 안에서 placement-new).

object의 키도 dynamic이다. 즉 키가 string뿐 아니라 int, bool 등도 가능하다(JSON spec엔 안 맞지만 in-memory에선 허용).

#생성/소멸

union 내부는 trivial 타입이 아닌 게 있으므로(string, vector, map), copy/move/destroy를 type_에 따라 분기해야 한다.

dynamic(const dynamic& other) : type_(other.type_) {
  switch (type_) {
    case STRING: new (&u_.s) std::string(other.u_.s); break;
    case ARRAY:  new (&u_.arr) std::vector<dynamic>(other.u_.arr); break;
    case OBJECT: new (&u_.obj) F14NodeMap<dynamic,dynamic>(other.u_.obj); break;
    default: u_ = other.u_;
  }
}


~dynamic() {
  switch (type_) {
    case STRING: u_.s.~basic_string(); break;
    case ARRAY:  u_.arr.~vector(); break;
    case OBJECT: u_.obj.~F14NodeMap(); break;
    default: break;
  }
}

std::variant와 비슷한 패턴이지만 타입 집합이 fixed라서 더 간결하다.

#std / abseil 비교

타입목적동적 접근JSON 변환
std::anytype-erase 단일 값xx
std::variant<Ts...>미리 정한 타입 집합visitor 필요x
nlohmann::jsonJSON 데이터 모델oo
folly::dynamicJSON 데이터 모델oo
absl::Cord큰 string fragmentxx

folly::dynamic의 자리는 nlohmann::json과 같다. 둘은 거의 1

호환 사용처이고, Folly는 jemalloc·F14·SmallVector 같은 Folly 생태계와의 통합이 더 자연스럽다는 게 차별점이다.

#코드 리뷰 포인트

#1. asInt vs getInt

obj["age"].asInt();  // 변환 가능하면 변환 (string "30" → 30)
obj["age"].getInt(); // 정확히 INT64 타입일 때만, 아니면 throw

as*는 coercion을 시도한다(string → number 등). get*은 strict.

PR 리뷰에서 의도를 명확히. 외부 JSON 파싱이라면 as*가 관대해서 편하지만 silent type drift를 만들 수 있다. 내부 계산이라면 get*이 안전.

#2. operator[] 부작용

folly::dynamic obj = folly::dynamic::object;
auto x = obj["missing"]; // missing 키를 nullptr로 *생성*함

object에 operator[]로 접근하면 키가 없으면 자동 생성된다. read-only 접근이 의도라면 at 또는 getDefault 사용.

// Good
if (obj.count("missing")) {
  auto v = obj["missing"];
}
auto v = obj.getDefault("missing", folly::dynamic());

#3. dynamic을 함수 인자로 const&

// 회피
void process(folly::dynamic d); // 매번 deep copy (object/array는 비쌈)


// Good
void process(const folly::dynamic& d);

dynamic은 object/array에서 무거운 deep copy를 한다. 항상 reference 또는 move로 전달.

#4. 키가 정말 string이면 string으로 명시

// 회피
obj[42] = "value"; // 키가 int (in-memory만 가능, JSON 변환 시 string화)


// Good
obj["42"] = "value";

JSON spec은 object 키가 string이다. int 키는 toJson 시 string 변환이 강제되고, 외부 시스템과의 호환에 혼선을 부른다.

#안티패턴

#1. 모든 데이터를 dynamic으로

// 회피 — 내부 데이터까지 dynamic
folly::dynamic User; // type-safe struct가 더 나음

dynamic은 외부 boundary(JSON parsing, RPC payload)에서만 사용. 내부 데이터는 struct로 변환해 type safety를 확보한다. 다음 절(part 11-03)에서 변환 패턴.

#2. 깊은 path 접근에서 throw 누락

// 회피
auto city = obj["user"]["address"]["city"].asString();
// user나 address가 없으면 그 단계에서 throw

외부 JSON이면 각 단계에서 키 존재 여부를 확인하거나 try/catch로 감싼다.

#3. dynamic을 hashmap의 키로

// 회피
folly::F14FastMap<folly::dynamic, int> m;

dynamic은 hash를 지원하지만 비교 비용이 비싸고 의미가 불분명. string 또는 정확한 struct 키 사용.

#정리

  • folly::dynamic은 JSON 6가지 타입을 담는 tagged union이다.
  • std::any/variant와 달리 path 접근 API와 JSON 변환을 직접 제공.
  • 내부적으로 union + enum tag. string/array/object는 heap.
  • asInt(coercion) vs getInt(strict) 구분.
  • operator[]로 read하면 missing 키가 자동 생성됨에 주의.
  • 외부 boundary에서만 사용, 내부는 struct로 변환.

#다음 편

Part 11-02 JSON conversion — toJson/parseJson. parse 옵션과 성능 특성을 본다.

#관련 항목

Folly Code Review · 50 of 89

  1. 1 Folly Code Review — Meta의 production-grade C++ 라이브러리 코드 분석
  2. 2 Folly 개요 — Meta가 production에서 검증한 utility 모음 분석
  3. 3 Folly vs Abseil 철학 비교 — performance-first vs std-compatible
  4. 4 Folly 빌드와 fbcode 환경 — monorepo의 그림자
  5. 5 Folly API stability 정책 — 어떤 보장도 없다는 솔직함
  6. 6 Folly production validation 문화 — peta-scale에서 단련된 코드
  7. 7 folly::Future 분석 — std::future의 한계를 넘는 composable async
  8. 8 folly::Promise·makeFuture — Future를 만드는 두 길
  9. 9 folly::SemiFuture vs Future — executor binding의 명시화
  10. 10 folly::Future thenValue·thenError·thenTry — continuation 체인 분석
  11. 11 folly::collect·collectAll·collectAny — fan-in 패턴 분석
  12. 12 folly::Future retry·window·via — 제어 흐름 조합자
  13. 13 folly::fibers 분석 — M:N stackful coroutine
  14. 14 folly::InlineExecutor — 호출자 thread에서 즉시 실행
  15. 15 folly::CPUThreadPoolExecutor — CPU-bound 작업의 표준 thread pool
  16. 16 folly::IOThreadPoolExecutor — libevent 기반 I/O pool
  17. 17 folly::ManualExecutor — 결정적 테스트를 위한 수동 진행
  18. 18 folly::EventBase 분석 — libevent 이벤트 루프의 핵심
  19. 19 folly::IOBuf 분석 — zero-copy buffer chain의 기본 단위
  20. 20 folly::IOBufQueue — chain의 push/pull 추상화
  21. 21 folly::io::Cursor·RWCursor — chain 위의 stream
  22. 22 folly Zero-copy 패턴 — IOBuf로 ScatterGather I/O 표현
  23. 23 folly::IOBuf shared semantics — clone·unshare·takeOwnership
  24. 24 folly::FBString 분석 — SSO + COW 구현
  25. 25 folly의 fmt::format 통합 — 모던 포맷팅 채택
  26. 26 folly::StringPiece — string_view 호환 분석
  27. 27 folly Join·Split utilities — 문자열 분해와 결합
  28. 28 folly::to·tryTo — text↔num 변환 분석
  29. 29 folly Conv Customization — 사용자 타입 지원
  30. 30 folly Conv 성능 비교 — sprintf·stringstream 대비
  31. 31 folly::F14ValueMap vs std::unordered_map
  32. 32 folly::F14NodeMap — stable pointer가 필요할 때
  33. 33 folly::F14VectorMap — cache-friendly iteration
  34. 34 folly::F14FastMap — auto-select 동작
  35. 35 folly F14 internals — SIMD probing 메커니즘
  36. 36 folly::small_vector — inline storage 분석
  37. 37 folly::FixedString — compile-time string
  38. 38 folly::AtomicHashMap — lock-free read 분석
  39. 39 folly::ConcurrentHashMap — sharded 동시 해시 맵
  40. 40 folly::EvictingCacheMap — LRU 구현 분석
  41. 41 folly::Synchronized — lock wrapper 패턴
  42. 42 folly::SharedMutex 분석
  43. 43 folly::Baton — one-shot wait 동기화
  44. 44 folly::RWSpinLock 분석
  45. 45 folly::PicoSpinLock — 1-byte spinlock
  46. 46 folly::ProducerConsumerQueue — SPSC 큐 분석
  47. 47 folly::MPMCQueue — multi-producer multi-consumer
  48. 48 folly::UnboundedQueue — 동적 크기 lock-free
  49. 49 folly::fibers::Channel — Go-like channel
  50. 50 folly::dynamic — JSON-like dynamic type 분석
  51. 51 folly JSON conversion — toJson·parseJson
  52. 52 folly dynamic ↔ struct — manual marshaling
  53. 53 folly dynamic Visitor pattern — type별 분기
  54. 54 folly::Singleton vs Meyers/static — 왜 Folly의 Singleton인가
  55. 55 folly::SingletonVault 분석 — 등록·소멸·의존성
  56. 56 folly::Singleton try_get·try_get_fast — TLS-cached 접근
  57. 57 folly::ExceptionWrapper — type-erased exception holder
  58. 58 folly::ScopeGuard·SCOPE_EXIT — RAII cleanup
  59. 59 folly::Optional vs std::optional
  60. 60 folly::Function vs std::function
  61. 61 folly::Lazy — 지연 초기화 wrapper
  62. 62 folly Meta 스타일 code review 패턴
  63. 63 folly anti-patterns — 잘못 쓰면 std보다 느림
  64. 64 folly vs std 선택 기준 분석
  65. 65 folly::coro 개요 — production C++20 코루틴 어댑터
  66. 66 folly::coro::Task — lazy single-shot 코루틴
  67. 67 folly::coro::AsyncGenerator — 비동기 스트림
  68. 68 folly coro blockingWait·collectAll — 동기 경계와 fan-in
  69. 69 folly::coro::Baton·Mutex — 코루틴-aware 동기화
  70. 70 folly::Expected — 결과 또는 오류
  71. 71 folly::Try — Future 결과 wrapper
  72. 72 folly::Try vs Expected 선택 기준
  73. 73 folly::Range — 일반 iterator pair
  74. 74 folly::Uri — URL 파서
  75. 75 folly Fingerprint64·128 — 분산 hash
  76. 76 folly SpookyHashV2 — fast non-crypto hash
  77. 77 folly::Init — main() 부트스트랩
  78. 78 folly::Indestructible — global lifetime 패턴
  79. 79 folly::MicroLock — 1-byte 락
  80. 80 folly::MicroSpinLock — 가장 좁은 spin lock
  81. 81 folly::format — legacy formatter 분석
  82. 82 folly::demangle — typeid 디망글링
  83. 83 folly::DynamicConverter — dynamic ↔ struct
  84. 84 folly::RecordIO — append-only 로그 파일 포맷
  85. 85 folly::io::Compression — zstd·lz4·snappy wrapper
  86. 86 folly::AsyncIO — io_uring·Linux AIO
  87. 87 folly::CancellationToken — 코루틴·Future 취소 전파
  88. 88 folly::observer — hot config의 atomic refresh
  89. 89 fbcode 패턴 모음 — folly 사용의 실전

관련 글

folly::DynamicConverter — dynamic ↔ struct

DynamicConverter의 역할 — folly::dynamic과 user struct 사이 boilerplate 없는 양방향 변환.

· cpp

같은 시리즈에서 이어 읽기

folly JSON conversion — toJson·parseJson

Part 11-02: toJson / parseJson — folly::dynamic ↔ JSON 문자열. parse 옵션, 성능, schema-less 처리.

· cpp

같은 시리즈에서 이어 읽기

folly dynamic Visitor pattern — type별 분기

Part 11-04: dynamic을 type별로 처리하는 visitor 패턴. std::visit-like helper로 switch boilerplate를 줄인다.

· cpp

같은 시리즈에서 이어 읽기

이 글을 참조하는 글 (6)