反射机制概述

什么是反射？

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

image.png

体会Java的动态性

  • 动态语言是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。 主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
  • 静态语言与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、 C++。Java不是动态语言。

  • Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。 Java的动态性让编程的时候更加灵活！

    1.  /*
    2.   体会反射的动态性
    3.    */
    4.   @Test
    5.   public void test2(){
    6.       for(int i = 0; i < 10; i++){
    7.           int num = new Random().nextInt(3);//0,1,2
    8.           String classPath = "";
    9.           switch(num){
    10.               case 0:
    11.                   classPath = "java.util.Date";
    12.                   break;
    13.               case 1:
    14.                   classPath = "java.lang.Object";
    15.                   break;
    16.               case 2:
    17.                   classPath = "Person";
    18.                   break;
    19.           }
    20.           try {
    21.               Object obj = getInstance(classPath);
    22.               System.out.println(obj);
    23.           } catch (Exception e) {
    24.               e.printStackTrace();
    25.           }
    26.       }
    27.   }
    29.   /*
    30.   创建一个指定类的对象，classPath：指定类的全类名
    31.    */
    32.   public Object getInstance(String classPath) throws Exception {
    33.       Class clazz =  Class.forName(classPath);
    34.       return clazz.newInstance();
    35.   }

    反射能做什么？

  • 在运行时判断任意一个对象所属的类

  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法

  • 在运行时处理注解生成动态代理

    反射相关的API

  • java.lang.Class:代表一个类

  • java.lang.reflect.Method:代表类的方法
  • java.lang.reflect.Field:代表类的成员变量
  • java.lang.reflect.Constructor:代表类的构造器
  • …….

Class类的理解与获取Class类的实例

关于java.lang.Class类的理解

类的加载过程：

  • 程序经过 javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。接着我们使用 java.exe 命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中，此过程就称为类的加载。
  • 加载到内存中的类，我们就称为运行时类，此运行时类就作为Class类的一个实例。换句话说，Class的实例就对应着一个运行时类。
  • 加载到内存中的运行时类，会缓存一定的时间，在此时间之内，我们可以通过不同的方式来获取此运行时类。

获取Class类的实例的4种方式

前三种方式需要掌握，第三种方式使用较多。

  1. @Test
  2. public void test2() throws ClassNotFoundException {
  3.     //方式一：调用运行时类的属性：.class
  4.     Class<Person> clazz1 = Person.class;
  5.     System.out.println(clazz1);//class com.atguigu.java.Person
  7.     //方式二：通过运行时类的对象
  8.     Person p1 = new Person();
  9.     Class<? extends Person> clazz2 = p1.getClass();
  10.     System.out.println(clazz2);//class com.atguigu.java.Person
  12.     //方式三：调用Class的静态方法：forName(String classPath)
  13.     Class<?> clazz3 = Class.forName("com.atguigu.java.Person");
  14.     System.out.println(clazz3);//class com.atguigu.java.Person
  16.     //方式四：使用类的加载器：ClassLoader
  17.     ClassLoader classLoader = ReflectionTest.class.getClassLoader();
  18.     Class<?> clazz4 = classLoader.loadClass("com.atguigu.java.Person");
  19.     System.out.println(clazz4);//class com.atguigu.java.Person
  21.     System.out.println(clazz1 == clazz3);//true
  22.     System.out.println(clazz2 == clazz3);//true
  23.     System.out.println(clazz1 == clazz4);//true
  24. }

创建类的对象的方式

1、new + 构造器。
2、要创建Xxx类的对象，可以考虑：Xxx、Xxxs、XxxFactory、XxxBuilder类中查看是否有静态方法的存在。可以调用其静态方法，创建Xxx对象。
3、通过反射。

哪些类型可以有Class对象

  • class：外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
  • interface：接口
  • []：数组
  • enum：枚举类
  • annotation：注解
  • primitive type：基本数据类型
  • void

