0.1.1 docs





    Jan 9, 2018

    Tampere, Helsinki, Finland


    Index of all namespaces

    « Project + dependencies

    Clojure library for fast JSON encoding and decoding.

    JSON encoding and decoding based on Jackson Databind.
    Encoding example:
        (require '[jsonista.core :as json])
        (json/write-value-as-string {:hello 1})
        ;; => "{\"hello\":1}"
    Decoding example:
        (def +data+ (json/write-value-as-string {:foo "bar"}))
        (json/read-value +data+)
        ;; => {"foo" "bar"}
    ## Configuration
    You can configure encoding and decoding by creating a custom mapper object
    with jsonista.core/object-mapper. The options are passed in as a map.
    For example, to convert map keys into keywords while decoding:
        (json/from-json +data+ (json/object-mapper {:decode-key-fn true}))
        ;; => {:foo "bar"}
    See the docstring of [[object-mapper]] for all available options.
    ## Custom encoders
    Custom encoder is a function that take a value and a JsonGenerator object as
    the parameters. The function should call JsonGenerator methods to emit the
    desired JSON. This is the same as how custom encoders work in Cheshire.
    Custom encoders are configured by the object-mapper option :encoders, which is a
    map from types to encoder functions.
    For example, to encode java.awt.Color:
         (let [encoders {java.awt.Color (fn [color gen] (.writeString gen (str color)))}
               mapper (json/object-mapper {:encoders encoders})]
           (json/write-value-as-string (java.awt.Color. 1 2 3) mapper))
         ;; => "\"java.awt.Color[r=1,g=2,b=3]\""
    ## Jsonista vs. Cheshire
    jsonista uses Jackson Databind while Cheshire uses Jackson Core. In our
    benchmarks, jsonista performs better than Cheshire (take look at
    json_perf_test.clj). On the other hand, Cheshire has a wider set of features
    and has been used in production much more.
    The README below is fetched from the published project artifact. Some relative links may be broken.

    jsonista Continuous Integration status

    jsonissa / jsonista / jsoniin, jsonilla / jsonilta / jsonille

    Clojure library for fast JSON encoding and decoding.

    • Explicit configuration
    • Embrace Java for speed
    • Uses Jackson directly
    • API docs

    Aiming to be faster than Cheshire while still having all the necessary features for web development. Designed for use with Muuntaja.

    Blogged: * Faster JSON processing with jsonista

    Latest version

    Clojars Project


    (require '[jsonista.core :as j])
    (j/write-value-as-string {"hello" 1})
    ;; => "{\"hello\":1}"
    (j/read-value *1)
    ;; => {"hello" 1}

    More examples

    Changing how map keys are encoded & decoded:

    (defn reverse-string [s] (apply str (reverse s)))
    (def mapper
        {:encode-key-fn (comp reverse-string name)
         :decode-key-fn (comp keyword reverse-string)}))
    (-> {:kikka "kukka"} 
        (doto prn) 
        (j/write-value-as-string mapper) 
        (doto prn) 
        (j/read-value mapper)
    ; {:kikka "kukka"}
    ; "{\"akkik\":\"kukka\"}"
    ; {:kikka "kukka"}

    Reading & writing directly into a file:

    (def file ( "hello.json"))
    (j/write-value file {"hello" "world"})
    (slurp file)
    ;; => "{\"hello\":\"world\"}"
    (j/read-value file)
    ;; => {"hello" "world"}


    • All standard encoders and decoders are written in Java
    • Protocol dispatch with read-value & write-value
    • Jackson ObjectMapper is used directly
    • Small functions to support JVM Inlining

    See perf-tests for details.




    Copyright © 2016-2017 Metosin Oy.

    Distributed under the Eclipse Public License, the same as Clojure.