Jackson Mapper - how to fail on null or empty values

Have you considered Bean Validation?

While Jackson is focused in JSON parsing, Bean Validation is all about declaring and performing validation on your beans.

You could use @NotNull or @NotBlank from Hibernate Validator, the Bean Validation reference implementation.

Alternatively you could use JSON Schema.

There is an option called: FAIL_ON_NULL_FOR_CREATOR_PARAMETERS.

So I assume it would be accessible at: DeserializationConfig.Feature.FAIL_ON_NULL_FOR_CREATOR_PARAMETERS;

Or in yml:

jackson:
    serialization:
      indent-output: false
    deserialization:
      fail-on-unknown-properties: true
      fail-on-missing-creator-properties: true
      fail-on-null-creator-properties: true

This works on all types, strings, ints, doubles etc..

Object specific custom Deserializer would have to be created.

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.ObjectCodec;
import com.fasterxml.jackson.core.Version;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.deser.std.StdDeserializer;
import com.fasterxml.jackson.databind.module.SimpleModule;

import java.io.IOException;

class JacksonDeserializerTest {

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        SimpleModule module = new SimpleModule("CustomPersonDeserializer", new Version(1, 0, 0, null, null, null));
        module.addDeserializer(Person.class, new CustomPersonDeserializer());
        mapper.registerModule(module);

        String jsonString = "{ \"id\": 1, \"name\": \"User 1 \"}";
        Person user = mapper.readValue(jsonString, Person.class);
        System.out.println("User: " + user.toString());

        jsonString = "{ \"id\": 1}";
        user = mapper.readValue(jsonString, Person.class);
    }

    static class CustomPersonDeserializer extends StdDeserializer<Person> {

        private static final long serialVersionUID = -4100181951833318756L;

        public CustomPersonDeserializer() {
            this(null);
        }

        public CustomPersonDeserializer(Class<?> vc) {
            super(vc);
        }

        @Override
        public Person deserialize(JsonParser parser, DeserializationContext deserializer) throws IOException, JsonProcessingException {
            Person person = new Person();
            ObjectCodec codec = parser.getCodec();
            JsonNode node = codec.readTree(parser);

            JsonNode idNode = node.get("id");
            int id = idNode.asInt();
            person.setId(id);

            JsonNode nameNode = node.get("name");
            if(nameNode == null){
                throw new IOException("name must be provided");
            }

            String name = nameNode.asText();
            if (name.trim().length() < 1){
                throw new IOException("name can not be empty");
            }

            person.setName(name);
            return person;
        }
    }

    static class Person {
        private int id;
        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", id=" + id +
                    '}';
        }
    }
}

Alternate way:
This works on the objects as well

ObjectMapper mapper= new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);