Java 类com.fasterxml.jackson.databind.ser.impl.SimpleBeanPropertyFilter 实例源码

@Test
public void findAllTest2() throws Exception {
    Auction auction = new Auction();
    auction.setRealmId(1);
    auction.setItemId(124105);
    List<Auction> auctions = auctionService.findAll(auction);
    ObjectMapper mapper = new ObjectMapper();
    FilterProvider filters = new SimpleFilterProvider().addFilter("auctionFilter",
            SimpleBeanPropertyFilter.filterOutAllExcept("owner"));

    MappingJacksonValue mappingJacksonValue = new MappingJacksonValue(auctions);
    mappingJacksonValue.setFilters(filters);
    System.out.println(mappingJacksonValue.getValue());
}

private ObjectMapper createMapper(JsonFactory mapping, ClassLoader classLoader) {
    ObjectMapper mapper = new ObjectMapper(mapping);
    mapper.addMixIn(MasterSlaveServersConfig.class, MasterSlaveServersConfigMixIn.class);
    mapper.addMixIn(SingleServerConfig.class, SingleSeverConfigMixIn.class);
    mapper.addMixIn(Config.class, ConfigMixIn.class);
    mapper.addMixIn(CodecProvider.class, ClassMixIn.class);
    mapper.addMixIn(ResolverProvider.class, ClassMixIn.class);
    mapper.addMixIn(Codec.class, ClassMixIn.class);
    mapper.addMixIn(RedissonNodeInitializer.class, ClassMixIn.class);
    mapper.addMixIn(LoadBalancer.class, ClassMixIn.class);
    FilterProvider filterProvider = new SimpleFilterProvider()
            .addFilter("classFilter", SimpleBeanPropertyFilter.filterOutAllExcept());
    mapper.setFilterProvider(filterProvider);
    mapper.setSerializationInclusion(Include.NON_NULL);

    if (classLoader != null) {
        TypeFactory tf = TypeFactory.defaultInstance()
                .withClassLoader(classLoader);
        mapper.setTypeFactory(tf);
    }

    return mapper;
}

@Test
public void renderSimpleBeanWithFilters() throws Exception {
    TestSimpleBeanFiltered bean = new TestSimpleBeanFiltered();
    bean.setProperty1("value");
    bean.setProperty2("value");
    Map<String, Object> model = new HashMap<String, Object>();
    model.put("bindingResult", mock(BindingResult.class, "binding_result"));
    model.put("foo", bean);
    FilterProvider filters = new SimpleFilterProvider().addFilter("myJacksonFilter",
            SimpleBeanPropertyFilter.serializeAllExcept("property2"));
    model.put(FilterProvider.class.getName(), filters);

    view.setUpdateContentLength(true);
    view.render(model, request, response);

    String content = response.getContentAsString();
    assertTrue(content.length() > 0);
    assertEquals(content.length(), response.getContentLength());
    assertThat(content, containsString("\"property1\":\"value\""));
    assertThat(content, not(containsString("\"property2\":\"value\"")));
    assertFalse(content.contains(FilterProvider.class.getName()));
}

@Test
public void test() throws Exception {
  SomeObject someObject = new SomeObject(1, 2, 3);
  PropertyFilter withoutB = SimpleBeanPropertyFilter.serializeAllExcept("b");

  String actual = mapper.writeValueAsString(someObject);
  Assert.assertEquals(1, parser.parse(actual).read("$.a", Integer.class).intValue());
  Assert.assertEquals(2, parser.parse(actual).read("$.b", Integer.class).intValue());
  Assert.assertEquals(3, parser.parse(actual).read("$.c", Integer.class).intValue());

  actual = mapper.writer(new DynamicFilterProvider(withoutB)).writeValueAsString(someObject);
  Assert.assertEquals(1, parser.parse(actual).read("$.a", Integer.class).intValue());
  Assert.assertNull(parser.parse(actual).read("$.b"));
  Assert.assertEquals(3, parser.parse(actual).read("$.c", Integer.class).intValue());

  actual = mapper.writeValueAsString(someObject);
  Assert.assertEquals(1, parser.parse(actual).read("$.a", Integer.class).intValue());
  Assert.assertEquals(2, parser.parse(actual).read("$.b", Integer.class).intValue());
  Assert.assertEquals(3, parser.parse(actual).read("$.c", Integer.class).intValue());

  actual = mapper.writer(new DynamicFilterProvider()).writeValueAsString(someObject);
  Assert.assertEquals(1, parser.parse(actual).read("$.a", Integer.class).intValue());
  Assert.assertEquals(2, parser.parse(actual).read("$.b", Integer.class).intValue());
  Assert.assertEquals(3, parser.parse(actual).read("$.c", Integer.class).intValue());
}

