Java反射整理

太过爱你忘了你带给我的痛 2022-06-05 00:52 172阅读 0赞

Java反射整理

*摘要：*         无论是在C\#还是Java（平常常玩儿的就这俩，所以这么举例，别的语言也雷同！），为了获取类的灵活性，我们会时常使用反射，将类的信息写入配置，通过运行时候动态获取类，类的方法，字段，等等。

无论是在C\#还是Java（平常常玩儿的就这俩，所以这么举例，别的语言也雷同！），为了获取类的灵活性，我们会时常使用反射，将类的信息写入配置，通过运行时候动态获取类，类的方法，字段，等等。

在Java中，我们通常是一个思路来动态访问类信息的，先获取类的Class 类，这个Class指明了是哪个类，然后通过获取到的Class get各种类信息。

# 一，获取Class类 #

public class ClassDemo1 { public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{ //Foo的实例对象如何表示 Foo foo1=new Foo();//foo1就表示出来了 //Foo这个类 也是一个实例对象，Class类的实例对象如何表示 //任何一个类都是Class类的实例对象，这个实例对象有3中表示方式 /*第一种表示方式--》实际在告诉我们任何一个类都有一个隐含的静态成员变量*/ Class c1=Foo.class; /*第二种表达方式：已知该类的对象，通过getClass方法*/ Class c2=foo1.getClass(); /*官网：c1/c2表示了Foo类的类类型（class type） * 类也是对象，是class类的实例对象 * 这个对象我们成为该类的类类型 * */ /*不管c1 or c2都代表了Foo类的类类型，一个类只可能是Class类的一个对象*/ System.out.println(c1==c2);//true //第三种表达方式 Class c3=null; c3=Class.forName("ShuiTian.NaiLuo.Reflect.Foo"); System.out.println(c3); /*我们完全可以通过类的类类型创建该类的对象 * 通过c1 or c2 or c3创建父的实例 * * */ Foo foo=(Foo)c1.newInstance();//使用newInstance需要有无参数的构造方法 } } class Foo{}

主要有上面三种方式：第一种通过类的静态变量获取；第二种通过实例的getClass方法获取，第三种通过一个字符串来动态加载；仔细观察这三种方式，感觉最后一种用的还是比较多的，比如为数据库加载驱动的时候，配置Spring的时候，这种方式使得类的装配更具有灵活性。例如，我们可以使用这种方式在运行时候动态加载类：

public class DynamicLoadClass { public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException{ String animalName="Cat"; Animal animal = null; switch (animalName){ case "Cat": animal=(Animal)Class.forName("ShuiTian.NaiLuo.Reflect.Cat").newInstance(); break; case "Dog": animal=(Animal)Class.forName("ShuiTian.NaiLuo.Reflect.Dog").newInstance(); break; } System.out.println(animal); System.out.println(animal.getClass().getSimpleName()); } } interface Animal{} class Cat implements Animal{} class Dog implements Animal{}

#  二，获取类信息 #

当我们使用各种方法获取到类class之后，就可以使用这个class访问类的信息了。

##        1，获取类的方法信息 ##

/*
    	 * 打印类的信息，包括类的成员函数，类的成员变量 参数是一个对象，该对象的所属信息
    	 */
    	public static void printClassMethodMessage(Object obj) {
    		// 要获取类的信息，首先要获取类的类类型 class type
    		Class c = obj.getClass();// 传递的是哪个子类的对象
    		// 获取类的名称
    		System.out.println(c.getName());
    		/*
    		 * Method类是方法对象 一个成员方法就是一个Method对象 getMethods获取的是所有的public函数，包括从父类继承而来的
    		 * c.getDeclaredMethods()获取的是所有该类声明的方法，不问访问权限
    		 */
    		Method[] ms = c.getMethods();  //获取类的方法数组
    		for (Method method : ms) { //对类的方法数组进行循环，在循环中获取函数返回值信息及参数信息，也可以对方法进行动态调用
    			// 得到方法的返回值类型的类类型
    			Class returnType = method.getReturnType();
    			System.out.print(returnType.getName() + "(");
    			// 得到方法的名称
    			System.out.print(method.getName());
    			// 获取方法的参数类型--->得到的是参数列表的类型的类类型
    			Class[] paramTypes = method.getParameterTypes();
    			for (Class c1 : paramTypes) {
    				System.out.print(c1.getName() + ",");
    			}
    			System.out.println(")");
    		}
    
    		printFieldMessage(obj);
    
    	}

##        2，获取类的成员变量的信息 ##

/*获取类的field信息*/
    	public static void printFieldMessage(Object obj) {
    		Class c=obj.getClass();
    		/*
    		 * 成员变量也是对象 java.lang.reflect.field Field类封装了关于成员变量的操作
    		 * getFields方法获取的是所有public成员变量的信息 getDeclaredFields获取的是该类自己声明的成员
    		 */
    		Field[] fs = c.getDeclaredFields();
    		for (Field field : fs) {
    			/* 得到成员变量的类类类型 */
    			Class fieldType = field.getType();
    			String typeName = fieldType.getName();
    
    			/* 得到成员变量的名称 */
    			String fieldName = field.getName();
    			System.out.println(fieldType + "," + fieldName);
    		}
    	}

##       3，获取对象的构造函数的信息 ##

/*打印对象的构造函数的信息*/ public static void printConMessage(Object obj){ Class c=obj.getClass(); /* * java.lang.constructors封装了构造函数的信息 * getConstructors()获取了所有的public的构造函数的信息 * getDeclaredConstructors:得到了自己声明的构造函数 * */ Constructor[] cs =c.getDeclaredConstructors(); //获取构造函数数组 for(Constructor con :cs ){ //分别对各个构造函数进行遍历 System.out.print(con.getName()+"("); //获取构造函数的参数列表----得到的是参数列表的类类型 Class[] paramTypes=con.getParameterTypes(); //得到构造函数的参数列表 for(Class param:paramTypes){ System.out.print(param.getName()+","); } System.out.println(")"); } }

##       4，通过反射动态调用方法 ##

/* * 测试方法的反射 * * */ public class MethodDemo1 { public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException { // 获取print（int,int）方法 Class a = Class.forName("ShuiTian.NaiLuo.Reflect.A"); /* * 获取方法名称，参数列表。。。 getMethod:获取的是public的方法 getDeclaredMethod:获得的是自己声明的方法 */ Method m = a.getMethod("print", new Class[] { int.class, int.class }); /* * 方法的反射操作 使用m对象来进行方法的调用 方法返回值问题 1，无返回值返回null 2，有返回值，返回具体值 */ m.invoke(a.newInstance(), 10, 10); // m.invoke(a,10,10); System.out.println("==========分割线============"); Method m2 = a.getMethod("print", String.class, String.class); m2.invoke(a.newInstance(), "lhc", "水田"); } } class A { public void print(int a, int b) { System.out.println(a + b); } public void print(String a, String b) { System.out.println(a.toUpperCase() + "," + b.toLowerCase()); } }

额，有了这个基础，再去看spring的源码，估计就差不多能看懂了。