templates.plugins.spincast-jackson-json.spincast-jackson-json.html Maven / Gradle / Ivy
Show all versions of spincast-website Show documentation
{% extends "../../layout.html" %}
{% block sectionClasses %}plugins hasBreadCrumb plugins-spincast-jackson-json{% endblock %}
{% block meta_title %}Plugins - Spincast Jackson Json{% endblock %}
{% block meta_description %}Spincast Jackson Json plugin provides Json functionalities using Jackson.{% endblock %}
{% block scripts %}
{% endblock %}
{% block body %}
Plugins- Spincast Jackson Json plugin
Overview
This plugin provides Json functionalities
using Jackson. It contains an implementation
of the JsonManager
interface : SpincastJsonManager.
Make sure you read the JsonObjects section for more information. The
Jackson documentation can also be very useful.
Installation
If you use the spincast-default artifact and the standard Bootstrapper,
this plugin is already installed by default so you have nothing to do!
If you start from scratch, using the spincast-core artifact, you can use the
plugin by :
1. Adding this Maven artifact to your project:
<dependency>
<groupId>org.spincast</groupId>
<artifactId>spincast-plugins-jackson-json</artifactId>
<version>{{spincast.spincastCurrrentVersion}}</version>
</dependency>
2. Installing the provided SpincastJacksonJsonPluginModule
module to your Guice context.
Plugin class
The class implementing the SpincastPlugin
interface is SpincastJacksonJsonPlugin.
Suggested add-on
-
Name :
json()
-
Component : JsonManager
-
Usage : to give your
Route Handlers access to Json
functionalitites.
Example :
public void myRouteHandler(DefaultRequestContext context) {
// Creates a new JsonObject
JsonObject obj = context.json().create();
//...
}
This add-on is already installed by default on the
Request Context type.
Javadoc
Main Configurations
You can bind a SpincastJsonManagerConfig
implementation to tweak the default configurations
used by the components this plugin provides. By default, the
SpincastJsonManagerConfigDefault
class is used as the implementation.
(De)serialization configurations
Jackson allows some configuration when serializing and deserializing an object.
Most of those configurations
are defined using annotations.
You can annotate the objects directly, or you can use mix-ins.
Annotating the objects :
If you don't minds annotating your objects with Jackson specific annotations,
this is maybe the simplest thing to do. For example, let's say you have a User
class that has two fields, name and title, and you don't want
to keep the title field when you
serialize an instance of this class:
public class User implements User {
private String name;
private String title;
@Override
public String getName() {
return this.name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
public String getTitle() {
return this.title;
}
@Override
public void setTitle(String title) {
this.title = title;
}
}
To ignore the title field to be included during the serialization, you can simply
annotate the getTitle() method with
@JsonIgnore:
public class User implements User {
private String name;
private String title;
@Override
public String getName() {
return this.name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
@JsonIgnore
public String getTitle() {
return this.title;
}
@Override
public void setTitle(String title) {
this.title = title;
}
}
If you serialize an instance of this class using the Json Manager,
only the name property would be kept:
User user = new User();
user.setName("Stromgol");
user.setTitle("alien");
String jsonString = getJsonManager().toJsonString(user);
assertEquals("{\"name\":\"Stromgol\"}", jsonString);
Using mix-ins:
Many developers (us included) don't like to pollute their model classes
with too many annotations. Lucky us, Jackson provides a way to configure
objects from the outside, without annotating the objects directly, by using what is called
mix-ins annotations.
Let's start with the same User class, without any Jackson annotations:
public class User implements User {
private String name;
private String title;
@Override
public String getName() {
return this.name;
}
@Override
public void setName(String name) {
this.name = name;
}
@Override
public String getTitle() {
return this.title;
}
@Override
public void setTitle(String title) {
this.title = title;
}
}
To use Json mix-ins in a Spincast application,
you first need to create the mix-in abstract class. Interfaces work too, but
only to annotate methods, not fields.
An example mix-in for our User objects:
public abstract class UserMixin implements User {
// Ignore this property!
@Override
@JsonIgnore
public abstract String getTitle();
}
As you can see, a mix-in extends the class/interface to configure, and adds
the Jackson annotations on the overriding fields or methods declarations.
Once the mix-in is defined, you have to register it, in your custom
Guice module:
public class AppModule extends SpincastDefaultGuiceModule {
public AppModule(String[] mainArgs) {
super(mainArgs);
}
@Override
protected void configure() {
super.configure();
bindJsonMixins();
//...
}
protected void bindJsonMixins() {
Multibinder<JsonMixinInfo> jsonMixinsBinder = Multibinder.newSetBinder(binder(), JsonMixinInfo.class);
jsonMixinsBinder.addBinding().toInstance(new JsonMixinInfo(User.class, UserMixin.class));
}
}
Explanation :
-
18 : A
multibinder is used
to collect the various mix-ins to register. The advantage of a multibinder
is that it allows to register mix-ins from any Guice module. For example, some
plugins may want to register their mix-ins, and you may want to register your custom ones.
-
19 : We register our mix-in, by binding a
JsonMixinInfo instance, which specifies the class to configure, and the
class of the mix-in used to configure it.
With this in place, Spincast will automatically configure Jackson so it uses your mix-ins, and
you would have the exact same result than annotating the User
class directly:
User user = new User();
user.setName("Stromgol");
user.setTitle("alien");
String jsonString = getJsonManager().toJsonString(user);
assertEquals("{\"name\":\"Stromgol\"}", jsonString);
{% endblock %}
Spincast Jackson Json 
Spincast Jackson Json