メソッド名を文字列として指定した場合、Javaメソッドを呼び出すにはどうすればよいですか?


684

2つの変数がある場合:

Object obj;
String methodName = "getName";

のクラスを知らずにobjmethodNameそれによって識別されたメソッドを呼び出すにはどうすればよいですか?

呼び出されるメソッドにはパラメーターがなく、String戻り値があります。それはだのJava Beanのゲッター


回答:


972

腰からコーディングすると、次のようになります。

java.lang.reflect.Method method;
try {
  method = obj.getClass().getMethod(methodName, param1.class, param2.class, ..);
} catch (SecurityException e) { ... }
  catch (NoSuchMethodException e) { ... }

パラメータは、必要な非常に具体的なメソッドを識別します(使用可能なオーバーロードがいくつかある場合、メソッドに引数がない場合は、のみを指定しますmethodName)。

次に、次の呼び出しによってそのメソッドを呼び出します

try {
  method.invoke(obj, arg1, arg2,...);
} catch (IllegalArgumentException e) { ... }
  catch (IllegalAccessException e) { ... }
  catch (InvocationTargetException e) { ... }

ここでも、引数.invokeがない場合は省略します。しかしそうです。Javaリフレクションについて読む


2
Javaが型消去を使用するという事実に少し動揺しましたが、少なくともReflectionが私を元気づけていることを知っている:Dそして、Java 8のラムダで、言語は現代の開発に本当に追いついています。現在欠けているのは、C#で知られているゲッターとセッター、またはプロパティのネイティブサポートだけです。
7hi4g0 14

120
フェアではない-1。Henrikはおそらく例外をつぶすことを推奨しておらず、反射を実証しようとしているだけなので、例外を何も記述しませんでした。
描いた

