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").

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

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
2. Use ObjectReader.readValues for sequences
3. Prefer 'ObjectReader'/'ObjectWriter' over 'ObjectMapper'