@Test
public void testReadRdf() throws IOException, JsonLdError {
    // FIXME this does not really test the output
    PhenoPacket packet = YamlReader
            .readFile("src/test/resources/context/phenopacket-with-context.yaml");
    Model model = RdfGenerator.toRdf(packet, null);
    String packetID = packet.getId();
    PhenoPacket newPacket = RdfReader.readModel(model,
            ContextUtil.expandIdentifierAsValue(packetID, packet));
    ObjectMapper m = new ObjectMapper();
    m.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    m.setFilterProvider(new SimpleFilterProvider().addFilter(
            "PhenoPacketClass", SimpleBeanPropertyFilter.serializeAll()));
    ObjectWriter writer = m.writerWithDefaultPrettyPrinter();
    System.out.println(writer.writeValueAsString(newPacket));
}

@Test
public void ensureThatSerializingASymbolWithoutProjectDoesNotCrash() throws JsonProcessingException {
    String expectedJson = "{\"actions\":["
                + "{\"type\":\"web_click\",\"disabled\":false,\"negated\":false,\"ignoreFailure\":false,"
                        + "\"errorOutput\":null,\"node\":null,\"doubleClick\":false},"
                + "{\"type\":\"web_checkForText\",\"disabled\":false,\"negated\":false,\"ignoreFailure\":false,"
                    + "\"errorOutput\":null,\"value\":\"F[oO0]+\",\"regexp\":true},"
                + "{\"type\":\"wait\",\"disabled\":false,\"negated\":false,\"ignoreFailure\":false,"
                    + "\"errorOutput\":null,\"duration\":" + ONE_SECOND + "}"
            + "],\"group\":2,\"id\":null,\"name\":\"WebSymbol\",\"project\":null,\"successOutput\":null}";
    symbol.setProject(null);

    ObjectMapper mapper = new ObjectMapper();
    mapper.addMixInAnnotations(Object.class, PropertyFilterMixIn.class);

    SimpleBeanPropertyFilter filter = SimpleBeanPropertyFilter.serializeAllExcept("hidden");
    FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name", filter);

    String json = mapper.writer(filters).writeValueAsString(symbol);

    assertEquals(expectedJson, json);
}

/**
 * Create a new JsonManager
 * @param theClass The class to create a json manager for (yes, also in the diamonds).
 */
public JsonManager (Class<T> theClass) {
    this.theClass = theClass;
    this.mapper = new ObjectMapper();
    mapper.addMixInAnnotations(Rectangle2D.class, Rectangle2DMixIn.class);
    mapper.registerModule(new GeoJsonModule());
    SimpleModule deser = new SimpleModule();

    deser.addDeserializer(LocalDate.class, new JacksonSerializers.LocalDateStringDeserializer());
    deser.addSerializer(LocalDate.class, new JacksonSerializers.LocalDateStringSerializer());

    deser.addDeserializer(Rectangle2D.class, new Rectangle2DDeserializer());
    mapper.registerModule(deser);
    mapper.getSerializerProvider().setNullKeySerializer(new JacksonSerializers.MyDtoNullKeySerializer());
    filters = new SimpleFilterProvider();
    filters.addFilter("bbox", SimpleBeanPropertyFilter.filterOutAllExcept("west", "east", "south", "north"));
    this.writer = mapper.writer(filters);
}

