第 14 章反射

反射机制概述
Class类的理解与获取Class类的实例
了解ClassLoader
反射的应用

反射机制概述

什么是反射？

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

体会Java的动态性

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

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

 /*
  体会反射的动态性
   */
  @Test
  public void test2(){
      for(int i = 0; i < 10; i++){
          int num = new Random().nextInt(3);//0,1,2
          String classPath = "";
          switch(num){
              case 0:
                  classPath = "java.util.Date";
                  break;
              case 1:
                  classPath = "java.lang.Object";
                  break;
              case 2:
                  classPath = "Person";
                  break;
          }
          try {
              Object obj = getInstance(classPath);
              System.out.println(obj);
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  }
  /*
  创建一个指定类的对象，classPath：指定类的全类名
   */
  public Object getInstance(String classPath) throws Exception {
      Class clazz =  Class.forName(classPath);
      return clazz.newInstance();
  }

反射能做什么？

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

反射相关的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种方式

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

@Test
public void test2() throws ClassNotFoundException {
    //方式一：调用运行时类的属性：.class
    Class<Person> clazz1 = Person.class;
    System.out.println(clazz1);//class com.atguigu.java.Person
    //方式二：通过运行时类的对象
    Person p1 = new Person();
    Class<? extends Person> clazz2 = p1.getClass();
    System.out.println(clazz2);//class com.atguigu.java.Person
    //方式三：调用Class的静态方法：forName(String classPath)
    Class<?> clazz3 = Class.forName("com.atguigu.java.Person");
    System.out.println(clazz3);//class com.atguigu.java.Person
    //方式四：使用类的加载器：ClassLoader
    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    Class<?> clazz4 = classLoader.loadClass("com.atguigu.java.Person");
    System.out.println(clazz4);//class com.atguigu.java.Person
    System.out.println(clazz1 == clazz3);//true
    System.out.println(clazz2 == clazz3);//true
    System.out.println(clazz1 == clazz4);//true
}

创建类的对象的方式

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

哪些类型可以有Class对象

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

【示例代码】

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

了解ClassLoader

类的加载过程

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

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

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

类的加载器的作用与分类

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

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

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

public class ClassLoaderTest {
    @Test
    public void test1(){
        //自定义类，使用系统类加载器进行加载
        ClassLoader classLoader1 = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader1);//sun.misc.Launcher$AppClassLoader@18b4aac2
        //调用系统类加载器的getParent()：获取扩展类加载器
        ClassLoader classLoader2 = classLoader1.getParent();
        System.out.println(classLoader2);//sun.misc.Launcher$ExtClassLoader@5056dfcb
        //调用扩展类加载器的getParent()：无法获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。
        ClassLoader classLoader3 = classLoader2.getParent();
        System.out.println(classLoader3);//null
        ClassLoader classLoader = String.class.getClassLoader();
        System.out.println(classLoader);//null
    }
    @Test
    public void test2() throws Exception {
        Properties properties = new Properties();
        //读取配置文件的方式一：此时的文件默认识别在当前的module下
//        FileInputStream fis = new FileInputStream("src/jdbc.properties");
//        properties.load(fis);
        //读取配置文件的方式二：此时的文件默认识别在当前module的src目录下
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc.properties");
        properties.load(is);
        String user = properties.getProperty("user");
        String password = properties.getProperty("password");
        System.out.println("user=" + user + ", password=" + password);
    }
}

反射的应用

创建运行时类的对象

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

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

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

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

获取运行时类的完整结构

获取属性

public class FieldTest {
    @Test
    public void test1(){
        Class<People> clazz = People.class;
        //获取属性结构
        //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field field : fields) {
            System.out.println(field);
            //public int People.id
            //public double Creature.weight
        }
        //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
            //private java.lang.String People.name
            //int People.age
            //public int People.id
        }
    }
    //获取属性的：权限修饰符、数据类型、变量名
    @Test
    public void test2(){
        Class<People> clazz = People.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            //1.权限修饰符
            int modifiers = declaredField.getModifiers();
            System.out.print(Modifier.toString(modifiers) + "\t");
            //2.数据类型
            Class<?> type = declaredField.getType();
            System.out.print(type.getName() + "\t");
            //3.变量名
            String declaredFieldName = declaredField.getName();
            System.out.print(declaredFieldName);
            System.out.println();
        }
    }
}

获取方法

