Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Main Portal page for the Jackson project

NotificationsYou must be signed in to change notification settings

FasterXML/jackson

Repository files navigation

Open Source

Jackson Project Home @github

This is the home page of the Jackson Project.

What is New?

See more releases information atJackson Releases.

What is Jackson?

Jackson has been known as "the Java JSON library"or "the best JSON parser for Java". Or simply as "JSON for Java".

More than that, Jackson is a suite of data-processing tools for Java (and the JVM platform),including the flagship streamingJSON parser / generator library,matching data-binding library (POJOs to and from JSON)and additional data format modules to process data encoded inAvro,BSON,CBOR,CSV,Smile,(Java) Properties,Protobuf,TOML,XMLorYAML;and even the large set of data format modules to support data types of widely useddata types such asGuava,Joda,PCollectionsand many, many more (see below).

While the actual core components live under their own projects -- including the three core packages(streaming,databind,annotations);data format libraries; data type libraries;JAX-RS provider;and a miscellaneous set of other extension modules -- this project act as the central hubfor linking all the pieces together.

A good companion to this README is theJackson Project FAQ.

Jackson Major Versions

Jackson suite has three major versions:

  • 1.x (org.codehaus.jackson) is deprecated and no versions are released;
  • 2.x (com.fasterxml.jackson) is the older actively developed and maintained version
  • 3.x (tools.jackson) is the newer actively developed and maintained version

These major versions use different Java packages and Maven artifact ids, so they are not mutually compatible, but can peacefully co-exist: a project can depend on both Jackson 1.x and 2.x (and eventually 3.x), without conflicts.This is by design and was chosen as the strategy to allow smoother migration from 1.x to 2.x (and from 2.x to 3.x, eventually).

The latest stable versions from these branches are:

  • 3.0.0, released on 03-Oct-2025
  • 2.20.0, released on 28-Aug-2025
    • 2.19.2 is the latest patch from previous stable branch
  • 1.9.13, released 14-Jul-2013

Recommended way to use Jackson is through Maven repositories; releases are made to Central Maven Repository (CMR).Individual projects' wiki pages sometimes also contain direct download links, pointing to CMR.

Release notes for 2.x and 3.x releases are found fromJackson Releases page.

Jackson 2.x to 3.0 migration

With Jackson 3.0.0 GA, some documentation exists to help migration:

Active Jackson projects

Most projects listed below are lead by Jackson development team; but some by other at-large Jackson community members.

We try to keep versioning of modules lined up to reduce confusion regarding which versions work together.

  • One exception to this isjackson-annotations which has a different versioning starting from 2.20 --2.20 instead of2.20.0 (no patch digit)
  • For fully consistent set of versions, consider using Jackson BOM (jackson-bom)

Core modules

Core modules are the foundation on which extensions (modules) build upon.There are 3 such modules currently (as of Jackson 2.x):

  • Streaming (docs) ("jackson-core") defines low-level streaming API, and includes JSON-specific implementations
  • Annotations (docs) ("jackson-annotations") contains standard Jackson annotations
  • Databind (docs) ("jackson-databind") implements data-binding (and object serialization) support onstreaming package; it depends both onstreaming andannotations packages

In addition:

  • Jackson BOM (jackson-bom) is useful for ensuring fully consistent set of versions for all official Jackson components. It is usually used by importing as pom in "managed dependencies" Maven section (or using similar mechanism in Gradle etc).

Third-party datatype modules

These extensions are plug-in JacksonModules (registered withObjectMapper.registerModule()),and add support for datatypes of various commonly used Java libraries, by addingserializers and deserializers so that Jacksondatabind package (ObjectMapper /ObjectReader /ObjectWriter) can read and write these types.

Datatype modules directly maintained by Jackson team are under the following Github repositories:

In addition, we are aware of additional modules that are not directly maintained by core Jackson team:

Providers for JAX-RS

Jackson JAX-RS Providers has handlers to add dataformatsupport for JAX-RS implementations (like Jersey, RESTeasy, CXF).Providers implementMessageBodyReader andMessageBodyWriter.Supported formats currently includeJSON,Smile,XML,YAML andCBOR.

Data format modules

Data format modules offer support for data formats other than JSON.Most of them simply implementstreaming API abstractions, so that databinding component can be used as is; some offer (and few require) additionaldatabind level functionality for handling things like schemas.

Currently following data format modules are fully usable and supported (version number in parenthesis, if included, is thefirst Jackson 2.x version to include module; if missing, included from 2.0)

  • Avro: supportsAvro data format, withstreaming implementation plus additionaldatabind-level support for Avro Schemas
  • CBOR: supportsCBOR data format (a binary JSON variant).
  • CSV: supportsComma-separated values format --streaming api, with optional conveniencedatabind additions
  • Ion (2.9): support forAmazon Ion binary data format (similar to CBOR, Smile, i.e. binary JSON - like)
  • (Java) Properties (2.8): creating nested structure out of implied notation (dotted by default, configurable), flattening similarly on serialization
  • Protobuf (2.6): supported similar toAvro
  • Smile: supportsSmile (binary JSON) -- 100% API/logical model compatible viastreaming API, no changes fordatabind
  • TOML: (added in 2.13) supportsTOML, supported with bothstreaming anddatabind implementations
  • XML: supports XML; provides bothstreaming anddatabind implementations. Similar to JAXB' "code-first" mode (no support for "XML Schema first", but can use JAXB beans)
  • YAML: supportsYAML, which being similar to JSON is fully supported with simplestreaming implementation

