Java 类com.fasterxml.jackson.databind.introspect.BeanPropertyDefinition 实例源码

@Override
public BeanSerializerBuilder updateBuilder(SerializationConfig config, BeanDescription beanDesc,
        BeanSerializerBuilder builder) {

    for (BeanPropertyWriter writer : builder.getProperties()) {

        JavaType propertyType = writer.getMember().getType();
        Class<?> type = propertyType.getRawClass();
        List<BeanPropertyDefinition> properties = getProperties(propertyType, config);

        Optional.ofNullable(AnnotationUtils.findAnnotation(type, ValueObject.class))//
                .filter(it -> properties.size() == 1)//
                .flatMap(it -> properties.stream().findFirst())//
                .ifPresent(it -> writer.assignSerializer(new PropertyAccessingSerializer(it)));
    }

    return builder;
}

private AnnotatedType getInputFieldType(AnnotatedType type, BeanPropertyDefinition propertyDefinition) {
    AnnotatedParameter ctorParam = propertyDefinition.getConstructorParameter();
    if (ctorParam != null) {
        Constructor<?> constructor = (Constructor<?>) ctorParam.getOwner().getMember();
        return ClassUtils.getParameterTypes(constructor, type)[ctorParam.getIndex()];
    }
    if (propertyDefinition.getSetter() != null) {
        return ClassUtils.getParameterTypes(propertyDefinition.getSetter().getAnnotated(), type)[0];
    }
    if (propertyDefinition.getGetter() != null) {
        return ClassUtils.getReturnType(propertyDefinition.getGetter().getAnnotated(), type);
    }
    if (propertyDefinition.getField() != null) {
        return ClassUtils.getFieldType(propertyDefinition.getField().getAnnotated(), type);
    }
    throw new UnsupportedOperationException("Unknown input field mapping style encountered");
}

/**
 * Add the given filter to the query.
 *
 * @param fieldName
 *          Name as seen in the query; not multi-value proxies ("id", not "ids")
 * @throws UnknownFieldException
 *           When no field named {@code fieldName} exists
 * @throws IllegalArgumentException
 *           When {@code value} is of the wrong type
 */
public void addFilter(String fieldName, Class<? extends Filter> filterType, Object value) {
  // Filter can be null; we only want FilterEntry for name normalization
  Filter filter = DefaultMetaUtils.getFilterInstance(filterType);
  FilterEntry filterEntry = new FilterEntry(filter, fieldName, this.getQueryType());
  BeanPropertyDefinition filterProperty = getMetaData().getFilterTable().get(filterEntry, filter.names()[0]);
  if (filterProperty == null) {
    throw new UnknownFieldException(String.format("No filter %s on field named '%s' exists.", filter.names()[0], fieldName));
  }
  BoundFilterEntry<T> boundColumn = new BoundFilterEntry<T>(filterEntry, filterProperty, getMetaData());
  FilterBy ann = filterProperty.getPrimaryMember().getAnnotation(FilterBy.class);
  if (Strings.emptyToNull(ann.as()) != null) {
    boundColumn.setActualField(getMetaData().getFieldMap().get(ann.as()));
  }

  if (boundColumn.isMultiValue()) {
    Collection<?> values = (Collection<?>) value;
    boundColumn = new MultiValuedBoundFilterEntry<T>(boundColumn, values);
  } else {
    filterProperty.getSetter().setValue(getBoundQuery(), value);
  }

  if (!getBoundFilterEntries().contains(boundColumn)) {
    getBoundFilterEntries().add(boundColumn);
  }
}

protected Collection<Ordering> getOrderings(List<String> orderStrings, MetaQuerySpec<T> meta) {
  Collection<Ordering> orderings = new ArrayList<>();
  if (orderStrings != null) {
    for (String order : orderStrings) {
      Ordering ordering = Ordering.fromString(order);
      FilterEntry entry = new FilterEntry(null, ordering.getFieldName(), getQueryType());
      BeanPropertyDefinition prop = meta.getFieldMap().get(entry.getQueryName());
      if (prop == null) {
        prop = meta.getFieldMap().get(entry.getFieldName());
      }
      if (prop != null && orderableFields.contains(prop.getName())) {
        orderings.add(new Ordering(entry.getFieldName(), entry.getQueryName(), ordering.getOrder()));
      }
    }
  }
  return orderings;
}