@Test
public void createTest() throws Exception {

    EntrezGene
            gene = new EntrezGene(6L, "GeneF", 9606, "", "10", "", "", "protein-coding", null, null, null);
    objectMapper.setFilterProvider(new SimpleFilterProvider().addFilter("fieldFilter",
            SimpleBeanPropertyFilter.serializeAllExcept()).setFailOnUnknownId(false));
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    mockMvc.perform(post(BASE_URL)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$", hasKey("entrezGeneId")))
            .andExpect(jsonPath("$.entrezGeneId", is(6)));

    mockMvc.perform(get(BASE_URL + "/{id}", 6L))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.entrezGeneId", is(6)));

    geneRepository.delete(6L);

}

private ObjectWriter getObjectWriter(ObjectMapper mapper, String[] fieldsToReturn) {

        if (fieldsToReturn.length != 0) {
            mapper.addMixInAnnotations(
                    Object.class, PropertyFilterMixIn.class);

            HashSet<String> givenFields = new HashSet<>();
            givenFields.add("schemas");
            Collections.addAll(givenFields, fieldsToReturn);
            String[] finalFieldsToReturn = givenFields.toArray(new String[givenFields.size()]);

            FilterProvider filters = new SimpleFilterProvider()
                    .addFilter("filter properties by name",
                            SimpleBeanPropertyFilter.filterOutAllExcept(
                                    finalFieldsToReturn));
            return mapper.writer(filters);
        }
        return mapper.writer();
    }

@Bean
public SimpleFilterProvider filterProvider() {
    final Set<String> set = ImmutableSet.of(
            "indexProtocol",
            "indexPort",
            "serviceProtocol",
            "servicePort",
            "productType",
            "productTypeRegex",
            "indexErrorMessage",
            "plaintextPassword",
            "currentPassword"
    );

    final SimpleBeanPropertyFilter.SerializeExceptFilter filter = new SimpleBeanPropertyFilter.SerializeExceptFilter(set);

    return new SimpleFilterProvider(ImmutableMap.of("configurationFilter", filter));
}

protected void configureJSONExporter() {
    mapper = new ObjectMapper();

    // configure
    mapper.enable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS);

    // set Mixins
    mapper.addMixInAnnotations(BaseNode.class, JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(TaskNode.class, JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(EventNode.class, JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(InfoNode.class, JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(SymLinkNode.class, JsonExportBaseNodeMixin.class);
    mapper.addMixInAnnotations(UrlResNode.class, JsonExportBaseNodeMixin.class);

    // add additional filters
    mapper.addMixInAnnotations(Object.class, PropertyFilterMixIn.class);
    String[] ignorableFieldNames = {"importTmpId", "fullSrc", "srcName"};
    FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name",
                    SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));
    writer = mapper.writer(filters);
}

@SuppressWarnings("deprecation")
@RequestMapping(value = "/api/path", method = RequestMethod.GET)
@ResponseBody
public String getPathsForProfile(Model model, String profileIdentifier,
                                 @RequestParam(value = "typeFilter[]", required = false) String[] typeFilter,
                                 @RequestParam(value = "clientUUID", defaultValue = Constants.PROFILE_CLIENT_DEFAULT_ID) String clientUUID) throws Exception {
    int profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);
    List<EndpointOverride> paths = PathOverrideService.getInstance().getPaths(profileId, clientUUID, typeFilter);

    HashMap<String, Object> jqReturn = Utils.getJQGridJSON(paths, "paths");

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.addMixInAnnotations(Object.class, ViewFilters.GetPathFilter.class);
    String[] ignorableFieldNames = {"possibleEndpoints", "enabledEndpoints"};
    FilterProvider filters = new SimpleFilterProvider().addFilter("Filter properties from the PathController GET",
                                                                  SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));

    ObjectWriter writer = objectMapper.writer(filters);

    return writer.writeValueAsString(jqReturn);
}

