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

/**
 * Can serialize field?
 *
 * @param pojo the pojo
 * @param writer the writer
 * @return the boolean
 */
private boolean canSerializeField(final Object pojo, final PropertyWriter writer) {
    boolean foundPackage = false;
    final String packageName = pojo.getClass().getPackage().getName();
    for (int i = 0; !foundPackage && i < INCLUDE_PACKAGES.length; i++) {
        foundPackage = (packageName.startsWith(INCLUDE_PACKAGES[i]));
    }
    if (!foundPackage) {
        LOGGER.trace("Package [{}] is ignored", packageName);
        return false;
    }


    boolean foundField = true;
    final String fieldName = writer.getFullName().getSimpleName();
    for (int i = 0; foundField && i < EXCLUDE_FIELDS.length; i++) {
        foundField = !fieldName.equalsIgnoreCase(EXCLUDE_FIELDS[i]);
    }

    if (!foundField) {
        LOGGER.trace("Field [{}] is excluded", fieldName);
        return false;
    }
    return true;
}

private Path getPath(PropertyWriter writer, JsonStreamContext sc) {
    LinkedList<PathElement> elements = new LinkedList<>();

    if (sc != null) {
        elements.add(new PathElement(writer.getName(), sc.getCurrentValue()));
        sc = sc.getParent();
    }

    while (sc != null) {
        if (sc.getCurrentName() != null && sc.getCurrentValue() != null) {
            elements.addFirst(new PathElement(sc.getCurrentName(), sc.getCurrentValue()));
        }
        sc = sc.getParent();
    }

    return new Path(elements);
}

/**
 * Can serialize field?
 *
 * @param pojo the pojo
 * @param writer the writer
 * @return the boolean
 */
private boolean canSerializeField(final Object pojo, final PropertyWriter writer) {
    boolean foundPackage = false;
    final String packageName = pojo.getClass().getPackage().getName();
    for (int i = 0; !foundPackage && i < INCLUDE_PACKAGES.length; i++) {
        foundPackage = (packageName.startsWith(INCLUDE_PACKAGES[i]));
    }
    if (!foundPackage) {
        LOGGER.trace("Package [{}] is ignored", packageName);
        return false;
    }


    boolean foundField = true;
    final String fieldName = writer.getFullName().getSimpleName();
    for (int i = 0; foundField && i < EXCLUDE_FIELDS.length; i++) {
        foundField = !fieldName.equalsIgnoreCase(EXCLUDE_FIELDS[i]);
    }

    if (!foundField) {
        LOGGER.trace("Field [{}] is excluded", fieldName);
        return false;
    }
    return true;
}

@Override
public void serializeAsField(
        final Object pojo,
        final JsonGenerator jgen,
        final SerializerProvider prov,
        final PropertyWriter writer) throws Exception {
    if (writer instanceof BeanPropertyWriter) {
        final BeanPropertyWriter beanPropertyWriter = (BeanPropertyWriter) writer;
        if (beanPropertyWriter.getAnnotation(LogRedact.class) == null) {
            super.serializeAsField(pojo, jgen, prov, writer);
        } else {
            if (_allowNull && beanPropertyWriter.get(pojo) == null) {
                super.serializeAsField(pojo, jgen, prov, writer);
            } else {
                jgen.writeStringField(beanPropertyWriter.getSerializedName().getValue(), REDACTION_STRING);
            }
        }
    } else {
        super.serializeAsField(pojo, jgen, prov, writer);
    }
}

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

@Override
public void serializeAsField(final Object pojo, final JsonGenerator jgen,
                             final SerializerProvider provider,
                             final PropertyWriter writer) throws Exception {
    try {
        if (!canSerializeField(pojo, writer)) {
            return;
        }
        super.serializeAsField(pojo, jgen, provider, writer);
    } catch (final Exception e) {
        LOGGER.debug(e.getMessage());
    }
}

public static void main(String[] args) throws Exception {
    ConfigurableApplicationContext context = SpringApplication.run(SampleDataJpaApplication.class, args);

    Iterable<ObjectMapper> objectMappers = context.getBeansOfType(ObjectMapper.class)
            .values();

    objectMappers.forEach(mapper -> mapper.registerModule(new Hibernate5Module()));

    Squiggly.init(objectMappers, new RequestSquigglyContextProvider() {
        @Override
        public void serializeAsIncludedField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception {
            if (isFilteringEnabled()) {
                Object value = writer.getMember().getValue(pojo);

                if (value instanceof PersistentCollection) {
                    ((PersistentCollection) value).forceInitialization();
                }
            }

            super.serializeAsIncludedField(pojo, jgen, provider, writer);
        }
    });


    ObjectMapper objectMapper = Iterables.getFirst(objectMappers, null);

    // Enable Squiggly for Jackson message converter
    if (objectMapper != null) {
        for (MappingJackson2HttpMessageConverter converter : context.getBeansOfType(MappingJackson2HttpMessageConverter.class).values()) {
            converter.setObjectMapper(objectMapper);
        }
    }
}

