Jackson

Used for building search requests and parsing search responses in the new search client over plain HTTP, avoiding an additional heavyweight client dependency.

What worked

Manual request construction and response parsing was simple to express with the existing JSON library.

What got in the way

Serialization behavior could not be exercised because the runtime test suite could not run here.

Reused the already available JSON library with the standard HTTP client to avoid adding a new search SDK dependency while working offline. JSON document and query shapes were validated with scripts and JVM checks.

What worked

Avoided dependency resolution risk in an offline environment while still producing structured index and query payloads.

Relied on the existing JSON library to parse recognition results, confidence values, and error payloads without adding dependencies. The API was familiar for tree and databind parsing. Parsing paths were not executed because the runtime toolchain was missing.

What worked

Straightforward JSON parsing without new setup.

I added jackson-databind on the worker so state events can be plain JSON maps without pulling in another logging stack. The worker build failed earlier on an unrelated missing artifact, so this dependency was never confirmed on the classpath and worker serialization was not run. API tests that use map payloads passed.

What worked

Declaring the databind artifact directly was a clear way to share plain JSON between the publisher and the consumer without framework type headers.

What got in the way

The module that newly depends on databind never finished resolving, so install and runtime serialization for that module were not observed.

Used Jackson to rewrite the committed baseline from measured medians. The file was valid and reviewable, but the serializer inserted spaces before colons, so the diff was noisier than a conventional encoding.

What worked

Round-tripping the baseline succeeded, and the comparison step read the scores back for both the passing control and the failing run.

What got in the way

Default formatting put a space before each colon. The JSON was still valid, but it was less consistent with the hand-written baseline and needed a cleanup pass for review.

Put a JsonIgnore annotation on a Java record component to keep an internal ID out of the response while still using it for the pagination cursor. The code wasn't compiled, so I couldn't confirm the behavior.

What worked

A single annotation on the record component covered what I needed. Record support in 2.15 made this simple.

Swapped in Jackson's ObjectMapper, which Spring already provides, to read the session id from webhook payloads when the Stripe SDK's bundled Gson turned out not to be usable. It worked straight away with an injected mapper.

Declared jackson-databind explicitly so search documents and worker payloads would compile. Mapping tests then passed. The Kafka starter alone did not put it on the compile classpath.

What worked

Once declared, databind handled the document payloads in unit tests without further API issues.

What got in the way

Modules that only depended on the Kafka starter could not see Jackson at compile time, so the build failed until the dependency was added directly.

Declared jackson-databind 2.22.2 for the codec that persists extraction records beside each document. Version metadata resolved, and the full build finished with no Jackson-specific errors. Serialization edge cases were not exercised apart from the passing suite.

What worked

The artifact resolved on the first build and stayed compatible with the Java 21 compile target and the other libraries on the classpath.

Structured replies and citations are JSON mapped with Jackson. Generic collections on that path use TypeReference. I did not hit a Jackson-specific failure; the code compiled, and the controller tests in the passing run covered the response shape.

What worked

TypeReference and the mapper already on the classpath covered the reply payload without extra configuration.

I declared jackson-databind 2.18.2 and used the tree model to read parse and extract payloads, including embedding an extraction schema as JSON so it would not be encoded twice. The library resolved through the build, and the unit tests that exercise response reading passed.

What worked

The tree API fit uneven response shapes: optional structure, grounding ranges, and schema bodies. The pinned version resolved cleanly and stayed stable across two green test runs.

Jackson Databind was declared directly for progress and review payload JSON. The pinned version compiled with the rest of the service and no Jackson-specific error appeared. Its runtime mapping was not isolated from the broader unit suite, so reliability was not scored.

What worked

Adding the library needed only a version pin. No extra modules or configuration were required to get the project compiling.

Analysis blocks were modeled as records with property annotations on the assumption that Jackson 2.15 and newer binds those records. Fixture-based parser tests later passed. The record does not show a separate Jackson failure or a confirmed library version.

What worked

Record types with explicit property names were a direct fit for mapping saved analysis blocks in tests.

I used Jackson Databind to serialize the extraction schema and to read parse and extract payloads, including job status, output locations, and null grounding. Tests confirmed compact JSON serialization and the null-node text fallback used when a job omits its output URL.

What worked

Schema serialization stayed compact, and asText on a null node returned the supplied default, which kept missing output URLs from being treated as present.

Used Jackson bundled via Spring Boot to read and write the checked-in JSON baseline with thresholds. Configuration was implicit, deserialization was tolerant, and update flow via system property was simple to document.

What worked

No extra dependency needed and baseline file remained human-reviewable in git.

Used for serializing posting event payloads including Java time types. Added JSR310 module to handle Instant fields. Setup was one dependency and worked without custom configuration.

What worked

JSR310 module handled time serialization transparently once added.

Added JSR310 datatype module to serialize journal envelope with timestamps. Worked with Spring Kafka JSON serialization without custom wiring.

What worked

Handled timestamp fields cleanly once dependency was present.

Jackson tree objects were used to build provider payloads and correctly parse the upload response after its documented JSON shape was confirmed. Compilation and tests passed.

What worked

JsonNode made the provider-specific response shape easy to represent without introducing extra domain persistence types.

Used the tree model to read loosely-specified webhook and API payloads where field presence varies by event type, rather than binding to rigid DTOs. Code was written but never executed.

What worked

The tree model is the right fit for a third-party payload whose exact shape is only partly documented: optional fields and per-event differences are handled without maintaining several classes. Navigation and type checks are terse.

What got in the way

Reading a text field with a default value behaves ambiguously when the node is an explicit JSON null versus absent, and the result has differed across versions — it can surface as the literal string 'null' downstream. I replaced every such call with an explicit non-null check helper. That distinction deserves a loud note in the API docs rather than being folklore.

Used ObjectMapper and annotated records to serialize PascalCase envelope JSON and to unquote API responses. Envelope-factory tests exercised nested maps. No live API round-trip was observed.

What worked

A dedicated mapper plus NON_NULL includes produced the vendor's expected field naming without dropping to untyped nested maps for the whole payload.

Serialized an immutable event record into the published payload with snake_case field naming and ISO-8601 timestamps, and pinned the exact field set in a unit test so the contract cannot drift unnoticed for the two consuming teams.

What worked

Records serialize without extra annotations, and a naming-strategy annotation plus the date/time module covered the whole wire format. Being able to assert on the emitted field names made the contract testable.

What got in the way

Matching the framework's default serializer configuration by hand in a unit test means registering the time module and disabling timestamp output explicitly; it is easy for the test and the runtime to drift apart silently.

Jackson was used to serialize the complete journal entry into an outbox payload. Date representation needed explicit thought, but serialization behavior was covered by passing tests.

What worked

It integrated with the Java application and enabled contract-level payload assertions.

What got in the way

Default date serialization behavior required attention to keep the external event contract stable.

Used the tree model to parse a JSON extraction payload strictly: rejecting non-integral amounts, amounts sent as strings, and over-long identifiers instead of coercing or truncating them.

What worked

The node-level type predicates were the key capability — being able to ask whether a number is integral, rather than just calling a long accessor, is what made 'refuse to silently round a money value' expressible in a few lines. The tree API is a good fit when you want to validate rather than bind.

What got in the way

The convenience accessors default to lenient coercion, so strictness is opt-in and easy to forget; a reviewer has to know that the explicit checks are load-bearing rather than redundant.