反射全解

反射概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

什么是反射 元数据（metadata）: 描述数据的描述数据 反射：得到类的元数据的过程 在运行时期，动态地去获取某一个类中的成员信息（构造器，方法，字段，内部类，接口，父类等等） 并且把类中的每一种成员，都描述程一个新类。 Class：表示所有的类 Constructor：表示所有的构造器 Method：表示所有的方法 Field：表示所有的字段

获取 Class 实例的四种方式

/** * 1. getCLass 和 .class 出现的时期不同：Class.forName()和getClass()是在运行时加载； * Class.class是在编译器加载，即.class是静态加载，.getClass()是动态加载 * * 2. 除内部类外的其他类的应用上.class功能完全等于.getClass()!只是一个是用类直接获得的， * 一个是用实例获得的 * * java.lang.Class : 是反射的源头 * 我们创建了一个类, 通过编译(javac.exe), 生成了对应的 .class文件, 之后我们使用 java.exe * 加载(JVM 的类加载器完成)此 .class 文件, 此 .class 文件加载到内存后, 就是一个运行时类,存 * 在缓冲区,那么这个运行时类本身就是一个 Class 实例. * 1. 一个运行时类只被加载一次 * 2. 有了 Class 的实例以后, 我们才可以进行如下的操作, * 1). 创建对应的运行时类的对象 * 2). 获取对应运行时类的完整结构(属性,方法,构造器,内部类,父类,异常,所在包,注解...) * 3). 调用对应的运行时类的指定结构(属性,方法,构造器) * 4). 反射的应用 ---> 动态代理 */ /** * 如何获取运行时类的实例(4种) * @throws ClassNotFoundException */ @Test public void test2() throws ClassNotFoundException { //1. 调用运行时类本身的 .class 属性 Class<Person> clazz1 = Person.class; System.out.println(clazz1.getName()); //2. 通过运行时类的对象获取 Person p = new Person(); Class clazz2 = p.getClass(); System.out.println(clazz2); //3. 通过 Class 的静态方法获取 String className = "com.anqi.refection.test.Person"; Class clazz3 = Class.forName(className); System.out.println(clazz3); //4. 通过类的加载器 ClassLoader classLoader = this.getClass().getClassLoader(); Class clazz4 = classLoader.loadClass(className); System.out.println(clazz4.getName()); }

ClassLoader

    虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是Java虚拟机的类加载机制。

【三个类加载器】

1. BootStrap ClassLoader：称为启动类加载器，是Java类加载层次中最顶层的类加载器，负责加载JDK中的核心类库，如：rt.jar、resources.jar、charsets.jar等，可通过如下程序获得该类加载器从哪些地方加载了相关的jar或class文件： 2. Extension ClassLoader：称为扩展类加载器，负责加载Java的扩展类库，默认加载JAVA_HOME/jre/lib/ext/目下的所有jar。 3. App ClassLoader：称为系统类加载器，负责加载应用程序classpath目录下的所有jar和class文件。

/** * ClassLoader 共有三层加载器 * Bootstrap classLoader * ExtClassLoader：扩展的class loader * AppClassLoader:系统class loader 获取不到, JVM 用来加载核心类库 获取的时候显示为 null * @throws ClassNotFoundException * @throws IOException */ @Test public void test3() throws ClassNotFoundException, IOException { ClassLoader loader1 = ClassLoader.getSystemClassLoader(); System.out.println(loader1); ClassLoader loader2 = loader1.getParent(); System.out.println(loader2); ClassLoader loader3 = loader2.getParent(); System.out.println(loader3);//null Class clazz = Person.class; ClassLoader loader4 = clazz.getClassLoader(); System.out.println(loader4); String className = "java.lang.Object"; Class clazz2 = Class.forName(className); ClassLoader loader5 = clazz2.getClassLoader(); System.out.println(loader5);//null //应用: 加载文件 // ClassLoader loader6 = this.getClass().getClassLoader(); // InputStream in = // loader6.getSystemResourceAsStream("db.properties"); // Properties properties = new Properties(); // properties.load(in); // String user = properties.getProperty("user"); // String password = properties.getProperty("password"); // System.out.println("user-"+user+"password-"+password); FileInputStream in = new FileInputStream(new File("‪db.properties")); Properties pro = new Properties(); pro.load(in); String user = pro.getProperty("user"); String password = pro.getProperty("password"); System.out.println("user-"+user+"password-"+password); }

Field全解

/** * Field -getgetDeclaredField(String name) * 获取指定 name 值的字段 * -getField(String name) * 获取指定 name 值的非 private 修饰的字段值 * -getFields() * 获取所有的字段,必须所有字段都不能被 private 修饰 * -getDeclaredFields() * 获取所有的字段 * -对 private 修饰的字段修改时，需要设置 * f1.setAccessible(true);压制修饰检查 */ //测试对应的运行时类的属性 @Test public void test1() { Class clazz = Person.class; //1. getFields(): 只能获取到运行时"类中及其父类中"声明为 public 的属性 Field[] fields = clazz.getFields(); for (Field field : fields) { System.out.println(field.getName()); } //2. getDeclareFields(): 获取运行时类"本类"声明的所有属性 Field[] fields2 = clazz.getDeclaredFields(); for (Field field : fields2) { System.out.println(field.getName()); } } //权限修饰符 变量类型 变量名 //获取属性的各个部分的内容 @Test public void test2() { Class clazz = Person.class; Field[] fields = clazz.getDeclaredFields(); for (Field field : fields) { //1. 获取每个属性的权限修饰符 int i = field.getModifiers(); //把修饰符标识码转化成字符串 String str1 = Modifier.toString(i); System.out.println(str1); //2. 获取属性的变量类型 Class type = field.getType(); System.out.println(type.getTypeName()); //3. 获取属性名 System.out.println(field.getName()); } } //调用运行时类中指定的属性 @Test public void test3() throws Exception { Class<Person> clazz = Person.class; //1. 获取指定的属性 //getField(String fieldName):获取运行时类中声明为 public 的指定属性名为 fieldName 的属性 Field name = clazz.getField("name"); //2. 创建运行时类的对象 Person p = (Person)clazz.newInstance(); //3. 将运行时类的指定的属性赋值 name.set(p, "Angel"); System.out.println(p); //getDeclaredFiled(String fieldName):获取运行时类中指定的名为 fieldName 的属性 Field age = clazz.getDeclaredField("age"); //由于属性权限修饰符的限制, 为了保证可以给属性赋值, 需要在操作前使得该属性可以被操作。 age.setAccessible(true); age.set(p, 21); System.out.println(p); }

Method全解

@Test public void test1() { Class clazz = Person.class; //1. getMethods() 获取运行时类及其父类中所有声明为 public 的方法 Method[] methods = clazz.getMethods(); for (Method method : methods) { //System.out.println(method); } Method[] methods2 = clazz.getDeclaredMethods(); for (Method method : methods2) { System.out.println(method); } } //注解 权限修饰符 返回值类型 形参列表 异常 @Test public void test2() { Class clazz = Person.class; Method[] m = clazz.getDeclaredMethods(); for (Method method : m) { //1.注解 Annotation[] ann = method.getAnnotations(); for (Annotation annotation : ann) { System.out.println(annotation); } //2.权限修饰符 String str = Modifier.toString(method.getModifiers()); System.out.print(str+" "); //3.返回值类型 Class returnType = method.getReturnType(); System.out.print(returnType.getName()+" "); //4.方法名 System.out.print(method.getName()); //5.形参列表 Class[] para = method.getParameterTypes(); for (Class p : para) { System.out.print("("); System.out.print(p); System.out.print(")"); } //6. 异常类型 Class[] exps = method.getExceptionTypes(); if(exps.length != 0) System.out.println("throws "); for (Class exp : exps) { System.out.println(exp.getName()); } } } //调用运行时类中指定的方法 @Test public void test3() throws Exception { Class<Person> clazz = Person.class; //getMethod(String methodName, Class...params):获取运行时类中声明为 public 的方法 Method m1 = clazz.getMethod("show"); Person p = clazz.newInstance(); //调用指定的方法:Object invoke(Object obj,Object...obj) Object returnVal = m1.invoke(p);//我是一个人 System.out.println(returnVal);//没有返回值,所以是null Method m2 = clazz.getMethod("toString"); Object returnVal1 = m2.invoke(p); System.out.println(returnVal1); //对于运行时类中静态方法的调用 Method m3 = clazz.getMethod("info"); m3.invoke(Person.class); //getDeclaredMethod(String methodName, Class...params):获取运行类中指定的方法 Method m4 = clazz.getDeclaredMethod("display",String.class); m4.setAccessible(true); m4.invoke(p, "CHN"); }

Constructor 构造器全解

@Test public void test1() throws Exception { Class<Person> clazz = (Class<Person>) Class.forName("com.anqi.refection.test.Person"); //创建对应的运行时类的对象, 使用 newInstance(), 实际上就是调用了运行时类的空参构造器 //要想能够创建成功, ① 要求对应的运行时类要有空参的构造器, ② 构造器的权限修饰符范围要大 Person p = clazz.newInstance(); System.out.println(p); } @Test public void test2() throws ClassNotFoundException { String className = "com.anqi.refection.test.Person"; Class<Person> clazz = (Class<Person>) Class.forName(className); //获取所有 public 修饰的构造器 Constructor[] cons = clazz.getConstructors(); for (Constructor constructor : cons) { System.out.println(constructor); } } //调用指定的构造器, 床架运行时类的对象 @Test public void test3() throws Exception{ Class<Person> clazz = Person.class; Constructor<Person> con = clazz.getDeclaredConstructor(String.class, int.class); con.setAccessible(true); Person p = con.newInstance("LiChen",18); System.out.println(p); }

通过反射获取父类、泛型、接口、注解、包等

/** * 获取运行时类的父类 */ @Test public void test() { Class<Person> clazz = Person.class; Class superClass = clazz.getSuperclass(); System.out.println(superClass); } /** * 获取带泛型的父类 */ @Test public void test2() { Class<Person> clazz = Person.class; Type type = clazz.getGenericSuperclass(); System.out.println(type); //com.anqi.refection.test.Creature<java.lang.String> } /** * 获取父类的泛型 */ @Test public void test3() { Class<Person> clazz = Person.class; Type type = clazz.getGenericSuperclass(); ParameterizedType t = (ParameterizedType) type; Type[] types = t.getActualTypeArguments(); System.out.println(types[0]); //class java.lang.String } /** * 获取实现的接口 */ @Test public void test4() { Class<Person> clazz = Person.class; Class[] interfaces = clazz.getInterfaces(); for (Class class1 : interfaces) { System.out.println(class1.getName()); } } /** * 获取所在的包 */ @Test public void test5() { Class<Person> clazz = Person.class; Package p = clazz.getPackage(); System.out.println(p); } /** * 获取注解 */ @Test public void test6() { Class<Person> clazz = Person.class; Annotation[] ann = clazz.getAnnotations(); for (Annotation annotation : ann) { System.out.println(annotation); } }