Home

Awesome

Build Status Maven Central Sonatype Snapshots Tidelift

Overview

Jackson is a fast JSON processor for Java that supports three models: streaming, node, and object mapping (akin to the three independent models SAX/[Stax], DOM and JAXB for XML processing).

The object mapping model is a high-level processing model that allows the user to project JSON data onto a domain-specific data model appropriate for their application, without having to deal with the low-level mechanics of JSON parsing. It is the standard object mapping parser implementaton in Jersey, the reference implementation for JSR-311 (Java API for Restful Web Services).

Scala is a functional programming language for the JVM that supports Java interoperability. Its standard library is quite distinct from Java, and does not fulfill the expectations of Jacksons default mappings. Notably, Scala collections do not derive from java.util.Collection or its subclasses, and Scala properties do not (by default) look like Java Bean properties.

The Scala Module supports serialization and limited deserialization of Scala Case Classes, Sequences, Maps, Tuples, Options, and Enumerations.

Version Support

Jackson-module-scala follows the same release strategy of jackson-databind. Master branch is used for Jackson 3 development. The latest releases are v2.12.x.

Scala 2.11, 2.12 and 2.13 are supported. Scala 2.10 support was dropped in v2.12.0. Java 8 is the minimum supported version now.

Scala 3

Scala 3 support was added in v2.13.0. There are a few differences from Scala 2 support.

Usage

To use the Scala Module in Jackson, simply register it with the ObjectMapper instance:

// With 2.10 and later
val mapper = JsonMapper.builder()
  .addModule(DefaultScalaModule)
  .build()

// versions before 2.10 (also support for later 2.x but not 3.0)
val mapper = new ObjectMapper()
mapper.registerModule(DefaultScalaModule)

DefaultScalaModule is a Scala object that includes support for all currently supported Scala data types. If only partial support is desired, the component traits can be included individually:

val module = new OptionModule with TupleModule {}
val mapper = JsonMapper.builder()
  .addModule(module)
  .build()

Prior to v2.16.0, ScalaObjectDeserializerModule was not part of DefaultScalaModule. This module is used to ensure that deserialization to a Scala object does not create a new instance of the object. Users of older versions can add this module explicitly.

DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES

It is recommended that Scala users enable DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES. This feature means that when you deserialize JSON and bind to a Scala/Java class and a required field is missing (or null), then the deserialization call will fail with a tools.jackson.databind.exc.MismatchedInputException. By default, the deserialization call will succeed and a null value will be set for the field.

val mapper = JsonMapper.builder()
  .addModule(DefaultScalaModule)
  .enable(DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES)
  .build()

ClassTagExtensions

You can also mixin ClassTagExtensions to get rich wrappers that automatically convert scala ClassTags directly into TypeReferences for Jackson to use:

val mapper = JsonMapper.builder().addModule(DefaultScalaModule).build() :: ClassTagExtensions
// or using old style
//val mapper = new ObjectMapper() with ClassTagExtensions
//mapper.registerModule(DefaultScalaModule)
val myMap = mapper.readValue[Map[String, Tuple2[Int,Int]]](src)

ClassTagExtensions is a replacement for ScalaObjectMapper, which was recently deprecated because it relies on Manifests and they are not supported in Scala 3.

This is the equivalent of

val mapper = JsonMapper.builder().addModule(DefaultScalaModule).build()
val myMap = mapper.readValue(src, new TypeReference[Map[String,Tuple2[Int,Int]]]{})

Consult the Scaladoc for further details.

Sbt

To import in sbt:

libraryDependencies += "tools.jackson.module" %% "jackson-module-scala" % "3.0.0-SNAPSHOT"

Java/Kotlin users

DefaultScalaModule is a Scala Object and to access it when you are not compiling with Scala compiler, you will need to use DefaultScalaModule$.MODULE$ instead.

import tools.jackson.module.scala.DefaultScalaModule$;

ObjectMapper mapper = JsonMapper.builder().addModule(DefaultScalaModule$.MODULE$).build();

Building

The master branch often depends on SNAPSHOT versions of the core Jackson projects, which are published to the Sonatype OSS Repository. To make these dependencies available, create a file called sonatype.sbt in the same directory as build.sbt with the following content. The project .gitignore file intentionally prevents this file from being checked in.

resolvers ++= Resolver.sonatypeOssRepos("snapshots")

Download, docs

Check out Wiki. API Scaladocs can be found on the project site but they are not really well suited to end users, as most classes are implementation details of the module.

Related Projects

Contributing

The main mechanisms for contribution are:

Support

Community support

Jackson components are supported by the Jackson community through mailing lists, Gitter forum, Github issues. See Participation, Contributing for full details.

Enterprise support

Available as part of the Tidelift Subscription.

The maintainers of jackson-module-scala and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. Learn more.

Core Development Team

Currently active core developers (ones who can review, accept and merge Pull Requests) are:

If you have questions on issues, implementation strategies, you may refer to core developers (and this is recommended if you are in doubt!), but keep in mind that these are voluntary positions: everyone is doing this because they want to, not because they are paid or contractually obligated to. This also means that time availability changes over time so getting answers may take time.

In addition, other Jackson developers with similar access (but less active) include:

Acknowledgements

Developed with IntelliJ IDEA