1、什么是反射？

➢Reflection （反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 Class C = Class.forName(“java.lang.String”) ➢加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一 个类只有一-个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到 类的结构。这个对象就像一面镜子， 透过这个镜子看到类的结构，所以,我们形象的称之为：反射

image.png

2、反射机制能做些什么？

➢在运行时判断任意一个对象 所属的类
➢在运行时构造任意一个类的对象
➢在运行时判断任意一个类所具有的成员变量和方法
➢在运行时获取泛型信息
➢在运行时调用任意一个对象的成员变量和方法
➢在运行时处理注解
➢生成动态代理
image.png

3、如何获取反射对象

3.1、class详解，反射操作的源头，获取class的几种方法

所有反射得来源都是操作class类，通过获取class类对反射进行操作

3.1.1、class类描述

对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE都为其保留一-个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[)的有关信息。
➢Class 本身也是一个类
➢Class 对象只能由系统建立对象
➢加载的类在JVM中只会有一个Class实例
➢一个Class对象对应的是- -个加载到JVM中的一个.class文件
➢每个类的实例都会记得自己是由哪个Class实例所生成
➢通过Class可以完整地得到一个类中的所有被加载的结构
➢Class类 是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
image.png

3.1.2、class类常用方法

image.png

3.1.3、获取class类得常用几种方法

  1. package com.haoker.reflection;
  3. /**
  4.  * @ClassName GetClass
  5.  * @Description TODO
  6.  * @Author 豪
  7.  * @Date 2021/8/2 21:38
  8.  * @Version I. 0
  9.  **/
  10. public class GetClass {
  11.     public static void main(String[] args) throws ClassNotFoundException {
  12.         //1、通过类名.class获得
  13.         Class c1 = User.class;
  14.         System.out.println(c1);
  15.         //2、通过forName获得
  16.         Class c2 = Class.forName("com.haoker.reflection.User");
  17.         System.out.println(c2);
  18.         //3、通过new对象后getClass方法获得
  19.         Class c3 = new User().getClass();
  20.         System.out.println(c3);
  21.         //获取父类
  22.         Class superclass = c1.getSuperclass();
  23.         System.out.println(superclass);
  24.     }
  25. }
  28. class User{
  29.     private String empName;
  30.     private String empNo;
  32.     public String getEmpName() {
  33.         return empName;
  34.     }
  36.     public void setEmpName(String empName) {
  37.         this.empName = empName;
  38.     }
  40.     public String getEmpNo() {
  41.         return empNo;
  42.     }
  44.     public void setEmpNo(String empNo) {
  45.         this.empNo = empNo;
  46.     }
  47. }

image.png

4、反射具体操作

