Add support for subset of jackson annotations

[bkhall]

To allow JSON tag names to NOT match field names, setters, and getters.

Ex:
Where a JSON object contains a tag like this: "name": "John",

It would properly populate a field in a class like this:

@JsonProperty("name")
protected String mPrettyName;

public String getPrettyName() {
    return mPrettyName;
}

public void setPrettyName(String prettyName) {
    mPrettyName = prettyName;
}

Note that the field, setter ,and getter do NOT match the JSON tag name.

[cowtowncoder]

I'll have to think about this. One of main goals for jackson-jr is to keep things very compact, and this is why no annotation support was added. At the same time, small high-value additions can be considered.

In this case, perhaps the first part would be to figure out an extension point for registering an object that could handle naming. Such an object could handle annotation-based renaming, but also possible alternate external naming strategy.

Another thing to consider from extensibility standpoint is the added dependency to jackson annotations. This could be a reason implement this as separate maven (sub-module), within same project. As such it could also be contained in jackson-jr-all uber-jar.

[bkhall]

Agreed, smaller is better, especially when using on Android. But, there's already a dependency on the jackson-core library due to an Exception reference from your project. The jackson-annotations library is only 33kb. Even adding it to the uber-jar, it's still smaller than the main jackson databinder.

[cowtowncoder]

@bkhall Yes, it is smaller, but unlike core, can not easily be shaded. Not so much wrt size of the result (which is small, agreed), but that it is one additional external dependency. Anyway, adding configuration mechanism as a separate sub-module is probably the way to go, shading it (but not annotations -- they need to be separate public, non-relocated types IMO) seems reasonable to me.

[gregschlom]

This seems especially useful to map property names with underscores to camel case

[cowtowncoder]

I think this should be an extension piece of some sort, similar to jr-stree, which is separate jar (except for uber-jar case). But would need hooks in jr-objects to plug in.

[mikeholler]

I think this is also a must in cases where object keys have spaces in them. In that case, such objects could not be represented by POJOs without the @JsonProperty annotation.

[cowtowncoder]

It has been a while but I am now considering doing something to handle this and related issues.
Approach would be to:

1. Create extension point that would allow sort of equivalent operations as Jackson's Bean[De]SerializerModifier, which allows for
   • Removal of properties (similar to @JsonIgnore, @JsonIgnoreProperties)
   • Renaming of properties (@JsonProperty)
   • Specifying serialization ordering (@JsonPropertyOrder)
2. Create new module that constructs pluggable object that can read useful subset of Jackson annotations for relevant cases.

I'll have to see how feasible this is, but if it is and I have time, this would go in version 2.10.

[mukhtar]

I assume this didn't make it into 2.10?

[cowtowncoder]

2.10 is not out yet. But it may be that I won't have time to do it properly... would really like to get it done if at all possible.

[cowtowncoder]

Did not make it in 2.10, but hoping to add in 2.11. Basic plan the same wrt Bean[De]SerializerModifier equivalent.

[cowtowncoder]

Now implemented: see

https://github.com/FasterXML/jackson-jr/tree/master/jr-annotation-support

for more details on usage, supported annotations.