protected boolean include(final PropertyWriter writer, final JsonGenerator jgen) {
    if (!contextProvider.isFilteringEnabled()) {
        return true;
    }

    JsonStreamContext streamContext = getStreamContext(jgen);

    if (streamContext == null) {
        return true;
    }

    Path path = getPath(writer, streamContext);
    SquigglyContext context = contextProvider.getContext(path.getFirst().getBeanClass());
    String filter = context.getFilter();


    if (AnyDeepName.ID.equals(filter)) {
        return true;
    }

    if (path.isCachable()) {
        // cache the match result using the path and filter expression
        Pair<Path, String> pair = Pair.of(path, filter);
        Boolean match = MATCH_CACHE.getIfPresent(pair);

        if (match == null) {
            match = pathMatches(path, context);
        }

        MATCH_CACHE.put(pair, match);
        return match;
    }

    return pathMatches(path, context);
}

@Override
public void serializeAsField(final Object pojo, final JsonGenerator jgen, final SerializerProvider provider,
                             final PropertyWriter writer) throws Exception {
    if (include(writer, jgen)) {
        contextProvider.serializeAsIncludedField(pojo, jgen, provider, writer);
    } else if (!jgen.canOmitFields()) {
        contextProvider.serializeAsExcludedField(pojo, jgen, provider, writer);
    }
}

@Override
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer)
    throws Exception {
    if (include(pojo, writer)) {
        super.serializeAsField(pojo, jgen, provider, writer);
    }
}

@Override
public void serializeAsField(final Object pojo, final JsonGenerator jgen,
                             final SerializerProvider provider,
                             final PropertyWriter writer) throws Exception {
    try {
        if (!canSerializeField(pojo, writer)) {
            return;
        }
        super.serializeAsField(pojo, jgen, provider, writer);
    } catch (final Exception e) {
        LOGGER.debug(e.getMessage());
    }
}

@Override
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception {
    String key = writer.getName();
    boolean prevDetails = details;

    JsonDetails det = writer.getAnnotation(JsonDetails.class);
    if (det != null) {
        if (!details && det.value()) {
            return;
        }

        if (det.simple()) {
            details = false;
        }
    }

    path.add(key);

    if (!permissionService.permits(perms, path)) {
        path.remove(key);
        return;
    }

    super.serializeAsField(pojo, jgen, provider, writer);

    details = prevDetails;
}

private boolean includeField(Object pojo, PropertyWriter writer) {
//        if (writer.getAnnotation(ApiPermissionsAllowed.class)  == null) {
//            return true;
//        }
//
//        return Arrays.asList(writer.getAnnotation(ApiPermissionsAllowed.class).value())
//                .stream()
//                .anyMatch(apiPermission -> apiPermission.equals(((ApiEntity) pojo).getrgetPermission()));
        return true;
    }

@Override
protected boolean include(PropertyWriter writer) {

    if (new CurrentSecurityContext().isStaffOrAdmin()) {
        return true;
    }
    return !privateFields.contains(writer.getName());
}

@Override
public Void answer(final InvocationOnMock invocation) throws Throwable {
    // CHECKSTYLE.ON: IllegalThrows
    if (invocation.getArguments()[3] instanceof BeanPropertyWriter) {
        _redactionFilter.serializeAsField(invocation.getArguments()[0], (JsonGenerator) invocation.getArguments()[1],
                (SerializerProvider) invocation.getArguments()[2], (BeanPropertyWriter) invocation.getArguments()[3]);
    } else {
        _redactionFilter.serializeAsField(invocation.getArguments()[0],
                (JsonGenerator) invocation.getArguments()[1],
                (SerializerProvider) invocation.getArguments()[2],
                (PropertyWriter) invocation.getArguments()[3]);
    }
    return null;
}

@Override
public void serializeAsField(final Object pojo,
                             final JsonGenerator jgen,
                             final SerializerProvider prov,
                             final PropertyWriter writer) throws Exception {
    if (include(writer.getName())) {
        writer.serializeAsField(pojo, jgen, prov);
    }
}

@Override
public void serializeAsElement(final Object elementValue,
                               final JsonGenerator jgen,
                               final SerializerProvider prov,
                               final PropertyWriter writer) throws Exception {
    if (include(writer.getName())) {
        writer.serializeAsElement(elementValue, jgen, prov);
    }
}

@Override
public void depositSchemaProperty(final PropertyWriter writer,
                                  final ObjectNode propertiesNode,
                                  final SerializerProvider provider) throws JsonMappingException {
    if (include(writer.getName())) {
        writer.depositSchemaProperty(propertiesNode, provider);
    }
}

@Override
public void depositSchemaProperty(final PropertyWriter writer,
                                  final JsonObjectFormatVisitor objectVisitor,
                                  final SerializerProvider provider) throws JsonMappingException {
    if (include(writer.getName())) {
        writer.depositSchemaProperty(objectVisitor, provider);
    }
}

private void processFirstPass(Node parentNode, Object pojo, SerializerProvider provider,
                              PropertyWriter writer, JsonGenerator generator) throws Exception {
  State state = this.state.get();
  Leaf leaf = Leaf.copyOf(state.propertyPath);

  // if this property _can_ contribute towards the path leading to a matching leaf then we have to check
  boolean matches = matcher.matches(leaf);
  if (matches || matcher.matchesParent(leaf)) {
    if (parentNode.isRoot()) {
      // make sure we don't actually write anything to the output, only replace if we are the root node, it will
      // be passed to other nodes as needed via recursive calls
      generator = new JsonFactory().createGenerator(CharStreams.nullWriter());
    }

    // prepare a node for this property so child branches can add to it as needed
    state.currentNode = new Node(parentNode, writer.getName());
    writer.serializeAsField(pojo, generator, provider);

    // check the results of processing the children
    if (state.currentNode.isEmpty()) {
      // either we don't have any children or none of them are matching leaves.
      // in any case
      if (matches) {
        // it turns out we match anyway so add this node
        parentNode.addChild(state.currentNode);
      }
    } else {
      // child leafs match so we need to include this node as a parent of them
      parentNode.addChild(state.currentNode);
    }
  }
}

public boolean matchesFirstChild(PropertyWriter writer) {
  if (children == null) {
    return false;
  }
  Node child = children.peekFirst();
  return child != null && child.matchesName(writer);
}

@Override
public void setUp() throws Exception {
  super.setUp();
  setDefault(Matcher.class, Matcher.all());
  setDefault(JsonGenerator.class, mock(JsonGenerator.class));
  setDefault(SerializerProvider.class, mock(SerializerProvider.class));
  setDefault(PropertyWriter.class, mock(PropertyWriter.class));
  setDefault(CharSequence.class, "*");
}

@Override
public void setUp() throws Exception {
  super.setUp();
  setDefault(JacksonRequestParamFilter.class, mock(JacksonRequestParamFilter.class));
  setDefault(Matcher.class, Matcher.all());
  setDefault(JsonGenerator.class, mock(JsonGenerator.class));
  setDefault(SerializerProvider.class, mock(SerializerProvider.class));
  setDefault(PropertyWriter.class, mock(PropertyWriter.class));
  setDefault(CharSequence.class, "*");
}

@Override
protected boolean include(PropertyWriter writer) {
    return include(writer.getType());
}

@Override
public void serializeAsIncludedField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception {
    writer.serializeAsField(pojo, jgen, provider);
}

@Override
public void serializeAsExcludedField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception {
    writer.serializeAsOmittedField(pojo, jgen, provider);
}

@Override
protected boolean include(final PropertyWriter writer) {
    throw new UnsupportedOperationException("Cannot call include without JsonGenerator");
}

@Override
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider prov,
    PropertyWriter writer) throws Exception {
  delegate.serializeAsField(pojo, jgen, prov, writer);
}

@Override
public void serializeAsElement(Object elementValue, JsonGenerator jgen, SerializerProvider prov,
    PropertyWriter writer) throws Exception {
  delegate.serializeAsElement(elementValue, jgen, prov, writer);
}

@SuppressWarnings("deprecation")
@Override
public void depositSchemaProperty(PropertyWriter writer, ObjectNode propertiesNode,
    SerializerProvider provider) throws JsonMappingException {
  delegate.depositSchemaProperty(writer, propertiesNode, provider);
}

@Override
public void depositSchemaProperty(PropertyWriter writer, JsonObjectFormatVisitor objectVisitor,
    SerializerProvider provider) throws JsonMappingException {
  delegate.depositSchemaProperty(writer, objectVisitor, provider);
}

public KatharsisFieldPropertyFilter(Predicate2<Object, PropertyWriter> includeChecker) {
    this.includeChecker = includeChecker;
}

private boolean include(Object bean, PropertyWriter writer) {
    return includeChecker.test(bean, writer);
}

@Override
protected boolean include(PropertyWriter writer) {
    return include(writer.getFullName().getSimpleName());
}

@Override
public void serializeAsElement(Object elementValue, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception {
    JsonSerializer ser = provider.findValueSerializer(writer.getType());
    WebAPI.getLogger().info(writer.getName() + ": " + (ser != null ? ser.getClass().getName() : ""));
    super.serializeAsElement(elementValue, jgen, provider, writer);
}

@Override
protected boolean include(PropertyWriter writer) {
    return include(writer.getFullName().getSimpleName());
}

@Override
public void serializeAsField(Object pojo, JsonGenerator jgen, SerializerProvider provider, PropertyWriter writer) throws Exception {
    if (includeField(pojo, writer)) {
        writer.serializeAsField(pojo, jgen, provider);
    }
}

@Override
protected boolean include(PropertyWriter writer) {
    return include(writer.getFullName().getSimpleName());
}

@Override
protected boolean include(BeanPropertyWriter writer) {
    return this.include((PropertyWriter)writer);
}