@SuppressWarnings("unchecked")
public QueryParser<T> build() {
  QueryParser<T> qp = (QueryParser<T>) CACHED_PARSERS.get(spec, strictMode);
  if (qp != null) {
    return qp;
  }

  if (meta == null) {
    meta = new DefaultMetaQuerySpec<>(spec);
  }

  if (uriParamParser == null) {
    uriParamParser = UriParamParser.newBuilder().build();
  }

  Map<String, BeanPropertyDefinition> fields = BeanPropertyIntrospector.getFields(spec);

  qp = new QueryParser<>(spec, strictMode, meta, uriParamParser);
  qp.setConstraints(spec);
  qp.buildOrderableFields(fields);

  CACHED_PARSERS.put(spec, strictMode, qp);

  return qp;
}

private void populateProperties(Class<?> domainType, BusinessEntity entity) {
    Map<String, EntityProperty> properties = new HashMap<>();
    final PersistentEntity<?, ?> persistentEntity = persistentEntities.getPersistentEntity(domainType);
    JacksonMetadata jacksonMetadata = new JacksonMetadata(objectMapper, domainType);
    for (BeanPropertyDefinition definition : jacksonMetadata) {
        PersistentProperty<?> persistentProperty = persistentEntity.getPersistentProperty(definition.getInternalName());
        PropertyFactoryContext context = new PropertyFactoryContext(definition, jacksonMetadata, persistentProperty);
        PropertyFactory factory = getFactoryFor(context);
        if (factory != null) {
            EntityProperty property = factory.create(context);
            properties.put(definition.getInternalName(), property);
            if(property.isRequired()) {
                entity.getRequired().add(definition.getInternalName());
            }
        }
    }
    entity.setProperties(properties);
}

@SuppressFBWarnings(value = "REC_CATCH_EXCEPTION", justification = "Need to wrap all runtime exceptions before they are given to the user")
@Override
public Set<String> getSerialisedFields(final String className) {
    final Class<?> clazz;
    try {
        clazz = Class.forName(className);
    } catch (final Exception e) {
        throw new IllegalArgumentException("Class name was not recognised: " + className, e);
    }

    final ObjectMapper mapper = new ObjectMapper();
    final JavaType type = mapper.getTypeFactory().constructType(clazz);
    final BeanDescription introspection = mapper.getSerializationConfig().introspect(type);
    final List<BeanPropertyDefinition> properties = introspection.findProperties();

    final Set<String> fields = new HashSet<>();
    for (final BeanPropertyDefinition property : properties) {
        fields.add(property.getName());
    }

    return fields;
}

@SuppressFBWarnings(value = "REC_CATCH_EXCEPTION", justification = "Need to wrap all runtime exceptions before they are given to the user")
@Override
public Response getSerialisedFields(final String className) {
    final Class<?> clazz;
    try {
        clazz = Class.forName(className);
    } catch (final Exception e) {
        throw new IllegalArgumentException("Class name was not recognised: " + className, e);
    }

    final ObjectMapper mapper = new ObjectMapper();
    final JavaType type = mapper.getTypeFactory().constructType(clazz);
    final BeanDescription introspection = mapper.getSerializationConfig()
                                                .introspect(type);
    final List<BeanPropertyDefinition> properties = introspection.findProperties();

    final Set<String> fields = new HashSet<>();
    for (final BeanPropertyDefinition property : properties) {
        fields.add(property.getName());
    }

    return Response.ok(fields)
                   .header(GAFFER_MEDIA_TYPE_HEADER, GAFFER_MEDIA_TYPE)
                   .build();
}

protected BeanPropertyWriter _constructWriter(SerializerProvider paramSerializerProvider, BeanPropertyDefinition paramBeanPropertyDefinition, TypeBindings paramTypeBindings, PropertyBuilder paramPropertyBuilder, boolean paramBoolean, AnnotatedMember paramAnnotatedMember)
{
  String str = paramBeanPropertyDefinition.getName();
  if (paramSerializerProvider.canOverrideAccessModifiers())
    paramAnnotatedMember.fixAccess();
  JavaType localJavaType = paramAnnotatedMember.getType(paramTypeBindings);
  BeanProperty.Std localStd = new BeanProperty.Std(str, localJavaType, paramBeanPropertyDefinition.getWrapperName(), paramPropertyBuilder.getClassAnnotations(), paramAnnotatedMember, paramBeanPropertyDefinition.isRequired());
  JsonSerializer localJsonSerializer1 = findSerializerFromAnnotation(paramSerializerProvider, paramAnnotatedMember);
  JsonSerializer localJsonSerializer2 = localJsonSerializer1;
  if ((localJsonSerializer1 instanceof ResolvableSerializer))
    ((ResolvableSerializer)localJsonSerializer2).resolve(paramSerializerProvider);
  if ((localJsonSerializer2 instanceof ContextualSerializer))
    localJsonSerializer2 = ((ContextualSerializer)localJsonSerializer2).createContextual(paramSerializerProvider, localStd);
  boolean bool = ClassUtil.isCollectionMapOrArray(localJavaType.getRawClass());
  TypeSerializer localTypeSerializer1 = null;
  if (bool)
    localTypeSerializer1 = findPropertyContentTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember);
  TypeSerializer localTypeSerializer2 = findPropertyTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember);
  return paramPropertyBuilder.buildWriter(paramBeanPropertyDefinition, localJavaType, localJsonSerializer2, localTypeSerializer2, localTypeSerializer1, paramAnnotatedMember, paramBoolean);
}

