There are a couple of ways to achieve custom null value serialising:

1. If you want to serialise a null as an empty String, try using this annotation on a property, or setter:

    @JsonSetter(nulls=Nulls.AS_EMPTY)
   

or the same for specific mapper:

MAPPER.configOverride(String.class).setSetterInfo(JsonSetter.Value.forValueNulls(Nulls.AS_EMPTY));

2. You can initialise properties with default values on the declaration or in the getter.
3. As you've already mentioned, by providing a custom serialiser.

I did try your code, and that serialised null value as expected when using an ObjectMapper instead of JodaMapper. Is there any particular reason for using a JodaMapper?

See the docs on Custom Serializers; there's an example of exactly this, works for me.

In case the docs move let me paste the relevant answer:

Converting null values to something else

(like empty Strings)

If you want to output some other JSON value instead of null (mainly because some other processing tools prefer other constant values -- often empty String), things are bit trickier as nominal type may be anything; and while you could register serializer for Object.class, it would not be used unless there wasn't more specific serializer to use.

But there is specific concept of "null serializer" that you can use as follows:

// Configuration of ObjectMapper:
{
    // First: need a custom serializer provider
   StdSerializerProvider sp = new StdSerializerProvider();
   sp.setNullValueSerializer(new NullSerializer());
   // And then configure mapper to use it
   ObjectMapper m = new ObjectMapper();
   m.setSerializerProvider(sp);
}

// serialization as done using regular ObjectMapper.writeValue()

// and NullSerializer can be something as simple as:
public class NullSerializer extends JsonSerializer<Object>
{
   public void serialize(Object value, JsonGenerator jgen,
SerializerProvider provider)
       throws IOException, JsonProcessingException
   {
       // any JSON value you want...
       jgen.writeString("");
   }
}

find a solution : the abstract class SerializerProvider has a method named findNullValueSerializer, which is called to get the serializer to use for serializing null values for specified property. We can override SerializerProvider#findNullValueSerializer and match String class:

@Override
public JsonSerializer<Object> findNullValueSerializer(BeanProperty property) throws JsonMappingException {
    if (property.getType().getRawClass().equals(String.class)) {
        return EmptyStringSerializer.INSTANCE;
    } else {
        return super.findNullValueSerializer(property);
    }
}

and then set SerializerProvider to our ObjectMapper instance.

done.

After looking through documentation I found that Jackson uses nullsUsing parameter in JsonSerialize. So for example:

@JsonSerialize(nullsUsing = NullMapSerializer.class)
private Map<String, String> map;

I defined different serializers like so:

public class NullMapSerializer extends JsonSerializer<Map> {
    @Override
    public void serialize(
            final Map value,
            final JsonGenerator jsonGenerator,
            final SerializerProvider serializerProvider
    ) throws IOException {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeEndObject();
    }
}

public class NullListSerializer extends JsonSerializer<List> {
    @Override
    public void serialize(
            final List list,
            final JsonGenerator jsonGenerator,
            final SerializerProvider serializerProvider
    ) throws IOException {
        jsonGenerator.writeStartArray();
        jsonGenerator.writeEndArray();
    }
}

public class NullStringSerializer extends JsonSerializer<String> {

    @Override
    public void serialize(
            final String value,
            final JsonGenerator jsonGenerator,
            final SerializerProvider serializerProvider
    ) throws IOException {
        jsonGenerator.writeString(StringUtils.EMPTY);
    }
}

This serializes fields into {}, [], or "" whenever values are null, and normally otherwise.

Yes, its possible to create a custom serializer which uses reflection to do this. You can do this by extending StdSerializer. Your implementation might look something like this:

public class NullSerializer<T> extends StdSerializer<T> {

    public NullSerializer() {
        this(null);
    }

    public NullSerializer(Class<T> t) {
        super(t);
    }

    @Override
    public void serialize(T item, JsonGenerator jgen, SerializerProvider provider)
            throws IOException, JsonProcessingException,
            IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException)
    {

        jgen.writeStartObject();

        // For all fields of the class you're serializing
        for (final Field field : item.getClass().getDeclaredFields())
        {
            field.setAccessible(true);

            Object value = field.get(item);

            // if the value is null, create a new instance
            if (value == null)
            {  
                value = field.getType().getConstructor().newInstance();
            }

            // write it
            jgen.writeObject(value);
        }

        jgen.writeEndObject();
    }
}

This relies on there being a public default constructor for each of the fields. You may want to catch some of the exceptions rather than declare them as thrown in the signature as I've done.

You need to register this serializer with the ObjectMapper. This article explains how to do that.

I don't think this is a particularly elegant solution, but it should fulfill your requirements. I would avoid having nullable fields in the first place, but maybe that's not possible in your case.

You have the annotation in the wrong place - it needs to be on the class, not the field. i.e:

@JsonInclude(Include.NON_NULL) //or Include.NON_EMPTY, if that fits your use case 
public static class Request {
  // ...
}

As noted in comments, in versions below 2.x the syntax for this annotation is:

@JsonSerialize(include = JsonSerialize.Inclusion.NON_NULL) // or JsonSerialize.Inclusion.NON_EMPTY

The other option is to configure the ObjectMapper directly, simply by calling mapper.setSerializationInclusion(Include.NON_NULL);

(for the record, I think the popularity of this answer is an indication that this annotation should be applicable on a field-by-field basis, @fasterxml)