@RequestMapping(value = "/api/path/test", method = RequestMethod.GET)
@ResponseBody
public String testPath(@RequestParam String url, @RequestParam String profileIdentifier,
                       @RequestParam Integer requestType) throws Exception {
    int profileId = ControllerUtils.convertProfileIdentifier(profileIdentifier);

    List<EndpointOverride> trySelectedRequestPaths = PathOverrideService.getInstance().getSelectedPaths(Constants.OVERRIDE_TYPE_REQUEST,
                                                                                                        ClientService.getInstance().findClient("-1", profileId),
                                                                                                        ProfileService.getInstance().findProfile(profileId), url, requestType, true);

    HashMap<String, Object> jqReturn = Utils.getJQGridJSON(trySelectedRequestPaths, "paths");

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.addMixInAnnotations(Object.class, ViewFilters.GetPathFilter.class);
    String[] ignorableFieldNames = {"possibleEndpoints", "enabledEndpoints"};
    FilterProvider filters = new SimpleFilterProvider().addFilter("Filter properties from the PathController GET",
                                                                  SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));

    ObjectWriter writer = objectMapper.writer(filters);

    return writer.writeValueAsString(jqReturn);
}

ObjectWriter newWriter(final boolean locationInfo, final boolean properties, final boolean compact) {
    final SimpleFilterProvider filters = new SimpleFilterProvider();
    final Set<String> except = new HashSet<>(2);
    if (!locationInfo) {
        except.add(this.getPropertNameForSource());
    }
    if (!properties) {
        except.add(this.getPropertNameForContextMap());
    }
    except.add(this.getPropertNameForNanoTime());
    filters.addFilter(Log4jLogEvent.class.getName(), SimpleBeanPropertyFilter.serializeAllExcept(except));
    final ObjectWriter writer = this.newObjectMapper().writer(compact ? this.newCompactPrinter() : this.newPrettyPrinter());
    return writer.with(filters);
}

public static String objectToJsonExclude(Object data,String filterName, String  ...exName) {
    try {
          SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter
                  .serializeAllExcept(exName);
          FilterProvider filters = new SimpleFilterProvider()
                  .addFilter(filterName, theFilter);

          return MAPPER.writer(filters).writeValueAsString(data);
} catch (JsonProcessingException e) {
    e.printStackTrace();
}
    return null;
  }

@ExceptionHandler(CerebroException.class)
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public String getErrorCode(final CerebroException exception) throws IOException {
    LOGGER.error("Service error", exception);
    ObjectMapper objectMapper = new ObjectMapper();
    FilterProvider filterProvider = new SimpleFilterProvider().addFilter("responseFilter",
        SimpleBeanPropertyFilter.filterOutAllExcept("errorCode", "errorMessage"));
    objectMapper.setFilterProvider(filterProvider);
    return objectMapper.writeValueAsString(exception);
}

@Test
public void filters() throws JsonProcessingException {
    ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json()
            .filters(new SimpleFilterProvider().setFailOnUnknownId(false)).build();
    JacksonFilteredBean bean = new JacksonFilteredBean("value1", "value2");
    String output = objectMapper.writeValueAsString(bean);
    assertThat(output, containsString("value1"));
    assertThat(output, containsString("value2"));

    objectMapper = Jackson2ObjectMapperBuilder.json().filters((new SimpleFilterProvider().setFailOnUnknownId(false)
            .setDefaultFilter(SimpleBeanPropertyFilter.serializeAllExcept("property2")))).build();
    output = objectMapper.writeValueAsString(bean);
    assertThat(output, containsString("value1"));
    assertThat(output, not(containsString("value2")));
}

@Bean
public DynamicFilterResponseBodyAdvice propertyFilterResponseBodyAdvice() {
  DynamicFilterResponseBodyAdvice advice = new DynamicFilterResponseBodyAdvice();
  advice.addResolvers(new DynamicFilterResolver<WithoutAB>() {
    @Override
    public PropertyFilter apply(WithoutAB t) {
      return SimpleBeanPropertyFilter.serializeAllExcept("a", "b");
    }
  });
  return advice;
}

public static String render(Object obj) throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
    mapper.setFilterProvider(new SimpleFilterProvider().addFilter(
            "PhenoPacketClass", SimpleBeanPropertyFilter.serializeAll()));
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
    return writer.writeValueAsString(obj);
}

private static ObjectNode generateSchema() throws JsonMappingException {
    ObjectMapper m = new ObjectMapper();
    m.setFilterProvider(new SimpleFilterProvider().addFilter(
            "PhenoPacketClass", SimpleBeanPropertyFilter.serializeAll()));
    SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
    m.acceptJsonFormatVisitor(m.constructType(PhenoPacket.class), visitor);
    JsonSchema jsonSchema = visitor.finalSchema();
    return (ObjectNode) m.valueToTree(jsonSchema);
}