【示例代码】

  1. @Test
  2. public void test4(){
  4.     //Class实例可以是下列结构：
  5.     Class<Object> c1 = Object.class;
  6.     Class<Comparable> c2 = Comparable.class;
  7.     Class<String[]> c3 = String[].class;
  8.     Class<int[][]> c4 = int[][].class;
  9.     Class<ElementType> c5 = ElementType.class;
  10.     Class<Override> c6 = Override.class;
  11.     Class<Integer> c7 = int.class;
  12.     Class<Void> c8 = void.class;
  13.     Class<Class> c9 = Class.class;
  15.     int[] a = new int[10];
  16.     int[] b = new int[100];
  17.     Class<? extends int[]> c10 = a.getClass();
  18.     Class<? extends int[]> c11 = b.getClass();
  20.     //只要元素类型与维度一样，就是同一个Class
  21.     System.out.println(c10 == c11);//true
  22. }

了解ClassLoader

类的加载过程

image.png
image.png
image.png

什么时候会发生类的初始化

  • 类的主动引用（一定会发生类的初始化）
    • 当虚拟机启动，先初始化main方法所在的类
    • new一个类的对象
    • 调用类的静态成员（除了final常量）和静态方法
    • 使用java.lang.reflect包的方法对类进行反射调用 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
  • 类的被动引用（不会发生类的初始化）
    • 当访问一个静态域时，只有真正声明这个域的类才会被初始化  当通过子类引用父类的静态变量，不会导致子类初始化
    • 通过数组定义类引用，不会触发此类的初始化
    • 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）

image.png

Java类编译、运行的执行流程

image.png

类的加载器的作用与分类

  • 类加载的作用： 将class文件字节码内容加载到内存中 ，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
  • 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。
image.png

使用ClassLoader加载src目录下的配置文件

  1. public class ClassLoaderTest {
  3.     @Test
  4.     public void test1(){
  5.         //自定义类，使用系统类加载器进行加载
  6.         ClassLoader classLoader1 = ClassLoaderTest.class.getClassLoader();
  7.         System.out.println(classLoader1);//sun.misc.Launcher$AppClassLoader@18b4aac2
  9.         //调用系统类加载器的getParent()：获取扩展类加载器
  10.         ClassLoader classLoader2 = classLoader1.getParent();
  11.         System.out.println(classLoader2);//sun.misc.Launcher$ExtClassLoader@5056dfcb
  13.         //调用扩展类加载器的getParent()：无法获取引导类加载器
  14.         //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。
  15.         ClassLoader classLoader3 = classLoader2.getParent();
  16.         System.out.println(classLoader3);//null
  17.         ClassLoader classLoader = String.class.getClassLoader();
  18.         System.out.println(classLoader);//null
  19.     }
  21.     @Test
  22.     public void test2() throws Exception {
  23.         Properties properties = new Properties();
  24.         //读取配置文件的方式一：此时的文件默认识别在当前的module下
  25. //        FileInputStream fis = new FileInputStream("src/jdbc.properties");
  26. //        properties.load(fis);
  28.         //读取配置文件的方式二：此时的文件默认识别在当前module的src目录下
  29.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
  30.         InputStream is = classLoader.getResourceAsStream("jdbc.properties");
  31.         properties.load(is);
  32.         String user = properties.getProperty("user");
  33.         String password = properties.getProperty("password");
  34.         System.out.println("user=" + user + ", password=" + password);
  35.     }
  36. }

反射的应用

创建运行时类的对象

调用Class对象的newInstance()方法
要求：

  • 类必须有一个无参数的构造器。
    • 在javabean中要求提供一个public的空参构造器。原因：便于通过反射，创建运行时类的对象，便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器。
  • 类的构造器的访问权限需要足够，通常设置为public。

难道没有无参的构造器就不能创建对象了吗？ 不是！
只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。 步骤如下：
1）通过Class类的getDeclaredConstructor(Class … parameterTypes)取得本类的指定形参类型的构造器
2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
3）通过Constructor实例化对象。

  1. @Test
  2. public void test1() throws IllegalAccessException, InstantiationException {
  3.     Class<Person> clazz = Person.class;
  4.     Person person = clazz.newInstance();
  5.     System.out.println(person);
  6. }

获取运行时类的完整结构