protected SettableBeanProperty constructSettableProperty(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanPropertyDefinition paramBeanPropertyDefinition, Type paramType)
{
  AnnotatedMember localAnnotatedMember = paramBeanPropertyDefinition.getMutator();
  if (paramDeserializationContext.canOverrideAccessModifiers())
    localAnnotatedMember.fixAccess();
  JavaType localJavaType1 = paramBeanDescription.resolveType(paramType);
  BeanProperty.Std localStd = new BeanProperty.Std(paramBeanPropertyDefinition.getName(), localJavaType1, paramBeanPropertyDefinition.getWrapperName(), paramBeanDescription.getClassAnnotations(), localAnnotatedMember, paramBeanPropertyDefinition.isRequired());
  JavaType localJavaType2 = resolveType(paramDeserializationContext, paramBeanDescription, localJavaType1, localAnnotatedMember);
  if (localJavaType2 != localJavaType1)
    localStd.withType(localJavaType2);
  JsonDeserializer localJsonDeserializer = findDeserializerFromAnnotation(paramDeserializationContext, localAnnotatedMember);
  JavaType localJavaType3 = modifyTypeByAnnotation(paramDeserializationContext, localAnnotatedMember, localJavaType2);
  TypeDeserializer localTypeDeserializer = (TypeDeserializer)localJavaType3.getTypeHandler();
  Object localObject;
  if ((localAnnotatedMember instanceof AnnotatedMethod))
    localObject = new MethodProperty(paramBeanPropertyDefinition, localJavaType3, localTypeDeserializer, paramBeanDescription.getClassAnnotations(), (AnnotatedMethod)localAnnotatedMember);
  else
    localObject = new FieldProperty(paramBeanPropertyDefinition, localJavaType3, localTypeDeserializer, paramBeanDescription.getClassAnnotations(), (AnnotatedField)localAnnotatedMember);
  if (localJsonDeserializer != null)
    localObject = ((SettableBeanProperty)localObject).withValueDeserializer(localJsonDeserializer);
  AnnotationIntrospector.ReferenceProperty localReferenceProperty = paramBeanPropertyDefinition.findReferenceType();
  if ((localReferenceProperty != null) && (localReferenceProperty.isManagedReference()))
    ((SettableBeanProperty)localObject).setManagedReferenceName(localReferenceProperty.getName());
  return localObject;
}

@Override
public boolean handleUnknownProperty(DeserializationContext ctxt,
                                     JsonParser jp,
                                     JsonDeserializer<?> deserializer,
                                     Object beanOrClass,
                                     String propertyName) throws IOException, JsonProcessingException {
    ObjectCodec objectCodec = jp.getCodec();
    if (objectCodec instanceof ObjectMapper) {
        ObjectMapper objectMapper = (ObjectMapper) objectCodec;
        BeanDescription beanDescription =
                objectMapper.getSerializationConfig().introspect(ctxt.constructType(beanOrClass.getClass()));
        for (BeanPropertyDefinition propertyDefinition : beanDescription.findProperties()) {
            if (propertyName.equals(propertyDefinition.getName())) {
                jp.skipChildren();
                return true;
            }
        }
    }
    return false;
}

private <T> void verifyClazzIsConfigurable(Class<T> clazz)
{
  final List<BeanPropertyDefinition> beanDefs = jsonMapper.getSerializationConfig()
                                                            .introspect(jsonMapper.constructType(clazz))
                                                            .findProperties();
  for (BeanPropertyDefinition beanDef : beanDefs) {
    final AnnotatedField field = beanDef.getField();
    if (field == null || !field.hasAnnotation(JsonProperty.class)) {
      throw new ProvisionException(
          String.format(
              "JsonConfigurator requires Jackson-annotated Config objects to have field annotations. %s doesn't",
              clazz
          )
      );
    }
  }
}

