I worked it out by adding a custom deserializer to an attribute in my model class and using JsonDeserialize annotation's contentUsing() method, like so:

@JsonDeserialize(contentUsing = MyCustomDeserializer.class)
private List<CustomClass> customClassObjList;

where MyCustomDeserializer class is a custom Jackson JSON deserializer defined as:

public class MyCustomDeserializer extends JsonDeserializer<CustomClass> {
    
    @Override
    public CustomClass deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        ...
    }
}

You can use a "HidableSerializer" for this and check the data during serialization

1. Create a IHidable interface

The interface has a isHidden method which is called during serialization

package ch.hasselba.jackson.test;

public interface IHidable {
    public boolean isHidden();
}

2. Change your BadItem class

Add the interface and change the setter of id. When property id is deserialized, it is tested if it is an Integer. If not, the item is marked as bad.

package ch.hasselba.jackson.test;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;

@JsonIgnoreProperties( {"hidden"} ) 
public class BadItem implements IHidable{
    private Integer id;
    public String name;
    private boolean isBadItem;
    public Integer getId(){
        return id;
    }
    public void setId(Object value){
        if( value instanceof Integer ){
            this.id = (Integer) value;
        }else{
            this.isBadItem = true;
        }
    }
    public boolean isHidden() {
        return isBadItem;
    }
}

3. Create a HidableSerializer

package ch.hasselba.jackson.test;

import java.io.IOException;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;


@SuppressWarnings("serial")
public class HidableSerializer<T> extends StdSerializer<T> {

    private JsonSerializer<T> defaultSerializer;

    protected HidableSerializer(Class<T> t) {
        super(t);
    }

    public JsonSerializer<T> getDefaultSerializer() {
        return defaultSerializer;
    }

    public void setDefaultSerializer(JsonSerializer<T> defaultSerializer) {
        this.defaultSerializer = defaultSerializer;
    }

    @Override
    public void serialize(T value, JsonGenerator jgen, SerializerProvider provider)
            throws IOException, JsonProcessingException {

        if( value instanceof IHidable ){
            IHidable hidableValue = (IHidable) value;
            if( hidableValue.isHidden() )
                return;
        }

        defaultSerializer.serialize(value, jgen, provider);
    }

}

4. Register the HidableSerializer and that's it

package ch.hasselba.jackson.test;

import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.BeanSerializerModifier;

public class Demo {

    @SuppressWarnings("serial")
    public static void main(String[] args) {

        // register the HidableSerializer
        ObjectMapper mapper = new ObjectMapper();
        mapper.setSerializationInclusion(Include.NON_EMPTY);
        mapper.registerModule(new SimpleModule() {
            @Override
            public void setupModule(SetupContext context) {
                super.setupModule(context);
                context.addBeanSerializerModifier(new BeanSerializerModifier() {
                    @Override
                    public JsonSerializer<?> modifySerializer(
                      SerializationConfig config, BeanDescription desc, JsonSerializer<?> serializer) {
                        if (BadItem.class.isAssignableFrom(desc.getBeanClass())) {
                            HidableSerializer ser = new HidableSerializer(BadItem.class);
                            ser.setDefaultSerializer(serializer);
                            return ser;
                        }
                        return serializer;
                    }
                });
            }
        });

        String content = "{  \"items\": [    {      \"id\": 1,      \"name\": \"Item1\"    },    {      \"id\": 2,      \"name\": \"Item2\"    },    {      \"id\":[],      \"name\": \"Item3\"    }  ]}";

        // build the Object
        BadList test = null;
        try {
            test =  mapper.readValue(content, BadList.class);
        } catch (Exception e) {
            e.printStackTrace();
        }

        // and now convert it back to a String
        String data = null;
        try {
             data = mapper.writeValueAsString(test);
        } catch (Exception e) {
            e.printStackTrace();
        }

        // print the result
        System.out.println( data );
    }

}

When changing the id "[]" to an Integer value, the Item is displayed, otherwise it is empty.

The result:

{"items":[{"id":1,"name":"Item1"},{"id":2,"name":"Item2"}]}

Since I don't want to implement a custom class (Username) just to map the username, I went with a little bit more elegant, but still quite ugly approach:

ObjectMapper mapper = new ObjectMapper();
JsonNode node = mapper.readTree(in);
JsonNode user = node.get("user");
FlickrAccount account = new FlickrAccount();
account.setId(user.get("id").asText());
account.setUsername(user.get("username").get("_content").asText());

It's still not as elegant as I hoped, but at least I got rid of all the ugly casting. Another advantage of this solution is, that my domain class (FlickrAccount) is not polluted with any Jackson annotations.

Based on @Michał Ziober's answer, I decided to use the - in my opinion - most straight forward solution. Using a @JsonDeserialize annotation with a custom deserializer:

@JsonDeserialize( using = FlickrAccountDeserializer.class )
public class FlickrAccount {
    ...
}

But the deserializer does not use any internal classes, just the JsonNode as above:

class FlickrAccountDeserializer extends JsonDeserializer<FlickrAccount> {
    @Override
    public FlickrAccount deserialize(JsonParser jp, DeserializationContext ctxt) throws 
            IOException, JsonProcessingException {
        FlickrAccount account = new FlickrAccount();
        JsonNode node = jp.readValueAsTree();
        JsonNode user = node.get("user");
        account.setId(user.get("id").asText());
        account.setUsername(user.get("username").get("_content").asText());
        return account;
    }
}