获取属性

  1. public class FieldTest {
  2.     @Test
  3.     public void test1(){
  4.         Class<People> clazz = People.class;
  5.         //获取属性结构
  6.         //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
  7.         Field[] fields = clazz.getFields();
  8.         for (Field field : fields) {
  9.             System.out.println(field);
  10.             //public int People.id
  11.             //public double Creature.weight
  12.         }
  14.         //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
  15.         Field[] declaredFields = clazz.getDeclaredFields();
  16.         for (Field declaredField : declaredFields) {
  17.             System.out.println(declaredField);
  18.             //private java.lang.String People.name
  19.             //int People.age
  20.             //public int People.id
  21.         }
  22.     }
  24.     //获取属性的：权限修饰符、数据类型、变量名
  25.     @Test
  26.     public void test2(){
  27.         Class<People> clazz = People.class;
  28.         Field[] declaredFields = clazz.getDeclaredFields();
  29.         for (Field declaredField : declaredFields) {
  30.             //1.权限修饰符
  31.             int modifiers = declaredField.getModifiers();
  32.             System.out.print(Modifier.toString(modifiers) + "\t");
  34.             //2.数据类型
  35.             Class<?> type = declaredField.getType();
  36.             System.out.print(type.getName() + "\t");
  38.             //3.变量名
  39.             String declaredFieldName = declaredField.getName();
  40.             System.out.print(declaredFieldName);
  42.             System.out.println();
  43.         }
  44.     }
  45. }

获取方法

  1. public class MethodTest {
  2.     @Test
  3.     public void test1(){
  4.         Class<People> clazz = People.class;
  5.         //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
  6.         Method[] methods = clazz.getMethods();
  7.         for (Method method : methods) {
  8.             System.out.println(method);
  9.         }
  11.         //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
  12.         Method[] declaredMethods = clazz.getDeclaredMethods();
  13.         for (Method declaredMethod : declaredMethods) {
  14.             System.out.println(declaredMethod);
  15.         }
  16.     }
  18.     /*
  19.     获取方法的结构
  20.     @Xxxx
  21.     权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
  22.      */
  23.     @Test
  24.     public void test2(){
  25.         Class<People> clazz = People.class;
  26.         Method[] declaredMethods = clazz.getDeclaredMethods();
  27.         for (Method declaredMethod : declaredMethods) {
  28.             //1.获取方法声明的注解
  29.             Annotation[] annotations = declaredMethod.getAnnotations();
  30.             for (Annotation annotation : annotations) {
  31.                 System.out.println(annotation);
  32.             }
  34.             //2.获取权限修饰符
  35.             System.out.print(Modifier.toString(declaredMethod.getModifiers()) + "\t");
  37.             //3.获取返回值类型
  38.             System.out.print(declaredMethod.getReturnType().getName() + "\t");
  40.             //4.获取方法名
  41.             System.out.print(declaredMethod.getName());
  42.             System.out.print("(");
  44.             //5.获取行参列表
  45.             Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
  46.             if (!(parameterTypes == null && parameterTypes.length == 0)) {
  47.                 for (int i = 0; i < parameterTypes.length; i++) {
  48.                     if (i == parameterTypes.length - 1) {
  49.                         System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
  50.                     }
  51.                     System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
  52.                 }
  53.             }
  54.             System.out.print(")");
  56.             //6.获取抛出的异常
  57.             Class<?>[] exceptionTypes = declaredMethod.getExceptionTypes();
  58.             if(exceptionTypes.length > 0){
  59.                 System.out.print("throws ");
  60.                 for(int i = 0;i < exceptionTypes.length;i++){
  61.                     if(i == exceptionTypes.length - 1){
  62.                         System.out.print(exceptionTypes[i].getName());
  63.                         break;
  64.                     }
  65.                     System.out.print(exceptionTypes[i].getName() + ",");
  66.                 }
  67.             }
  68.         }
  69.     }
  70. }

获取构造器

  1. @Test
  2. public void test1(){
  3.     Class<People> clazz = People.class;
  4.     //getConstructors():获取当前运行时类中声明为public的构造器
  5.     Constructor<?>[] constructors = clazz.getConstructors();
  6.     for (Constructor<?> constructor : constructors) {
  7.         System.out.println(constructor);
  8.     }
  9.     System.out.println();
  11.     //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
  12.     Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
  13.     for (Constructor<?> constructor : declaredConstructors) {
  14.         System.out.println(constructor);
  15.     }
  16. }

