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

@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()));
}

@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 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);
}

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();
    }

protected FindConfigFileService(final FilterProvider filterProvider,
                                final TextEncryptor textEncryptor,
                                final JsonSerializer<FieldPath> fieldPathSerializer,
                                final JsonDeserializer<FieldPath> fieldPathDeserializer) {

    final ObjectMapper objectMapper = new Jackson2ObjectMapperBuilder()
        .featuresToEnable(SerializationFeature.INDENT_OUTPUT)
        .mixIns(customMixins())
        .serializersByType(ImmutableMap.of(FieldPath.class, fieldPathSerializer))
        .deserializersByType(ImmutableMap.of(FieldPath.class, fieldPathDeserializer))
        .createXmlMapper(false)
        .build();

    setConfigFileLocation(CONFIG_FILE_LOCATION);
    setConfigFileName(CONFIG_FILE_NAME);
    setDefaultConfigFile(getDefaultConfigFile());
    setMapper(objectMapper);
    setTextEncryptor(textEncryptor);
    setFilterProvider(filterProvider);
}

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);
}

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);
}

/**
 * Filter out undesired attributes from the given model.
 * The return value can be either another {@link Map} or a single value object.
 * <p>The default implementation removes {@link BindingResult} instances and entries
 * not included in the {@link #setModelKeys renderedAttributes} property.
 * @param model the model, as passed on to {@link #renderMergedOutputModel}
 * @return the value to be rendered
 */
@Override
protected Object filterModel(Map<String, Object> model) {
    Map<String, Object> result = new HashMap<String, Object>(model.size());
    Set<String> modelKeys = (!CollectionUtils.isEmpty(this.modelKeys) ? this.modelKeys : model.keySet());
    for (Map.Entry<String, Object> entry : model.entrySet()) {
        if (!(entry.getValue() instanceof BindingResult) && modelKeys.contains(entry.getKey()) &&
                !entry.getKey().equals(JsonView.class.getName()) &&
                !entry.getKey().equals(FilterProvider.class.getName())) {
            result.put(entry.getKey(), entry.getValue());
        }
    }
    return (this.extractValueFromSingleKeyModel && result.size() == 1 ? result.values().iterator().next() : result);
}

/**
 * Filter and optionally wrap the model in {@link MappingJacksonValue} container.
 * @param model the model, as passed on to {@link #renderMergedOutputModel}
 * @param request current HTTP request
 * @return the wrapped or unwrapped value to be rendered
 */
protected Object filterAndWrapModel(Map<String, Object> model, HttpServletRequest request) {
    Object value = filterModel(model);
    Class<?> serializationView = (Class<?>) model.get(JsonView.class.getName());
    FilterProvider filters = (FilterProvider) model.get(FilterProvider.class.getName());
    if (serializationView != null || filters != null) {
        MappingJacksonValue container = new MappingJacksonValue(value);
        container.setSerializationView(serializationView);
        container.setFilters(filters);
        value = container;
    }
    return value;
}

/**
 * Write the actual JSON content to the stream.
 * @param stream the output stream to use
 * @param object the value to be rendered, as returned from {@link #filterModel}
 * @throws IOException if writing failed
 */
protected void writeContent(OutputStream stream, Object object)
        throws IOException {

    JsonGenerator generator = this.objectMapper.getFactory().createGenerator(stream, this.encoding);

    writePrefix(generator, object);
    Class<?> serializationView = null;
    FilterProvider filters = null;
    Object value = object;

    if (value instanceof MappingJacksonValue) {
        MappingJacksonValue container = (MappingJacksonValue) value;
        value = container.getValue();
        serializationView = container.getSerializationView();
        filters = container.getFilters();
    }
    if (serializationView != null) {
        this.objectMapper.writerWithView(serializationView).writeValue(generator, value);
    }
    else if (filters != null) {
        this.objectMapper.writer(filters).writeValue(generator, value);
    }
    else {
        this.objectMapper.writeValue(generator, value);
    }
    writeSuffix(generator, object);
    generator.flush();
}

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;
    }

