Jackson will give you null for other objects, but for String it will give empty String.

But you can use a Custom JsonDeserializer to do this:

class CustomDeserializer extends JsonDeserializer<String> {

    @Override
    public String deserialize(JsonParser jsonParser, DeserializationContext context) throws IOException, JsonProcessingException {
        JsonNode node = jsonParser.readValueAsTree();
        if (node.asText().isBlank()) {
            return null;
        }
        return node.toString();
    }

}

In class you have to use it for location field:

class EventBean {
    public Long eventId;
    public String title;

    @JsonDeserialize(using = CustomDeserializer.class)
    public String location;
}

Yep, it's very simple: use own Serializer for fields which can be empty and must be null:

class TestEntity {

    @JsonProperty(value = "test-field")
    @JsonSerialize(usung = ForceNullStringSerializer.class)
    private String testField;
}

class ForceNullStringSerializer extends JsonSerializer<String> {

    @Override
    public void serialize(String value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        if (value == null || value.equals("")) {
            gen.writeNull();
        } else {
            gen.writeString(value);
        }
    }
}

This serializer can be applied to all fields where you need to return null.

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("");
   }
}

You will have to write a custom Jackson Serializer - a good example is here - http://wiki.fasterxml.com/JacksonHowToCustomSerializers (there is a specific example of how to convert null values to empty Strings that you can use)

Here are all the steps(for Jackson < 2.0):

Write your custom null Serializer:

import java.io.IOException;

import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.map.JsonSerializer;
import org.codehaus.jackson.map.SerializerProvider;

public class NullSerializer extends JsonSerializer<Object> {

    @Override
    public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
        jgen.writeString("");
    }
}

Register this with Jackson Objectmapper:

import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.ser.StdSerializerProvider;


public class CustomObjectMapper extends ObjectMapper{
    public CustomObjectMapper(){
        StdSerializerProvider sp = new StdSerializerProvider();
        sp.setNullValueSerializer(new NullSerializer());
        this.setSerializerProvider(sp);
    }

}

Register this objectmapper with Spring MVC:

<mvc:annotation-driven> 
   <mvc:message-converters register-defaults="true">
       <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter">
           <property name="objectMapper">
               <bean class="CustomObjectMapper"/>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

You can override default ObjectMapper (provided by Spring Boot auto-configuration) and configure globally format to use for properties of type String.

@Configuration
public class JacksonConfiguration {

    @Bean
    ObjectMapper jacksonObjectMapper(Jackson2ObjectMapperBuilder builder) {
        final var objectMapper = builder.createXmlMapper(false).build();
        objectMapper.configOverride(String.class).setSetterInfo(JsonSetter.Value.forValueNulls(Nulls.AS_EMPTY));
        return objectMapper;
    }

}

I finally found what was my issue.

In my application, I use a custom RestTemplate. But this CustomRestTemplate use the default constructor of the Spring RestTemplate class. So it use the default MessageConverter list.

The solution was to add a constructor for my CustomRestTemplate with the MessageConverter list as input.

@Component
public class CustomRestTemplate extends RestTemplate {
    @Autowired
    public CustomRestTemplate (List<HttpMessageConverter<?>> messageConverters) {
        super(messageConverters);
    }
}

And to configuration the converter with the disabled "ACCEPT_EMPTY_STRING_AS_NULL_OBJECT" feature :

@Configuration
@ComponentScan(basePackages = "com.geodis.rt")
public class WebApplicationConfig extends WebMvcConfigurerAdapter {

    @Override
    public void configureMessageConverters( List<HttpMessageConverter<?>> converters ) {
        converters.add(0, converter());
    }

    @Bean
    MappingJackson2HttpMessageConverter converter() {
        MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
        converter.getObjectMapper().disable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        return converter;
    }

}

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?

DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT is not going to help you because it means "deserialise empty string JSON value as null for object field" and unfortunately your String fields are scalars not JSON objects. I think there is no convenient way to get behaviour you want. It is possible to override deserializaton behaviour for all fields with type String but you may not want it. Also you can define custom deserialzer but you will need to annotate every field like this:

@JsonDeserialize(using = MyStringDeseralizer.class)
private String businessTitle;

where class MyStringDeseralizer extends JsonDeserializer<String> and implement conversion logic you need.

You could enable ACCEPT_EMPTY_STRING_AS_NULL_OBJECT in your ObjectMapper:

ObjectMapper mapper = new ObjectMapper();
mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);

Alternatively, you could define a custom deserializer:

public class CustomStringDeserializer extends JsonDeserializer<String> {

    @Override
    public String deserialize(JsonParser p, DeserializationContext ctxt) 
            throws IOException {

        String value = StringDeserializer.instance.deserialize(p, ctxt);
        if (value == null || value.trim().isEmpty()) {
            return null;
        }

        return value;
    }
}

And register it to a module in your ObjectMapper:

SimpleModule module = new SimpleModule();
module.addDeserializer(String.class, new CustomStringDeserializer());

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(module);

This deserializer will be used to deserialize all strings.