protected void serializeFieldCustomized(
        Entity entity,
        JsonGenerator gen,
        BeanPropertyDefinition property,
        List<BeanPropertyDefinition> properties,
        CustomSerialization annotation) throws Exception {
    // check if encoding field is present in current bean
    // get calue
    // call CustomSerializationManager
    Optional<BeanPropertyDefinition> encodingProperty = properties.stream().filter(p -> p.getName().equals(annotation.encoding())).findFirst();
    if (!encodingProperty.isPresent()) {
        // TODO use more specific exception type
        throw new Exception("can not serialize instance of class '" + entity.getClass() + "'! \n"
                + "Reason: trying to use custom serialization for field '" + property.getName() + "' but field '" + annotation.encoding() + "' specifying enconding is not present!");
    }
    Object value = encodingProperty.get().getAccessor().getValue(entity);
    String encodingType = null;
    if (value != null) {
        encodingType = value.toString();
    }
    String customJson = CustomSerializationManager.getInstance()
            .getSerializer(encodingType)
            .serialize(property.getAccessor().getValue(entity));
    if (customJson != null && !customJson.isEmpty()) {
        gen.writeFieldName(property.getName());
        gen.writeRawValue(customJson);
    }
}

protected void serializeField(
        Entity entity,
        JsonGenerator gen,
        SerializerProvider serializers,
        BeanDescription beanDescription,
        BeanPropertyDefinition beanPropertyDefinition) throws Exception {
    serializeFieldTyped(entity, gen, serializers, beanDescription, beanPropertyDefinition, null);
}

protected void serializeFieldTyped(
        Entity entity,
        JsonGenerator gen,
        SerializerProvider serializers,
        BeanDescription beanDescription,
        BeanPropertyDefinition beanPropertyDefinition,
        TypeSerializer typeSerializer) throws Exception {
    try {
        if (typeSerializer == null) {
            typeSerializer = serializers.findTypeSerializer(serializers.constructType(beanPropertyDefinition.getAccessor().getRawType()));
        }
        if (typeSerializer == null) {
            // if not static type if available use dynamic type if available
            Object propertyValue = beanPropertyDefinition.getAccessor().getValue(entity);
            if (propertyValue != null) {
                typeSerializer = serializers.findTypeSerializer(serializers.constructType(propertyValue.getClass()));
            }
        }

        BeanPropertyWriter bpw = new BeanPropertyWriter(
                beanPropertyDefinition,
                beanPropertyDefinition.getAccessor(),
                beanDescription.getClassAnnotations(),
                beanPropertyDefinition.getAccessor().getType(),
                null, // will be searched automatically
                typeSerializer, // will not be searched automatically
                beanPropertyDefinition.getAccessor().getType(),
                suppressNulls(serializers.getConfig().getDefaultPropertyInclusion()),
                suppressableValue(serializers.getConfig().getDefaultPropertyInclusion()));
        bpw.serializeAsField(entity, gen, serializers);
    } catch (JsonMappingException ex) {
        Logger.getLogger(EntitySerializer.class.getName()).log(Level.SEVERE, null, ex);
    }
}

@Override
public Set<InputField> getInputFields(AnnotatedType type) {
    JavaType javaType = objectMapper.getTypeFactory().constructType(type.getType());
    BeanDescription desc = objectMapper.getDeserializationConfig().introspect(javaType);
    return desc.findProperties().stream()
            .filter(BeanPropertyDefinition::couldDeserialize)
            .map(def -> new InputField(def.getName(), def.getMetadata().getDescription(), getInputFieldType(type, def)))
            .collect(Collectors.toSet());
}

@Override
public ResourceSchema getResourceSchema(TypeToken<?> type, ApiConfig config) {
  ResourceSchema schema = super.getResourceSchema(type, config);
  if (schema != null) {
    return schema;
  }
  ObjectMapper objectMapper =
      ObjectMapperUtil.createStandardObjectMapper(config.getSerializationConfig());
  JavaType javaType = objectMapper.getTypeFactory().constructType(type.getRawType());
  BeanDescription beanDescription = objectMapper.getSerializationConfig().introspect(javaType);
  ResourceSchema.Builder schemaBuilder = ResourceSchema.builderForType(type.getRawType());
  Set<String> genericDataFieldNames = getGenericDataFieldNames(type);
  for (BeanPropertyDefinition definition : beanDescription.findProperties()) {
    TypeToken<?> propertyType = getPropertyType(type, toMethod(definition.getGetter()),
        toMethod(definition.getSetter()), definition.getField(), config);
    String name = definition.getName();
    if (genericDataFieldNames == null || genericDataFieldNames.contains(name)) {
      if (hasUnresolvedType(propertyType)) {
        logger.warning("skipping field '" + name + "' of type '" + propertyType
            + "' because it is unresolved.");
        continue;
      }
      if (propertyType != null) {
        schemaBuilder.addProperty(name, ResourcePropertySchema.of(propertyType));
      } else {
        logger.warning("No type found for property '" + name + "' on class '" + type + "'.");
      }
    } else {
      logger.fine("skipping field '" + name + "' because it's not a Java client model field.");
    }
  }
  return schemaBuilder.build();
}

