利用反射技术和读配置文件文件的方式实现动态加载类和执行函数，要求

利用反射技术和读配置文件文件的方式实现动态加载类和执行函数，要求

1、需要动态调用一个类中的多个函数

2、查资料实现有参数函数的调用

//Test 类

package th;

import java.io.Closeable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Iterator;
import java.util.Properties;
import java.util.Scanner;

public class Test {

	public static void main(String[] args) {
		
		Class<?> c1 = null ;		
		String strClassName="";
		String strMethodName="";
		Scanner sc = new Scanner(System.in);
		
		Properties pro = new OrderedProperties();
		File f = new File("D:\\java-2020-12\\Fanshe\\src\\Test.properties");
		
		try {
			String strArgs[];
			String strArgsType[]= {};
			Class[] oArgsType=null;
			Object[] oArgs=null;
			Object obj = null;
			String flag="0";
			pro.load(new FileInputStream(f));
			Iterator<String> it=pro.stringPropertyNames().iterator();
            while(it.hasNext()){
                String key=it.next();
                if(key.equals("class"))
                {
                	strClassName =pro.getProperty(key);
                	c1 = Class.forName(strClassName) ;               	
                	obj = c1.newInstance();
                }
                if(key.substring(0, 1).equals("f"))
                {
                	flag = pro.getProperty(key);
                }
                if(key.subSequence(0, 1).equals("m"))
                {
                	strMethodName = pro.getProperty(key);
                	
                }
                if(key.substring(0, 1).equals("k"))
                {
                	strArgsType= pro.getProperty(key).split(",");
                	oArgsType = new Class[strArgsType.length];
                    for (int i = 0; i < strArgsType.length; i++) {
                        oArgsType[i] = getPrimitiveClass(strArgsType[i]);
                    }               
                }
                if(key.substring(0, 1).equals("v"))
                {
                	strArgs= pro.getProperty(key).split(",");
                	oArgs = new Object[strArgs.length];
                    for (int i = 0; i < strArgs.length; i++) {
                        oArgs[i] = transferArguments(strArgsType[i], strArgs[i]);
                    }
                }
                if(key.substring(0, 1).equals("e"))
                {
                	Method met;
                	if(flag.equals("1"))
                	{
	                	if(oArgsType!=null)
	                	{
	                		met= c1.getMethod(strMethodName, oArgsType);
	                		met.invoke(obj, oArgs);
	                		oArgsType = null;
	                		oArgs = null;
	                	}
	                	else
	                	{
	                		met = c1.getMethod(strMethodName);
	                		met.invoke(obj);
	                	}
                	}
                }
               
            }
           
			
		} catch (Exception e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		} 
	}
	private static Object transferArguments(String type, String value) {
        type = type.toLowerCase();
        switch (type) {
            case "int":
                return Integer.valueOf(value);
            case "double":
                return Double.valueOf(value);
            case "float":
                return Float.valueOf(value);
            case "char":
                return (char)value.getBytes()[0];
            case "string":
                return value;
            default:
                System.out.println("undefined!");
                return null;
        }
	}
	private static Class getPrimitiveClass(String str) {
	    str = str.toLowerCase();
	    switch (str) {
	        case "int":
	            return int.class;
	        case "double":
	            return double.class;
	        case "float":
	            return float.class;
	        case "char":
	            return char.class;
	        case "string":
	            return String.class;
	        default:
	            System.out.println("undefined!");
	            return Object.class;
	    }
	}
	

}

//用来顺序读配置文件
package th;

import java.util.Collections;
import java.util.Enumeration;
import java.util.LinkedHashSet;
import java.util.Properties;
import java.util.Set;

public class OrderedProperties extends Properties {

    private static final long serialVersionUID = -4627607243846121965L;

    private final LinkedHashSet<Object> keys = new LinkedHashSet<Object>();

    public Enumeration<Object> keys() {
        return Collections.<Object> enumeration(keys);
    }

    public Object put(Object key, Object value) {
        keys.add(key);
        return super.put(key, value);
    }

    public Set<Object> keySet() {
        return keys;
    }

    public Set<String> stringPropertyNames() {
        Set<String> set = new LinkedHashSet<String>();

        for (Object key : this.keys) {
            set.add((String) key);
        }

        return set;
    }
}

package th;
public class Person{
 public void Sayhello(String a,int b) {
	 System.out.println(a+"  sayhello  "+b);
 }
 public void Saybyebye(int a,int b,int c) {
	 System.out.println("a:"+a+"  b:"+b+"  c:"+c);
 }
 public void Saygood() {
	 System.out.println("Good! man");
 }
}

//Test.properties 配置文件  
class=th.Person
f1=1
m1=Sayhello
k1=string,int
v1=li,10
e1=1
class=th.Person
f2=1
m2=Saybyebye
k2=int,int,int
v2=10,20,25
e2=1
class=th.Person
f3=1
m3=Saygood

e3=1