70
さらに、いくつかの潜在的な例外を示すための1つ。私がこれを書いたとしたら、それは... catch(Exception e){...
mikbanUtah

1
の「変数が初期化されていない可能性があります」を取得しmethodましたmethod.invoke(obj, arg1, arg2,...);。a method = null;は問題を解決しますが、回答でそれを言及することは悪い考えではありません。
2016

2
@ DeaMon1 Javaメソッドは「終了コード」を使用しませんが、メソッドが何かを返す場合、返されたものを返しますinvoke。メソッドの実行中に例外が発生した場合、例外はでラップされますInvocationTargetException
ThePyroEagle 16

194

使用するメソッド呼び出しを反射から:

Class<?> c = Class.forName("class name");
Method method = c.getDeclaredMethod("method name", parameterTypes);
method.invoke(objectToInvokeOn, params);

どこ:

  • "class name" クラスの名前です
  • objectToInvokeOn タイプObjectであり、メソッドを呼び出すオブジェクトです
  • "method name" 呼び出したいメソッドの名前です
  • parameterTypes型でClass[]あり、メソッドが取るパラメータを宣言します
  • params型でObject[]あり、メソッドに渡されるパラメータを宣言します

クール、私はあなたがgetDeclaredMethod()としている権利は、それはおそらくgetMethodより「安全な」()..だと思う
brasskazoo

22
違う。はい、getDeclaredMethodはプライベートメソッドと保護メソッドで機能します。ただし、スーパークラスで定義されたメソッド(継承されたメソッド)では機能しません。だから、それはあなたが何をしたいかに強く依存します。多くの場合、メソッドが定義されている正確なクラスに関係なく機能させる必要があります。
jrudolph 2008年

そして、「クラス」ファイルはどこに置くべきですか?できればEclipse IDEについて説明してください
Dr.jacky

クラスパスの@ Mr.Hyde。
Stijn de Witt 2017

呼び出しているメソッドがパラメーターをまったく受け入れない場合、method.invoke()の中に何を入れればよいですか?2つ目のパラメーターを指定する必要があるようですが、空のオブジェクト配列にする必要がありますか?
イゴール

101

Java 7で簡単なコード例が必要な場合:

Dog クラス:

package com.mypackage.bean;

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

    public Dog() {
        // empty constructor
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 void printDog(String name, int age) {
        System.out.println(name + " is " + age + " year(s) old.");
    }
}

ReflectionDemo クラス:

package com.mypackage.demo;

import java.lang.reflect.*;

public class ReflectionDemo {

    public static void main(String[] args) throws Exception {
        String dogClassName = "com.mypackage.bean.Dog";
        Class<?> dogClass = Class.forName(dogClassName); // convert string classname to class
        Object dog = dogClass.newInstance(); // invoke empty constructor

        String methodName = "";

        // with single parameter, return void
        methodName = "setName";
        Method setNameMethod = dog.getClass().getMethod(methodName, String.class);
        setNameMethod.invoke(dog, "Mishka"); // pass arg

        // without parameters, return string
        methodName = "getName";
        Method getNameMethod = dog.getClass().getMethod(methodName);
        String name = (String) getNameMethod.invoke(dog); // explicit cast

        // with multiple parameters
        methodName = "printDog";
        Class<?>[] paramTypes = {String.class, int.class};
        Method printDogMethod = dog.getClass().getMethod(methodName, paramTypes);
        printDogMethod.invoke(dog, name, 3); // pass args
    }
}

出力: Mishka is 3 year(s) old.


次のようにして、パラメーターを指定してコンストラクターを呼び出すことができます。

Constructor<?> dogConstructor = dogClass.getConstructor(String.class, int.class);
Object dog = dogConstructor.newInstance("Hachiko", 10);

または、削除することもできます

String dogClassName = "com.mypackage.bean.Dog";
Class<?> dogClass = Class.forName(dogClassName);
Object dog = dogClass.newInstance();

そして、やります

Dog dog = new Dog();

Method method = Dog.class.getMethod(methodName, ...);
method.invoke(dog, ...);

推奨読書: 新しいクラスインスタンスの作成


1
ここで最良の答えです。完全かつ簡潔
Reuben JaMesAveñoGruta 2017年

1
正解を正解します。
Dhara Patel

どこでMethodオブジェクトを取得しますか?
18

リフレクトパッケージから。
シルバー

55

このようにしてメソッドを呼び出すことができます。他にも可能性があります(リフレクションAPIを確認してください)。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.junit.Assert;
import org.junit.Test;

public class ReflectionTest {

    private String methodName = "length";
    private String valueObject = "Some object";

    @Test
    public void testGetMethod() throws SecurityException, NoSuchMethodException, IllegalArgumentException,
            IllegalAccessException, InvocationTargetException {
        Method m = valueObject.getClass().getMethod(methodName, new Class[] {});
        Object ret = m.invoke(valueObject, new Object[] {});
        Assert.assertEquals(11, ret);
    }



}

7
OPが彼の質問で「パラメーターなし」を指定していることを認識した唯一の回答の+1(およびそれが私が探していたものでもあったため)。
John Fitzpatrick 2013年

16

まず、しないでください。この種のコードは避けてください。これは本当に悪いコードで安全でない傾向があります(Javaプログラミング言語セキュアコーディングガイドラインバージョン2.0のセクション6を参照)。

そうする必要がある場合は、リフレクションではなくjava.beansを使用してください。Beansはリフレクションをラップし、比較的安全で従来のアクセスを可能にします。


11
同意しません。安全のためにそのようなコードを書くのは非常に簡単で、私は複数の言語でそうしました。たとえば、許可されるメソッドのセットを作成し、その名前がセットに含まれている場合にのみメソッドの呼び出しを許可することができます。さらに安全な(それでもなお重要な点)は、許可される各メソッドを特定の状態に制限し、スレッド/インターフェイス/ユーザー/そのような基準に適合しない限り、メソッドを呼び出せないようにします。
JSON

そのような問題についてそんなにcategoricallになることはありません。現在、ユーザーがWebインターフェイスを使用して任意のオブジェクトに対して任意のタスクを定義できるようにする簡単なプログラムを作成しています。確かに安全ではありませんが、構成を受け取ると適切なテストが実行されます。これにより、プログラマー以外の人でもタスクを簡単に構成でき、カスタムクラスを汎用コードにリンクできるようになります(つまり、 GUIを更新せずに、Webインターフェイスを介して使用するメソッドを構成できるようにするために、リフレクションを使用する部分。
DGoiko

14

同僚の回答を完成させるために、次のことに細心の注意を払うことをお勧めします。

  • 静的またはインスタンスの呼び出し(1つのケースでは、クラスのインスタンスは不要です。もう1つのケースでは、既存のデフォルトコンストラクターに依存する必要がある場合があります
  • パブリックまたは非パブリックメソッドの呼び出し(後者の場合、doPrivilegedブロック内のメソッドでsetAccessibleを呼び出す必要があります。他のfindbugsは満足できません
  • 多数のJavaシステム例外をスローする場合は、1つ以上の管理可能なアプリケーション例外にカプセル化します(以下のコードではCCExceptionです)。

これらの点を考慮した古いjava1.4コードは次のとおりです。

/**
 * Allow for instance call, avoiding certain class circular dependencies. <br />
 * Calls even private method if java Security allows it.
 * @param aninstance instance on which method is invoked (if null, static call)
 * @param classname name of the class containing the method 
 * (can be null - ignored, actually - if instance if provided, must be provided if static call)
 * @param amethodname name of the method to invoke
 * @param parameterTypes array of Classes
 * @param parameters array of Object
 * @return resulting Object
 * @throws CCException if any problem
 */
public static Object reflectionCall(final Object aninstance, final String classname, final String amethodname, final Class[] parameterTypes, final Object[] parameters) throws CCException
{
    Object res;// = null;
    try {
        Class aclass;// = null;
        if(aninstance == null)
        {
            aclass = Class.forName(classname);
        }
        else
        {
            aclass = aninstance.getClass();
        }
        //Class[] parameterTypes = new Class[]{String[].class};
    final Method amethod = aclass.getDeclaredMethod(amethodname, parameterTypes);
        AccessController.doPrivileged(new PrivilegedAction() {
    public Object run() {
                amethod.setAccessible(true);
                return null; // nothing to return
            }
        });
        res = amethod.invoke(aninstance, parameters);
    } catch (final ClassNotFoundException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+CLASS, e);
    } catch (final SecurityException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_SECURITY_ISSUE, e);
    } catch (final NoSuchMethodException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_NOT_FOUND, e);
    } catch (final IllegalArgumentException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_ILLEGAL_ARGUMENTS+String.valueOf(parameters)+GenericConstants.CLOSING_ROUND_BRACKET, e);
    } catch (final IllegalAccessException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_ACCESS_RESTRICTION, e);
    } catch (final InvocationTargetException e) {
    throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_INVOCATION_ISSUE, e);
    } 
    return res;
}