@Override
public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder) {
    for (BeanPropertyDefinition propDef : beanDesc.findProperties()) {
        if (!propDef.hasGetter() || propDef.hasSetter()) {
            continue;
        }
        AnnotatedMember getter = propDef.getAccessor();
        if (!Keeper.class.equals(getter.getRawType())) {
            continue;
        }

        builder.addOrReplaceProperty(new CustomGetterBeanProperty(propDef, getter), true);
    }
    return builder;
}

public static <T extends Annotation> T findAnnotation(BeanPropertyDefinition prop, Class<T> type) {
  T ann = null;
  if (prop.hasField()) {
    ann = prop.getField().getAnnotation(type);
  }
  if (ann == null && prop.hasGetter()) {
    ann = prop.getGetter().getAnnotation(type);
  }
  if (ann == null && prop.hasSetter()) {
    ann = prop.getSetter().getAnnotation(type);
  }
  return ann;
}

/**
 * Add the given order-by clause. The operation is not checked against allowed order-bys.
 *
 * @param fieldName
 *          Name as seen in the query; not multi-value proxies ("id", not "ids")
 */
public void addOrdering(String fieldName, SortOrder order) {
  FilterEntry entry = new FilterEntry(null, fieldName, getQueryType());
  BeanPropertyDefinition prop = getMetaData().getFieldMap().get(entry.getQueryName());
  if (prop == null) {
    prop = getMetaData().getFieldMap().get(entry.getFieldName());
  }
  if (prop != null) {
    orderings.add(new Ordering(entry.getFieldName(), entry.getQueryName(), order));
  }
}

public static Map<String, Object> makeBoundMap(Object object) {
  Map<String, Object> propertyMap = new HashMap<>();

  for (Map.Entry<String, BeanPropertyDefinition> entry : getFields(object.getClass()).entrySet()) {
    BeanPropertyDefinition definition = entry.getValue();

    if (!definition.couldSerialize()) {
      continue;
    }

    Object value = definition.getAccessor().getValue(object);

    if (value != null) {
      if (hasAnnotation(definition, StoredAsJson.class) ||
          !Primitives.wrap(getFieldType(definition)).isAssignableFrom(value.getClass())) {

        try {
          value = Rosetta.getMapper().writeValueAsString(value);
        } catch (JsonProcessingException e) {
          throw Throwables.propagate(e);
        }
      }
    }

    propertyMap.put(entry.getKey(), value);
  }

  return propertyMap;
}

public static Class<?> getFieldType(BeanPropertyDefinition definition) {
  Class<?> fieldType = null;

  if (definition.hasField()) {
    fieldType = definition.getField().getAnnotated().getType();
  } else if (definition.hasGetter()) {
    fieldType = definition.getGetter().getRawReturnType();
  } else if (definition.hasSetter()) {
    fieldType = definition.getSetter().getRawParameterType(0);
  }

  return fieldType;
}

public static <T extends Annotation> T getAnnotation(BeanPropertyDefinition definition, Class<T> type) {
  if (definition.hasField() && definition.getField().getAnnotation(type) != null) {
    return definition.getField().getAnnotation(type);
  } else if (definition.hasGetter() && definition.getGetter().getAnnotation(type) != null) {
    return definition.getGetter().getAnnotation(type);
  } else if (definition.hasSetter() && definition.getSetter().getAnnotation(type) != null) {
    return definition.getSetter().getAnnotation(type);
  }
  return null;
}

@Override
@SuppressWarnings("unchecked")
// Unchecked is an empty array.
public Class<? extends Filter>[] getFiltersForField(String name) {
  BeanPropertyDefinition prop = fieldMap.get(name);
  if (prop != null) {
    FilterBy ann = DefaultMetaUtils.findFilterBy(prop);
    if (ann != null) {
      return ann.value();
    }
  }
  return new Class[] {};
}

private void buildMetaData() {
  final Map<String, BeanPropertyDefinition> fields = BeanPropertyIntrospector.getFields(specType);

  for (Map.Entry<String, BeanPropertyDefinition> entry : fields.entrySet()) {
    fieldMap.put(entry.getKey(), entry.getValue());
    filterTable.putAll(tableFor(entry.getValue(), getFiltersForField(entry.getKey())));
  }
}

