How do you get values set inside a annotation?
I have the following annotation defined:
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface JsonElement {
int type();
}
And here is the method that uses it in a POJO class
@JsonElement(type=GETTER_METHOD)
public String getUsername{
........................
}
And the util class that uses reflection to check if this method has the JSonElement annotation present and to check what the type value is.
Method methods[] = classObject.getClass().getDeclaredMethods();
JSONObject jsonObject = new JSONObject();
try {
for (int i = 0; i < methods.length; i++) {
String key = methods[i].getName();
System.out.println(key);
if (methods[i].isAnnotationPresent(JsonElement.class) && key.startsWith(GET_CHAR_SEQUENCE)) {
methods[i].getDeclaredAnnotations();
key = key.replaceFirst(GET_CHAR_SEQUENCE, "");
jsonObject.put(key, methods[i].invoke(classObject));
}
}
return jsonObject;
} catch (Exception e) {
e.printStackTrace();
return null;
}
How do I find out what type()
value is? I can find whether the annotation is present, but I can't find a method that finds out what value - if any - was set for type()
.
Use @Field to define a structured data type's field name for an object mapped to NoSql data. Annotation Elements. Table 2-24 describes this annotation's elements.
Annotations, just like methods or fields, can be inherited between class hierarchies. If an annotation declaration is marked with @Inherited , then a class that extends another class with this annotation can inherit it.
reflect. Method. getAnnotation(Class< T > annotationClass) method of Method class returns Method objects's annotation for the specified type passed as parameter if such an annotation is present, else null. This is important method to get annotation for Method object.
JsonElement jsonElem = methods[i].getAnnotation(JsonElement.class);
int itsTypeIs = jsonElem.type();
Note that you must be sure that jsonElem
is not null
either by your
isAnnotationPresent(JsonElement.class)
or a simple
if (jsonElem != null) {
}
check.
Additionally, if you changed your annotation to
public @interface JsonElement {
int type() default -1;
}
you wouldn't have to state the type
attribute at every occurence of @JsonElement
in your code - it would default to -1
.
You could also consider using an enum
for this instead of some integer flags, for example:
public enum JsonType {
GETTER, SETTER, OTHER;
}
public @interface JsonElement {
JsonType type() default JsonType.OTHER;
}
You can check if annotation belongs to JSonElement if yes you can cast and call your methods
If looping through all the annotation then
for(Annotation annotation : methods[i].getAnnotations()) {
if(annotation instanceOf(JsonElement)){
((JsonElement)annotation).getType();
}
}
or
JSonElement jSonElement = methods[i].getAnnotations(JSonElement.class);
jSonElement.getType();
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With