private static String prettyJsonString(Object obj)
        throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    mapper.setFilterProvider(new SimpleFilterProvider().addFilter(
            "PhenoPacketClass", SimpleBeanPropertyFilter.serializeAll()));
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    ObjectWriter writer = mapper.writerWithDefaultPrettyPrinter();
    return writer.writeValueAsString(obj);
}

private void makeSchema(Class c, String fn) throws IOException {

        ObjectMapper m = new ObjectMapper();
        m.setFilterProvider(new SimpleFilterProvider().addFilter(
                "PhenoPacketClass", SimpleBeanPropertyFilter.serializeAll()));
        SchemaFactoryWrapper visitor = new SchemaFactoryWrapper();
        m.acceptJsonFormatVisitor(m.constructType(c), visitor);
        JsonSchema jsonSchema = visitor.finalSchema();
        String s = m.writerWithDefaultPrettyPrinter().writeValueAsString(
                jsonSchema);
        System.out.println(s);
        writeSchema(fn, s);
    }

private void makeSchema(Class<?> c, String fn) throws IOException {
    // Protobuf cannot serialize freeform Objects
    ObjectMapper mapper = new ProtobufMapper()
            .setFilterProvider(new SimpleFilterProvider().addFilter(
                    "PhenoPacketClass",
                    SimpleBeanPropertyFilter.serializeAllExcept("@context")));
    // TODO: make these compile and pass!
    ProtobufSchemaGenerator gen = new ProtobufSchemaGenerator();
    mapper.acceptJsonFormatVisitor(c, gen);
    ProtobufSchema schemaWrapper = gen.getGeneratedSchema();
    String s = schemaWrapper.getSource().toString();
    writeSchema(fn, s);

}

public ObjectMapperExceptField(Class<?> targetClass, String property) {
    super();
    SimpleBeanPropertyFilter theFilter = SimpleBeanPropertyFilter.serializeAllExcept(property);
    FilterProvider filters = new SimpleFilterProvider().addFilter("myFilter", theFilter);
    addMixInAnnotations(targetClass, PropertyFilterMixIn.class);
    setFilters(filters);
}

public static String writeGroup(SymbolGroup group) throws JsonProcessingException {
    SimpleBeanPropertyFilter filter = SimpleBeanPropertyFilter.serializeAllExcept("symbolAmount");
    FilterProvider filters = new SimpleFilterProvider().addFilter("filter properties by name", filter);
    ObjectMapper mapper = new ObjectMapper();
    mapper.addMixInAnnotations(Object.class, PropertyFilterMixIn.class);
    return mapper.writer(filters).writeValueAsString(group);
}

@Override
public void initialize(Bootstrap<SystemApiConfiguration> maintenanceConfigurationBootstrap) {
    ObjectMapper mapper = maintenanceConfigurationBootstrap.getObjectMapper();
    mapper.addMixInAnnotations(NetworkInterface.class, NetworkInterfaceMixin.class);
    FilterProvider filterProvider = new SimpleFilterProvider()
            .addFilter("networkInterface filter", SimpleBeanPropertyFilter.serializeAllExcept("name", "displayName", "inetAddresses", "interfaceAddresses", "mtu", "subInterfaces"));
    mapper.setFilters(filterProvider);
}

public static FilterProvider getFilterProvider(final String... fieldsToExclude) {
    if (null == fieldsToExclude || fieldsToExclude.length == 0) {
        // Use the 'serializeAllExcept' method so it is compatible with older versions of jackson
        return new SimpleFilterProvider()
                .addFilter(FILTER_FIELDS_BY_NAME, (BeanPropertyFilter) SimpleBeanPropertyFilter.serializeAllExcept());
    }

    return new SimpleFilterProvider()
            .addFilter(FILTER_FIELDS_BY_NAME, (BeanPropertyFilter) SimpleBeanPropertyFilter.serializeAllExcept(fieldsToExclude));
}

protected MappingJacksonValue buildResponse(Object resource, String attributes) {

        MappingJacksonValue wrapper = new MappingJacksonValue(resource);
        if (!Strings.isNullOrEmpty(attributes)) {
            Set<String> attributesSet = extractAttributes(attributes);
            FilterProvider filterProvider = new SimpleFilterProvider().addFilter(
                    "attributeFilter", SimpleBeanPropertyFilter.filterOutAllExcept(attributesSet)
            );
            wrapper.setFilters(filterProvider);
        }
        return wrapper;
    }

/**
 * Convert a {@link Marathon} object to Json.
 *
 * @param marathon
 * @return
 * @throws IOException
 */
@Override
public String serializeMarathon(Marathon marathon) throws IOException {
    FilterProvider filters = new SimpleFilterProvider().addFilter("filterConstraints",
            SimpleBeanPropertyFilter.serializeAllExcept("constraints"));

    String json = objectMapper.setFilterProvider(filters).writeValueAsString(marathon);
    return json;
}

@Override
public String process(String textToProcess, JsonNode configuration) throws Throwable {
    HttpResponseForAvailability httpResponseForAvailability = JsonConverter.jsonStringToObject(textToProcess, HttpResponseForAvailability.class);

    ObjectMapper mapper = new ObjectMapper();
    String[] ignorableFieldNames = { "httpStatusCode"};
    FilterProvider filters = new SimpleFilterProvider()
            .addFilter("httpFilter", SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));
    ObjectWriter writer = mapper.writer(filters);
    return  writer.writeValueAsString(httpResponseForAvailability);
}

@Override
public String process(String textToProcess, JsonNode configuration) throws Throwable {
    HttpResponseForAvailability httpResponseForAvailability =
            JsonConverter.jsonStringToObject(textToProcess, HttpResponseForAvailability.class);

    ObjectMapper mapper = new ObjectMapper();
    String[] ignorableFieldNames = { "body"};
    FilterProvider filters = new SimpleFilterProvider()
            .addFilter("httpFilter",SimpleBeanPropertyFilter.serializeAllExcept(ignorableFieldNames));
    ObjectWriter writer = mapper.writer(filters);
    return writer.writeValueAsString(httpResponseForAvailability);
}

@Test
public void updateTest() throws Exception {

    EntrezGene gene = new EntrezGene(7L, "GeneG", 9606, "", "10", "", "", "protein-coding", null, 
            null, null);
    objectMapper.setFilterProvider(new SimpleFilterProvider().addFilter("fieldFilter",
                    SimpleBeanPropertyFilter.serializeAllExcept()).setFailOnUnknownId(false));
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

    mockMvc.perform(post(BASE_URL)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isCreated());

    gene.setPrimaryGeneSymbol("TEST_GENE");

    mockMvc.perform(put(BASE_URL + "/{id}", 7L)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$", hasKey("entrezGeneId")))
            .andExpect(jsonPath("$.entrezGeneId", is(7)))
            .andExpect(jsonPath("$.primaryGeneSymbol", is("TEST_GENE")));

    mockMvc.perform(get(BASE_URL + "/{id}", 7L))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$.entrezGeneId", is(7)))
            .andExpect(jsonPath("$.primaryGeneSymbol", is("TEST_GENE")));

    geneRepository.delete(7L);

}

@Test
public void postTest() throws Exception {
    EntrezGene
            gene = new EntrezGene(6L, "GeneF", 9606, "", "10", "", "", "protein-coding", null, null, null);
    objectMapper.setFilterProvider(new SimpleFilterProvider().addFilter("fieldFilter",
            SimpleBeanPropertyFilter.serializeAllExcept()).setFailOnUnknownId(false));
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mockMvc.perform(post(BASE_URL)
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isMethodNotAllowed());
}

@Test
public void putTest() throws Exception {
    EntrezGene
            gene = new EntrezGene(6L, "GeneF", 9606, "", "10", "", "", "protein-coding", null, null, null);
    objectMapper.setFilterProvider(new SimpleFilterProvider().addFilter("fieldFilter",
            SimpleBeanPropertyFilter.serializeAllExcept()).setFailOnUnknownId(false));
    objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mockMvc.perform(put(BASE_URL + "/1")
            .contentType(MediaType.APPLICATION_JSON)
            .content(objectMapper.writeValueAsBytes(gene)))
            .andExpect(status().isMethodNotAllowed());
}

public static String toXml(final Ds3ObjectList objects, final boolean isBulkPut) {
    if (isBulkPut) {
        return XmlOutput.toXml(objects);
    }
    final FilterProvider filters = new SimpleFilterProvider().addFilter("sizeFilter",
            SimpleBeanPropertyFilter.serializeAllExcept("Size"));
    return XmlOutput.toXml(objects, filters);
}

public HappyDroidObjectMapper() {
    super();

    configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
    happyModules = new SimpleModule();
    happyModules.addSerializer(new StackTraceSerializer());
    registerModule(happyModules);

    setFilters(new SimpleFilterProvider().addFilter("HappyDroidServiceObject", SimpleBeanPropertyFilter.serializeAllExcept("id")));
}

/**
 * Enables/Disables redaction support when serializing complex objects.  Redacted fields/properties marked
 * with the @LogRedact annotation will be output as a string with the value "{@code <REDACTED>}".
 *
 * @param redactEnabled - true to filter out redacted fields
 *
 * @since 1.1.0
 */
public void setRedactEnabled(final boolean redactEnabled) {
    final SimpleFilterProvider simpleFilterProvider = new SimpleFilterProvider();
    if (redactEnabled) {
        simpleFilterProvider.addFilter(RedactionFilter.REDACTION_FILTER_ID, new RedactionFilter(!_redactNull));
    } else {
        simpleFilterProvider.addFilter(RedactionFilter.REDACTION_FILTER_ID,
                SimpleBeanPropertyFilter.serializeAllExcept(Collections.<String>emptySet()));
    }
    _objectMapper.setFilterProvider(simpleFilterProvider);
    _redactEnabled = redactEnabled;
}

/**
 * Create a JSON serializer for these validation results.
 * @param results
 */
public JsonSerializer (FeedValidationResultSet results) {
    super(results);
    mapper = new ObjectMapper();
    mapper.addMixInAnnotations(Rectangle2D.class, Rectangle2DMixIn.class);
    SimpleModule deser = new SimpleModule();
    deser.addDeserializer(Rectangle2D.class, new Rectangle2DDeserializer());
    mapper.registerModule(deser);
    SimpleFilterProvider filters = new SimpleFilterProvider();
    filters.addFilter("bbox", SimpleBeanPropertyFilter.filterOutAllExcept("west", "east", "south", "north"));
    writer = mapper.writer(filters);
}

@Override
@SuppressWarnings("unchecked")
public PropertyFilter findPropertyFilter(final Object filterId, final Object valueToFilter) {
    if (filterId instanceof String) {
        final String id = (String) filterId;

        // FilterId should represent a class only in case of root entity is marshalled.
        if (id.equals(root.getEntityClass().getName())) {
            stack.clear();
            return stack.push(root);
        }

        while (!stack.isEmpty()) {
            final FilteringPropertyFilter peek = stack.peek();
            final FilteringPropertyFilter subfilter = peek.findSubfilter(id);

            if (subfilter != null) {
                stack.push(subfilter);

                // Need special handling for maps here - map keys can be filtered as well so we just say that every key is
                // allowed.
                if (valueToFilter instanceof Map) {
                    final Map<String, ?> map = (Map<String, ?>) valueToFilter;
                    return new FilteringPropertyFilter(Map.class, map.keySet(),
                            Collections.emptyMap());
                }
                return subfilter;
            } else {
                stack.pop();
            }
        }
    }
    return SimpleBeanPropertyFilter.filterOutAllExcept();
}

@Override
public String getBody() throws Exception {
    Set<String> properties = new HashSet<String>();
    for (String field : fields) {
        properties.add(field);
    }
    SimpleBeanPropertyFilter filter = new SimpleBeanPropertyFilter.FilterExceptFilter(properties);
    SimpleFilterProvider provider = new SimpleFilterProvider();
    provider.addFilter("update inventory request filter", filter);
    return mapper.writer(provider).writeValueAsString(inventory);
}