public class MethodTest {
    @Test
    public void test1(){
        Class<People> clazz = People.class;
        //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
    }
    /*
    获取方法的结构
    @Xxxx
    权限修饰符  返回值类型  方法名(参数类型1 形参名1,...) throws XxxException{}
     */
    @Test
    public void test2(){
        Class<People> clazz = People.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            //1.获取方法声明的注解
            Annotation[] annotations = declaredMethod.getAnnotations();
            for (Annotation annotation : annotations) {
                System.out.println(annotation);
            }
            //2.获取权限修饰符
            System.out.print(Modifier.toString(declaredMethod.getModifiers()) + "\t");
            //3.获取返回值类型
            System.out.print(declaredMethod.getReturnType().getName() + "\t");
            //4.获取方法名
            System.out.print(declaredMethod.getName());
            System.out.print("(");
            //5.获取行参列表
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            if (!(parameterTypes == null && parameterTypes.length == 0)) {
                for (int i = 0; i < parameterTypes.length; i++) {
                    if (i == parameterTypes.length - 1) {
                        System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
                    }
                    System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
                }
            }
            System.out.print(")");
            //6.获取抛出的异常
            Class<?>[] exceptionTypes = declaredMethod.getExceptionTypes();
            if(exceptionTypes.length > 0){
                System.out.print("throws ");
                for(int i = 0;i < exceptionTypes.length;i++){
                    if(i == exceptionTypes.length - 1){
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName() + ",");
                }
            }
        }
    }
}

获取构造器

@Test
public void test1(){
    Class<People> clazz = People.class;
    //getConstructors():获取当前运行时类中声明为public的构造器
    Constructor<?>[] constructors = clazz.getConstructors();
    for (Constructor<?> constructor : constructors) {
        System.out.println(constructor);
    }
    System.out.println();
    //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
    Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
    for (Constructor<?> constructor : declaredConstructors) {
        System.out.println(constructor);
    }
}

获取父类

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

获取带泛型的父类

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

获取带泛型父类的泛型

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

获取运行时类实现的接口

@Test
public void test5(){
    Class<People> clazz = People.class;
    Class<?>[] interfaces = clazz.getInterfaces();
    for (Class<?> aninterface :interfaces){
        System.out.println(aninterface);//interface java.lang.Comparable、interface MyInterface
    }
    System.out.println();
    //获取运行时类的父类实现的接口
    Class<?>[] interfaces1 = clazz.getSuperclass().getInterfaces();
    for (Class<?> aClass : interfaces1) {
        System.out.println(aClass);//interface java.io.Serializable
    }
}

获取运行时类所在的包

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

获取运行时类声明的注解

@Test
public void test7(){
    Class clazz = People.class;
    Annotation[] annotations = clazz.getAnnotations();
    for(Annotation annotation : annotations){
        System.out.println(annotation);//@MyAnnotation(value=hello)
    }
}

小结

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

调用运行时类的指定结构

调用指定的属性

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

调用指定的方法

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

调用指定的构造器

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

关于setAccessible方法的使用

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

动态代理

静态代理举例

public class ProxyTest {
    public static void main(String[] args) {
        NikeClothFactory nike = new NikeClothFactory();
        ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);
        proxyClothFactory.produceCloth();
    }
}
interface ClothFactory {
    void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory {
    //用被代理类进行实例化
    private ClothFactory factory;
    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }
    public ProxyClothFactory() {
    }
    @Override
    public void produceCloth() {
        System.out.println("前期准备工作");
        factory.produceCloth();
        System.out.println("后期准备工作");
    }
}
class NikeClothFactory implements ClothFactory {
    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产运动服");
    }
}

执行结果：

前期准备工作
Nike工厂生产运动服
后期准备工作

动态代理举例

public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
        System.out.println(proxyInstance.getBelief());//I believe I can fly!
        proxyInstance.eat("四川麻辣烫");//我喜欢吃四川麻辣烫
    }
}
interface Human {
    String getBelief();
    void eat(String food);
}
//被代理类
class SuperMan implements Human {
    @Override
    public String getBelief() {
        return "I believe I can fly!";
    }
    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }
}
/*
要想实现动态代理，需要解决的问题？
问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
 */
class ProxyFactory {
    //调用此方法，返回一个代理类的对象。解决问题一
    public static Object getProxyInstance(Object obj) {
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
                obj.getClass().getInterfaces(), handler);
    }
}
class MyInvocationHandler implements InvocationHandler {
    private Object obj;//需要使用被代理类的对象进行赋值
    public void bind(Object obj) {
        this.obj = obj;
    }
    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue = method.invoke(obj, args);
        //上述方法的返回值就作为当前类中的invoke()的返回值。
        return returnValue;
    }
}

第 14 章 反射