Java Jackson忽略列表属性中对象的属性

可以使用

@JsonIgnoreProperties

作为类级注释忽略类的属性。但假设你有以下两门课

class Client {

      @JsonIgnoreProperties ("owner")
      List<Vehicle> vehicles;
}


Class Vehicle {

      @JsonIgnoreProperties ("vehicles")
      Client owner;
}

}

---

这将始终忽略

所有者

信息。我想要得到的是，如果我有

客户机

对象，并且我得到的是

车辆

，我不需要得到

车辆

的车主信息，因为我已经有了

客户机

对象。但是如果我有一个

车辆

对象作为开始，我需要它的

所有者

属性，不包括

客户

拥有的所有

车辆

。

我不确定你说的是什么，因此，我在测试/示例部分描述了数据序列化时过滤数据的所有可能功能。例如：

@JsonIgnore

，

@jsonignoreporties

，

@JsonIgnoreType

，

@JsonView

，

@JsonFilter

和通过

mixin

/

rootType

序列化数据。您可以选择一个您喜欢的

测试/示例

---

我不确定你说的是什么，所以我在测试/示例部分描述了数据序列化时过滤数据的所有可能功能。例如：

@JsonIgnore

，

@JsonIgnoreProperties

，

@JsonIgnoreType

，

@JsonView

，

@JsonFilter

和通过

mixin

/

rootType

序列化数据。您可以选择一个您喜欢的

测试/示例

---

你必须为你的问题定义一些带有混音的模块。@holi java我在哪里可以得到一个很好的例子？我的答案不能解决你的问题？是的。我说我已经直接从数据库中检索到

车辆

对象，jackson将忽略所有者属性。我只想让它在作为