12
Object obj;

Method method = obj.getClass().getMethod("methodName", null);

method.invoke(obj, null);

オブジェクトには少なくとも値が必要です。
Lova Chittumuri

これは、私が必要とするものに対して本当にうまくいきました。すでにインスタンス化されているクラスがあり、それからメソッドを取得するだけで十分でした。ここでは、例外のキャッチを追加することをお勧めしますが、それ以外の場合は、これでうまくいきました。私はnull例外を回避する方法はnullableを使用することであったと思いますが、私は非常に制限された範囲のメソッド名(文字通り1から4までのカウンター)を使用していました。
Jain Waldrip

12
//Step1 - Using string funClass to convert to class
String funClass = "package.myclass";
Class c = Class.forName(funClass);

//Step2 - instantiate an object of the class abov
Object o = c.newInstance();
//Prepare array of the arguments that your function accepts, lets say only one string here
Class[] paramTypes = new Class[1];
paramTypes[0]=String.class;
String methodName = "mymethod";
//Instantiate an object of type method that returns you method name
 Method m = c.getDeclaredMethod(methodName, paramTypes);
//invoke method with actual params
m.invoke(o, "testparam");

8

呼び出しを数回行う場合は、Java 7で導入された新しいメソッドハンドルを使用できます。ここでは、メソッドが文字列を返すようにします。

Object obj = new Point( 100, 200 );
String methodName = "toString";  
Class<String> resultType = String.class;

MethodType mt = MethodType.methodType( resultType );
MethodHandle methodHandle = MethodHandles.lookup().findVirtual( obj.getClass(), methodName, mt );
String result = resultType.cast( methodHandle.invoke( obj ) );

System.out.println( result );  // java.awt.Point[x=100,y=200]

1
将来の読者へ。パフォーマンスが気になる場合は、invokeExactいつでも使用できます。そのため、呼び出しサイトのシグネチャは、メソッドハンドルタイプと正確に一致する必要があります。通常、作業に入るには少し手を加える必要があります。この場合、最初のパラメーターを次のようにキャストし、次のmethodHandle = methodHandle.asType(methodHandle.type().changeParameterType(0, Object.class));ように呼び出す必要がありますString result = (String) methodHandle.invokeExact(obj);
Jorn Vernee

7

これは、Javaリフレクションパッケージで実行可能なことのように聞こえます。

http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html

特に、名前によるメソッドの呼び出しの

import java.lang.reflect。*;

public class method2 {
  public int add(int a, int b)
  {
     return a + b;
  }

  public static void main(String args[])
  {
     try {
       Class cls = Class.forName("method2");
       Class partypes[] = new Class[2];
        partypes[0] = Integer.TYPE;
        partypes[1] = Integer.TYPE;
        Method meth = cls.getMethod(
          "add", partypes);
        method2 methobj = new method2();
        Object arglist[] = new Object[2];
        arglist[0] = new Integer(37);
        arglist[1] = new Integer(47);
        Object retobj 
          = meth.invoke(methobj, arglist);
        Integer retval = (Integer)retobj;
        System.out.println(retval.intValue());
     }
     catch (Throwable e) {
        System.err.println(e);
     }
  }
}

