Java反射实现动态加载

延迟加载，动态应该就体现在运行时，而不是编译时的。

//首先定义一个接口来隔离类：
public interface Operator
{
//    public java.util.List act(java.util.List params);
    public java.util.List act(String content,String content2,java.util.List params);
}



// 下面依次是两个实现类
import java.util.*;

public class Success implements Operator{

 public static void main(String[] args) {
    List list = new ArrayList();
    list.add("Success3");
    Operator op = new Success();
    System.out.println("act===" + op.act("Success1", "Success2", list));
}

//实现接口的方法
//       public java.util.List act(java.util.List params)
public java.util.List act(String content, String content2,java.util.List params) {
    List result = new ArrayList();
    result.add(content);
    result.add(content2);
    result.add(params);
    return result;
}

}


import java.util.*;
public class Load implements Operator{

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("Load3");
    Operator op = new Load();
    System.out.println("act===" + op.act("Load1", "Load2", list));
}

//       public java.util.List act(java.util.List params)
public java.util.List act(String content, String content2,java.util.List params)
{
    List result = new ArrayList();
    result.add(content);
    result.add(content2);
    result.add(params);
    return result;
}

}

这个方法面向接口编程,然后在程序运行时用到的时候再加载类,可以实现动态扩展。根据线程加载classloader，再利用反射找到需要扩展的类

import java.lang.reflect.*;
import java.util.Properties;
import java.io.FileInputStream;
import java.util.List;
//这个程序是针对Operator编程的，所以无需做任何修改，直接提供Load和Store类，

//就可以支持2000、3000做参数的调用
//有了这样的反射机制，可以把接口的作用发挥到极至，设计模式也更能体现出威力，

public class TestReflect
{
//加载配置文件,查询消息头对应的类名
private String loadProtocal(String header)
{
    String result=null;
    try
    {
    Properties prop=new Properties();
    //           FileInputStream fis=new FileInputStream("emp.properties");
    //           id = prop.getProperty(idString);
    //           prop.load(fis);
    //           fis.close();
    prop.load(getTCL().getResourceAsStream("emp.properties"));
    result=prop.getProperty(header);
    }catch(Exception e){
        System.out.println(e);
    }
return result;
}

private static ClassLoader getTCL() throws IllegalAccessException,
InvocationTargetException {
    Method method = null;
    try {
    method = Thread.class.getMethod("getContextClassLoader", null);
    } catch (NoSuchMethodException e) {
    return null;
    }
return (ClassLoader)method.invoke(Thread.currentThread(), null);
}

//针对消息作出响应,利用反射导入对应的类
public String response(String header,String content,String content2,List list)
{
    String result=null;
    String s=null;
    try
    {
    /*
    * 导入属性文件emp.properties,查询header所对应的类的名字
    * 通过反射机制动态加载匹配的类,所有的类都被Operator接口隔离
    * 可以通过修改属性文件、添加新的类(继承MsgOperator接口)来扩展协议
    */
    s="org.bromon.reflect."+this.loadProtocal(header).trim();
    //加载类
    System.out.println("s==="+s);//打印 s===org.bromon.reflect.Success
    Class c=Class.forName(s);
    //java.lang.reflect.Methods 是用来描述某个类中单个方法的一个类
    //           Method m[] = c.getDeclaredMethods();//
    //           for (int i = 0; i < m.length; i++)//
    //               System.out.println(m[i].toString());
    //  打印   public java.util.List org.bromon.reflect.Success.act(java.util.List)
    //创建类的事例
    Operator mo=(Operator)c.newInstance();
    System.out.println("mo==="+mo);
    //构造参数列表
    Class params[]=new Class[3];
    //           params[0]=Class.forName("java.util.List");
    params[0]=Class.forName("java.lang.String");
    params[1]=Class.forName("java.lang.String");
    params[2]=Class.forName("java.util.List");
    System.out.println("params[0]==="+params[0]);
    //           //查询act方法
    Method m=c.getMethod("act",params);
    System.out.println("method=="+m.toString());
    Object[] args=new Object[3];
    args[0]=content;
    args[1]=content2;
    args[2]=list;
    //           //调用方法并且获得返回
    Object returnObject=m.invoke(mo,args);//这个地方出问题了，抛异常~~~~
    //           System.out.println("returnObject==="+returnObject);
    List result2 = (List)returnObject;
    result = (String)result2.get(0);
    System.out.println("result2=="+result2);
    //
    }catch(Exception e) {
    System.out.println("Handler-response:"+e);

    //Handler-response:java.lang.IllegalArgumentException: argument type mismatch
    //IllegalArgumentException - 如果该方法是实例方法，且指定对象参数不是声明基础方法的类或接口（或其中的子类或实现程序）的实例；
    //如果实参和形参的数量不相同；如果基本参数的解包转换失败；或者如果在解包后，无法通过方法调用转换将参数值转换为相应的形参类型。
    }
return result;
}

public static void main(String args[])
{
    TestReflect tr=new TestReflect();
    List list = new java.util.ArrayList();
    list.add("测试List");
    tr.response("2000","Load1","Load2",list);//1000是Success,2000是Load
    tr.response("1000","Success1","Success2",list);//1000是Success,2000是Load

}
}

原文：

https://www.cnblogs.com/junhuawang/p/7429322.html