Configuration and Meta-Annotations

/**
 * Configure property auto-detection visibility levels
 * @param getterVisibility Visibility level for getter methods
 * @param isGetterVisibility Visibility level for is-getter methods  
 * @param setterVisibility Visibility level for setter methods
 * @param creatorVisibility Visibility level for creator methods/constructors
 * @param fieldVisibility Visibility level for fields
 */
@JsonAutoDetect(JsonAutoDetect.Visibility getterVisibility = JsonAutoDetect.Visibility.DEFAULT,
                JsonAutoDetect.Visibility isGetterVisibility = JsonAutoDetect.Visibility.DEFAULT,
                JsonAutoDetect.Visibility setterVisibility = JsonAutoDetect.Visibility.DEFAULT,
                JsonAutoDetect.Visibility creatorVisibility = JsonAutoDetect.Visibility.DEFAULT,
                JsonAutoDetect.Visibility fieldVisibility = JsonAutoDetect.Visibility.DEFAULT)
public @interface JsonAutoDetect {
    
    enum Visibility {
        /** Detect members with any visibility */
        ANY,
        
        /** Detect non-private members (public, protected, package) */
        NON_PRIVATE,
        
        /** Detect protected and public members only */
        PROTECTED_AND_PUBLIC,
        
        /** Detect public members only */
        PUBLIC_ONLY,
        
        /** Do not auto-detect any members */
        NONE,
        
        /** Use default detection rules */
        DEFAULT;
        
        public boolean isVisible(Member member);
    }
}

// Detect all fields regardless of visibility
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
public class AllFieldsVisible {
    private String privateField;      // Will be serialized
    protected String protectedField;  // Will be serialized
    public String publicField;        // Will be serialized
}

// Only use explicitly annotated properties
@JsonAutoDetect(
    fieldVisibility = JsonAutoDetect.Visibility.NONE,
    getterVisibility = JsonAutoDetect.Visibility.NONE,
    setterVisibility = JsonAutoDetect.Visibility.NONE
)
public class ExplicitOnly {
    private String name;           // Won't be serialized
    private String description;    // Won't be serialized
    
    @JsonProperty
    private String title;          // Will be serialized (explicit annotation)
    
    @JsonGetter
    public String getName() {      // Will be serialized (explicit annotation)
        return name;
    }
}

// Custom visibility combinations
@JsonAutoDetect(
    fieldVisibility = JsonAutoDetect.Visibility.PROTECTED_AND_PUBLIC,
    getterVisibility = JsonAutoDetect.Visibility.PUBLIC_ONLY,
    setterVisibility = JsonAutoDetect.Visibility.ANY
)
public class MixedVisibility {
    private String privateField;      // Not serialized
    protected String protectedField;  // Serialized (field visibility)
    public String publicField;        // Serialized (field visibility)
    
    public String getPublicData() { return "data"; }    // Serialized (getter visibility)
    protected String getProtectedData() { return ""; }  // Not serialized (getter visibility)
    
    private void setPrivateValue(String value) { }      // Used for deserialization (setter visibility ANY)
}

/**
 * Specify filter ID for property filtering
 * @param value Filter identifier used with SimpleFilterProvider
 */
@JsonFilter(String value)
public @interface JsonFilter;

@JsonFilter("userFilter")
public class User {
    private String username;
    private String email;
    private String password;
    private String ssn;
    private String internalId;
}

// Usage with ObjectMapper:
SimpleFilterProvider filters = new SimpleFilterProvider();
filters.addFilter("userFilter", 
    SimpleBeanPropertyFilter.filterOutAllExcept("username", "email"));

ObjectMapper mapper = new ObjectMapper();
mapper.setFilterProvider(filters);

// Only username and email will be serialized

/**
 * Define view classes for property inclusion
 * @param value Array of view classes
 */
@JsonView(Class<?>[] value = {})
public @interface JsonView;