获取父类

  1. @Test
  2. public void test2(){
  3.     Class<People> clazz = People.class;
  4.     Class<? super People> superclass = clazz.getSuperclass();
  5.     System.out.println(superclass);//class Creature
  6. }

获取带泛型的父类

  1. @Test
  2. public void test3(){
  3.     Class<People> clazz = People.class;
  4.     Type genericSuperclass = clazz.getGenericSuperclass();
  5.     System.out.println(genericSuperclass);//Creature<java.lang.String>
  6. }

获取带泛型父类的泛型

  1. @Test
  2. public void test4(){
  3.     Class<People> clazz = People.class;
  4.     Type genericSuperclass = clazz.getGenericSuperclass();
  5.     ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
  6.     //获取泛型类型
  7.     Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
  8.     System.out.println(actualTypeArguments[0].getTypeName());//java.lang.String
  9. }

获取运行时类实现的接口

  1. @Test
  2. public void test5(){
  3.     Class<People> clazz = People.class;
  4.     Class<?>[] interfaces = clazz.getInterfaces();
  5.     for (Class<?> aninterface :interfaces){
  6.         System.out.println(aninterface);//interface java.lang.Comparable、interface MyInterface
  7.     }
  8.     System.out.println();
  9.     //获取运行时类的父类实现的接口
  10.     Class<?>[] interfaces1 = clazz.getSuperclass().getInterfaces();
  11.     for (Class<?> aClass : interfaces1) {
  12.         System.out.println(aClass);//interface java.io.Serializable
  13.     }
  14. }

获取运行时类所在的包

  1. @Test
  2. public void test6(){
  3.     Class<People> clazz = People.class;
  4.     Package pack = clazz.getPackage();
  5.     System.out.println(pack);//null
  6. }

获取运行时类声明的注解

  1. @Test
  2. public void test7(){
  3.     Class clazz = People.class;
  4.     Annotation[] annotations = clazz.getAnnotations();
  5.     for(Annotation annotation : annotations){
  6.         System.out.println(annotation);//@MyAnnotation(value=hello)
  7.     }
  8. }

小 结

1、在实际的操作中，取得类的信息的操作代码，并不会经常开发。
2、一定要熟悉java.lang.reflect包的作用，反射机制。
3、如何取得属性、方法、构造器的名称，修饰符等。

调用运行时类的指定结构

调用指定的属性

  1. @Test
  2. public void testFields() throws Exception {
  3.     Class<People> clazz = People.class;
  4.     //创建运行时类的对象
  5.     People people = clazz.newInstance();
  7.     //1.getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
  8.     Field name = clazz.getDeclaredField("name");
  10.     //2.保证当前属性是可访问的
  11.     name.setAccessible(true);
  13.     //3.获取、设置指定对象的此属性值
  14.     name.set(people, "Tom");
  15.     System.out.println(name.get(people));//Tom
  16. }

调用指定的方法

  1. @Test
  2. public void testMethods() throws Exception {
  3.     Class<People> clazz = People.class;
  5.     //创建运行时类的对象
  6.     People people = clazz.newInstance();
  8.     /*
  9.      1.获取指定的某个方法
  10.      getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
  11.      */
  12.     Method show = clazz.getDeclaredMethod("show", String.class);
  14.     //2.保证当前方法是可访问的
  15.     show.setAccessible(true);
  17.     /*
  18.      3. 调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
  19.      invoke()的返回值即为对应类中调用的方法的返回值。
  20.      */
  21.     Object obj = show.invoke(people, "CHN");//String nation = p.show("CHN");
  22.     System.out.println(obj);
  24.     System.out.println("***************如何调用静态方法******************");
  26.     Method showDesc = clazz.getDeclaredMethod("showDesc");
  27.     showDesc.setAccessible(true);
  28.     //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
  29.     //以下两种写法都可以，People.class或者null
  30.     //Object object = showDesc.invoke(People.class);
  31.     Object object = showDesc.invoke(null);
  32.     System.out.println(object);//null
  33. }