@Override
@SafeVarargs
public final Table<BoundFilterEntry<T>, String, BeanPropertyDefinition> tableFor(BeanPropertyDefinition field,
    Class<? extends Filter>... filters) {

  final Table<BoundFilterEntry<T>, String, BeanPropertyDefinition> table = HashBasedTable.create();

  JoinCondition join = null;

  FilterJoin filterJoin = DefaultMetaUtils.findFilterJoin(field);
  if (filterJoin != null) {
    join = new JoinCondition(DSL.table(DSL.name(filterJoin.table())),
        DSL.field(DSL.name(instance.tableName(), filterJoin.on()))
            .eq(DSL.field(DSL.name(filterJoin.table(), filterJoin.eq()))));
  }

  for (Class<? extends Filter> filterType : filters) {
    assert Filter.class.isAssignableFrom(filterType);

    Filter filter = DefaultMetaUtils.getFilterInstance(filterType);
    if (join != null) {
      filter = new JoinFilter(filter, join);
    }

    BoundFilterEntry<T> fe = new BoundFilterEntry<T>(filter, field, this);

    for (String filterName : filter.names()) {
      table.put(fe, filterName, field);
    }
  }
  return table;
}

protected void buildOrderableFields(final Map<String, BeanPropertyDefinition> fields) {
  OrderBy ann;
  for (Map.Entry<String, BeanPropertyDefinition> entry : fields.entrySet()) {
    ann = DefaultMetaUtils.findOrderBy(entry.getValue());
    if (ann != null) {
      orderableFields.add(entry.getKey());
    }
  }
}

@SuppressWarnings({"rawtypes", "unchecked"})
private Field getSortField(Ordering order) {
  Map<String, BeanPropertyDefinition> fieldMap = meta.getFieldMap();
  BeanPropertyDefinition bpd = fieldMap.get(order.getQueryName());
  String fieldName = order.getQueryName();
  Class fieldType = meta.getFieldType(order.getFieldName());
  if (bpd.getField().getAnnotation(OrderBy.class).isGenerated()) {
    // it's possible to sort by generated fields
    // but we shouldn't qualify them with table name in the ORDER BY clause
    return DSL.field(DSL.name(fieldName), fieldType);
  } else {
    return factory.createField(fieldName, fieldType, getTable());
  }
}

private List<EntityProperty> buildProperties(Class<?> domainType) {
    List<EntityProperty> properties = new ArrayList<>();
    final PersistentEntity<?, ?> persistentEntity = persistentEntities.getPersistentEntity(domainType);
    JacksonMetadata jacksonMetadata = new JacksonMetadata(objectMapper, domainType);
    for (BeanPropertyDefinition definition : jacksonMetadata) {
        PersistentProperty<?> persistentProperty = persistentEntity.getPersistentProperty(definition.getInternalName());
        PropertyFactoryContext context = new PropertyFactoryContext(definition, jacksonMetadata, persistentProperty);
        PropertyFactory factory = getFactoryFor(context);
        if (factory != null) {
            properties.add(factory.create(context));
        }
    }
    return properties;
}

@Override
public List<BeanPropertyDefinition> updateProperties(DeserializationConfig config,
                                                     BeanDescription beanDesc,
                                                     List<BeanPropertyDefinition> propDefs) {
    List<BeanPropertyDefinition> definitions = super.updateProperties(config, beanDesc, propDefs);
    List<BeanPropertyDefinition> remove = new ArrayList<>();
    List<BeanPropertyDefinition> add = new ArrayList<>();
    for (BeanPropertyDefinition definition : definitions) {
        if (definition.hasGetter() &&
                Collection.class.isAssignableFrom(definition.getGetter().getRawType())) {

            if (definition instanceof POJOPropertyBuilder) {
                POJOPropertyBuilder builder = (POJOPropertyBuilder) definition;
                builder = new POJOPropertyBuilder(builder, builder.getFullName()) {
                    @Override
                    public boolean hasField() {
                        return false; // forces the getter to be used on the collection
                    }
                };
                remove.add(definition);
                add.add(builder);
            }
        }
    }

    definitions.removeAll(remove);
    definitions.addAll(add);

    return definitions;
}

@Override
public List<BeanPropertyDefinition> updateProperties(DeserializationConfig config,
        BeanDescription beanDesc, List<BeanPropertyDefinition> propDefs) {
    if (!thinnables.contains(beanDesc.getBeanClass())) {
        return propDefs;
    }
    List<BeanPropertyDefinition> newPropDefs = new ArrayList<>();
    for (BeanPropertyDefinition propDef : propDefs) {
        if (!ignorables.contains(propDef.getName())) {
            newPropDefs.add(propDef);
        }
    }
    return newPropDefs;
}

protected List<BeanPropertyWriter> findBeanProperties(SerializerProvider paramSerializerProvider, BeanDescription paramBeanDescription, BeanSerializerBuilder paramBeanSerializerBuilder)
{
  List localList = paramBeanDescription.findProperties();
  SerializationConfig localSerializationConfig = paramSerializerProvider.getConfig();
  removeIgnorableTypes(localSerializationConfig, paramBeanDescription, localList);
  if (localSerializationConfig.isEnabled(MapperFeature.REQUIRE_SETTERS_FOR_GETTERS))
    removeSetterlessGetters(localSerializationConfig, paramBeanDescription, localList);
  if (localList.isEmpty())
    return null;
  boolean bool = usesStaticTyping(localSerializationConfig, paramBeanDescription, null);
  PropertyBuilder localPropertyBuilder = constructPropertyBuilder(localSerializationConfig, paramBeanDescription);
  ArrayList localArrayList = new ArrayList(localList.size());
  TypeBindings localTypeBindings = paramBeanDescription.bindingsForBeanType();
  Iterator localIterator = localList.iterator();
  while (localIterator.hasNext())
  {
    BeanPropertyDefinition localBeanPropertyDefinition = (BeanPropertyDefinition)localIterator.next();
    AnnotatedMember localAnnotatedMember = localBeanPropertyDefinition.getAccessor();
    if (localBeanPropertyDefinition.isTypeId())
    {
      if (localAnnotatedMember != null)
      {
        if (localSerializationConfig.canOverrideAccessModifiers())
          localAnnotatedMember.fixAccess();
        paramBeanSerializerBuilder.setTypeId(localAnnotatedMember);
      }
    }
    else
    {
      AnnotationIntrospector.ReferenceProperty localReferenceProperty = localBeanPropertyDefinition.findReferenceType();
      if ((localReferenceProperty == null) || (!localReferenceProperty.isBackReference()))
        if ((localAnnotatedMember instanceof AnnotatedMethod))
          localArrayList.add(_constructWriter(paramSerializerProvider, localBeanPropertyDefinition, localTypeBindings, localPropertyBuilder, bool, (AnnotatedMethod)localAnnotatedMember));
        else
          localArrayList.add(_constructWriter(paramSerializerProvider, localBeanPropertyDefinition, localTypeBindings, localPropertyBuilder, bool, (AnnotatedField)localAnnotatedMember));
    }
  }
  return localArrayList;
}

protected void removeIgnorableTypes(SerializationConfig paramSerializationConfig, BeanDescription paramBeanDescription, List<BeanPropertyDefinition> paramList)
{
  AnnotationIntrospector localAnnotationIntrospector = paramSerializationConfig.getAnnotationIntrospector();
  HashMap localHashMap = new HashMap();
  Iterator localIterator = paramList.iterator();
  while (localIterator.hasNext())
  {
    AnnotatedMember localAnnotatedMember = ((BeanPropertyDefinition)localIterator.next()).getAccessor();
    if (localAnnotatedMember == null)
    {
      localIterator.remove();
    }
    else
    {
      Class localClass = localAnnotatedMember.getRawType();
      Boolean localBoolean1 = (Boolean)localHashMap.get(localClass);
      Object localObject = localBoolean1;
      if (localBoolean1 == null)
      {
        Boolean localBoolean2 = localAnnotationIntrospector.isIgnorableType(paramSerializationConfig.introspectClassAnnotations(localClass).getClassInfo());
        localObject = localBoolean2;
        if (localBoolean2 == null)
          localObject = Boolean.FALSE;
        localHashMap.put(localClass, localObject);
      }
      if (((Boolean)localObject).booleanValue())
        localIterator.remove();
    }
  }
}

protected void removeSetterlessGetters(SerializationConfig paramSerializationConfig, BeanDescription paramBeanDescription, List<BeanPropertyDefinition> paramList)
{
  Iterator localIterator = paramList.iterator();
  while (localIterator.hasNext())
  {
    BeanPropertyDefinition localBeanPropertyDefinition = (BeanPropertyDefinition)localIterator.next();
    if ((!localBeanPropertyDefinition.couldDeserialize()) && (!localBeanPropertyDefinition.isExplicitlyIncluded()))
      localIterator.remove();
  }
}

