Getting data using reflection

java.lang.reflect.Field class

The Field class provides information about and dynamic access to a single field of a class or interface. Field also allows a widening type conversion during a get or set access operation, but throws an IllegalArgumentException if narrowing would occur.

To get a Field object, we'll first write a class:

public class Person {
    private String name;
    private int age;
    
    public boolean isMale;
    
    protected String address;
    
    public static final int MAX_AGE = 120;
    public static final int MIN_AGE = 0;
}

And here's our code for working with that class:

public class Main {
    public static void main(String[] args) {
        Field[] fields = Person.class.getDeclaredFields();
        List<Field> actualFields = getFieldNames(fields);
        System.out.println(actualFields);
    }

    static List<Field> getFieldNames(Field[] fields) {
        return List.of(fields);
    }
}

This is how we get the list of the fields of our class, which we will work with later. Here's the result:

Now let's figure out what we can do with this data. Let's talk about the methods of the Field class:

getType(), getName(), and getModifiers() methods

We can use the getType() method to can get the type of our field. Let's write a method:

static void printTypes(List<Field> fields){
      fields.forEach(e -> System.out.println(e.getType()));
  }

And we get this result:

Now let's add a method to our class to get the name of a field. This will make it easier to navigate the fields of our class.

static void printTypesAndNames(List<Field> fields){
   fields.forEach(e -> System.out.printf("Field type - %s\nField name - %s\n\n", e.getType(), e.getName()));
}

Now the result is more understandable:

Great! Let's modify our method some more! We'll add access modifiers here

static void printFieldInfo(List<Field> fields){
   fields.forEach(e -> System.out.printf("Field type - %s\nField name - %s\nModifiers - %s\n\n", e.getType(), e.getName(), Modifier.toString(e.getModifiers())));
}

And let's look at what e.getModifiers() returns. This method returns an int that lets us determine the state our field's access modifiers. The Modifier class contains static variables responsible for each specific modifier of the field.

Let's wrap our return value in Modifier.toString() and immediately get its value as text:

Here's what it looks like without Modifier.toString():

getAnnotations(), getAnnotatedType(), and getGenericType() methods

Let's modify the Person class to work with these methods. We'll write our own annotation and apply it to our fields. And we'll add a few more fields.

Let's create two annotations. We will pass the variable name in Pig Latin to one, and we will use the second for elements:

@Target(value=ElementType.FIELD)
@Retention(value= RetentionPolicy.RUNTIME)
public @interface Name {
    String name();
}

@Target({ ElementType.TYPE_USE })
@Retention(RetentionPolicy.RUNTIME)
public @interface Number {
}

And we'll change our main class and the Person class:

public class Person {
    @Name(name = "Ame-nay")
    private String name;

    @Name(name = "User nicknames")
    List<String> nicknames;

    private final Class<Object> type;

    private int @Number[] number;

    public Person(Class<Object> type) {
        this.type = type;
    }
}

public static void main(String[] args) {
    Field[] fields = Person.class.getDeclaredFields();
    List<Field> actualFields = getFieldNames(fields);
    
    printAdditionalInfo(actualFields);
}

static void printAdditionalInfo(List<Field> fields) {
   System.out.println("\ngetAnnotatedType:");
   fields.forEach(e -> System.out.println(e.getAnnotatedType()));

   System.out.println("\ngetGenericType:");
   fields.forEach(e -> System.out.println(e.getGenericType()));

   System.out.println("\ngetAnnotations:");
   fields.forEach(e -> System.out.println(Arrays.toString(e.getAnnotations())));
}

It's time to look at the results of our methods and figure out what they are for:

• getAnnotatedType returns the annotation for the given field, if any. We get the annotation for the field and we can see it perfectly.

• getGenericType lets you correctly display a parameterized type.

• getAnnotations returns the annotations applied to our object.

This is how we can easily get all the data about each field in our class, as well as its access modifiers, annotations and data types.

java.lang.reflect.Method class

Super! We've talked about the fields of our class. Now it's time to talk about the methods.

To get a Method object, we call the getMethod method, passing it the name of our method. This is the basic way to get a Method object:

Method getNameMethod =  Person.class.getMethod("getName");

We'll continue to work with our class. Let's add getters and setters, and hashCode, equals and toString methods:

public class Person {
    private String name;
    private int age;

    public boolean isMale;

    protected String address;

    public static final int MAX_AGE = 120;
    public static final int MIN_AGE = 0;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public boolean isMale() {
        return isMale;
    }

    public void setMale(boolean male) {
        isMale = male;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", isMale=" + isMale +
                ", address='" + address + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && isMale == person.isMale && Objects.equals(name, person.name) && Objects.equals(address, person.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, isMale, address);
    }
}

Now let's prepare a set of methods that we will examine using the Method class. Here is a list of the most important methods:

To get an array of the methods of our class will, we can call this method:

Method[] methods = Person.class.getDeclaredMethods();

