JAVA类加载机制与反射，动态代理Proxy串联分析与应用

最新推荐文章于 2024-04-18 15:53:03 发布

像风一样的攻城狮

最新推荐文章于 2024-04-18 15:53:03 发布

阅读量320

点赞数

本文链接：https://blog.csdn.net/qq_17586893/article/details/78134312

版权

JAVA类加载机制与反射，通过反射绕过泛型的编译验证

1.类加载机制

当程序使用一个还未被加载到内存的类时，JVM会通过加载、连接、初始化三个步骤将该类进行初始化。类的加载指的是将类的class文件读入内存，并为之创建一个java.lang.Class对象。

（1）.CLASS类

Class类也是类的一种，只是名字和class关键字高度相似。Java是大小写敏感的语言。
Class类的对象内容是你创建的类的类型信息，比如你创建一个shapes类，那么，Java会生成一个内容是shapes的Class类的对象
Class类的对象不能像普通类一样，以 new shapes() 的方式创建，它的对象只能由JVM创建，因为这个类没有public构造函数
Class类的作用是运行时提供或获得某个对象的类型信息，和C++中的typeid()函数类似。这些信息也可用于反射。

获得一个Class类对象

第一种办法，Class类的forName函数注意，这里forName(arg)里面传入的是类的全称

public class shapes{}  
Class obj= Class.forName("shapes");

第二种办法，使用对象的getClass()函数

public class shapes{}
shapes s1=new shapes();
Class obj=s1.getClass();
Class obj1=s1.getSuperclass();//这个函数作用是获取shapes类的父类的类型

第三种办法，使用类字面常量注意，使用这种办法生成Class类对象时，不会使JVM自动加载该类（如String类）。而其他办法会使得JVM初始化该类。

Class obj=String.class;
Class obj1=int.class;

（2）静态加载类

静态加载类导致的弊端是，假如一个类里面需要加载多个类，其中某一个类有问题，或者不存在，则在程序编译的过程中，会导致编译报错；尤其是在一个主干上加载一些功能型模块，我们一般希望某个功能出问题不要影响其他功能的实现，这就需要引入动态加载类的概念

public class StaticLoadingClass {
	public static void main(String[] args) {
		//new 创建对象 是静态加载类，在编译时刻就需要加载所有可能使用到的类
		String[] args1=new String[]{"QQ","WEIXIN"};
		if("QQ".equals(args1[0])){
			QQ qq =new QQ();            //<------假设只定义了QQ这个类，这句话会正确编译
			qq.begin();
		}
		if("WEIXIN".equals(args1[1])){
			WEIXIN weixin=new WEIXIN();  //<-----假设没有定义WEIXIN这个类，那么这句话编译时报错
			weixin.begin();
		}
	}
}

（3）动态加载类

思考：下面的class.forMame可以动态的给，假设场景是，用户在前台点击多个功能按钮中的一个，会传不同的参数到这里，假如是QQ，这个QQ功能模块是能正常使用的，假如某个用户点击WEIXIN这个模块，这时程序才会报错，这样就隔离了QQ和微信的功能模块之间的关系

DynamicLoadingClass.java

public class DynamicLoadingClass {
	public static void main(String[] args) {
		try {
			//动态加载类，在运行时刻加载
			Class c=Class.forName("javareflect.loadingClass.QQ");
			//通过类类型，创建该类对象
			Tencent tx=(Tencent)c.newInstance();
			tx.begin();
			Class b=Class.forName("javareflect.loadingClass.WEIXIN");
			Tencent tx1=(Tencent)b.newInstance();
			tx1.begin();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

Tencent.java

interface Tencent {
	public void begin();	
}

QQ.java

public class QQ implements Tencent{
	public void begin(){
		System.out.println("QQ......begin");
	}
}

2.通过反射查看类的信息

下面例子是通过反射获取方法，成员变量，构造函数的信息

package javareflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ClassUtil {
	/*
	 * 打印类的信息，包活类的成员函数
	 * 
	 * @param obj 该对象所属类的信息
	 */
	public static void printClassMessage(Object obj) {
		// 要获取类的信息 首先获取类的类类型
		Class<? extends Object> c = obj.getClass();// 传递的是哪个子类的对象，c就是该类的类类型
		// 获取类的名称
		System.out.println("类的名称是:" + c.getName());
		/*
		 * Method类，方法对象 一个成员方法就是一个Method对象 public Method[]
		 * getMethods()返回某个类的所有公用（public）方法包括其继承类的公用方法， 当然也包括它所实现接口的方法。 public
		 * Method[] getDeclaredMethods()对象表示的类或接口声明的所有方法，
		 * 包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。当然也包括它所实现接口的方法。
		 */
		Method[] ms = c.getMethods();
		for (int i = 0; i < ms.length; i++) {
			// 得到方法的返回值类型的类类型
			Class<?> returnType = ms[i].getReturnType();
			System.out.print(returnType.getSimpleName() + " ");
			// 得到方法名称
			System.out.println(ms[i].getName() + "(");
			// 获取参数类型--->得到参数列表的类型的类类型
			Class[] paramType = ms[i].getParameterTypes();
			for (Class<?> paramTypeList : paramType) {
				System.out.print(paramTypeList.getName() + ",");
			}
			System.out.println(")");
		}
	}

	private static void getFieldMessage(Object obj) {
		Class c = obj.getClass();
		/*
		 * 成员变量也是对象 java.lang.reflect.Field Field类封装了关于成员变量的操作
		 * getFields()方法获取的是所有的public的成员变量的信息
		 * getDeclaredFields()方法获取的是该类自己声明的成员变量的信息
		 */
		// Field[] fs = c.getFields();
		Field[] fs = c.getDeclaredFields();
		for (Field field : fs) {
			// 得到成员变量的类型的类类型
			Class fieldType = field.getType();
			String typeName = fieldType.getName();
			// 得到成员变量的名称
			String fieldName = field.getName();
			System.out.println(typeName + " " + fieldName);
		}
	}
	
	private static void getConstructMessage(Object obj){
		Class c=obj.getClass();
		/*
		 * 构造函数也是对象
		 * java.lang.Constructor封装了构造函数信息
		 * getConstructors()获取所有的public的构造函数
		 * getDeclaredConstructors()得到所有构造函数
		 */
		//Constructor[] cs = c.getConstructors();
		Constructor[] cs = c.getDeclaredConstructors();
		for(Constructor construor:cs){
			System.out.println(construor.getName()+"(");
			//获取构造函数的参数列表，得到的是参数列表的类类型
			Class[] paramTypes=construor.getParameterTypes();
			for(Class class1:paramTypes){
				System.out.print(class1.getName()+",");
			}
			System.out.println(")");
		}
	}
	public static void main(String[] args) {
		String str = "1";
		printClassMessage(str);
		System.out.println("+++++++++++++++++++++++++++++++++");
		getFieldMessage(str);
		System.out.println("+++++++++++++++++++++++++++++++++");
		getConstructMessage(str);
	}
}

3.方法的反射

（1）如何获取某个方法：

方法的名称和方法的参数列表才能唯一决定某个方法

（2）方法反射的操作

method.invoke(对象，参数列表)

这里有一个需要注意的是：c.getDeclaredMethod(name, parameterTypes) 表示的类或接口声明的所有方法，假如要获取一个私有的private方法，需要在反射出这个方法后，给这个方法开启私有访问权限

Method m2 = c.getDeclaredMethod("printNullParameterTypes");

m2.setAccessible(true);// 开启私有访问权限

m2.invoke(a);

package javareflect;

import java.lang.reflect.Method;

/*
 * 1.如何获取某个方法：方法名称和方法的参数列表才能唯一决定某个方法
 * 2.方法的反射操作：  method.invoke(对象，参数列表)
 */
public class MethodInvoke {
	public static void main(String[] args) {
		// 要获取print(int,int)方法 1.要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
		A a = new A();
		Class c = a.getClass();
		/*
		 * 2.获取方法 名称和参数列表决定 getMethod(name, parameterTypes)获取的是public方法
		 * c.getDeclaredMethod(name, parameterTypes) 表示的类或接口声明的所有方法
		 */
		try {
			// Method m=c.getMethod("print", new Class[]{int.class,int.class});
			Method m = c.getMethod("print", int.class, int.class);

			// 方法反射操作
			// a.print(10,20);
			// m.invoke(a, new Object[]{10,20});
			Object obj = m.invoke(a, 10, 20);

			/*
			 * Method m1=c.getMethod("printNullParameterTypes"); Object
			 * obj1=m1.invoke(a);
			 */

			Method m2 = c.getDeclaredMethod("printNullParameterTypes");
			m2.setAccessible(true);// 开启私有访问权限
			m2.invoke(a);

		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

class A {
	private void printNullParameterTypes() {
		System.out.println("null参数");
	}

	public void print(int a, int b) {
		System.out.println(a + b);
	}
}

4.通过Class，Method来认识泛型的本质

java中集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译就无效了，我们可以通过方法的反射绕过编译

package javareflect;

import java.lang.reflect.Method;
import java.util.ArrayList;

/*
 * 通过Class，Method认识泛型本质
 */
public class GenericityReflect {
	public static void main(String[] args) {
		ArrayList list=new ArrayList();
		
		ArrayList<String> list1=new ArrayList<String>();
		list1.add("hello");
		//list1.add(10); 编译错误
		Class c1 =list.getClass();
		Class c2=list1.getClass();
		System.out.println(c1==c2);
		//反射操作都是编译之后的操作
		/*
		 * c1==c2结果返回true 表示编译之后集合的泛型是去泛型化的
		 * java中集合的泛型是为了防止错误输入，只在编译阶段有效，绕过编译阶段就失效了
		 * 我们可以通过方法的反射操作，绕过编译，验证上一句话
		 */
		try {
			Method m=c2.getMethod("add", Object.class);
			Object obj=m.invoke(list1,10);
			System.out.println(list1.size());
			System.out.println(list1);
//			for(String str:list1){
//				System.out.println(str);
//			}  不能这么编译，因为有int型也传入进去了
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

}