客户机的孩子访问时忽略这些信息。你能清楚地描述你的问题吗？我不能像你之前描述的那样清楚地理解你的问题。你必须为你的问题定义一些带有一些混合的模块。@holi java我从哪里可以得到一个这样的好例子？我的答案不能解决你的问题问题？是的。我说我已经直接从数据库中检索到
车辆
对象，jackson将忽略所有者属性。我只希望它在作为
客户机
的孩子访问时忽略这些信息。你能清楚地描述你的问题吗？我不能像你之前描述的那样清楚地理解你的问题。让我试试这个。@obby我已经更新了我的答案，你可以复制测试并选择一个你需要的。非常感谢。我明天早上去试试。这里是下午6点。明天早上我一考试我就选择答案让我试试这个。@obby我已经更新了我的答案，你可以复制考试并选择你需要的答案。非常感谢。我明天早上去试试。这里是下午6点。我明天早上一考试就会选择答案
@JsonIgnoreProperties ("owner")
Class Vehicle {

   Client owner;

package com.holi.jackson;

import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonIgnoreType;
import com.fasterxml.jackson.annotation.JsonView;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.Version;
import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.introspect.NopAnnotationIntrospector;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.fasterxml.jackson.databind.ser.impl.SimpleFilterProvider;
import com.jayway.jsonassert.JsonAssert;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

import static com.fasterxml.jackson.annotation.PropertyAccessor.FIELD;
import static com.fasterxml.jackson.databind.SerializationFeature.FAIL_ON_EMPTY_BEANS;
import static com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter.serializeAllExcept;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 * Created by holi on 3/20/17.
 */
public class Jackson2SerializingFilteringTest {
    private final User bob = new User("bob", "123456", "bob@example.com");
    private final ObjectMapper jackson2 = new ObjectMapper();


    @BeforeEach
    void configure() {
        jackson2.registerModules(configuration());
        //write {} for empty bean
        jackson2.disable(FAIL_ON_EMPTY_BEANS);
        jackson2.setFilterProvider(serializeAll());
        jackson2.setVisibility(FIELD, Visibility.ANY);
    }

    private Module configuration() {
        return new SimpleModule() {
            @Override
            public void setupModule(SetupContext context) {
                context.insertAnnotationIntrospector(filterIdAsClassName());
            }
        };
    }

    private NopAnnotationIntrospector filterIdAsClassName() {
        return new NopAnnotationIntrospector() {
            @Override
            public Object findFilterId(Annotated ann) {
                return ann.getRawType().getName();
            }

            @Override
            public Version version() {
                return super.version();
            }
        };
    }

    private SimpleFilterProvider serializeAll() {
        SimpleFilterProvider filters = new SimpleFilterProvider();
        //serialize all if filter not found,rather than throws an exception
        filters.setFailOnUnknownId(false);
        return filters;
    }

    @Test
    void serializingAll() throws JsonProcessingException {
        String json = jackson2.writer().writeValueAsString(bob);

        JsonAssert.with(json)
                .assertThat("$[*]", hasSize(3))
                .assertEquals("name", bob.name)
                .assertEquals("password", bob.password)
                .assertEquals("mail", bob.mail);
    }

    @Test
    void serializingAllExceptIgnoredProperties() throws JsonProcessingException {
        @JsonIgnoreProperties({"name", "version"})
        class JSONRoot {
            String name = "jackson";
            String version = "2.0";
        }
        JSONRoot root = new JSONRoot();

        String json = jackson2.writer().writeValueAsString(root);

        assertEquals("{}", json);
    }

    @Test
    void serializingAllExceptIgnoredProperty() throws JsonProcessingException {
        class JSONRoot {
            String name = "jackson";
            @JsonIgnore
            String version = "2.0";
        }
        JSONRoot root = new JSONRoot();

        String json = jackson2.writer().writeValueAsString(root);

        JsonAssert.with(json)
                .assertThat("$[*]", hasSize(1))
                .assertEquals("name", root.name);
    }

    @Test
    void serializingAllExceptIgnoredType() throws JsonProcessingException {
        @JsonIgnoreType
        class Ignored {
        }
        class JSONRoot {
            Ignored ignored = new Ignored();
        }

        String json = jackson2.writer().writeValueAsString(new JSONRoot());

        assertEquals("{}", json);
    }

    @Test
    void serializingMixInAnnotations() throws JsonProcessingException {
        jackson2.addMixIn(User.class, ExcludingMail.class);

        String json = jackson2.writer().writeValueAsString(bob);

        JsonAssert.with(json)
                .assertThat("$[*]", hasSize(2))
                .assertEquals("name", bob.name)
                .assertEquals("password", bob.password);
    }

    @Test
    void serializingUseFiltersToExcludingProperties() throws JsonProcessingException {
        String json = jackson2.writer(excludes("password")).writeValueAsString(bob);

        JsonAssert.with(json)
                .assertThat("$[*]", hasSize(2))
                .assertEquals("name", bob.name)
                .assertEquals("mail", bob.mail);
    }

    @Test
    void serializingRootTypePropertiesOnly() throws JsonProcessingException {
        String json = jackson2.writerFor(Contactable.class).writeValueAsString(bob);

        JsonAssert.with(json)
                .assertThat("$[*]", hasSize(1))
                .assertEquals("mail", bob.mail);
    }

    @Test
    void serializingViewPropertiesOnly() throws JsonProcessingException {
        String json = jackson2.writerWithView(Public.class).writeValueAsString(bob);

        JsonAssert.with(json)
                .assertThat("$[*]", hasSize(2))
                .assertEquals("name", bob.name)
                .assertEquals("mail", bob.mail);
    }

    private SimpleFilterProvider excludes(String... propertyNames) {
        SimpleFilterProvider filters = serializeAll();
        filters.addFilter(User.class.getName(), serializeAllExcept(propertyNames));
        return filters;
    }


    private class User implements Contactable {
        final String name;
        @JsonView(Privacy.class)
        String password;
        @JsonView(Public.class)
        final String mail;

        public User(String name, String password, String mail) {
            this.name = name;
            this.password = password;
            this.mail = mail;
        }

        public String getMail() {
            return mail;
        }
    }

    @interface Public {
    }

    @interface Privacy {
    }

    private interface Contactable {
        String getMail();
    }

    @JsonIgnoreProperties("mail")
    private class ExcludingMail {
    }
}