/**
 * Bulk update a set of documents using partial documents.
 *
 * @param index            document index
 * @param documentType     Type of the document
 * @param filterProvider   Serialization filterProvider to use in document serialization to only output fields we wish to update.
 * @param documentIds      documents to update.
 * @param documentTemplate the document template to apply changes from
 */
final protected void updateDocuments(String index, String documentType, FilterProvider filterProvider, Set<String> documentIds, IDocument documentTemplate) {
    if (documentIds.size() == 0) {
        return;
    }

    BulkRequestBuilder bulkRequestBuilder = this.getClient().prepareBulk();
    ObjectWriter writer = getObjectWriter(documentTemplate.getClass()).with(filterProvider);
    this.updateDocumentDatesTracking(documentTemplate);

    for (String documentId : documentIds) {
        UpdateRequestBuilder request = this.getClient().prepareUpdate()
                .setIndex(index)
                .setId(documentId)
                .setType(documentType)
                .setDoc(this.getSourceFromDocument(writer, documentTemplate));

        bulkRequestBuilder.add(request);
    }

    try {
        bulkRequestBuilder.setRefresh(true);
        BulkResponse response = bulkRequestBuilder.execute().actionGet();
        if (response.hasFailures()) {
            throw new SearchServiceException(String.format("Unexpected failure bulk updating documents %s", response.buildFailureMessage()));
        }
    } catch (VersionConflictEngineException vc) {
        throw new ConcurrentModificationException(vc);
    } catch (ElasticsearchException ex) {
        throw new SearchServiceException("Unexpected failure while indexing a document.", ex);
    }
}

/**
 * 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);
}

@Autowired
public HodFindConfigFileService(
        final FilterProvider filterProvider,
        final TextEncryptor textEncryptor,
        final JsonSerializer<FieldPath> fieldPathSerializer,
        final JsonDeserializer<FieldPath> fieldPathDeserializer) {
    super(filterProvider, textEncryptor, fieldPathSerializer, fieldPathDeserializer);
}

@Autowired
public IdolFindConfigFileService(
        final FilterProvider filterProvider,
        final TextEncryptor textEncryptor,
        final JsonSerializer<FieldPath> fieldPathSerializer,
        final JsonDeserializer<FieldPath> fieldPathDeserializer,
        final IdolConfigUpdateHandler idolConfigUpdateHandler
) {
    super(filterProvider, textEncryptor, fieldPathSerializer, fieldPathDeserializer);

    this.idolConfigUpdateHandler = idolConfigUpdateHandler;
}

protected BeanPropertyFilter findFilter(SerializerProvider paramSerializerProvider)
{
  Object localObject = this._propertyFilterId;
  FilterProvider localFilterProvider = paramSerializerProvider.getFilterProvider();
  if (localFilterProvider == null)
    throw new JsonMappingException("Can not resolve BeanPropertyFilter with id '" + localObject + "'; no FilterProvider configured");
  return localFilterProvider.findFilter(localObject);
}

private SerializationConfig(SerializationConfig paramSerializationConfig, FilterProvider paramFilterProvider)
{
  super(paramSerializationConfig);
  this._serFeatures = paramSerializationConfig._serFeatures;
  this._serializationInclusion = paramSerializationConfig._serializationInclusion;
  this._filterProvider = paramFilterProvider;
}

private static String toXml(final Object object, final FilterProvider filterProvider) {
    try {
        if (filterProvider == null) {
            return mapper.writeValueAsString(object);
        }
        else {
            return mapper.writer(filterProvider).writeValueAsString(object);
        }
    }
    catch(final JsonProcessingException e) {
        throw new XmlProcessingException(e);
    }
}

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);
}

/**
 * {@inheritDoc}
 */
@Override
public FilterProvider transform(final ObjectGraph graph) {
    // Root entity.
    final FilteringPropertyFilter root = new FilteringPropertyFilter(graph.getEntityClass(),
            graph.getFields(),
            createSubfilters(graph.getEntityClass(), graph.getSubgraphs()));

    return new FilteringFilterProvider(root);
}

@Override
protected void configure() {
    bindAsContract(JacksonObjectProvider.class)
            // FilteringObjectProvider.
            .to(new GenericType<ObjectProvider<FilterProvider>>() {
            })
                    // FilteringGraphTransformer.
            .to(new GenericType<ObjectGraphTransformer<FilterProvider>>() {
            })
                    // Scope.
            .in(Singleton.class);
}