There are also other data format modules, provided by developers outside Jackson core team:

  • BEncode: support for reading/writingBEncode (BitTorrent format) encoded data
  • bson4jackson: adds support forBSON data format (by Mongo project).
    • Implemented as full streaming implementation, which allows full access (streaming, data-binding, tree-model)
    • Also see [MongoJack] library below; while not a dataformat module, it allows access to BSON data as well.
  • EXIficient supportsEfficient XML Interchange
  • jackson-dataformat-msgpack adds supportMessagePack (akaMsgPack) format
    • Implemented as full streaming implementation, which allows full access (streaming, data-binding, tree-model)
  • HOCON: experimental, partial implementation to supportHOCON format -- work in progress
  • Rison: Jackson backend to supportRison

JVM Language modules

  • Kotlin to handle native types ofKotlin
  • Scala to handle native Scala types (including but not limited to Scala collection/map types, case classes)
    • Currently (October 2022) Scala 2.11, 2.12, 2.13 and 3 are supported (2.9 was supported up to Jackson 2.3 and 2.10 up to Jackson 2.11)

Support for Schemas

Jackson annotations define intended properties and expected handling for POJOs, and in addition to Jackson itselfusing this for reading/writing JSON and other formats, it also allows generation of external schemas.Some of this functionality is included in above-mentioned data-format extensions; but there are alsomany stand-alone Schema tools, such as:

JSON Schema

Other schema languages

Other modules, stable

Other fully usable modules by FasterXML team include:

  • Base modules:
    • Afterburner: speed up databinding by 30-40% with bytecode generation to replace use of Reflection for field access, method/constructor calls
    • Guice: extension that allows injection values from Guice injectors (and basic Guice annotations), instead of standard@JacksonInject (or in addition to)
    • JAXB Annotations: allow use ofJAXB annotations as an alternative (in addition to or instead of) standard Jackson annotations
    • Mr Bean: "type materialization" -- let Mr Bean generate implementation classes on-the-fly (NO source code generation), to avoid monkey code
    • OSGi: allows injection of values from OSGi registry, via standard Jackson@JacksonInject annotation
    • Paranamer: tiny extension for automatically figuring out creator (constructor, factory method) parameter names, to avoid having to specify@JsonProperty.

Jackson jr

WhileJackson databind is a good choice for general-purpose data-binding, itsfootprint and startup overhead may be problematic in some domains, such as mobile phones; and especiallyfor light usage (couple of reads or writes). In addition, some developers find full Jackson API overwhelming.

For all these reasons, we decided to create a much simpler, smaller library, which supports a subset offunctionality, calledJackson jr.It builds onJackson Streaming API, but does not depend on databind. As a resultits size (both jar, and runtime memory usage) is considerably smaller; and its API is very compact.

Third-party non-module libraries based on Jackson

Jackson helper libraries

  • Jackson Ant path filter adds powerful filtering of properties to serialize, using Ant Path notation for hierarchic filtering

Support for datatypes

Event processing

  • json-events -- Event processing for JSON, similar to SAX (for XML), based onjackson-core.

Other things related to or inspired by Jackson

  • Jackson-js is a Javascript/Node object serialization/deserialization library with API inspired by Jackson
  • Pyckson is a Python library that aims for same goals as Java Jackson, such as Convention over Configuration
  • Rackson is a Ruby library that offers Jackson-like functionality on Ruby platform

Contributing

If you would like to help with Jackson project, please check outContributing.

You may also want to check out:

Support

Community support

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

Enterprise support

In addition to free (for all) community support, enterprise support—starting with version 2.10—is available as part of theTidelift Subscription for (most) Jackson components.

The maintainers ofJackson 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.

Reporting security vulnerabilities

The recommended mechanism for reporting possible security vulnerabilities followsso-called "Coordinated Disclosure Plan" (seedefinition of DCPfor general idea). The first step is to file aTidelift security contact:Tidelift will route all reports via their system to maintainers of relevant package(s), and start theprocess that will evaluate concern and issue possible fixes, send update notices and so on.Note that you do not need to be a Tidelift subscriber to file a security contact.

Alternatively you may also report possible vulnerabilities toinfo at fasterxml dot commailing address. Note that filing an issue to go with report is fine, but if you do that pleaseDO NOT include details of security problem in the issue but only in email contact.This is important to give us time to provide a patch, if necessary, for the problem.

Note on reporting Bugs

Jackson bugs need to be reported against component they affect: for this reason, issue trackeris not enabled for this project.If you are unsure which specific project issue affects, the most likely componentisjackson-databind, so you would useJackson Databind Issue Tracker.

For suggestions and new ideas, tryJackson Future Ideas

Documentation

Web sites

Tutorials

For first-time users there are many good Jackson usage tutorials,including general usage / JSON tutorials:

and more specific tutorials:

Reports

Following reports have been published about Jackson components

Java JSON library comparisons

Since you probably want opinions by Java developers NOT related to Jackson project, regarding which library to use,here are links to some of existing independent comparisons:

About

Main Portal page for the Jackson project

Topics

Resources

Contributing

Security policy

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Contributors58

[8]ページ先頭
©2009-2025 Movatter.jp