リフレクションを使用したデータの取得

java.lang.reflect.Field クラス

Fieldクラスは、クラスまたはインターフェイスの単一フィールドに関する情報と、そのフィールドへの動的アクセスを提供します。Field では、get または set アクセス操作中に拡大型変換も可能ですが、縮小が発生した場合はIllegalArgumentExceptionがスローされます。

Fieldオブジェクトを取得するには、まずクラスを作成します。

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 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);
    }
}

これは、クラスのフィールドのリストを取得する方法であり、後で使用します。結果は次のとおりです。

では、このデータを使って何ができるかを考えてみましょう。Fieldクラスのメソッドについて話しましょう。

getType()、getName()、および getModifiers() メソッド

getType()メソッドを使用してフィールドのタイプを取得できます。メソッドを書いてみましょう:

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

そして、次の結果が得られます。

次に、フィールドの名前を取得するメソッドをクラスに追加しましょう。これにより、クラスのフィールド間の移動が容易になります。

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

結果がよりわかりやすくなりました。

素晴らしい！メソッドをもう少し修正してみましょう。ここにアクセス修飾子を追加します

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())));
}

e.getModifiers() が何を返すかを見てみましょう。このメソッドは、フィールドのアクセス修飾子の状態を判断できるintを返します。Modifierクラスには、フィールドの特定の各修飾子を担当する静的変数が含まれています。

戻り値をModifier.toString()でラップし、その値をテキストとしてすぐに取得しましょう。

Modifier.toString()を使用しない場合は次のようになります。

getAnnotations()、getAnnotatedType()、および getGenericType() メソッド

これらのメソッドを使用できるようにPersonクラスを変更しましょう。独自のアノテーションを作成し、それをフィールドに適用します。さらにいくつかのフィールドを追加します。

2 つのアノテーションを作成しましょう。Pig Latin の変数名を 1 つに渡し、2 つ目を要素に使用します。

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

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

そして、メインクラスとPersonクラスを変更します。

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())));
}

メソッドの結果を見て、その目的を理解しましょう。

• getAnnotatedType は、指定されたフィールドの注釈を返します (存在する場合)。フィールドの注釈を取得し、それを完全に確認できます。

• getGenericType を使用すると、パラメーター化された型を正しく表示できます。

• getAnnotations は、オブジェクトに適用されたアノテーションを返します。

これにより、クラス内の各フィールドに関するすべてのデータだけでなく、そのアクセス修飾子、注釈、データ型も簡単に取得できるようになります。

java.lang.reflect.Method クラス

素晴らしい！私たちはクラスの分野について話しました。今度はメソッドについて話します。

Methodオブジェクトを取得するには、 getMethodメソッドを呼び出し、メソッドの名前を渡します。これはMethodオブジェクトを取得する基本的な方法です。

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

これからもクラス全員で協力していきます。getter と setter、および hashCode、 equals、toStringメソッドを追加しましょう。

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);
    }
}

次に、 Methodクラスを使用して調べる一連のメソッドを準備しましょう。最も重要なメソッドのリストを次に示します。

クラスのメソッドの配列を取得するには、次のメソッドを呼び出します。

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

これにより、クラス内のすべてのメソッドが得られます。

getName() メソッドと getModifiers() メソッド

getName を使用して各メソッドの名前を取得できます。

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

次に、修飾子を取得するために、 getModifiersを使用するメソッドを作成しましょう。

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

主な方法は次のとおりです。

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

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

私たちの結果:

すべてのメソッドにはpublic修飾子があるため、最後のメソッドは 1 の配列を返します。コードを変更すると、修飾子自体が表示されます。

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

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

getReturnedType()

このメソッドを使用すると、メソッドの戻り値の型を取得できます。

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

getGenericReturnType()

パラメータ化された型でラップされた型を返すメソッドをPersonクラスに与え、その戻り値を取得してみます。

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

そして、メインメソッドを更新します。

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

私たちの方法の結果:

getParameterTypes() メソッドと getGenericParameterTypes() メソッド

引き続きPersonクラスを変更し、さらに 2 つのメソッドを追加します。

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

1 つ目ではメソッドのパラメータを取得でき、2 つ目ではパラメータ化された型も取得できます。

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);
        }
}

いずれかのメソッドのみにアクセスします。特定の名前でメソッドにアクセスするには、getMethodを呼び出し、必要なメソッドの名前とパラメーターを渡します。

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);
}

コードを実行すると、メソッドがどのように異なり、何を返すかがわかります。

getExceptionTypes() メソッドと getGenericExceptionTypes() メソッド

これらのメソッドを使用すると、メソッドがスローできる例外の配列と、パラメーター化された型を持つ例外 (存在する場合) を取得できます。非表示の静的クラスを持つ新しい例を使用してみましょう。

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

    private void process() throws IOException {}
}

そして、 Processorクラスのメソッドを呼び出します。

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

これで、例外が確認できます。

次に、型をパラメータ化しましょう。メインクラスを変更します。

private static class Processor<E extends IOException> {

    private void process() throws E {
    }
}

そして、メインメソッドのコードは次のとおりです。

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);
            }
        }
    }
}

このメソッド内で、型変数の汎用親インターフェイスであるTypeVariablesオブジェクトを取得しました。そしてその中で、内部パラメータ、つまりネストされた例外を取得できるようになりました。

getAnnotations() メソッドと getDeclaredAnnotations() メソッド

この新しいクラスを引き続き使用し、いくつかの注釈を追加しましょう。独自のAnnotationアノテーションを作成します。

@Retention(RetentionPolicy.RUNTIME)
@interface Annotation {

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

そしてそれを私たちのメソッドに適用します。

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

}

そしてもちろん、すべての注釈を表示するメソッドを追加します。

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();
    }
}

mainメソッドの実装:

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

結果の画面出力は次のようになります。

これは、メソッドに適用されたアノテーションを取得する方法であり、getAnnotationsメソッドを使用すると、クラスの親アノテーションにもアクセスできます。

今日は、リフレクションがメソッドやフィールドでどのように機能するのか、そしてリフレクションを使用してどのようなデータを取得できるのかについて学びました。