SJF4J: A Structured JSON Facade for Java

Source: Dev.to

Introduction

Working with JSON in Java usually means choosing between two approaches:

• Data binding (POJO) – strong typing, but rigid
• Tree model (JsonNode / Map) – flexible, but unstructured

Most libraries force you to pick one and live with the trade‑offs.

SJF4J (Simple JSON Facade for Java) takes a different approach:

• Not a JSON parser – it is a facade layer built on top of existing parsers (e.g., Jackson)
• Provides a unified node model
• Supports structured + dynamic access
• Offers schema‑aware capabilities
• Enables JSON‑semantic operations

The goal is to make JSON handling more consistent, expressive, and extensible. In SJF4J, all JSON values are treated as nodes with consistent behavior. You can operate on them via:

• Object‑oriented APIs (JsonObject, JsonArray)
• Static utilities (Nodes)

Two access styles are supported:

• toXxx() → type‑safe access
• asXxx() → semantic conversion

This removes the need to constantly switch between parsing styles.

Hybrid Model (JOJO)

A key feature is that SJF4J does not force a strict boundary between POJO and dynamic JSON. You can define structured fields while still allowing flexible extensions.

public class Student extends JsonObject {
    private String name;
    private Map scores;
    private List friends;
}

This is neither a traditional POJO nor a raw JSON tree—it’s a hybrid model that SJF4J calls JOJO (JSON Object Java Object).

Core Features

Navigation & Patch

• JSON Path‑like navigation
• Patch‑style updates

student.putByPath("$.profile.name", "Alice");

These features let you manipulate deeply nested structures without manual traversal.

Schema Integration

SJF4J integrates JSON Schema as a runtime concept:

• Validate data dynamically
• Support conditional rules
• Separate domain invariants from runtime constraints

This complements traditional validation approaches like Jakarta Bean Validation.

Cross‑Cutting Operations

• Path navigation
• Patch updates
• Schema validation

All built on top of existing parsers, so performance depends on the underlying implementation.

Performance Considerations

• Overhead is modest in typical scenarios.
• In some cases (e.g., JOJO + optimized I/O), performance can be comparable to or slightly better than direct parser usage.

The design goal is capability without significant cost.

When to Use SJF4J

Useful when:

• JSON structure is partially dynamic.
• You need both typed access and flexible fields.
• Schemas evolve over time.
• A unified model for JSON operations is desired.

Less necessary if:

• Your schema is completely static.
• You only need simple serialization/deserialization.

Relationship to Other Libraries

Jackson and Gson excel at:

• Serialization / deserialization
• Data binding

SJF4J focuses on a different layer:

• JSON as a structured data model
• Cross‑cutting operations (path, patch, schema)
• Hybrid static + dynamic access

It does not replace existing libraries; it builds on top of them.

Project

https://github.com/sjf4j-projects/sjf4j