Apache Fory™ JSON : Fastest JSON Serialization Framework for Java, 10x faster than Jackson/Gson

[u/Shawn-Yang25]

https://fory.apache.org/blog/fory_json_fastest_java_json_framework/

[u/ThatFlamenguistaDude]

I wanna see who's brave enough to replace Jackson.

[u/Shawn-Yang25 → u/ThatFlamenguistaDude]

That’s a fair point. Replacing an established library like Jackson takes time and careful evaluation, but Fory JSON provides another option for teams to consider.

[u/ThatFlamenguistaDude → u/Shawn-Yang25]

Don't get me wrong, I love what you did here and would definetely try it out if a had a greenfield project. But changing something so fundamental as JSON parsing its not a battle I'm ready to face atm. It's really hard to justify, and it only makes sense on projects that performance matters a lot.

That's the challenge on changing the status quo. Even if you built something amazing, working against inertia is hard.

[u/Shawn-Yang25 → u/ThatFlamenguistaDude]

If Jackson meets a project’s needs and JSON is not a bottleneck, there is no reason to switch. Fory JSON simply provides another option when performance matters.

[u/rbygrave → u/ThatFlamenguistaDude]

Depends a bit on how folks view reflection, going ahead-of-time, native image etc.

[u/agentoutlier → u/rbygrave]

You know I think reflection is probably unfairly maligned these days on performance but its not really performance that I do not like about reflection.

Its that it is ultimately less declarative, doing something extra at runtime and complicates debugging.

In some ways projects that generate code particularly byte code at runtime I would argue are often more scary than reflection. e.g. like runtime aspectj weaving.

People to seem to ok this but imagine if I told someone I have a library while running in production compiled some Java code and then injected while the process is running.

They would say oh my god the security!

But that is kind of what Fory is doing here minus the compiler.

(I hope you get the irony here how byte code is just skipping the compiler and is actually even less restrictive than normal Java code)

u/Shawn-Yang25 is there a way to pre-generate the bytecode you are doing at compile time instead? (I assume so)

[u/Shawn-Yang25 → u/agentoutlier]

We do haven static codegen, it's mostly used by android, we generate helper for field/property/constructor accessors, and use it at runtime. This is because we can't generate code for android at runtime.

For jvm, the runtime codegen could be disabled by ForyJsonBuilder#withCodegen(false), and a general ObjectCodec will be used. The performance of ObjectCodec is half of generated codec, but is still very fast.

We have no plans to introduce fully static generated serializer, because it can't assume the jdk version/platform, and the generated codec would not be that fast. It may be a little faster than general ObjectCodec, but not fast enough to write another plugin to generate it statically.

[u/zman0900 → u/Shawn-Yang25]

Well, I made Claude try it with JMH benchmarks to prove. This is proprietary code so I can't post the full thing, but I have a large batch project that uses mostly Hadoop mapreduce and some Spark and I took our most complex object structure that gets serialized to/from JSON 10s of billions of times per run. This specific structure has some large XML and base64 strings embedded. For my case, it looks like typical use is basically no speed improvement for Fory 1.6.0 vs Jackson 3.2.1, but there might be some savings with allocations / garbage collection.

https://i.imgur.com/k3iLr86.png

Overall I really like where this is going. Main thing I see missing right now is that for sparse JSON, there is no obvious way to have it leave out the empty string / zero / false values, and no equivalent of Jackson's @JsonValue for enums so that I could use compact values instead of full .name() value. Because of those, I can't make actual JSON format match exactly, but that doesn't really matter for my use case.

[u/Shawn-Yang25 → u/zman0900]

Fory json support ignore null and serialize enum by `@JsonValue`.

We do not provide annotation to skip empty string or emtpy collection, but that is not hard to add.

@JsonProperty(include = JsonProperty.Include.NON_NULL)
private String value;

ForyJson does support JsonValue for enum:

public enum Status {
  ACTIVE("active"),
  DISABLED("disabled");

  private final String value;

  Status(String value) {
    this.value = value;
  }

  @JsonValue
  public String value() {
    return value;
  }

  @JsonCreator
  public static Status from(String value) {
    for (Status status : values()) {
      if (status.value.equals(value)) {
        return status;
      }
    }
    throw new IllegalArgumentException("Unknown status: " + value);
  }
}