反射做动态编程

反射用来做动态编程
根据配置文件的配置，通过反射来创建对象，执行方法
在一个固定的程序执行流程中，执行的类、执行的方法，可以通过配置文件来动态调整

  //类对象
                Classc=Class.forName(a[0]);
                //新建实例
                Object obj=c.newInstance();//无参构造
                //获取方法
                Method m = c.getMethod(a[1], String.class);

可在src下建立cfg.txt,编码格式要为GBK

src

config.txt

#注释-完整类名，完整方法
    dongtai.A,a
    dongtai.B,b
    dongtai.A,a

#注意包名别写错
    dongtai.C,c
    dongtai.C,c
    dongtai.B,b

在src下新建dongtai包，再建立类A,B,C,Runner,Test

image.png

类A

package dongtai;
public class A {
    public String a(String s){
        System.out.println("A.a方法参数("+s+")");
        return "A.a方法计算结果";
    }
}

类B

package dongtai;
public class B {
    public String b(String s){
        System.out.println("B.b方法参数("+s+")");
        return "B.b方法计算结果";
    }
}

类C

package dongtai;
public class C {
    public String c(String s){
        System.out.println("C.c方法参数("+s+")");
        return "C.c方法计算结果";
    }
}

类Runner

package dongtai;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.net.URLDecoder;
import java.util.ArrayList;
import java.util.List;

/**
 * 读取配置文件
 * 把字符串放入集合里（类名，方法名）
 */
public class Runner {
    //内存中只有一个，定义为静态
    private static List list=new ArrayList();
    //静态初始化块，第一次用到类被加载时执行
    static{
        try {
            /**
             * 相对路径，用Runner类的类对象，getResource()方法
             * 用相对路径来获得一个文件的完整路径
             * 
             * 相对路径:
             *   "/"表示这个类的类文件存放目录
             *   "/cfg.txt" bin\cfg.txt
             *   "/dongtai/cfg.txt" bin\dongtai\cfg.txt
             */
            String path=Runner.class.getResource("/config.txt").getPath();
            path=URLDecoder.decode(path,"UTF-8");
            /**
             * BufferedReader--InputStreamRreader--FileInputStream--path
             */
            BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(path), "GBK"));
            String line;
            
            while((line=in.readLine())!=null)
            {
                //去除空格
                line=line.trim();
                //如果遇到#注释或者空行跳过
                if(line.startsWith("#")||line.length()==0)continue;
                list.add(line);
            }
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
            in.close();
        } catch (Exception e) {
            //静态块抛异常抛给虚拟机
            throw new RuntimeException(e);
        }
    }
    public static void launch(){
        try {
            String p="初始参数";
            for (String s : list) {
                //day1602dynamticprogram.C,c
                String []a=s.split(",");
                //类对象
                Classc=Class.forName(a[0]);
                //新建实例
                Object obj=c.newInstance();//无参构造
                //获取方法
                Method m = c.getMethod(a[1], String.class);
                //执行这个方法
                p=(String) m.invoke(obj, p);
            }
            System.out.println("最终结果:"+p);
        } catch (Exception e) {
            System.out.println("执行失败");
        }
    }
    
}

运行结果

dongtai.A,a
dongtai.B,b
dongtai.A,a
dongtai.C,c
dongtai.C,c
dongtai.B,b
A.a方法参数(初始参数)
B.b方法参数(A.a方法计算结果)
A.a方法参数(B.b方法计算结果)
C.c方法参数(A.a方法计算结果)
C.c方法参数(C.c方法计算结果)
B.b方法参数(C.c方法计算结果)
最终结果:B.b方法计算结果