public BeanPropertyWriter(BeanPropertyDefinition paramBeanPropertyDefinition, AnnotatedMember paramAnnotatedMember, Annotations paramAnnotations, JavaType paramJavaType1, JsonSerializer<?> paramJsonSerializer, TypeSerializer paramTypeSerializer, JavaType paramJavaType2, boolean paramBoolean, Object paramObject)
{
  this._member = paramAnnotatedMember;
  this._contextAnnotations = paramAnnotations;
  this._name = new SerializedString(paramBeanPropertyDefinition.getName());
  this._wrapperName = paramBeanPropertyDefinition.getWrapperName();
  this._declaredType = paramJavaType1;
  this._serializer = paramJsonSerializer;
  PropertySerializerMap localPropertySerializerMap;
  if (paramJsonSerializer == null)
    localPropertySerializerMap = PropertySerializerMap.emptyMap();
  else
    localPropertySerializerMap = null;
  this._dynamicSerializers = localPropertySerializerMap;
  this._typeSerializer = paramTypeSerializer;
  this._cfgSerializationType = paramJavaType2;
  this._isRequired = paramBeanPropertyDefinition.isRequired();
  if ((paramAnnotatedMember instanceof AnnotatedField))
  {
    this._accessorMethod = null;
    this._field = ((Field)paramAnnotatedMember.getMember());
  }
  else if ((paramAnnotatedMember instanceof AnnotatedMethod))
  {
    this._accessorMethod = ((Method)paramAnnotatedMember.getMember());
    this._field = null;
  }
  else
  {
    throw new IllegalArgumentException("Can not pass member of type " + paramAnnotatedMember.getClass().getName());
  }
  this._suppressNulls = paramBoolean;
  this._suppressableValue = paramObject;
  this._includeInViews = paramBeanPropertyDefinition.findViews();
  this._nullSerializer = null;
}

protected SettableBeanProperty constructSetterlessProperty(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanPropertyDefinition paramBeanPropertyDefinition)
{
  AnnotatedMethod localAnnotatedMethod = paramBeanPropertyDefinition.getGetter();
  if (paramDeserializationContext.canOverrideAccessModifiers())
    localAnnotatedMethod.fixAccess();
  JavaType localJavaType1 = localAnnotatedMethod.getType(paramBeanDescription.bindingsForBeanType());
  JsonDeserializer localJsonDeserializer = findDeserializerFromAnnotation(paramDeserializationContext, localAnnotatedMethod);
  JavaType localJavaType2 = modifyTypeByAnnotation(paramDeserializationContext, localAnnotatedMethod, localJavaType1);
  Object localObject = new SetterlessProperty(paramBeanPropertyDefinition, localJavaType2, (TypeDeserializer)localJavaType2.getTypeHandler(), paramBeanDescription.getClassAnnotations(), localAnnotatedMethod);
  if (localJsonDeserializer != null)
    localObject = ((SettableBeanProperty)localObject).withValueDeserializer(localJsonDeserializer);
  return localObject;
}

protected List<BeanPropertyDefinition> filterBeanProps(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanDeserializerBuilder paramBeanDeserializerBuilder, List<BeanPropertyDefinition> paramList, Set<String> paramSet)
{
  ArrayList localArrayList = new ArrayList(Math.max(4, paramList.size()));
  HashMap localHashMap = new HashMap();
  Iterator localIterator = paramList.iterator();
  while (localIterator.hasNext())
  {
    BeanPropertyDefinition localBeanPropertyDefinition = (BeanPropertyDefinition)localIterator.next();
    String str = localBeanPropertyDefinition.getName();
    if (!paramSet.contains(str))
      if (!localBeanPropertyDefinition.hasConstructorParameter())
      {
        Class localClass;
        if (localBeanPropertyDefinition.hasSetter())
        {
          localClass = localBeanPropertyDefinition.getSetter().getRawParameterType(0);
        }
        else
        {
          boolean bool = localBeanPropertyDefinition.hasField();
          localClass = null;
          if (bool)
            localClass = localBeanPropertyDefinition.getField().getRawType();
        }
        if ((localClass != null) && (isIgnorableType(paramDeserializationContext.getConfig(), paramBeanDescription, localClass, localHashMap)))
          paramBeanDeserializerBuilder.addIgnorable(str);
      }
      else
      {
        localArrayList.add(localBeanPropertyDefinition);
      }
  }
  return localArrayList;
}

@Override
public VirtualBeanPropertyWriter withConfig(
        final MapperConfig<?> config,
        final AnnotatedClass declaringClass,
        final BeanPropertyDefinition propDef,
        final JavaType type) {
    return this;
}

@Override
public VirtualBeanPropertyWriter withConfig(
        final MapperConfig<?> config,
        final AnnotatedClass declaringClass,
        final BeanPropertyDefinition propDef, final JavaType type) {
    return this;
}

private Function<BeanPropertyDefinition, String> beanPropertyByInternalName() {
    return new Function<BeanPropertyDefinition, String>() {
        public String apply(BeanPropertyDefinition input) {
            return input.getInternalName();
        }
    };
}