Ditch Traditional JSON Parsing: Boost Spring Boot API Performance by 30×

When users submitted an order, the page stalled for about 900 ms per request, flooding the monitoring dashboard with alerts and causing many customers to abandon their carts. The author spent four months adding indexes, tuning the connection pool, and deploying read‑only replicas, yet the root cause remained hidden.

Using async‑profiler for a 30‑second sample of live traffic showed that Jackson’s ObjectMapper.readValue and writeValue together accounted for 62% of CPU usage, while the database query consumed only 11%.

Jackson’s default behavior fully constructs a POJO graph for every request, performing reflection, type conversion, and field mapping on a ~4 KB JSON payload. This overhead is negligible at low traffic but becomes a hard bottleneck as request volume grows.

To eliminate the cost, the author replaced the standard Jackson binding with its native streaming API, parsing only the required fields and writing the response directly to the output stream. The before‑and‑after implementations are:

// Before: full POJO deserialization and serialization
@PostMapping("/order")
public OrderResponse process(@RequestBody OrderRequest req) {
    return service.handle(req);
}

// After: streaming read/write, no POJO construction
@PostMapping("/order")
public void process(HttpServletRequest http, HttpServletResponse res) throws IOException {
    JsonFactory fac = new JsonFactory();
    String orderId = null;
    String userId = null;
    try (JsonParser p = fac.createParser(http.getInputStream())) {
        while (p.nextToken() != null) {
            if ("orderId".equals(p.getCurrentName())) {
                p.nextToken();
                orderId = p.getText();
            }
            if ("userId".equals(p.getCurrentName())) {
                p.nextToken();
                userId = p.getText();
            }
        }
    }
    String result = service.handle(orderId, userId);
    res.setContentType("application/json");
    try (JsonGenerator g = fac.createGenerator(res.getOutputStream())) {
        g.writeStartObject();
        g.writeStringField("status", "ok");
        g.writeStringField("ref", result);
        g.writeEndObject();
    }
}

Benchmarking the two versions produced the following results:

Metric                Before   After
-----------------------------------
Avg response time      912 ms   28 ms
P99 latency          2100 ms   61 ms
CPU usage (peak)       91%     34%
Throughput (req/sec)   620    4800
GC pause time (avg)   140 ms   12 ms

The most striking improvement was in GC behavior: the original implementation generated many short‑lived objects that caused 140 ms pauses during traffic spikes, whereas the streaming version produced almost no garbage, eliminating those pauses.

The new request flow can be visualised as:

🚀 HTTP Request (Incoming JSON Stream)
          │
          ▼
┌──────────────────────────────────────────┐
│          Spring Boot Controller          │
│  🔍 [Jackson Stream Parser] parses only │
│      needed fields → String arguments      │
└──────────────────────────────────────────┘
          │
          ▼
┌──────────────────────────────────────────┐
│          Service Layer (lightweight)      │
│  📦 Receives String args, avoids POJO cost │
└──────────────────────────────────────────┘
          │
          ▼
┌──────────────────────────────────────────┐
│          DB / Core Logic (persist/compute)│
└──────────────────────────────────────────┘
          │
          ▼
┌──────────────────────────────────────────┐
│          Stream Writer (writes JSON)     │
│  ✍️ Bypasses POJO, writes directly to   │
│      response buffer                    │
└──────────────────────────────────────────┘
          │
          ▼
          🎉 HTTP Response (Chunked/Streamed)

While the performance gains are substantial, the streaming approach has drawbacks: the code is longer and harder to read, manual validation is required, and the technique is unsuitable for endpoints that need full object mapping or complex nested structures.

In summary, abandoning Jackson’s default POJO binding in favour of its streaming API can reduce latency by over 30×, cut CPU and GC overhead dramatically, and increase throughput, but teams must weigh the loss of readability and automatic validation against the performance benefits.