BAEL-9174 | Dynamic Ignore with Jackson

jackson-modules/jackson-annotations/src/main/java/com/baeldung/jackson/dynamicignore/UserWithFilter.java

@@ -0,0 +1,28 @@
+package com.baeldung.jackson.dynamicignore;
+
+import com.fasterxml.jackson.annotation.JsonFilter;
+
+@JsonFilter("publicFilter")
+public class UserWithFilter {
+
+    private Long id;
+
+    private String name;
+
+    public UserWithFilter(Long id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public UserWithFilter() {
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+}

jackson-modules/jackson-annotations/src/main/java/com/baeldung/jackson/dynamicignore/UserWithMixin.java

@@ -0,0 +1,36 @@
+package com.baeldung.jackson.dynamicignore;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+public class UserWithMixin {
+
+    private Long id;
+
+    private String name;
+
+    public UserWithMixin(Long id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public UserWithMixin() {
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    /**
+     * Mixin interface that is used to hide sensitive information
+     */
+    public interface PublicMixin {
+
+        @JsonIgnore
+        Long getId();
+    }
+
+}

jackson-modules/jackson-annotations/src/main/java/com/baeldung/jackson/dynamicignore/UserWithView.java

@@ -0,0 +1,43 @@
+package com.baeldung.jackson.dynamicignore;
+
+import com.fasterxml.jackson.annotation.JsonView;
+
+public class UserWithView {
+
+    @JsonView(InternalView.class)
+    private Long id;
+
+    @JsonView(PublicView.class)
+    private String name;
+
+    public UserWithView(Long id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+
+    public UserWithView() {
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    /**
+     * View that is used to hide sensitive information
+     */
+    public interface PublicView {
+
+    }
+
+    /**
+     * View that is used to show all information
+     */
+    public interface InternalView extends PublicView {
+
+    }
+
+}

jackson-modules/jackson-annotations/src/test/java/com/baeldung/jackson/dynamicignore/DynamicIgnoreJsonFilterUnitTest.java

@@ -0,0 +1,70 @@
+package com.baeldung.jackson.dynamicignore;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter;
+import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class DynamicIgnoreJsonFilterUnitTest {
+
+    @Test
+    void whenWritingWithoutFilter_thenIdIsPresent() throws JsonProcessingException {
+        UserWithFilter user = new UserWithFilter(1000L, "John");
+
+        SimpleFilterProvider filterProvider = new SimpleFilterProvider();
+        filterProvider.addFilter("publicFilter", SimpleBeanPropertyFilter.serializeAll());
+
+        ObjectMapper objectMapper = new ObjectMapper().setFilterProvider(filterProvider);
+        String result = objectMapper.writeValueAsString(user);
+
+        assertThat(result).contains("John");
+        assertThat(result).contains("1000");
+    }
+
+    @Test
+    void whenWritingWithFilter_thenIdIsIgnored() throws JsonProcessingException {
+        UserWithFilter user = new UserWithFilter(1000L, "John");
+
+        SimpleFilterProvider filterProvider = new SimpleFilterProvider();
+        filterProvider.addFilter("publicFilter", SimpleBeanPropertyFilter.serializeAllExcept("id"));
+
+        ObjectMapper objectMapper = new ObjectMapper().setFilterProvider(filterProvider);
+        String result = objectMapper.writeValueAsString(user);
+
+        assertThat(result).contains("John");
+        assertThat(result).doesNotContain("1000");
+    }
+
+    @Test
+    void whenReadingWithoutFilter_thenIdIsPresent() throws JsonProcessingException {
+        String json = "{\"id\":1000,\"name\":\"John\"}";
+
+        SimpleFilterProvider filterProvider = new SimpleFilterProvider();
+        filterProvider.addFilter("publicFilter", SimpleBeanPropertyFilter.serializeAll());
+
+        ObjectMapper objectMapper = new ObjectMapper().setFilterProvider(filterProvider);
+        UserWithFilter result = objectMapper.readValue(json, UserWithFilter.class);
+
+        assertEquals(1000L, result.getId());
+        assertEquals("John", result.getName());
+    }
+
+    @Test
+    void whenReadingWithFilter_thenIdIsStillPresent() throws JsonProcessingException {
+        String json = "{\"id\":1000,\"name\":\"John\"}";
+
+        SimpleFilterProvider filterProvider = new SimpleFilterProvider();
+        filterProvider.addFilter("publicFilter", SimpleBeanPropertyFilter.serializeAllExcept("id"));
+
+        ObjectMapper objectMapper = new ObjectMapper().setFilterProvider(filterProvider);
+        UserWithFilter result = objectMapper.readValue(json, UserWithFilter.class);
+
+        assertEquals(1000L, result.getId());
+        assertEquals("John", result.getName());
+    }
+}

jackson-modules/jackson-annotations/src/test/java/com/baeldung/jackson/dynamicignore/DynamicIgnoreJsonMixinUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.jackson.dynamicignore;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+class DynamicIgnoreJsonMixinUnitTest {
+
+    @Test
+    void whenWritingWithoutMixin_thenIdIsPresent() throws JsonProcessingException {
+        UserWithMixin user = new UserWithMixin(1000L, "John");
+        String result = new ObjectMapper().writeValueAsString(user);
+        assertThat(result).contains("John");
+        assertThat(result).contains("1000");
+    }
+
+    @Test
+    void whenWritingWithPublicMixin_thenIdIsIgnored() throws JsonProcessingException {
+        UserWithMixin user = new UserWithMixin(1000L, "John");
+        ObjectMapper objectMapper = new ObjectMapper().addMixIn(UserWithMixin.class, UserWithMixin.PublicMixin.class);
+        String result = objectMapper.writeValueAsString(user);
+        assertThat(result).contains("John");
+        assertThat(result).doesNotContain("1000");
+    }
+
+    @Test
+    void whenReadingWithoutMixin_thenIdIsPresent() throws JsonProcessingException {
+        String json = "{\"id\":1000,\"name\":\"John\"}";
+        UserWithMixin user = new ObjectMapper().readValue(json, UserWithMixin.class);
+        assertEquals(1000L, user.getId());
+        assertEquals("John", user.getName());
+    }
+
+    @Test
+    void whenReadingWithPublicMixin_thenIdIsIgnored() throws JsonProcessingException {
+        String json = "{\"id\":1000,\"name\":\"John\"}";
+        ObjectMapper objectMapper = new ObjectMapper().addMixIn(UserWithMixin.class, UserWithMixin.PublicMixin.class);
+        UserWithMixin user = objectMapper.readValue(json, UserWithMixin.class);
+        assertNull(user.getId());
+        assertEquals("John", user.getName());
+    }
+}

jackson-modules/jackson-annotations/src/test/java/com/baeldung/jackson/dynamicignore/DynamicIgnoreJsonViewUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.jackson.dynamicignore;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.ObjectReader;
+import com.fasterxml.jackson.databind.ObjectWriter;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+class DynamicIgnoreJsonViewUnitTest {
+
+    @Test
+    void whenWritingWithPublicView_thenIdIsIgnored() throws JsonProcessingException {
+        UserWithView user = new UserWithView(1000L, "John");
+        ObjectWriter objectWriter = new ObjectMapper().writerWithView(UserWithView.PublicView.class);
+        String result = objectWriter.writeValueAsString(user);
+        assertThat(result).contains("John");
+        assertThat(result).doesNotContain("1000");
+    }
+
+    @Test
+    void whenWritingWithInternalView_thenIdIsPresent() throws JsonProcessingException {
+        UserWithView user = new UserWithView(1000L, "John");
+        ObjectWriter objectWriter = new ObjectMapper().writerWithView(UserWithView.InternalView.class);
+        String result = objectWriter.writeValueAsString(user);
+        assertThat(result).contains("John");
+        assertThat(result).contains("1000");
+    }
+
+    @Test
+    void whenReadingWithPublicView_thenIdIsIgnored() throws JsonProcessingException {
+        String json = "{\"id\":1000,\"name\":\"John\"}";
+        ObjectReader objectReader = new ObjectMapper().readerWithView(UserWithView.PublicView.class)
+            .forType(UserWithView.class);
+        UserWithView user = objectReader.readValue(json);
+        assertEquals("John", user.getName());
+        assertNull(user.getId());
+    }
+
+    @Test
+    void whenReadingWithInternalView_thenIdIsPresent() throws JsonProcessingException {
+        String json = "{\"id\":1000,\"name\":\"John\"}";
+        ObjectReader objectReader = new ObjectMapper().readerWithView(UserWithView.InternalView.class)
+            .forType(UserWithView.class);
+        UserWithView user = objectReader.readValue(json);
+        assertEquals("John", user.getName());
+        assertEquals(1000L, user.getId());
+    }
+
+}