6

インデックス作成(高速)

を使用FunctionalInterfaceして、メソッドをコンテナに保存し、インデックスを作成できます。配列コンテナを使用して数値で呼び出すか、ハッシュマップを使用して文字列で呼び出すことができます。このトリックにより、メソッドをインデックスに登録して動的に高速に呼び出すことができます

@FunctionalInterface
public interface Method {
    double execute(int number);
}

public class ShapeArea {
    private final static double PI = 3.14;

    private Method[] methods = {
        this::square,
        this::circle
    };

    private double square(int number) {
        return number * number;
    }

    private double circle(int number) {
        return PI * number * number;
    }

    public double run(int methodIndex, int number) {
        return methods[methodIndex].execute(aNumber);
    }
}

ラムダ構文

ラムダ構文を使用することもできます。

public class ShapeArea {
    private final static double PI = 3.14;

    private Method[] methods = {
        number -> {
            return number * number;
        },
        number -> {
            return PI * number * number;
        },
    };

    public double run(int methodIndex, int number) {
        return methods[methodIndex].execute(aNumber);
    }
}

1
この手法は反射よりもはるかに優れているようです。
John O

本当にもっと良いのでしょうか?
ディミトリコプリワ

@DimitriKopriwaインデックスは、CPU計算の代わりにRAMを使用する方法です。整数インデックスの場合、アルゴリズムの難しさはO(1)です。
アミールFo

5
Method method = someVariable.class.getMethod(SomeClass);
String status = (String) method.invoke(method);

SomeClassはクラスでsomeVariableあり、変数です。


someVariableが実際にオブジェクトである場合は、someVariable.getClass()を呼び出します。また、クラスを唯一の引数としてgetMethod()を呼び出すことはできません。どちらのメソッドもメソッドとともに呼び出すことはできません。正しい例:someVariable.getClass()。getMethod( "coolMethod"、parameterClasses).invoke(arguments);
Orangle

5

私はこれをこのようにします:

try {
    YourClass yourClass = new YourClass();
    Method method = YourClass.class.getMethod("yourMethodName", ParameterOfThisMethod.class);
    method.invoke(yourClass, parameter);
} catch (Exception e) {
    e.printStackTrace();
}

5

以下のコードを参考にしてください。

public static Method method[];
public static MethodClass obj;
public static String testMethod="A";

public static void main(String args[]) 
{
    obj=new MethodClass();
    method=obj.getClass().getMethods();
    try
    {
        for(int i=0;i<method.length;i++)
        {
            String name=method[i].getName();
            if(name==testMethod)
            {   
                method[i].invoke(name,"Test Parameters of A");
            }
        }
    }
    catch(Exception ex)
    {
        System.out.println(ex.getMessage());
    }
}

ありがとう...


これは、Javaで文字列を比較する方法ではありません。.equalsメソッドを使用する必要があります。それ以外の場合は、それらが同じオブジェクト参照であることを比較するだけであり、実際にはオブジェクト参照については気にせず、文字列の内容のみが一致します。リフレクションを介して名前でメソッドを取得することもできるので、なぜ独自にロールバックするのかわかりませんか?
Lo-Tan

5

ここにメソッドを使用する準備ができています:

引数なしでメソッドを呼び出すには:

public static void callMethodByName(Object object, String methodName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    object.getClass().getDeclaredMethod(methodName).invoke(object);
}

引数を使用してメソッドを呼び出すには:

    public static void callMethodByName(Object object, String methodName, int i, String s) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName, int.class, String.class).invoke(object, i, s);
    }

上記の方法を以下のように使用します。

package practice;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

public class MethodInvoke {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, IOException {
        String methodName1 = "methodA";
        String methodName2 = "methodB";
        MethodInvoke object = new MethodInvoke();
        callMethodByName(object, methodName1);
        callMethodByName(object, methodName2, 1, "Test");
    }

    public static void callMethodByName(Object object, String methodName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName).invoke(object);
    }

    public static void callMethodByName(Object object, String methodName, int i, String s) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName, int.class, String.class).invoke(object, i, s);
    }

    void methodA() {
        System.out.println("Method A");
    }

    void methodB(int i, String s) {
        System.out.println("Method B: "+"\n\tParam1 - "+i+"\n\tParam 2 - "+s);
    }
}

出力:

方法A  
方法B:  
	パラメータ1-1  
	パラメータ2-テスト

