DSON is a dart library which converts Dart Objects into their JSON representation.
This library was initially a fork from Dartson. Now it contains some differences:
- Dartson uses custom transformers to convert objects to JSON. This produce faster and smaller code after dart2Js. Instead DSON uses serializable and built_mirrors libraries. This should produce code as fast and small as Dartson transformer.
- DSON has the ability to serialize cyclical objects by mean of
depthparameter, which allows users to specify how deep in the object graph they want to serialize.
- DSON has the ability to exclude attributes for serialziation in two ways.
@ignoreover every attribute. This make excluding attributes too global and hardcoded, so users can only specify one exclusion schema.
excludemap as parameter for
toJsonmethod. This is more flexible, since it allows to have many exclusion schemas for serialization.
- DSON uses the annotation
@entitywhich is used by Dartson.
Comparison with other libraries
Create a new dart project.
Add dependencies to
... dependencies: ... dson: any # replace for latest version ...
web/main.dartand add the code shown in any of the samples below.
pub run build_runner build, or
pub run build_runner watch, or
pub run build_runner servein the console
Convert objects to JSON strings
To convert objects to JSON strings you only need to use the
toJson function, annotate the object with
@serializable and pass the
object to the
toJson function as parameter:
Converting objects to Maps
To convert objects to Maps you only need to use the
toMap function, annotate the object with
@serializable and pass the
toMap function as parameter:
Serializing Cyclical Objects
To serialize objects that contains Cyclical References it would be needed to use the annotation
@cyclical. If this annotation is present and the
depth variable is not set then the non-primitive objects are not going to be parsed and only the id (or hashmap if the object does not contains id) is going to be present. Let's see next example:
as you can see employee has an address, and the address has an owner of type Employee. If the property
id is not present in the object then it is going to take the
hashcode value from the object as reference. And finally, the
depth parameter passed to serialize function tells serializer how deep you want to go throw the reference. This help us not only to avoid cyclical reference, but to determine what referenced objects should be serialized.
The same applies for lists:
Without the annotation
@cyclical the program is going to throw a stack overflow error caused by the serializing of cyclical objects.
Excluding attributes from being serialized
To exclude parameter from being serialized we have two options the first option is using
@ignore over the attribute to ignore. However this approach is too global. What I want to say with this is that the attribute is going to be ignored always.
Another way to exclude attributes is adding the parameter
serialize function. In this way we only exclude those attributes during that serialization.
Convert JSON strings to objects
To convert JSON strings to objects you only need to use the
fromJsonList functions and pass the
json string to deserialize and the
Type of the object as parameters:
Lists<Map> to dart objects
Frameworks like Angular.dart come with several HTTP services which already transform the HTTP response to a map using
JSON.encode. To use those encoded Maps or Lists use
Extend serializable Objects
To extends objects that are going to be serializable you will need to add the comment:
// ignore: mixin_inherits_from_not_object
This is to advice the analyzer to ignore the error caused by inheriting from an object that is not a mixin. For example:
Serialize/Deserialize immutable objects
To make an immutable class to be able to serialize/deserialize you only need to declare it with a constructor which only contains final parameters. For example: