@Override protected ObjectMapper initializeObjectMapper() { final ObjectMapper mapper = super.initializeObjectMapper(); final FilterProvider filters = new SimpleFilterProvider() .addFilter("beanObjectFilter", new CasSimpleBeanObjectFilter()); mapper.setFilters(filters); mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); mapper.configure(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS, false); mapper.configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false); mapper.setSerializationInclusion(JsonInclude.Include.NON_EMPTY); mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); mapper.addMixIn(Object.class, CasSimpleBeanObjectFilter.class); mapper.disable(SerializationFeature.INDENT_OUTPUT); mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); return mapper; }
@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 testSerializeComment() throws IOException { final Comment aComment = new Comment(); aComment.setContent("<b>There it is</b>"); ByteArrayOutputStream out = new ByteArrayOutputStream(); jsonHelper.withWriter(out, new Writer() { @Override public void writeContents(JsonGenerator generator, ObjectMapper objectMapper) throws JsonGenerationException, JsonMappingException, IOException { FilterProvider fp = new SimpleFilterProvider().addFilter( JacksonHelper.DEFAULT_FILTER_NAME, new ReturnAllBeanProperties()); objectMapper.writer(fp).writeValue(generator, aComment); } }); assertTrue(out.toString().contains("{\"content\":\"<b>There it is</b>\"")); }
@Test public void testNullInComment() throws IOException { final Comment aComment = new Comment(); aComment.setContent(null); ByteArrayOutputStream out = new ByteArrayOutputStream(); jsonHelper.withWriter(out, new Writer() { @Override public void writeContents(JsonGenerator generator, ObjectMapper objectMapper) throws JsonGenerationException, JsonMappingException, IOException { FilterProvider fp = new SimpleFilterProvider().addFilter( JacksonHelper.DEFAULT_FILTER_NAME, new ReturnAllBeanProperties()); objectMapper.writer(fp).writeValue(generator, aComment); } }); assertEquals("Null values should not be output.", "{\"canEdit\":false,\"canDelete\":false}", out.toString()); }
@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())); }
private ObjectMapper getDefaultObjectMapper(boolean xml, boolean details, TreeNode<String, Boolean> perms) { if (perms == null) { throw new NullPointerException("Permissions may not be null"); } ObjectMapper om = xml ? new XmlMapper() : new ObjectMapper(); om.setSerializationInclusion(JsonInclude.Include.NON_NULL); SimpleModule mod = new SimpleModule(); for (Map.Entry<Class, BaseSerializer> entry : serializers.entrySet()) { mod.addSerializer(entry.getKey(), entry.getValue()); } mod.addDeserializer(ItemStack.class, new ItemStackDeserializer()); mod.addDeserializer(BlockState.class, new BlockStateDeserializer()); mod.addDeserializer(ItemStackSnapshot.class, new ItemStackSnapshotDeserializer()); mod.addDeserializer(Location.class, new LocationDeserializer()); om.registerModule(mod); SimpleFilterProvider filterProvider = new SimpleFilterProvider(); filterProvider.addFilter(BaseFilter.ID, new BaseFilter(details, perms)); om.setFilterProvider(filterProvider); om.setAnnotationIntrospector(new AnnotationIntrospector(details)); return om; }
@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)); }
@Before public void setUp() { _objectMapper = new ObjectMapper(); _objectMapper.setAnnotationIntrospector(new StenoAnnotationIntrospector(_objectMapper)); // CHECKSTYLE.OFF: IllegalInstantiation - No Guava dependency here. final Map<String, Object> filterMap = new HashMap<>(); // CHECKSTYLE.ON: IllegalInstantiation filterMap.put(RedactionFilter.REDACTION_FILTER_ID, new RedactionFilter(false)); _objectMapper.setFilterProvider(new SimpleFilterProvider(filterMap)); // CHECKSTYLE.OFF: IllegalInstantiation - No Guava dependency here. final Map<String, Object> beanMap = new HashMap<>(); // CHECKSTYLE.ON: IllegalInstantiation beanMap.put("foo", "bar"); _redactedBean = new RedactedBean("string", 1234, 1.0d, new String[] {"string1", "string2"}, true, beanMap); _nonRedactedBean = new NonRedactedBean("string", 1234, 1.0d, new String[] {"string1", "string2"}, true, beanMap); }
/** * @deprecated Provided for test compatibility with deprecated method in Jackson. */ @Test @Deprecated public void testDeprecatedSerializeAsFieldWithNull() throws Exception { final RedactionFilter mockFilter = Mockito.mock(RedactionFilter.class); Mockito.doAnswer(new SerializeAsFieldAnswer(new RedactionFilter(true))) .when(mockFilter).serializeAsField( Mockito.any(), Mockito.any(JsonGenerator.class), Mockito.any(SerializerProvider.class), Mockito.any(PropertyWriter.class)); // CHECKSTYLE.OFF: IllegalInstantiation - No Guava dependency here. final Map<String, Object> filterMap = new HashMap<>(); // CHECKSTYLE.ON: IllegalInstantiation filterMap.put(RedactionFilter.REDACTION_FILTER_ID, mockFilter); _objectMapper.setFilters(new SimpleFilterProvider(filterMap)); final JsonNode actualTree = _objectMapper.valueToTree(_redactedBean); final JsonNode expectedTree = readTree("testDeprecatedSerializeAsFieldWithNull.json"); Assert.assertEquals(expectedTree, actualTree); }
/** * @deprecated Provided for test compatibility with deprecated method in Jackson. */ @Test @Deprecated public void testDeprecatedSerializeAsFieldWithoutNull() throws Exception { final RedactionFilter mockFilter = Mockito.mock(RedactionFilter.class); Mockito.doAnswer(new SerializeAsFieldAnswer(new RedactionFilter(false))) .when(mockFilter).serializeAsField( Mockito.any(), Mockito.any(JsonGenerator.class), Mockito.any(SerializerProvider.class), Mockito.any(PropertyWriter.class)); // CHECKSTYLE.OFF: IllegalInstantiation - No Guava dependency here. final Map<String, Object> filterMap = new HashMap<>(); // CHECKSTYLE.ON: IllegalInstantiation filterMap.put(RedactionFilter.REDACTION_FILTER_ID, mockFilter); _objectMapper.setFilters(new SimpleFilterProvider(filterMap)); final JsonNode actualTree = _objectMapper.valueToTree(_redactedBean); final JsonNode expectedTree = readTree("testDeprecatedSerializeAsFieldWithoutNull.json"); Assert.assertEquals(expectedTree, actualTree); }
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); }
/** * Outfit the given {@link ObjectMapper} with a filter that will treat all metadata map entries as transient. * * @param om object mapper to modify */ private static void outfitMetadataFilter(ObjectMapper om) { final String filterName = "exclude-metadata"; SimpleFilterProvider filters = new SimpleFilterProvider(); filters.addFilter(filterName, new MetadataPropertyFilter()); om.setAnnotationIntrospector(new JsonWrapperIntrospector(filterName)); om.setFilterProvider(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; }
@Test public void testSerializeMultipleObjects() throws IOException { final Collection<Comment> allComments = new ArrayList<Comment>(); Comment aComment = new Comment(); aComment.setContent("<b>There it is</b>"); allComments.add(aComment); aComment = new Comment(); aComment.setContent("<p>I agree with the author</p>"); allComments.add(aComment); ByteArrayOutputStream out = new ByteArrayOutputStream(); jsonHelper.withWriter(out, new Writer() { @Override public void writeContents(JsonGenerator generator, ObjectMapper objectMapper) throws JsonGenerationException, JsonMappingException, IOException { FilterProvider fp = new SimpleFilterProvider().addFilter( JacksonHelper.DEFAULT_FILTER_NAME, new ReturnAllBeanProperties()); objectMapper.writer(fp).writeValue(generator, allComments); } }); assertTrue(out.toString().contains("content\":\"<b>There it is</b>")); assertTrue(out.toString().contains("content\":\"<p>I agree with the author</p>")); }
@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); }
@Before public void beforeEachTest() { if (!init) { issue = buildIssue(); objectMapper = new ObjectMapper(); filterProvider = new SimpleFilterProvider(); objectMapper.setFilterProvider(filterProvider); objectMapper.addMixIn(Object.class, SquigglyPropertyFilterMixin.class); init = true; } filterProvider.removeFilter(SquigglyPropertyFilter.FILTER_ID); }
@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"))); }
@Test public void setFilters() throws JsonProcessingException { this.factory.setFilters(new SimpleFilterProvider().setFailOnUnknownId(false)); this.factory.afterPropertiesSet(); ObjectMapper objectMapper = this.factory.getObject(); JacksonFilteredBean bean = new JacksonFilteredBean("value1", "value2"); String output = objectMapper.writeValueAsString(bean); assertThat(output, containsString("value1")); assertThat(output, containsString("value2")); }
@PostConstruct public void addRolesFilter() { if (jsonFilters == null || jsonFilters.isEmpty()) { return; } // Register filter final SimpleFilterProvider filterProvider = new SimpleFilterProvider(); for (final AbstractJsonFilter jsonFilter : jsonFilters) { filterProvider.addFilter(jsonFilter.getFilterIdentifier(), jsonFilter); } objectMapper.setConfig(objectMapper.getSerializationConfig().withFilters(filterProvider)); }
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 Ds3SpecParserImpl() { module = new JacksonXmlModule(); module.setDefaultUseWrapper(false); mapper = new XmlMapper(module); mapper.registerModule(new GuavaModule()); final SimpleFilterProvider filterProvider = new SimpleFilterProvider().setFailOnUnknownId(false); 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; }