【Java】Java类动态替换Class

Java类动态替换Class

通过Java的Class对象，可以实现动态替换Class。
预习几个知识点

getClassLoader

Java提供的ClassLoader可用于动态加载的Java类，可以通过多种形式获取ClassLoader。比如通过Class类获取

// 通过Class获取
ClassLoader classLoader = LinduoClass.class.getClassLoader();

利用ClassLoader，传入ClassName就可以加载类

ClassLoader classLoader = LinduoClass.class.getClassLoader();
Class<?> myClass = classLoader.loadClass("com.linduo.test.TestClass");

现在可以把Class加载出来。要创建类对象的话，需要知道Class的构造函数，以及构造函数的各个参数。

getDeclaredConstructors

Java.lang.Class类提供了getDeclaredConstructors。通过这个方法，可以获取类中所有声明的构造函数。

ClassLoader classLoader = LinduoClass.class.getClassLoader();
Class<?> myClass = classLoader.loadClass("com.linduo.test.TestClass");
// 获取所有构造函数
Constructor<?>[] methods= myClass.getDeclaredConstructors();

getParameterTypes

Method类型，提供了getParameterTypes方法，它用于获取方法的参数类型（Constructor也是方法）

ClassLoader classLoader = LinduoClass.class.getClassLoader();
Class<?> myClass = classLoader.loadClass("com.linduo.test.TestClass");
// 获取所有构造函数
Constructor<?>[] methods= myClass.getDeclaredConstructors();
// 获取构造函数的参数类型
for (Constructor<T> method : methods) { 
	// 获取每个构造函数的参数类型
	Class<?>[] paramTypes = method.getParameterTypes();
}

Method类提供的newInstance，可以用于创建并返回指定类的实例。

// 可变参数，表示要传递给构造函数的参数列表
public Object newInstance(Object... initargs)

动态替换Class对象

基于上面的几个方法，可以实现动态替换Class对象。比如，FunctionA和FunctionB，同时继承了FunctionBase。可以在代码中，利用上面的方式，将FunctionA动态替换为FunctionB。

class FunctionBase
{
	plublic FunctionBase(int a, int b) {
	}
}

class FunctionA extends FunctionBase
{
	plublic FunctionA (int a, int b) {
		super(a, b)
	}
}

class FunctionB extends FunctionBase
{
	plublic FunctionA (int a, int b) {
		super(a, b)
	}
}

// 某处代码中，将A替换为B。
int arg1 = 1;
int arg2 = 2;
FunctionBase myFunction = replaceToB(FunctionA.class, arg1 , arg2);

上述代码中，可以将FunctionA动态替换为FunctionB。Linduo.replaceToB的具体实现如下。

public boolean canReplace(params, classParams) {
    // 长度不等
    if (params.length != classParams.length) {
        return false;
    }

    // 判断参数类型是否相同
    int count = 0;
    for (int i = 0; i < params.length; i++) {
        if (params[i] == classParams[i]) {
            count++;
        }
    }

    if (count == params.length) {
        // 相等
        return true;
    } 

    return false;
}

public FunctionBase replaceToB(Class<?> classA, Object... args) {
	String name;
	String nameA = classA.getName();
	if (nameA != "com.linduo.FunctionA") {
		return null;
	} else {
		// 如果是FunctionA类，则使用FunctionB代替。
		name = FunctionB.class.getName();
	}

    // 加载FunctionB类
    Class cl= Linduo.class.getClassLoader().loadClass(name);
    // 获取B类的方法
    Constructor<FunctionBase>[] methods = cl.getDeclaredConstructors();

    // 构造参数列表
    Class<?>[] params = new Class[args.length];
    for (int i = 0; i < args.length; i++) {
        params[i] = args[i].getClass();
    }

    for (Constructor<T> method : methods) {
        // 获取构造函数的参数列表
        Class<?>[] classParams = method.getParameterTypes();
        if (canReplace(params, classParams)) {
            // 如果参数相等，设置setAccessible为True，用来访问构造函数
            method.setAccessible(true);
            return method.newInstance(args);
        }
    }

    return null;
}

}

此方式的用途

如加以完善，动态替换Class可以实现很多有用的业务功能。至于具体的业务，受限于一些原因不方便举例子，大家自行领悟吧。