4.1、获取运行时类得详细信息

  1. package com.haoker.reflection;
  3. import com.haoker.annotations.ColCopy;
  5. import java.lang.reflect.Constructor;
  6. import java.lang.reflect.Field;
  7. import java.lang.reflect.Method;
  9. /**
  10.  * @ClassName GetClass
  11.  * @Description 反射获取类得名称、属性、方法、构造方法、注解和泛型
  12.  * @Author 豪
  13.  * @Date 2021/8/2 21:38
  14.  * @Version I. 0
  15.  **/
  16. public class GetClassInfo {
  17.     public static void main(String[] args) throws Exception, IllegalAccessException {
  18.         //1、通过forName获得
  19.         Class c2 = Class.forName("com.haoker.reflection.User2");
  20.         System.out.println(c2);
  21.         //2、获取类全路径名称
  22.         String name = c2.getName();
  23.         System.out.println(name);
  24.         //3、获取类名，不包含路径
  25.         String simpleName = c2.getSimpleName();
  26.         System.out.println(simpleName);
  28.         //获取类所有得属性,只获取共有属性
  29.         Field[] fields = c2.getFields();
  30.         for (Field field : fields) {
  31.             System.out.println(field);
  32.         }
  33.         //获取类所有得属性，包括私有属性
  34.         Field[] declaredFields = c2.getDeclaredFields();
  35.         for (Field declaredField : declaredFields) {
  36.             System.out.println(declaredField);
  37.         }
  38.         //获取类指定属性
  39.         Field empName = c2.getDeclaredField("empName");
  40.         System.out.println(empName);
  41.         //获取类指定属性，共有
  42.         Field empName2 = c2.getField("age");
  43.         System.out.println("获取类指定属性，共有" + empName2);
  44.         //获取本类和父类得全部方法
  45.         Method[] methods = c2.getMethods();
  46.         for (Method method : methods) {
  47.             System.out.println("获取本类和父类所有方法" +method);
  48.         }
  49.         //获取本类所有方法
  50.         Method[] methods2 = c2.getDeclaredMethods();
  51.         for (Method method : methods2) {
  52.             System.out.println("获取本类所有方法" + method);
  53.         }
  54.         //获取类指定方法，方法名和入参
  55.         Method methods3 = c2.getMethod("getEmpName",null);
  56.         System.out.println(methods3);
  57.         Method methods4 = c2.getMethod("setEmpName",String.class);
  58.         System.out.println(methods4);
  59.         //获取全部得构造器
  60.         Constructor[] constructors = c2.getConstructors();
  61.         for (Constructor constructor : constructors) {
  62.             System.out.println(constructor);
  63.         }
  64.         //获取全部得构造器
  65.         Constructor[] declaredConstructors = c2.getDeclaredConstructors();
  66.         for (Constructor constructor : declaredConstructors) {
  67.             System.out.println(constructor);
  68.         }
  69.         //获取指定名称得构造器
  70.         Constructor constructor = c2.getDeclaredConstructor();
  71.         System.out.println(constructor);
  72.         Constructor constructor2 = c2.getDeclaredConstructor(String.class,String.class,String.class);
  73.         System.out.println(constructor2);
  74.         //操作注解,看注解得位置再哪里，再属性上，就需要先获取到属性
  75.         Field empName3 = c2.getDeclaredField("empName");
  76.         if(empName3.isAnnotationPresent(ColCopy.class)){
  77.             ColCopy empName1 = empName3.getAnnotation(ColCopy.class);
  78.             System.out.println(empName1.name());
  79.         }
  80.         //操作泛型，泛型一般都是再方法中，所以先要操作方法，再获取泛型对应得实体，因为泛型再程序编译完成后，会编译成具体对应得类
  82.     }
  83. }
  85. class User2{
  86.     @ColCopy(name ="empName")
  87.     private String empName;
  88.     private String empNo;
  89.     public String age;
  91.     public User2() {
  92.     }
  94.     public User2(String empName, String empNo, String age) {
  95.         this.empName = empName;
  96.         this.empNo = empNo;
  97.         this.age = age;
  98.     }
  100.     public String getEmpName() {
  101.         return empName;
  102.     }
  104.     public void setEmpName(String empName) {
  105.         this.empName = empName;
  106.     }
  108.     public String getEmpNo() {
  109.         return empNo;
  110.     }
  112.     public void setEmpNo(String empNo) {
  113.         this.empNo = empNo;
  114.     }
  116.     public String getAge() {
  117.         return age;
  118.     }
  120.     public void setAge(String age) {
  121.         this.age = age;
  122.     }
  123. }

4.2、对方法、属性、构造函数进行操作

  1. package com.haoker.reflection;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.Method;
  7. /**
  8.  * @ClassName GetClass
  9.  * @Description 反射获取类得方法，然后对方法进行执行
  10.  *              反射获取属性值，然后对属性进行赋值
  11.  * @Author 豪
  12.  * @Date 2021/8/2 21:38
  13.  * @Version I. 0
  14.  **/
  15. public class GetClassIovoke {
  16.     public static void main(String[] args) throws Exception, IllegalAccessException {
  17.         //1、通过forName获得
  18.         Class c2 = Class.forName("com.haoker.reflection.User3");
  19.         System.out.println(c2);
  20.         //2、对方法、属性进行操作得时候，入参是类
  21.         User3 o = (User3) c2.newInstance();
  22.         //操作构造函数
  23.         Constructor declaredConstructor = c2.getDeclaredConstructor(String.class, String.class, String.class);
  24.         User3 lin = (User3) declaredConstructor.newInstance("lin", "999", "27");
  25.         System.out.println(lin.getEmpName());
  26.         //操作方法
  27.         Method methods5 = c2.getMethod("setEmpName",String.class);
  28.         methods5.invoke(o,"123");
  29.         System.out.println(o.getEmpName());
  30.         //操作属性得时候
  31.         Field empName1 = c2.getDeclaredField("empName");
  32.         empName1.setAccessible(true);
  33.         empName1.set(o,"333");
  34.         System.out.println(o.getEmpName());
  35.     }
  36. }
  38. class User3{
  39.     private String empName;
  40.     private String empNo;
  41.     public String age;
  43.     public User3() {
  44.     }
  46.     public User3(String empName, String empNo, String age) {
  47.         this.empName = empName;
  48.         this.empNo = empNo;
  49.         this.age = age;
  50.     }
  52.     public String getEmpName() {
  53.         return empName;
  54.     }
  56.     public void setEmpName(String empName) {
  57.         this.empName = empName;
  58.     }
  60.     public String getEmpNo() {
  61.         return empNo;
  62.     }
  64.     public void setEmpNo(String empNo) {
  65.         this.empNo = empNo;
  66.     }
  68.     public String getAge() {
  69.         return age;
  70.     }
  72.     public void setAge(String age) {
  73.         this.age = age;
  74.     }
  75. }