public class Views {
    public static class Public { }
    public static class Internal extends Public { }
    public static class Admin extends Internal { }
}

public class UserAccount {
    @JsonView(Views.Public.class)
    private String username;
    
    @JsonView(Views.Public.class)
    private String email;
    
    @JsonView(Views.Internal.class)
    private String fullName;
    
    @JsonView(Views.Internal.class)
    private LocalDateTime lastLogin;
    
    @JsonView(Views.Admin.class)
    private String passwordHash;
    
    @JsonView(Views.Admin.class)
    private List<String> permissions;
    
    // No view annotation - included in all views
    private String id;
}

// Usage:
ObjectMapper mapper = new ObjectMapper();

// Public view - only username, email, id
String publicJson = mapper.writerWithView(Views.Public.class)
    .writeValueAsString(user);

// Internal view - username, email, fullName, lastLogin, id
String internalJson = mapper.writerWithView(Views.Internal.class)
    .writeValueAsString(user);

// Admin view - all fields
String adminJson = mapper.writerWithView(Views.Admin.class)
    .writeValueAsString(user);

/**
 * Define property serialization order
 * @param value Array of property names in desired order
 * @param alphabetic Whether to order remaining properties alphabetically
 */
@JsonPropertyOrder(String[] value = {},
                   boolean alphabetic = false)
public @interface JsonPropertyOrder;

@JsonPropertyOrder({"id", "name", "email", "created"})
public class OrderedUser {
    private String email;
    private String name;
    private Long id;
    private LocalDateTime created;
    private String department;  // Will appear after the ordered properties
}

@JsonPropertyOrder(alphabetic = true)
public class AlphabeticalUser {
    private String username;
    private String email;
    private String firstName;
    private String lastName;
    // All properties will be ordered alphabetically
}

@JsonPropertyOrder(value = {"priority", "status"}, alphabetic = true)
public class MixedOrderUser {
    private String status;
    private String priority;
    private String username;    // Alphabetical after priority/status
    private String email;       // Alphabetical
    private String firstName;   // Alphabetical
}

/**
 * Define root wrapper name
 * @param value Root element name
 * @param namespace XML namespace for root element
 */
@JsonRootName(String value,
              String namespace = "")
public @interface JsonRootName;

@JsonRootName("user")
public class User {
    private String name;
    private String email;
}

// With root wrapping enabled:
// {"user": {"name": "John", "email": "john@email.com"}}

@JsonRootName(value = "product", namespace = "http://example.com/products")
public class Product {
    private String name;
    private BigDecimal price;
}

// With XML: <product xmlns="http://example.com/products"><name>...</name><price>...</price></product>

/**
 * Meta-annotation marking Jackson annotations for processing
 */
@JacksonAnnotation
public @interface JacksonAnnotation;

/**
 * Meta-annotation for creating combo annotations containing multiple Jackson annotations
 */
@JacksonAnnotationsInside
public @interface JacksonAnnotationsInside;

// Custom combination annotation
@JacksonAnnotationsInside
@JsonIgnoreProperties(ignoreUnknown = true)
@JsonInclude(JsonInclude.Include.NON_NULL)
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
public @interface FlexibleJson {
}

// Usage
@FlexibleJson
public class ApiResponse {
    private String status;
    private String message;
    private Object data;
    // Combines all the annotations from @FlexibleJson
}

// API-specific annotation
@JacksonAnnotationsInside
@JsonIgnoreProperties(ignoreUnknown = true)
@JsonPropertyOrder({"id", "type", "attributes"})
@JsonView(Views.Public.class)
public @interface ApiResource {
}

@ApiResource
public class ResourceEntity {
    private Long id;
    private String type;
    private Map<String, Object> attributes;
}

