protected Optional<String> getName(Method method) { ObjectMapper objectMapper = context.getObjectMapper(); SerializationConfig serializationConfig = objectMapper.getSerializationConfig(); if (serializationConfig != null && serializationConfig.getPropertyNamingStrategy() != null) { String name = ClassUtils.getGetterFieldName(method); Annotation[] declaredAnnotations = method.getDeclaredAnnotations(); AnnotationMap annotationMap = buildAnnotationMap(declaredAnnotations); int paramsLength = method.getParameterAnnotations().length; AnnotationMap[] paramAnnotations = new AnnotationMap[paramsLength]; for (int i = 0; i < paramsLength; i++) { AnnotationMap parameterAnnotationMap = buildAnnotationMap(method.getParameterAnnotations()[i]); paramAnnotations[i] = parameterAnnotationMap; } AnnotatedClass annotatedClass = AnnotatedClassBuilder.build(method.getDeclaringClass(), serializationConfig); AnnotatedMethod annotatedField = AnnotatedMethodBuilder.build(annotatedClass, method, annotationMap, paramAnnotations); return Optional.of(serializationConfig.getPropertyNamingStrategy().nameForGetterMethod(serializationConfig, annotatedField, name)); } return Optional.empty(); }
@Test public void fieldNamingStrategySerialize() throws IOException { final ObjectMapper mapper = new VPackMapper(); mapper.setPropertyNamingStrategy(new PropertyNamingStrategy() { private static final long serialVersionUID = 1L; @Override public String nameForGetterMethod( final MapperConfig<?> config, final AnnotatedMethod method, final String defaultName) { return "bla"; } }); final VPackSlice vpack = new VPackSlice(mapper.writeValueAsBytes(new TestEntityA())); assertThat(vpack, is(notNullValue())); assertThat(vpack.isObject(), is(true)); final VPackSlice bla = vpack.get("bla"); assertThat(bla.isString(), is(true)); assertThat(bla.getAsString(), is("a")); }
@Test public void fieldNamingStrategyDeserialize() throws IOException { final VPackBuilder builder = new VPackBuilder(); builder.add(ValueType.OBJECT); builder.add("bla", "test"); builder.close(); final ObjectMapper mapper = new VPackMapper(); mapper.setPropertyNamingStrategy(new PropertyNamingStrategy() { private static final long serialVersionUID = 1L; @Override public String nameForSetterMethod( final MapperConfig<?> config, final AnnotatedMethod method, final String defaultName) { return "bla"; } }); final TestEntityA entity = mapper.readValue(builder.slice().getBuffer(), TestEntityA.class); assertThat(entity, is(notNullValue())); assertThat(entity.a, is("test")); }
/** * Extract name to be used by Katharsis from getter's name. It uses * {@link ResourceFieldNameTransformer#getMethodName(Method)}, {@link JsonProperty} annotation and * {@link PropertyNamingStrategy}. * * @param method method to extract name * @return method name */ public String getName(Method method) { String name = getMethodName(method); if (method.isAnnotationPresent(JsonProperty.class) && !"".equals(method.getAnnotation(JsonProperty.class).value())) { name = method.getAnnotation(JsonProperty.class).value(); } else if (serializationConfig != null && serializationConfig.getPropertyNamingStrategy() != null) { Annotation[] declaredAnnotations = method.getDeclaredAnnotations(); AnnotationMap annotationMap = buildAnnotationMap(declaredAnnotations); int paramsLength = method.getParameterAnnotations().length; AnnotationMap[] paramAnnotations = new AnnotationMap[paramsLength]; for (int i = 0; i < paramsLength; i++) { AnnotationMap parameterAnnotationMap = buildAnnotationMap(method.getParameterAnnotations()[i]); paramAnnotations[i] = parameterAnnotationMap; } AnnotatedClass annotatedClass = AnnotatedClassBuilder.build(method.getDeclaringClass(), serializationConfig); AnnotatedMethod annotatedField = AnnotatedMethodBuilder.build(annotatedClass, method, annotationMap, paramAnnotations); name = serializationConfig.getPropertyNamingStrategy().nameForGetterMethod(serializationConfig, annotatedField, name); } return name; }
@Override public Object findDeserializationConverter(Annotated a) { JtToMap ann = a.getAnnotation(JtToMap.class); if (ann == null) { return null; } JavaType javaType = a.getType(); if(a instanceof AnnotatedMethod) { AnnotatedMethod am = (AnnotatedMethod) a; if(am.getParameterCount() == 1) { javaType = am.getParameterType(0); } else { throw new RuntimeException("Invalid property setter: " + am.getAnnotated()); } } return new DeserializationConverterImpl(ann, new Ctx(a, javaType)); }
@Override public Object findDeserializationConverter(Annotated a) { Class<? extends PropertyInterceptor>[] interceptors = getInterceptors(a); if (interceptors == null) { return null; } JavaType javaType = a.getType(); if(a instanceof AnnotatedMethod) { AnnotatedMethod am = (AnnotatedMethod) a; if(am.getParameterCount() == 1) { javaType = am.getParameterType(0); } else { throw new RuntimeException("Invalid property setter: " + am.getAnnotated()); } } return new KvInterceptorsDeserializationConverter(interceptors, new KvPropertyContextImpl(a, javaType)); }
protected AnnotatedMethod _findFactory(AnnotatedClass cls, String name, Class<?>... argTypes) { final int argCount = argTypes.length; for (AnnotatedMethod method : cls.getFactoryMethods()) { if (!name.equals(method.getName()) || (method.getParameterCount() != argCount)) { continue; } for (int i = 0; i < argCount; ++i) { Class<?> argType = method.getParameter(i).getRawType(); if (!argType.isAssignableFrom(argTypes[i])) { continue; } } return method; } return null; }
@Override public PropertyName findNameForSerialization(Annotated a) { if (!(a instanceof AnnotatedField) && !(a instanceof AnnotatedMethod)) { return super.findNameForSerialization(a); } IndexableProperty property = a.getAnnotation(IndexableProperty.class); if (property != null && !property.name().isEmpty()) { return new PropertyName(property.name()); } IndexableComponent component = a.getAnnotation(IndexableComponent.class); if (component != null && !component.name().isEmpty()) { return new PropertyName(component.name()); } IndexableProperties properties = a.getAnnotation(IndexableProperties.class); if (properties != null && !properties.name().isEmpty()) { return new PropertyName(properties.name()); } return PropertyName.USE_DEFAULT; }
@Override public PropertyName findNameForDeserialization(Annotated a) { if (!(a instanceof AnnotatedField) && !(a instanceof AnnotatedMethod)) { return super.findNameForDeserialization(a); } IndexableProperty property = a.getAnnotation(IndexableProperty.class); if (property != null && !property.name().isEmpty()) { return new PropertyName(property.name()); } IndexableComponent component = a.getAnnotation(IndexableComponent.class); if (component != null && !component.name().isEmpty()) { return new PropertyName(component.name()); } IndexableProperties properties = a.getAnnotation(IndexableProperties.class); if (properties != null && !properties.name().isEmpty()) { return new PropertyName(properties.name()); } return PropertyName.USE_DEFAULT; }
protected AnnotatedMethod _findFactory(AnnotatedClass cls, String name, Class<?>... argTypes) { final int argCount = argTypes.length; for (AnnotatedMethod method : cls.getStaticMethods()) { if (!name.equals(method.getName()) || (method.getParameterCount() != argCount)) { continue; } for (int i = 0; i < argCount; ++i) { Class<?> argType = method.getParameter(i).getRawType(); if (!argType.isAssignableFrom(argTypes[i])) { continue; } } return method; } return null; }
@Override public void setupModule(SetupContext context) { context.insertAnnotationIntrospector(new NopAnnotationIntrospector() { private static final long serialVersionUID = 479313244908256455L; @Override public boolean hasIgnoreMarker(AnnotatedMember m) { if (!(m instanceof AnnotatedMethod)) { return super.hasIgnoreMarker(m); } AnnotatedMethod method = (AnnotatedMethod) m; return method.getName().startsWith("lambda$") ? true : super.hasIgnoreMarker(m); } }); }
@Override public Object findDeserializer( Annotated annotated ) { if( ! annotated.hasAnnotation(Column.class) || ! isStringType(annotated) ) { return super.findDeserializer( annotated ); } Class classType; try { classType = ( (AnnotatedMethod) annotated ).getRawParameterType( 0 ); } catch( Exception e ) { classType = annotated.getRawType(); } if( Types.isNotString(classType) ) { if( Types.isBoolean(classType) ) { return ColumnBooleanDeserializer.class; } else if( ! Types.isPrimitive(classType) ) { return ColumnBeanDeserializer.class; } } return super.findDeserializer( annotated ); }
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig paramDeserializationConfig, Class<?> paramClass, AnnotatedMethod paramAnnotatedMethod) { Class localClass = paramAnnotatedMethod.getRawParameterType(0); Object localObject; if (localClass == String.class) localObject = null; else if ((localClass == Integer.TYPE) || (localClass == Integer.class)) localObject = Integer.class; else if ((localClass == Long.TYPE) || (localClass == Long.class)) localObject = Long.class; else throw new IllegalArgumentException("Parameter #0 type for factory method (" + paramAnnotatedMethod + ") not suitable, must be java.lang.String or int/Integer/long/Long"); if (paramDeserializationConfig.canOverrideAccessModifiers()) ClassUtil.checkAndFixAccess(paramAnnotatedMethod.getMember()); return new FactoryBasedDeserializer(paramClass, paramAnnotatedMethod, (Class)localObject); }
protected void addReferenceProperties(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanDeserializerBuilder paramBeanDeserializerBuilder) { Map localMap = paramBeanDescription.findBackReferenceProperties(); if (localMap != null) { Iterator localIterator = localMap.entrySet().iterator(); while (localIterator.hasNext()) { Map.Entry localEntry = (Map.Entry)localIterator.next(); String str = (String)localEntry.getKey(); AnnotatedMember localAnnotatedMember = (AnnotatedMember)localEntry.getValue(); Object localObject; if ((localAnnotatedMember instanceof AnnotatedMethod)) localObject = ((AnnotatedMethod)localAnnotatedMember).getGenericParameterType(0); else localObject = localAnnotatedMember.getRawType(); paramBeanDeserializerBuilder.addBackReferenceProperty(str, constructSettableProperty(paramDeserializationContext, paramBeanDescription, SimpleBeanPropertyDefinition.construct(paramDeserializationContext.getConfig(), localAnnotatedMember), (Type)localObject)); } } }
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; }
public PropertyName findNameForDeserialization(Annotated paramAnnotated) { String str; if ((paramAnnotated instanceof AnnotatedField)) str = findDeserializationName((AnnotatedField)paramAnnotated); else if ((paramAnnotated instanceof AnnotatedMethod)) str = findDeserializationName((AnnotatedMethod)paramAnnotated); else if ((paramAnnotated instanceof AnnotatedParameter)) str = findDeserializationName((AnnotatedParameter)paramAnnotated); else str = null; if (str != null) { if (str.length() == 0) return PropertyName.USE_DEFAULT; return new PropertyName(str); } return null; }
public PropertyName findNameForSerialization(Annotated paramAnnotated) { String str; if ((paramAnnotated instanceof AnnotatedField)) str = findSerializationName((AnnotatedField)paramAnnotated); else if ((paramAnnotated instanceof AnnotatedMethod)) str = findSerializationName((AnnotatedMethod)paramAnnotated); else str = null; if (str != null) { if (str.length() == 0) return PropertyName.USE_DEFAULT; return new PropertyName(str); } return null; }
/** * Factory method used when Enum instances are to be deserialized * using a creator (static factory method) * * @return Deserializer based on given factory method, if type was suitable; * null if type can not be used */ public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config, Class<?> enumClass, AnnotatedMethod factory) { // note: caller has verified there's just one arg; but we must verify its type Class<?> paramClass = factory.getRawParameterType(0); if (paramClass == String.class) { paramClass = null; } else if (paramClass == Integer.TYPE || paramClass == Integer.class) { paramClass = Integer.class; } else if (paramClass == Long.TYPE || paramClass == Long.class) { paramClass = Long.class; } else { throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory +") not suitable, must be java.lang.String or int/Integer/long/Long"); } if (config.canOverrideAccessModifiers()) { ClassUtil.checkAndFixAccess(factory.getMember()); } return new FactoryBasedDeserializer(enumClass, factory, paramClass); }
public static String okNameForRegularGetter(AnnotatedMethod am, String name) { if (name.startsWith("get")) { /* 16-Feb-2009, tatu: To handle [JACKSON-53], need to block * CGLib-provided method "getCallbacks". Not sure of exact * safe criteria to get decent coverage without false matches; * but for now let's assume there's no reason to use any * such getter from CGLib. * But let's try this approach... */ if ("getCallbacks".equals(name)) { if (isCglibGetCallbacks(am)) { return null; } } else if ("getMetaClass".equals(name)) { /* 30-Apr-2009, tatu: [JACKSON-103], need to suppress * serialization of a cyclic (and useless) reference */ if (isGroovyMetaClassGetter(am)) { return null; } } return manglePropertyName(name.substring(3)); } return null; }
/** * This method was added to address [JACKSON-53]: need to weed out * CGLib-injected "getCallbacks". * At this point caller has detected a potential getter method * with name "getCallbacks" and we need to determine if it is * indeed injectect by Cglib. We do this by verifying that the * result type is "net.sf.cglib.proxy.Callback[]" *<p> * Also, see [JACKSON-177]; Hibernate may repackage cglib * it uses, so we better catch that too */ protected static boolean isCglibGetCallbacks(AnnotatedMethod am) { Class<?> rt = am.getRawType(); // Ok, first: must return an array type if (rt == null || !rt.isArray()) { return false; } /* And that type needs to be "net.sf.cglib.proxy.Callback". * Theoretically could just be a type that implements it, but * for now let's keep things simple, fix if need be. */ Class<?> compType = rt.getComponentType(); // Actually, let's just verify it's a "net.sf.cglib.*" class/interface Package pkg = compType.getPackage(); if (pkg != null) { String pname = pkg.getName(); if (pname.startsWith("net.sf.cglib") // also, as per [JACKSON-177] || pname.startsWith("org.hibernate.repackage.cglib")) { return true; } } return false; }
public static AnnotatedMethod build(final AnnotatedClass annotatedClass, final Method method, final AnnotationMap annotationMap, final AnnotationMap[] paramAnnotations) { final Constructor<?> constructor = AnnotatedMethod.class.getConstructors()[0]; return ExceptionUtil.wrapCatchedExceptions(new Callable<AnnotatedMethod>() { @Override public AnnotatedMethod call() throws Exception { return buildAnnotatedField(annotatedClass, method, annotationMap, paramAnnotations, constructor); } }, "Exception while building AnnotatedMethod"); }
private static AnnotatedMethod buildAnnotatedField(AnnotatedClass annotatedClass, Method method, AnnotationMap annotationMap, AnnotationMap[] paramAnnotations, Constructor<?> constructor) throws IllegalAccessException, InstantiationException, InvocationTargetException { Class<?> firstParameterType = constructor.getParameterTypes()[0]; PreconditionUtil.assertTrue(CANNOT_FIND_PROPER_CONSTRUCTOR, firstParameterType == AnnotatedClass.class || TypeResolutionContext.class.equals(firstParameterType)); return (AnnotatedMethod) constructor.newInstance(annotatedClass, method, annotationMap, paramAnnotations); }
private boolean isReadable(BeanDescription beanDesc, BeanPropertyWriter writer) { String parentType = beanDesc.getType().getRawClass().getName(); String type = writer.getPropertyType().getName(); AnnotatedMethod setter = findSetter(beanDesc, writer); // If there's a setter, we assume it's OK to report on the value, // similarly, if there's no setter but the package names match, we assume // that its a nested class used solely for binding to config props, so it // should be kosher. This filter is not used if there is JSON metadata for // the property, so it's mainly for user-defined beans. return (setter != null) || ClassUtils.getPackageName(parentType) .equals(ClassUtils.getPackageName(type)); }
private AnnotatedMethod findSetter(BeanDescription beanDesc, BeanPropertyWriter writer) { String name = "set" + StringUtils.capitalize(writer.getName()); Class<?> type = writer.getPropertyType(); AnnotatedMethod setter = beanDesc.findMethod(name, new Class<?>[] { type }); // The enabled property of endpoints returns a boolean primitive but is set // using a Boolean class if (setter == null && type.equals(Boolean.TYPE)) { setter = beanDesc.findMethod(name, new Class<?>[] { Boolean.class }); } return setter; }
@Override public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) { if (method.getDeclaringClass() == this.effectiveType) { return fieldToJsonMapping .getOrDefault(defaultName, super.nameForGetterMethod(config, method, defaultName)); } else { return super.nameForGetterMethod(config, method, defaultName); } }
@Override public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method, String defaultName) { if (method.getDeclaringClass() == this.effectiveType) { return fieldToJsonMapping .getOrDefault(defaultName, super.nameForSetterMethod(config, method, defaultName)); } else { return super.nameForSetterMethod(config, method, defaultName); } }
protected Class<?> rawDeserializationType(Annotated a) { if (a instanceof AnnotatedMethod) { AnnotatedMethod am = (AnnotatedMethod) a; if (am.getParameterCount() == 1) { return am.getRawParameterType(0); } } return a.getRawType(); }
@Override public Object findSerializer(Annotated a) { if (a instanceof AnnotatedMethod) { AnnotatedElement m = a.getAnnotated(); DateTimeFormat an = m.getAnnotation(DateTimeFormat.class); if (an != null) { if (!DEFAULT_DATE_FORMAT.equals(an.pattern())) { return new JsonDateSerializer(an.pattern()); } } } return super.findSerializer(a); }
public static AnnotatedMethod build(AnnotatedClass annotatedClass, Method method, AnnotationMap annotationMap, AnnotationMap[] paramAnnotations) { for(Constructor<?> constructor : AnnotatedMethod.class.getConstructors()) { try { return buildAnnotatedField(annotatedClass, method, annotationMap, paramAnnotations, constructor); } catch (IllegalAccessException | InstantiationException | InvocationTargetException e) { throw new InternalException("Exception while building " + AnnotatedMethod.class.getCanonicalName(), e); } } throw new InternalException(CANNOT_FIND_PROPER_CONSTRUCTOR); }
private static AnnotatedMethod buildAnnotatedField(AnnotatedClass annotatedClass, Method method, AnnotationMap annotationMap, AnnotationMap[] paramAnnotations, Constructor<?> constructor) throws IllegalAccessException, InstantiationException, InvocationTargetException { Class<?> firstParameterType = constructor.getParameterTypes()[0]; if (firstParameterType == AnnotatedClass.class || "TypeResolutionContext".equals(firstParameterType.getSimpleName())) { return (AnnotatedMethod) constructor.newInstance(annotatedClass, method, annotationMap, paramAnnotations); } else { throw new InternalException(CANNOT_FIND_PROPER_CONSTRUCTOR); } }
private boolean isReadable(BeanDescription beanDesc, BeanPropertyWriter writer) { Class<?> parentType = beanDesc.getType().getRawClass(); Class<?> type = writer.getType().getRawClass(); AnnotatedMethod setter = findSetter(beanDesc, writer); // If there's a setter, we assume it's OK to report on the value, // similarly, if there's no setter but the package names match, we assume // that its a nested class used solely for binding to config props, so it // should be kosher. This filter is not used if there is JSON metadata for // the property, so it's mainly for user-defined beans. return (setter != null) || ClassUtils.getPackageName(parentType) .equals(ClassUtils.getPackageName(type)); }
private AnnotatedMethod findSetter(BeanDescription beanDesc, BeanPropertyWriter writer) { String name = "set" + StringUtils.capitalize(writer.getName()); Class<?> type = writer.getType().getRawClass(); AnnotatedMethod setter = beanDesc.findMethod(name, new Class<?>[] { type }); // The enabled property of endpoints returns a boolean primitive but is set // using a Boolean class if (setter == null && type.equals(Boolean.TYPE)) { setter = beanDesc.findMethod(name, new Class<?>[] { Boolean.class }); } return setter; }
@Override public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) { List<BeanPropertyWriter> result = new ArrayList<BeanPropertyWriter>(); for (BeanPropertyWriter writer : beanProperties) { AnnotatedMethod setter = beanDesc.findMethod( "set" + StringUtils.capitalize(writer.getName()), new Class<?>[] { writer.getType().getRawClass() }); if (setter != null && this.conversionService.canConvert(String.class, writer.getType().getRawClass())) { result.add(writer); } } return result; }
private JavaType extractType(Annotated annotated) { if (annotated instanceof AnnotatedMethod) { AnnotatedMethod method = (AnnotatedMethod) annotated; if (ClassUtils.isSetter(method.getAnnotated())) { return method.getParameterType(0); } return method.getType(); } return annotated.getType(); }
private boolean isReadable(BeanDescription beanDesc, BeanPropertyWriter writer) { String parentType = beanDesc.getType().getRawClass().getName(); String type = writer.getType().getTypeName(); AnnotatedMethod setter = findSetter(beanDesc, writer); // If there's a setter, we assume it's OK to report on the value, // similarly, if there's no setter but the package names match, we assume // that its a nested class used solely for binding to config props, so it // should be kosher. This filter is not used if there is JSON metadata for // the property, so it's mainly for user-defined beans. return (setter != null) || ClassUtils.getPackageName(parentType) .equals(ClassUtils.getPackageName(type)); }
@Override public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException { if (property != null) { Annotated annotated = property.getMember(); if (annotated instanceof AnnotatedField || annotated instanceof AnnotatedMethod) { IndexableProperty indexableProperty = annotated.getAnnotation(IndexableProperty.class); if (indexableProperty != null && !indexableProperty.format().isEmpty()) { formatString = indexableProperty.format(); } } } return this; }
@Override public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException { if (property != null) { Annotated annotated = property.getMember(); if (annotated instanceof AnnotatedField || annotated instanceof AnnotatedMethod) { IndexableProperty indexableProperty = annotated.getAnnotation(IndexableProperty.class); if (indexableProperty != null && !indexableProperty.format().isEmpty()) { formatString = indexableProperty.format(); } } } return this; }
@Override public boolean hasIgnoreMarker(AnnotatedMember m) { if (!(m instanceof AnnotatedField) && !(m instanceof AnnotatedMethod)) return false; return (m.getAnnotation(IndexableProperty.class) == null && m.getAnnotation(IndexableComponent.class) == null && m.getAnnotation(IndexableProperties.class) == null); }