Version: 1.2.1 Release date: 03-Oct-2009 Description: Bug-fix release for 1.2.0. Problems fixed: * [JACKSON-177] Problems with Hibernate, repackaged cglib (reported by Ted B) * [JACKSON-179] Single-long-arg factory Creators were not working (reported by Brian M) ------------------------------------------------------------------------ == History: == ------------------------------------------------------------------------ 1.2.1 [03-Oct-2009] Problems fixed: * [JACKSON-162] OSGi packaging problems for xc package. (reported by Troy Waldrep) * [JACKSON-171] Self-referential types cause infinite recursion when using only JAXB annotation introspector (reported by Randy L) 1.2.0 [01-Aug-2009] Improvements: * Added "-use" flag for generating javadocs (suggested by Dain S) * [JACKSON-136] JsonParser and JsonGenerator should implement java.io.Closeable (since they already have close() method) (suggested by Dain S) * [JACKSON-148] Changed configuration methods to allow chaining, by returning 'this' (instead of 'void') New features: * [JACKSON-33] Allow use of "non-default constructors" and multiple-argument factory methods for constructing beans to deserialize * [JACKSON-69] Support parsing non-standard JSON where Object keys are not quoted * [JACKSON-76] Mix-in annotations: allow dynamic attachment of annotations to existing classes, for purposes of configuring serialization/deserialization behavior * [JACKSON-92] Allow use of @JsonCreator for constructors and static methods that take a single deserializable type as argument (so-called delegating creators) * [JACKSON-114] Add feature and annotations to make serialization use static (declared) type over concrete (actual/runtime) type * [JACKSON-131] Allow constructing and passing of non-shared SerializationConfig/DeserializationConfig instances to ObjectMapper * [JACKSON-135] Add basic JsonNode construction support in ObjectMapper * [JACKSON-147] Add global deserialization feature for suppressing error reporting for unknown properties * [JACKSON-149] Add ser/deser features (DeserializationConfig.Feature.USE_ANNOTATIONS, SerializationConfig.Feature.USE_ANNOTATIONS) to allow disabling use of annotations for serialization and/or deserialization config 1.1.2 [31-Jul-2009] Fixes: * [JACKSON-143] NPE on ArrayNode.equals() when comparing empty array node to non-empty array node (reported by Gregory G) * [JACKSON-144] Static "getter-like" methods mistaken for getters (for serialization) (reported by Dan S) 1.1.1 [18-Jul-2009] Fixes: * [JACKSON-139] Non-numeric double values (NaN, Infinity) are serialized as invalid JSON tokens (reported by Peter H) * Core jar incorrectly included much of "mapper" classes (in addition to core classes) * Now compiles again using JDK 1.5 javac (1.1.0 didn't) 1.1.0 [22-Jun-2009] Fixes: * [JACKSON-109] Allow deserializing into generics Bean classes (like Wrapper) not just generic Maps and Collections * [JACKSON-121] Problems deserializing Date values of some ISO-8601 variants (like one using 'Z' to indicate GMT timezone) * [JACKSON-122] Annotated serializers and deserializers had to be public classes with public default constructor; not any more. Improvements: * [JACKSON-111] Added "jackson-xc" jar to contains XML Compatibility extensions. New features: * [JACKSON-70] Add support for generating JSON Schema * [JACKSON-98] Allow serializing/deserializing field-accessible properties, in addition to method-accessible ones. * [JACKSON-105] Allow suppressing output of "default values"; which means value of a property when bean is constructed using the default no-arg constructor (requested by Christoph S) * [JACKSON-119] Add (optional) support for using JAXB annotations (by using JaxbAnnotationIntrospector) (requested by Ryan H) * [JACKSON-120] Add annotations @JsonSerialize, @JsonDeserialize, to streamline annotation by replacing host of existing annotations. * [JACKSON-123] Add "chaining" AnnotationIntrospector (implemented as inner class, AnnotationIntrospector.Pair) that allows combining functionality of 2 introspectors. 1.0.1 [04-Jun-2009] Fixes: * [JACKSON-104] Build fails on JDK 1.5, assorted other minor issues (reported by Oleksander A) * [JACKSON-121] Problems deserializing Date values of some ISO-8601 variants (like one using 'Z' to indicate GMT timezone) 1.0.0 [09-May-2009] Fixes: * [JACKSON-103] Serializing Groovy objects; need to exclude getter method "getMetaClass" from serialization to prevent infinite recursion (reported by Ray T) Improvements: * Removed JAX-RS META-INF/services - based auto-registration for JAX-RS MessageBodyReader/MessageBodyWriter, because it could conflict with other application/json content handlers. 0.9.9-6 [27-Apr-2009] Improvements: * Improved jax-rs provider integration with jersey; now properly auto-registers as handler for json media type(s), and allows for defining custom ObjectMapper to be injected. 0.9.9-5 [20-Apr-2009] New features: * [JACKSON-88]: Support for "Setter-less" collection (and Map) types Improvements: * [JACKSON-100]: Allow specifying that BigInteger should be used instead of Integer or Long for "generic" integral numeric types (Object, Number) (DeserializationConfig.Feature.USE_BIG_INTEGER_FOR_INTS) * [JACKSON-101]: Allow disabling of access modifier overrides (SerializationgConfig.Feature.CAN_OVERRIDE_ACCESS_MODIFIERS) to support more security-constrainted running environments. 0.9.9-4 [14-Apr-2009] Fixes: * [JACKSON-94] Added missing "JsonParser.readValueAsTree()" method. * JacksonJsonProvider was using strict equality comparison against JSON type; instead needs to use "isCompatible". There were other similar problems (reported by Stephen D) * [JACKSON-97] Generic types (with bound wildcards) caused problems when Class introspector could not figure out that a concrete method was overriding/implementing generic method; as well as having problems with synthetic bridge methods. Improvements: * [JACKSON-95] Added support for deserializing simple exceptions (Throwable and its sub-classes): anything with a String constructor (assumed to take "message") should work to some degree. * [JACKSON-99] IOExceptions should not be wrapped during object mapping. (reported by Eldar A) New features: * [JACKSON-85]: Make Date deserialization (more) configurable (add DeserializationConfig.setDateFormat()) * [JACKSON-93]: Allow overriding the default ClassIntrospector. * [JACKSON-96]: Allow enabling pretty-printing with data binding, through SerializationConfig object. 0.9.9-3 [03-Apr-2009] Fixes: * [JACKSON-79]: Primitive value deserialization fragile wrt nulls * [JACKSON-81]: Data binding code could lead to unnecessary blocking because it tried to advance parser (and stream) after binding (reported by Eldar A) New features: * [JACKSON-61]: Allow suppressing writing of bean properties with null values (requested by Justin F) * [JACKSON-63]: Create CustomDeserializerFactory to allow for adding custom deserializers for non-structured/generic types. * [JACKSON-75]: Add "any setter" method; ability to catch otherwise unknown (unmapped) properties and call a method with name+value. * [JACKSON-80]: Add @JsonValue annotation, to specify that a Bean value is to be serialized as value returned by annotated method: can for example annotate "toString()" method. * [JACKSON-84]: Added JsonGenerator.writeRawValue methods to augment existing JsonGenerator.writeRaw() method (requested by Scott A) * [JACKSON-86]: Added JsonParser.isClosed() and JsonGenerator.isClosed() methods. * [JACKSON-87]: Added ability to customized Date/Calendar serialization, both by toggling between timestamp (number) and textual (ISO-8601), and by specifying alternate DateFormat to use. 0.9.9-2 [19-Mar-2009]: Fixes: * [JACKSON-75]: Didn't have Deserializer for Number.class. Improvements: * [JACKSON-68]: Add DeserializationProblemListener, and DeserializationConfig.addHandler to add instances to ObjectMapper. * [JACKSON-71]: Add support ser/deser of Class.class. * [JACKSON-72]: Allow specifying that BigDecimal should be used instead of Double for "generic" numeric types (Object, Number) (DeserializationConfig.Feature.USE_BIG_DECIMAL_FOR_FLOATS) * [JACKSON-73]: Refactored ser/deser configuration settings into separate configuration classes. * [JACKSON-78]: Should be able to deserialize ints into Booleans (0 == false) New features: * [JACKSON-45]: Add convenience methods to help writing custom serializers (requested by Scott A) 0.9.9 [02-Mar-2009]: Fixes: * [JACKSON-59]: NPE with String[] serializer (reported by Kevin G) * [JACKSON-62]: NPE with JsonMappingException if source exception used null message. (reported by Justin F) * [JACKSON-64]: Handling of property name (with @JsonGetter, @JsonSetter) made bit more intuitive; uses bean naming convention if no explicit name given. Improvements: * [JACKSON-60]: Method annotations did not follow intuitive expectations of inheritability; now do. * [JACKSON-65]: Need to support typing using "java.lang.reflect.Type", to help integration with frameworks. * [JACKSON-66]: ObjectMapper now has "canSerialize" and "canDeserialize" methods to help frameworks figure out what is supported. New features: * [JACKSON-52]: Allow disabling name-based auto-detection of getter methods (requested by Justin F) * [JACKSON-58]: Allow defining custom global Enum serializer (to, for example, make Enums be serialized using Enum.toString(), or lower-case name or such) * [JACKSON-67]: Add JAX-RS provider based on Jackson that can handle JSON content type; initially as a separate jar. Other: * [JACKSON-22]: all contributors now have submitted contributor agreement, stored under 'DEV/agreements-received' in svn trunk. 0.9.8 [18-Feb-2009]: Fixes: * [JACKSON-49]: Incorrect bounds check for Float values resulted in exception when trying to serializer 0.0f. New features: * [JACKSON-32]: add annotations to configure serialization process (@JsonClass/@JsonContentClass/@JsonKeyClass; @JsonUseSerializer, @JsonUseDeserializer, @JsonIgnore) * [JACKSON-36]: add annotations to define property names that differ from bean naming convention (@JsonGetter/@JsonSetter) Improvements: * [JACKSON-47]: Change DeserializerProvider.findValueDeserializer to take "referrer" information. This is needed to be able to give contextual mappings where a given type may be deserialized differently (by different deserializer, and possibly to a different java class) depending on where the reference is from. * [JACKSON-48]: Integrate ObjectMapper with JsonGenerator, JsonParser; add MappingJsonFactory. (suggested by Scott A) * [JACKSON-50]: JsonNode.getElements() and .iterator() now work for ObjectNodes too, not just ArrayNodes. Also added convenience factory methods to allow constructing child nodes directly from container nodes. * [JACKSON-53]: iBatis proxied value classes didn't work; fixed by prevent CGLib-generated "getCallbacks" from getting called. (reportd by Justin F) * [JACKSON-55]: Added support for reference-path-tracking in JsonMappingException, made serializers populate it: this to make it easier to trouble-shoot nested serialization problems * [JACKSON-56]: Added support for RFC-1123 date format, along with simpler "standard" format; and can add more as need be. 0.9.7 [04-Feb-2009]: Improvements: * [JACKSON-34]: Improved packaging by adding an intermediate directory in source tarball, to not mess up the current directory (and to indicate version number as well) * [JACKSON-37]: Make Jackson run on Android, by ensuring that there are no hard linkages to classes that Android SDK doesn't have (the only reference that was there, to XMLGregorianCalendar, was changed to soft linkage) * [JACKSON-42]: Add new JsonNode sub-class, BinaryNode, to represent base64 encoded binary content. New features: * [JACKSON-6]: Implement JsonParser.getBinaryValue() so that one can now also read Base64-encoded binary, not just write. * [JACKSON-40]: Add JsonParser.nextValue() for more convenient iteration. * [JACKSON-46]: Allow disabling quoting of field names by disabling feature 'JsonGenerator.feature.QUOTE_FIELD_NAMES' (requested by Scott Anderson) 0.9.6 [14-Jan-2009]: Bug fixes: * Serialization of some core types (boolean/java.lang.Boolean, long/java.lang.Long) was not working due to incorrectly mapped serializers. New features: * [JACKSON-31]: Complete rewrite of ObjectMapper's deserialization: now supports Beans, typed (generics-aware) Lists/Maps/arrays. Improvements: * [JACKSON-24]: Add efficient byte-array - based parser factory method to JsonFactory (has maybe 5% improvement over wrapping in ByteArrayInputStream). * [JACKSON-29]: Split classes in 2 jars: core that has parser and generator APIs and implementations; and mapper jar that has object and tree mapper code. * [JACKSON-30]: Renamed "JavaTypeMapper" as "ObjectMapper", and "JsonTypeMapper" as "TreeMapper"; new names should be more intuitive to indicate their purpose. Will leave simple implementations of old classes to allow for gradual migration of existing code. 0.9.5 [10-Dec-2008]: Bug fixes: * [JACKSON-25]: Problems with Maven pom for lgpl version (report by Ray R) note: backported to 0.9.4 Codehaus Maven repo Improvements: * [JACKSON-13]: JavaTypeMapper can now take JsonFactory argument, and thus is able to construct JsonParser/JsonGenerator instances as necessary * [JACKSON-17]: Handling of unknown types now configurable with JavaTypeMapper serialization (see JsonSerializerProvider for methods) * [JACKSON-20]: Handling of nulls (key, value) configurable with JavaTypeMapper serialization (see JsonSerializerProvider for methods) * [JACKSON-26]: Add convenience JsonGenerator.writeXxxField() methods to simplify json generation. New features: * [JACKSON-27]: Allow automatic closing of incomplete START_ARRAY and START_OBJECT events, when JsonGenerator.close() is called. 0.9.4 [26-Nov-2008]: Bug fixes: * [JACKSON-16]: JavaDocs regarding whether Jackson is to close underlying streams, readers and writers, were incorrect. Additionally added parser/generator features to allow specifying whether automatic closing is to be done by Jackson: feature is enabled by default, both for backwards compatibility, and because it seems like the right setting. * [JACKSON-18]: ArrayIndexOutOfBounds on IntNode, due to off-by-one problem with comparisons (reported by Michael D) * Fixed a problem with CR (\r) handling; was sometimes skipping characters (problematic if there's no indentation). * Multiple UTF-8 decoding fixes: was specifically not working for names. Improvements: * More complete JavaDoc comments for core public classes. * Internal cleanup of core parsing, to unify handling of Object and Array entries New features: * [JACKSON-9]: Add support for (non-standard) Json comments. (requested by Mike G) * [JACKSON-11]: Implement base64/binary methods for json generator. * [JACKSON-15]: Add copy-through methods to JsonGenerator for pass-through copying of content (copyCurrentEvent, copyCurrentStructure) * [JACKSON-23]: Add OSGi manifest headers for jars (to run on OSGi container). * Added generic "feature" mechanism to parsers, writers; features are togglable (on/off) things with well-defined default values, implemented as Enums. 0.9.3 [05-Sep-2008]: Bug fixes: * [JACKSON-5]: Symbol table construction was not thread-safe for utf-8 encoded content (new bug with 0.9.2, not present with earlier) (reported by Tudor B) * [JACKSON-8]: Serialization of BigDecimal broken with JavaTypeMapper (reported by Johannes L) * [JACKSON-14]: Problems with generic collections, serializer method signatures (due to lack of covariance wrt collection types) * Implicit conversions for numbers could sometimes lose accuracy, if floating-point number was first accessed as int/long, and then as a BigDecimal. * One Nasty NPE fixed from NameCanonicalizer (which was added in 0.9.2) New features: * [JACKSON-1]: JsonNode now implements Iterable so that it is possible use Java 5 foreach loop over array/object nodes. (suggested by Michael M) * [JACKSON-4] Added JsonParser.skipChildren() method. 0.9.2 [24-Apr-2008]: Bug fixes: * UTF-16/32 handling was not completely correct, was erroneously skipping first 2/4 bytes in some cases (even when no BOM included). Also, related unit tests added/fixed. Changes: * Replace JsonFactory.Encoding enum with JsonEncoding enum (NOTE: this is a backwards-incompatible API change) Improvements: * New higher performing UTF-8 scanner. 0.9.1 [14-Mar-2008]: New features: * JsonGenerator.useDefaultPrettyPrinter()/.setPrettyPrinter() allow for pretty printing (indentation). (thanks to Ziad M for suggestion, sample code) 0.8.0 - 0.9.0 [between 17-Oct-2007 and 14-Feb-2008]: Bug fixes: * Java type mapper had a bug in Collection mapping (mismatched calls between writeStartArray and writeEndObject!) (reported by Mike E) * Java type mapper had a bug which prevented custom mappers (as well as slower interface-based introspection) from working. (reported by Mike E) * Numeric value parsing had some problems * JavaTypeMapper and JsonTypeMapper had a bug which resulted in NullPointerException when stream ends, instead of returning null to indicate it. (reported by Augusto C) * JavaTypeMapper did not implicitly flush generator after mapping objects: it should, and now will (note: JsonTypeMapper not directly affected, flushing still needed) (suggested by Maciej P)