/**
 * <p>setObjectWriterInjector.</p>
 *
 * @param provider    a {@link javax.inject.Provider} object.
 * @param genericType a {@link java.lang.reflect.Type} object.
 * @param annotations an array of {@link java.lang.annotation.Annotation} objects.
 * @throws java.io.IOException if any.
 */
public static void setObjectWriterInjector(Provider<ObjectProvider<FilterProvider>> provider,
                                           final Type genericType,
                                           final Annotation[] annotations) throws IOException {
    final FilterProvider filterProvider = provider.get().getFilteringObject(genericType, true, annotations);
    if (filterProvider != null) {
        ObjectWriterInjector.set(new FilteringObjectWriterModifier(filterProvider, ObjectWriterInjector.getAndClear()));
    }
}

@Override
public void dispatchNotification(final Date creationDate, final Activity.ActivityAction activityAction, final NodeObserver.Event mobSOSEvent,
                                 final int dataId, final Activity.DataType dataType, final int userId) {

    // Filters to generate JSON elements
    FilterProvider filters =
            new SimpleFilterProvider().addFilter(
                    "ActivityFilter",
                    SimpleBeanPropertyFilter.filterOutAllExcept("id", "name"));
    mapper = new ObjectMapper();
    mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
    mapper.setFilters(filters);

    Activity.AdditionalObject additionalObject = generateAdditionalObject(dataType, dataId, userId);

    try {
        if (emailDispatcher != null && (activityAction == Activity.ActivityAction.CREATE || activityAction == Activity.ActivityAction.UPDATE ||
                activityAction == Activity.ActivityAction.REALIZE)) {
            // add email
            emailDispatcher.addEmailNotification(creationDate, activityAction, dataId, dataType, userId, additionalObject);
        }
        if (activityDispatcher != null && (activityAction == Activity.ActivityAction.CREATE || activityAction == Activity.ActivityAction.UPDATE ||
                activityAction == Activity.ActivityAction.REALIZE || activityAction == Activity.ActivityAction.DEVELOP ||
                activityAction == Activity.ActivityAction.LEADDEVELOP || activityAction == Activity.ActivityAction.FOLLOW ||
                activityAction == Activity.ActivityAction.VOTE)) {
            // dispatch activity
            activityDispatcher.sendActivityOverRMI(creationDate, activityAction, dataId, dataType, userId, additionalObject);
        }
        if (mobSOSEvent != null) {
            // dispatch mobSOS log call
            L2pLogger.logEvent(mobSOSEvent, Context.getCurrent().getMainAgent(), mapper.writeValueAsString(additionalObject));
        }
    } catch (JsonProcessingException e) {
        logger.warning(e.getMessage());
    }
}

@Test
public void success() throws Exception {
  User user = createUser();
  ObjectMapper mapper = new ObjectMapper();
  mapper.addMixInAnnotations(Thing.class, ThingMixin.class);
  FilterProvider filterProvider = new SimpleFilterProvider()
    .addFilter("thing filter", SimpleBeanPropertyFilter.serializeAllExcept("user"));
  mapper.setFilters(filterProvider);

  StringWriter writer = new StringWriter();
  mapper.writeValue(writer, user);
}

@Override
public ObjectWriter modify(EndpointConfigBase<?> endpoint, MultivaluedMap<String, Object> responseHeaders, Object valueToWrite,
        ObjectWriter w, JsonGenerator g) throws IOException {
    SimpleBeanPropertyFilter filter = null;
    if (includes != null && !includes.isEmpty()) {
        filter = new SimpleBeanPropertyFilter.FilterExceptFilter(includes);
    } else if (excludes != null && !excludes.isEmpty()) {
        filter = SimpleBeanPropertyFilter.serializeAllExcept(excludes);
    } else {
        filter = SimpleBeanPropertyFilter.serializeAllExcept(new HashSet<String>());
    }
    FilterProvider provider = new SimpleFilterProvider().addFilter("property_filter", filter);
    return w.with(provider);
}