java 反射机制之 getDeclaredMethod（）获取方法，然后invoke执行实例对应的方法

关于反射中getDeclaredMethod（）.invoke()的学习，来源于项目中的一行代码：

subjectService = new SubjectService();
subjectService.getclass().getDeclaredMethod(autoMatchConfig.getMethodName(), Integer.class).invoke(subjectService, GlobalConfig.OPEN_TO_IPLAN);
                  

获取反射的方法有：

第一种：

Class c = SubjectService.class

第二种：

Class c = Class.forName(SubjectService)

获取到 Class 之后，便可以获取有参方法

c.getDeclaredMethod(String name, Class<?>... parameterTypes)

获取本类中的所有方法 (只拿本类中的)

c.getDeclaredMethods();

继续解析代码中的

SubjectService.class.getDeclaredMethod(autoMatchConfig.getMethodName(), Integer.class)

其中，传入的第一个参数是方法名，第二个参数名是方法参数，传入这两个参数之后，便可以根据方法名和方法参数通过反射获取带有参数的方法

然后

MethodName.invoke(subjectService, GlobalConfig.OPEN_TO_IPLAN)
其中，invoke方法中传入的是上一步获取到的方法的实例对象和方法传入的实参

由此，通过反射获取方法名和参数名，然后invoke方法注入方法对象和实参，

      getDeclaredMethod：返回Method方法对象；

      invoke：根据传入的对象实例，通过配置的实参参数来调用方法

简答举个例子：

package com;
public class Person {
 
    private int age;
    private String name;
 
    public Person( String name,int age) {
        this.age = age;
        this.name = name;
    }
 
    public Person() {
    }
 
 
    //公有 有参方法
    public void public_show(String str,int i)
    {
        System.out.println("public show "+str+"..."+i);
    }

    //公有 无参方法
    public void public_prin()
    {
        System.out.println("public prin");
    }
 
 
    //私有 有参方法
    private void private_show(String str,int i)
    {
        System.out.println("private show "+str+"..."+i);
    }

    //私有 无参方法
    private void private_prin()
    {
        System.out.println("private prin");
    }
 
}

 

public class Main {
    public static void main(String[] args)  throws Exception {
 
        //获取字节码文件中 方法 再取出其公有方法
 
        String classname = "com.Person";
        //寻找名称的类文件，加载进内存 产生class对象
        Class cl = Class.forName(classname);

        //获取一个Person对象
        System.out.println("获取一个Person对象:");
        Object obj=cl.newInstance();
        System.out.println();
 
 
        //1.获取 公有 无参方法 public void demo2.Person.public_prin()
        Method Person_public_prin=cl.getMethod("public_prin",null);
        System.out.println("获取执行 public void demo2.Person.public_prin() :");
        Person_public_prin.invoke(obj,null);
 
        System.out.println();
 
        //2.获取 公有 有参方法 public void demo2.Person.public_show(java.lang.String,int)
        Method Person_public_show=cl.getMethod("public_show",String.class,int.class);
        System.out.println("获取执行 public void demo2.Person.public_show(java.lang.String,int) :");
        Person_public_show.invoke(obj,"神奇的我",12);
 
        System.out.println();
 
        //3.获取 私有 无参方法 private void demo2.Person.private_prin()
        Method Person_private_prin=cl.getDeclaredMethod("private_prin",null);
        Person_private_prin.setAccessible(true);
        System.out.println("获取执行 private void demo2.Person.private_prin() :");
        Person_private_prin.invoke(obj,null);
 
        System.out.println();
 
        //4.获取 私有 有参方法 private void demo2.Person.private_show(java.lang.String,int)
        Method Person_private_show=cl.getDeclaredMethod("private_show",String.class,int.class);
        Person_private_show.setAccessible(true);
        System.out.println("获取执行 private void demo2.Person.private_show(java.lang.String,int) :");
        Person_private_show.invoke(obj,"神奇的私有",23);
 
        System.out.println();
    }

demo

用反射实现对sdk的调用.实现对sdk的解耦;
public class RWSDKStringResource extends StringResource {
    private AimSdkWrap aimSdk;
    String readFunc;
    String writeFunc;
    public RWSDKStringResource(String name, boolean bWrite, AimSdkWrap aimSdk, String readFunc, String writeFunc) {
        super(name, bWrite);
        this.aimSdk = aimSdk;
        this.readFunc = readFunc;
        this.writeFunc = writeFunc;
    }
    @Override
    public String getValue() {
        String value = null;
        if (readFunc != null){
            try {
                value = (String) aimSdk.getClass().getDeclaredMethod(this.readFunc).invoke(aimSdk, null);
            } catch (Exception ex) {
                ;
            }
        }
        return value;
    }
    @Override
    public void setValue(String value) {
        if (writeFunc != null) {
            try {
                aimSdk.getClass().getDeclaredMethod(this.writeFunc, String.class).invoke(aimSdk, value);
            } catch (Exception ex) {
                ;
            }
        }
        super.setValue(value);
    }
}

public class AimSdkWrap {
    private static final Logger LOG = LoggerFactory.getLogger(AimSdkWrap.class);
    private Context mContext;
    // using framework-level sdk lib
    private static Advanlib mAdvanLib;
    // using app-level sdk lib
    //private static AppSdkLib mAdvanLib;

    public AimSdkWrap(Context context) {
        LOG.info("Initial Advanlib");
        mContext = context;
        mAdvanLib = new Advanlib(context);
        //mAdvanLib = new AppSdkLib(context);
    }

    // invode from AdvanLib
    public boolean isWifiEnabled() {
        boolean bRet = false;
        bRet = mAdvanLib.isWifiEnabled();
        LOG.info("isWifiEnabled: ret=" + bRet);
        return bRet;
    }

    public void enableWifi(boolean enable) {
        LOG.info("enableWifi: " + enable);
        mAdvanLib.enableWifi(enable);
    }

    public boolean isBluetoothEnabled() {
        boolean bRet = false;
        bRet = mAdvanLib.isBluetoothEnabled();
        LOG.info("isBluetoothEnabled: ret=" + bRet);
        return bRet;
    }

}