Presentation: Jackson Performance

Turbo-charging Jackson

Although Jackson JSON Processor is fast right out-of-the-box, with default settings and common usage patterns, there are ways to make it process things even faster. This presentation looks at couple of things you can use that can make a big difference in performance, for cases where every last drop of CPU power is needed.

Basics: Things You Should Do Anyway

(note: this section is inspired by Jackson Performance: best practices Uncyclo page at FasterXML Jackson Uncyclo

There is a small number of basic ground rules to follow, to ensure that Jackson processes things at optimal level. These are things that you should "do anyway", even if you do not have actual performance problems: think of them as an interpretation of the "Boy Scout Rule" ("Always leave the campground cleaner than you found it"). Note that guidelines are shown in loosely decreasing order of importance.

1. Reuse heavy-weight objects: ObjectMapper (data-binding) and `JsonFactory (streaming API)

• To a lesser degree, you may also want to reuse ObjectReader and ObjectWriter instances -- this is just some icing on the cake, but they are fully thread-safe and reusable

1. Close things that need to be closed: JsonParser, JsonGenerator

• This helps reuse underlying things such as symbol tables, reusable input/output buffers
• Nothing to close for ObjectMapper

1. Use "unrefined" (least processed) forms of input: i.e. do not try decorating input sources and output targets:

• Input: byte[] is better if you have it; InputStream next best; Reader then -- and in every case, do NOT try reading input into String!
• Output: OutputStream is best; Writer second best; calling writeValueAsString() is the least efficient (why construct intermediate String?)
• Rationale: Jackson is very good at finding the most efficient (sometimes zero-copy) way to consume/produce JSON encoded data -- let it do its magic

1. If you need to re-process, replay, don't re-parse

• Sometimes you need to process things in multiple phases; for example, you may need to parser part of JSON to figure out further processing or data-binding rules, and/or modify intermediate presentation for further processing
• Instead of writing out intermediate forms back as JSON (which will incur both JSON writing and reading overhead), it is better to use a more efficient intermediate form
• The most efficient intermediate form is TokenBuffer (flat sequence of JSON Tokens); followed by JSON Tree model (JsonNode)
• May also want to use ObjetMapper.convertValue(), to convert between Object types

1. Use ObjectReader method readValues() for reading sequences of same POJO type

• Functionally equivalent to calling readValue() multiple times, but both more convenient AND (slightly) more efficient

1. Prefer 'ObjectReader'/'ObjectWriter' over 'ObjectMapper'

• ObjectReader and ObjectWriter are safer to use -- they are fully immutable and freely shareable between threads -- but they can also be bit more efficient, since they can avoid some of the lookups that ObjectMapper has to do

Specific options for further improving performance: ease vs compatibility