调用指定的构造器

  1. @Test
  2. public void testConstructor() throws Exception {
  3.     Class<People> clazz = People.class;
  4.     //private Person(String name)
  5.     /*
  6.      1.获取指定的构造器
  7.      getDeclaredConstructor():参数：指明构造器的参数列表
  8.      */
  9.     Constructor<People> constructor = clazz.getDeclaredConstructor(String.class);
  11.     //2.保证此构造器是可访问的
  12.     constructor.setAccessible(true);
  14.     //3.调用此构造器创建运行时类的对象
  15.     People people = constructor.newInstance("Tom");
  16.     System.out.println(people);
  17. }

关于setAccessible方法的使用

  • Method和Field、Constructor对象都有setAccessible()方法。
  • setAccessible启动和禁用访问安全检查的开关。
  • 参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
    • 提高反射的效率。如果代码中必须用反射，而该句代码需要频繁的被调用，那么请设置为true。
    • 使得原本无法访问的私有成员也可以访问
  • 参数值为false则指示反射的对象应该实施Java语言访问检查。


    反射的应用-动态代理

    image.png
    image.png
    image.png

静态代理举例

  1. public class ProxyTest {
  2.     public static void main(String[] args) {
  3.         NikeClothFactory nike = new NikeClothFactory();
  4.         ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);
  5.         proxyClothFactory.produceCloth();
  6.     }
  7. }
  9. interface ClothFactory {
  10.     void produceCloth();
  11. }
  13. //代理类
  14. class ProxyClothFactory implements ClothFactory {
  16.     //用被代理类进行实例化
  17.     private ClothFactory factory;
  19.     public ProxyClothFactory(ClothFactory factory) {
  20.         this.factory = factory;
  21.     }
  23.     public ProxyClothFactory() {
  24.     }
  26.     @Override
  27.     public void produceCloth() {
  28.         System.out.println("前期准备工作");
  29.         factory.produceCloth();
  30.         System.out.println("后期准备工作");
  31.     }
  32. }
  34. class NikeClothFactory implements ClothFactory {
  36.     @Override
  37.     public void produceCloth() {
  38.         System.out.println("Nike工厂生产运动服");
  39.     }
  40. }

执行结果：

  1. 前期准备工作
  2. Nike工厂生产运动服
  3. 后期准备工作

动态代理举例

  1. public class ProxyTest {
  2.     public static void main(String[] args) {
  3.         SuperMan superMan = new SuperMan();
  5.         //proxyInstance:代理类的对象
  6.         Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
  8.         //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
  9.         System.out.println(proxyInstance.getBelief());//I believe I can fly!
  10.         proxyInstance.eat("四川麻辣烫");//我喜欢吃四川麻辣烫
  11.     }
  12. }
  15. interface Human {
  16.     String getBelief();
  18.     void eat(String food);
  19. }
  22. //被代理类
  23. class SuperMan implements Human {
  25.     @Override
  26.     public String getBelief() {
  27.         return "I believe I can fly!";
  28.     }
  30.     @Override
  31.     public void eat(String food) {
  32.         System.out.println("我喜欢吃" + food);
  33.     }
  34. }
  36. /*
  37. 要想实现动态代理，需要解决的问题？
  38. 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
  39. 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
  40.  */
  41. class ProxyFactory {
  42.     //调用此方法，返回一个代理类的对象。解决问题一
  43.     public static Object getProxyInstance(Object obj) {
  44.         MyInvocationHandler handler = new MyInvocationHandler();
  45.         handler.bind(obj);
  46.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
  47.                 obj.getClass().getInterfaces(), handler);
  48.     }
  49. }
  51. class MyInvocationHandler implements InvocationHandler {
  53.     private Object obj;//需要使用被代理类的对象进行赋值
  55.     public void bind(Object obj) {
  56.         this.obj = obj;
  57.     }
  59.     //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
  60.     //将被代理类要执行的方法a的功能就声明在invoke()中
  61.     @Override
  62.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  63.         //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
  64.         //obj:被代理类的对象
  65.         Object returnValue = method.invoke(obj, args);
  66.         //上述方法的返回值就作为当前类中的invoke()的返回值。
  67.         return returnValue;
  68.     }
  69. }