A 250 lines single-source-file hackable JSON deserializer for the JVM. Reinventing the JSON wheel.

Last update: Jan 4, 2023

Related tags

Overview

JSON Wheel

Have you ever written scripts in Java 11+ and needed to operate on some JSON string? Have you ever needed to extract just that one deeply-nested value of an application/json response without modelling the whole hierarchy? Have you ever felt someone should indeed reinvent that wheel and provide the JVM universe with yet another JSON deserializer?

If the answer to any of those is "yes" then look no further, JSON Wheel's got you covered. It's a 250 lines single-source-file hackable JSON deserializer written in plain Java.

If the answer is "no": Fine by me, I still had fun writing it the thing. :-)

It is ...

small
deserialization-only
hackable
compatible to JDK 8+
dependency-less
not tooo slow

It is not ...

trying to be 100% spec-conforming
typed (except for its own API's types)
safe for malformed input
safe for malicious input (at least I don't give that guarantee)

Usage

Within Your Script

Copy the content of the most recent version of JsonWheel.java as-is into your existing script.
Remove imports if colliding with your pre-existing ones.

Within Your Project

Copy the most recent version of JsonWheel.java as a file into your project's source directory, e.g. /src/main/java.
Adjust the package declaration, i.e. introduce one, if needed.

With JBang's `//SOURCES`

Create a JBang script, e.g. with jbang init.
Add the //SOURCES JBang directive, as demonstrated here. If you care for your script to not break, you best set a version directly in the link and don't use the main blob.

Then you can ...

1) Deserialize JSON objects

var json = """
    {
        "foo": 1,
        "bar": "baz",
        "qux": null
    }""";

var node = JsonWheel.read(json);
var foo = node.get("foo").val(Integer.class); // 1
var bar = node.get("bar").val(String.class);  // "baz"
var qux = node.get("qux").val(String.class);  // null

2) Deserialize JSON arrays

e.val(Integer.class)) .toList(); // 1 2 3">

var json = """
    [
        1,
        2,
        3
    ]""";

var node = JsonWheel.read(json);
var list = node.elements()
        .stream()
        .map(e -> e.val(Integer.class))
        .toList();  // 1 2 3

3) Deserialize "complex" JSON

e.val(Integer.class)) .toList(); // 1 2 3 var baz = node.get("foo").get("baz").val(String.class); // "qux"">

var json = """
    {
        "foo": {
            "bar" : [
                1,
                2,
                3
            ],
            "baz": "qux"
        }
    }""";

var node = JsonWheel.read(json);
var bar = node.get("foo").get("bar").elements()
        .stream()
        .map(e -> e.val(Integer.class))
        .toList(); //   1 2 3
var baz = node.get("foo").get("baz").val(String.class); //  "qux"

Comments

Boolean values

Hi, thank you for this library.

I noticed a problem handling fields when a literal value starting with n, f or t is supplied.

The error is shown in this test which is passing when ran against the current code.

This PR offers a fix and some test for it.

Cheers, Enrico

opened by enr 4
Support escapes and proper numbers
The current parser doesn't properly support all valid escapes and also doesn't support all valid floating point numbers:

officially only ", /, \ and the letters b, f, n, r, t, u are allowed for escapes. But perhaps you don't mind being more flexible than the standard, but

the parser needs to support \uxxxx to be able to accept all valid JSON documents, and

numbers without a . can also be valid numbers, eg. 5e10 is a valid number (and would have to be parsed as a Double).

It's probably a good idea to take a look at syntax diagram here: https://www.json.org/json-en.html

There is also a test suite that's very useful: https://www.json.org/JSON_checker (at the bottom where it says "test suite")
enhancement
opened by quintesse 3
Improve testsuite
[x] Add json.org's testsuite (https://www.json.org/JSON_checker/test.zip). At least add the pass ones. Let's see about the fail ones.

[x] Reorganize existing tests. Make sure JSON Wheel always outputs the same as Jackson.

[x] Cover failure paths.

[x] Add integerUnderflowLargeNegativeToDoublePrecision

enhancement
opened by romanboehm 2
Various improvements
N.B.: If the individual items get to big I might split them off into separate issues. This is more of a collection of thoughts for now.

[x] Incorporate a ./mvnw test invocation into [prepare-]release.sh.

[x] Integrate the two "large" switch statements into a single one.

[x] Add a check for uncommitted items to release.sh.

enhancement
opened by romanboehm 0
Make source compliant with Java 8

At the moment, there's no reason not to. The source is already compliant and more folks could use JsonWheel, e.g. with JBang. The only reason to keep the 11 baseline would be not wanting to maintain it forever on Java < 11.
enhancement

opened by romanboehm 0
Make number parsing more spec conforming
[x] Don't allow all letters

[x] Provide custom exception instead of NumberFormatException

[x] Handle large numbers automatically

[x] Handle e-notation better

bug enhancement
opened by romanboehm 0

Releases(1.3.2)

1.3.2(Jan 8, 2023)

Source code(tar.gz)
Source code(zip)
JsonWheel.java(9.23 KB)
1.3.1(Jan 8, 2023)

Source code(tar.gz)
Source code(zip)
JsonWheel.java(9.23 KB)
1.3(Jan 8, 2023)

Source code(tar.gz)
Source code(zip)
JsonWheel.java(9.23 KB)

Owner

Roman Böhm

Father, husband, AC/DC listener, software developer at Spreadgroup. Some of it professionally.

GitHub

MapNeat is a JVM library written in Kotlin that provides an easy to use DSL (Domain Specific Language) for transforming JSON to JSON, XML to JSON, POJO to JSON in a declarative way.

MapNeat is a JVM library written in Kotlin that provides an easy to use DSL (Domain Specific Language) for transforming JSON to JSON, XML to JSON, POJ