It will give us all the methods in our class.

getName() and getModifiers() methods

We can use getName to get the name of each method:

static List<String> getMethodsName(Method[] methods) {
    return Arrays.asList(methods)
            .stream()
            .map(Method::getName)
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
}

Now to get the modifiers, let's write a method that uses getModifiers:

static List<String> getModifiers(Method[] methods) {
    return Arrays
            .stream(methods)
            .map(Method::getModifiers)
            .map(String::valueOf)
            .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
}

Here's our main method:

public static void main(String[] args) {
    Method[] methods = Person.class.getDeclaredMethods();

    System.out.println(getMethodsName(methods));
    System.out.println(getModifiers(methods));
}

Our result:

All of our methods have the public modifier, so the last method returns an array of ones. If we modify our code, we will see our the modifiers themselves:

public static void main(String[] args) {
    Method[] methods = Person.class.getDeclaredMethods();

    System.out.println(getMethodsName(methods));
    System.out.println(modifyModifiers(getModifiers(methods)));
}

getReturnedType()

This method lets us get the return type of the method:

static void getReturnedType(Method[] methods) {
    Arrays.stream(methods)
            .map(Method::getReturnType)
            .forEach(System.out::println);
}

getGenericReturnType()

Let's give our Person class a method that returns the type wrapped in a parameterized type, and try to get its return value:

public List<String> someMethod() {
    // Very useful and important method
    return null;
}

And we'll update our main method:

static void getGenericReturnType(Method[] methods) {
    Arrays.stream(methods)
            .map(Method::getGenericReturnType)
            .forEach(System.out::println);
}

Result of our method:

getParameterTypes() and getGenericParameterTypes() methods

We continue to modify our Person class, adding two more methods:

public List<String> someMethod(List<String> list, String s) {
    // Very useful and important method
    return null;
}

The first one will let us get the parameters of our methods, and the second one will give us parameterized types as well.

static void getParameterTypes(Method[] methods) {
    Class<?>[] types = method.getParameterTypes();
        for (Class<?> type : types) {
            System.out.println(type);
        }
}

static void getGenericParameterTypes(Method[] methods) {
   Type[] types = method.getGenericParameterTypes();
        for (Type type : types) {
            System.out.println(type);
        }
}

We will access only one of our methods. To access a method by a specific name, we call getMethod and pass in the name and parameters of the method we want:

public static void main(String[] args) throws NoSuchMethodException {
    Method currentMethod = Person.class.getMethod("someMethod", List.class, String.class);

    getParameterTypes(currentMethod);
    System.out.println();
    getGenericParameterTypes(currentMethod);
}

Running our code, we will see how the methods differ and what they return:

getExceptionTypes() and getGenericExceptionTypes() methods

We can use these methods to get an array of exceptions that our method can throw, as well as exceptions with parameterized types (if any). Let's use a new example that has a hidden static class:

private static class Processor {
    private void init() {}

    private void process() throws IOException {}
}

And we'll call methods on our Processor class:

public static void main(String... args) throws NoSuchMethodException {
    Method method = Processor.class.getDeclaredMethod("process");
    Type[] type = method.getExceptionTypes();
    System.out.println(Arrays.toString(type));
}

Now we can see our exception:

Now let's parameterize the type. We'll modify our main class:

private static class Processor<E extends IOException> {

    private void process() throws E {
    }
}

And the code of the main method:

public static void main(String... args) throws NoSuchMethodException {
    Method m = Processor.class.getDeclaredMethod("process");
    Type[] t = m.getGenericExceptionTypes();
    System.out.println(Arrays.toString(t));

    for (Type type : t) {
        if (type instanceof TypeVariable) {
            for (Type type1 : ((TypeVariable) type).getBounds()) {
                System.out.println(type1);
            }
        }
    }
}

Inside this method, we got a TypeVariables object, which is a generic parent interface for type variables. And inside that, we can now get the internal parameter, namely our nested exception:

getAnnotations() and getDeclaredAnnotations() methods

Let's continue using this new class and add a couple of annotations to it. We'll create our own Annotation annotation:

@Retention(RetentionPolicy.RUNTIME)
@interface Annotation {

    public String key();
    public String value();
}

And apply it to our method:

@Annotation(key = "key", value = "value")
private void process() throws E{

}

And of course we'll add a method to display all of our annotations:

static void getMethodAnnotations(Class<?> clazz) {
    Method[] methods = clazz.getDeclaredMethods();
    for (Method method : methods) {
        System.out.println(method.getName());
        System.out.println(Arrays.toString(method.getAnnotations()));
        System.out.println();
    }
}

Implementation of our main method:

public static void main(String... args) {
    Class clazz = Processor.class;
    getMethodAnnotations(clazz);
}

The resulting screen output is:

This is how we can get the annotations that have been applied to our methods, and the getAnnotations method lets us access the parent annotations of the class as well.

Today we got acquainted with how reflection can work with methods and fields, and what data we can get with it!