3

Student.java

class Student{
    int rollno;
    String name;

    void m1(int x,int y){
        System.out.println("add is" +(x+y));
    }

    private void m3(String name){
        this.name=name;
        System.out.println("danger yappa:"+name);
    }
    void m4(){
        System.out.println("This is m4");
    }
}

StudentTest.java

import java.lang.reflect.Method;
public class StudentTest{

     public static void main(String[] args){

        try{

            Class cls=Student.class;

            Student s=(Student)cls.newInstance();


            String x="kichha";
            Method mm3=cls.getDeclaredMethod("m3",String.class);
            mm3.setAccessible(true);
            mm3.invoke(s,x);

            Method mm1=cls.getDeclaredMethod("m1",int.class,int.class);
            mm1.invoke(s,10,20);

        }
        catch(Exception e){
            e.printStackTrace();
        }
     }
}

1

リフレクションを使用する必要があります。クラスオブジェクト、次にこのクラスのメソッドを初期化し、オプションのパラメーターを持つオブジェクトでこのメソッドを呼び出します。次のスニペットをtry-catchブロックでラップすることを忘れないでください

それが役に立てば幸い!

Class<?> aClass = Class.forName(FULLY_QUALIFIED_CLASS_NAME);
Method method = aClass.getMethod(methodName, YOUR_PARAM_1.class, YOUR_PARAM_2.class);
method.invoke(OBJECT_TO_RUN_METHOD_ON, YOUR_PARAM_1, YOUR_PARAM_2);

1

これは私にとってはうまくいきます:

public class MethodInvokerClass {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, ClassNotFoundException, InvocationTargetException, InstantiationException {
        Class c = Class.forName(MethodInvokerClass.class.getName());
        Object o = c.newInstance();
        Class[] paramTypes = new Class[1];
        paramTypes[0]=String.class;
        String methodName = "countWord";
         Method m = c.getDeclaredMethod(methodName, paramTypes);
         m.invoke(o, "testparam");
}
public void countWord(String input){
    System.out.println("My input "+input);
}

}

出力:

My input testparam

その名前を別のメソッド(mainなど)に渡すことで、メソッドを呼び出すことができます。


1

を使用して import java.lang.reflect.*;

public static Object launchProcess(String className, String methodName, Class<?>[] argsTypes, Object[] methodArgs)
        throws Exception {

    Class<?> processClass = Class.forName(className); // convert string classname to class
    Object process = processClass.newInstance(); // invoke empty constructor

    Method aMethod = process.getClass().getMethod(methodName,argsTypes);
    Object res = aMethod.invoke(process, methodArgs); // pass arg
    return(res);
}

そしてこれがあなたの使い方です:

String className = "com.example.helloworld";
String methodName = "print";
Class<?>[] argsTypes = {String.class,  String.class};
Object[] methArgs = { "hello", "world" };   
launchProcess(className, methodName, argsTypes, methArgs);

0

jooRそれは単にです。

on(obj).call(methodName /*params*/).get()

これはより複雑な例です:

public class TestClass {

    public int add(int a, int b) { return a + b; }
    private int mul(int a, int b) { return a * b; }
    static int sub(int a, int b) { return a - b; }

}

import static org.joor.Reflect.*;

public class JoorTest {

    public static void main(String[] args) {
        int add = on(new TestClass()).call("add", 1, 2).get(); // public
        int mul = on(new TestClass()).call("mul", 3, 4).get(); // private
        int sub = on(TestClass.class).call("sub", 6, 5).get(); // static
        System.out.println(add + ", " + mul + ", " + sub);
    }
}

これは印刷します:

3、12、1


-10

私にとって、かなり単純で愚かな証明の方法は、次のように単純にメソッド呼び出し側メソッドを作成することです。

public static object methodCaller(String methodName)
{
    if(methodName.equals("getName"))
        return className.getName();
}

次に、メソッドを呼び出す必要があるときは、単にこのようなものを入れてください

//calling a toString method is unnessary here, but i use it to have my programs to both rigid and self-explanitory 
System.out.println(methodCaller(methodName).toString()); 

4
コンパイル時にインスタンスがすでにわかっている場合は、なぜそうしないのですclassName.getName().toString()か?あなたは反射の全体のポイントを逃しています。
BalusC 2010年

先ほど言ったように、この場合は不要ですが、インスタンスがプログラミングの悪い習慣であることが常にわかると思います。
SMayne

2
@SMayne:この投稿を削除することをお勧めします。
lpapp 14

悪いプログラミングはこの場合はむしろ賛辞になるでしょう
pdenti
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.