4.3、对注解进行获取操作

  1. //操作注解,看注解得位置再哪里，再属性上，就需要先获取到属性
  2. Field empName3 = c2.getDeclaredField("empName");
  3. if(empName3.isAnnotationPresent(ColCopy.class)){
  4.     ColCopy empName1 = empName3.getAnnotation(ColCopy.class);
  5.     System.out.println(empName1.name());
  6. }

4.4、对泛型进行操作

  1. package com.haoker.reflection;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.ParameterizedType;
  5. import java.lang.reflect.Type;
  6. import java.util.List;
  7. import java.util.Map;
  9. /**
  10.  * @ClassName GetClass
  11.  * @Description 反射操作泛型
  12.  * @Author 豪
  13.  * @Date 2021/8/2 21:38
  14.  * @Version I. 0
  15.  **/
  16. public class GetClassT {
  18.     public void test1(Map<String,User3> maps,List<String> lists){
  19.         System.out.println(maps);
  20.     }
  22.     public static void main(String[] args) throws Exception, IllegalAccessException {
  23.         //1、通过forName获得
  24.         Class c2 = Class.forName("com.haoker.reflection.GetClassT");
  25.         System.out.println(c2);
  26.         //获取方法
  27.         Method test1 = c2.getMethod("test1", Map.class, List.class);
  28.         //获取方法得参数类型
  29.         Type[] genericParameterTypes = test1.getGenericParameterTypes();
  30.         for (Type genericParameterType : genericParameterTypes) {
  31.             //循环继续获取集合里面得真正类型得参数
  32.             if(genericParameterType instanceof ParameterizedType){
  33.                 Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
  34.                 for (Type parameterType : actualTypeArguments) {
  35.                     System.out.println(parameterType);
  36.                 }
  37.             }
  38.         }
  39.     }
  40. }

image.png

5、反射性能和普通new方法对比，优缺点

优点:
➢可以实现动态创建对象和编译，体现出很大的灵活性
优点:
➢对性能有影响。使用反射一般比使用普通得new要慢一点

6、内加载内存分析

6.1、类加载的过程，主要第一步类得加载得时候会把class文件生成

image.png

image.png
image.png

6.2、分析类初始化

image.png

6.3、类加载器

image.png
image.png

6.4、双亲委派机制

6.4.1、双亲委派机制原理

白话文得说法：遇到事情得时候，儿子先不处理问题，先向父亲反馈，然后父亲再向爷爷反馈，看爷爷能不能处理，爷爷不能处理，再告诉父亲，看父亲能不能处理，不能再让儿子处理。意思就是，类加载得时候，类加载器先一级一级向父级请求，然后父级再一级一级往下查找由谁加载，就好像金字塔那样子得走向。
image.png

6.4.2、如何破环双亲委派机制

双亲委派，就是一级一级往上找，然后再往下找。为了能够保证唯一性而不错乱。只要把唯一性不错乱给破坏了，自然而然把双亲委派破坏了。

1、自定义类加载器 ，重写loadclass方法，这样就会存在多个相同得类，导致双亲委派破坏

java反射 - 图14

7、思考题

7.1、能不能自己写-一个限定名为java.lang.String的类，并在程序中调用它?

分情况，如果只是单纯得再java项目中，新建一个java.lang得包，然后再新建这个string类，然后main函数启动，是不行得，因为根据双亲委派机制，会一级一级往上找，找到得不是我们自己建得类，而找到得类中，是没有main方法得，所以，无法运行程序！但是，如果是再web项目中，可以在WEB-INF/clsssess目录下创建对应得string类，此时程序加载得时候，读取得是我们自己建得string类，但是这样原来得string类得方法都不能用了。