// Configure at class level
@JsonAutoDetect(
    fieldVisibility = JsonAutoDetect.Visibility.NONE,
    getterVisibility = JsonAutoDetect.Visibility.PUBLIC_ONLY,
    isGetterVisibility = JsonAutoDetect.Visibility.PUBLIC_ONLY,
    setterVisibility = JsonAutoDetect.Visibility.PUBLIC_ONLY,
    creatorVisibility = JsonAutoDetect.Visibility.PUBLIC_ONLY
)
public class RestrictedVisibility {
    // Only public getters/setters and explicitly annotated fields
}

// Or configure globally on ObjectMapper
ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE);
mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.PUBLIC_ONLY);

public class ViewHierarchy {
    public static class Basic { }
    public static class Detailed extends Basic { }
    public static class Admin extends Detailed { }
    
    public static class Export { }
    public static class AuditLog extends Export { }
}

public class Document {
    @JsonView({ViewHierarchy.Basic.class, ViewHierarchy.Export.class})
    private String title;
    
    @JsonView(ViewHierarchy.Detailed.class)
    private String content;
    
    @JsonView({ViewHierarchy.Admin.class, ViewHierarchy.AuditLog.class})
    private String createdBy;
    
    @JsonView(ViewHierarchy.AuditLog.class)
    private List<String> modifications;
}

@JsonFilter("dynamicFilter")
public class ConfigurableEntity {
    private String publicData;
    private String sensitiveData;
    private String internalData;
    private String adminData;
}

// Dynamic filter based on user role
public PropertyFilter createUserFilter(UserRole role) {
    switch (role) {
        case PUBLIC:
            return SimpleBeanPropertyFilter.filterOutAllExcept("publicData");
        case INTERNAL:
            return SimpleBeanPropertyFilter.serializeAllExcept("adminData");
        case ADMIN:
            return SimpleBeanPropertyFilter.serializeAll();
        default:
            return SimpleBeanPropertyFilter.filterOutAll();
    }
}

/**
 * Value class for JsonAutoDetect configuration
 */
public static class JsonAutoDetect.Value implements JacksonAnnotationValue<JsonAutoDetect> {
    public static final JsonAutoDetect.Value DEFAULT;
    public static final JsonAutoDetect.Value NO_OVERRIDES;
    
    public static JsonAutoDetect.Value construct(
        JsonAutoDetect.Visibility getters,
        JsonAutoDetect.Visibility isGetters,
        JsonAutoDetect.Visibility setters,
        JsonAutoDetect.Visibility creators,
        JsonAutoDetect.Visibility fields);
    
    public JsonAutoDetect.Visibility getGetterVisibility();
    public JsonAutoDetect.Visibility getIsGetterVisibility();
    public JsonAutoDetect.Visibility getSetterVisibility();
    public JsonAutoDetect.Visibility getCreatorVisibility();
    public JsonAutoDetect.Visibility getFieldVisibility();
    
    public JsonAutoDetect.Value withGetterVisibility(JsonAutoDetect.Visibility v);
    public JsonAutoDetect.Value withIsGetterVisibility(JsonAutoDetect.Visibility v);
    public JsonAutoDetect.Value withSetterVisibility(JsonAutoDetect.Visibility v);
    public JsonAutoDetect.Value withCreatorVisibility(JsonAutoDetect.Visibility v);
    public JsonAutoDetect.Value withFieldVisibility(JsonAutoDetect.Visibility v);
}

/**
 * Define human-readable description for annotated class
 * @param value Description text for the class
 */
@JsonClassDescription(String value = "")
public @interface JsonClassDescription;

@JsonClassDescription("Represents a user account in the system")
public class User {
    private String username;
    private String email;
}

@JsonClassDescription("Configuration settings for application features")
@JsonIgnoreProperties(ignoreUnknown = true)
public class AppConfig {
    private boolean debugMode;
    private String environment;
    private Map<String, Object> features;
}

@JsonClassDescription("API response wrapper with status and data")
public class ApiResponse<T> {
    private String status;
    private T data;
    private List<String> errors;
}