【java基础】 15 反射

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

2 动态语言、静态语言

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

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

3 应用

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

4 主要API

java.lang.Class:代表一个类（通用地描述类）
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造器
... ...

15.2 理解Class类并获取Class的实例

1 举例

建立一个Person类

public class Person {
    private String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Person() { }
    private Person(String name) {
        this.name = name;
    }
    //还包括get set toString方法
    public void show(){
        System.out.println("person");
    }
    public String showNation(String nation){
        System.out.println("国籍为：" + nation);
        return nation;
    }
}

//有反射之前，对于Person的操作
public void test1(){
    //1.创建对象
    Person p1 = new Person("Tom", 12);
    //2.通过对象调用内部属性、方法
    p1.age = 10;
    System.out.println(p1.toString());
    p1.show();
    //Person类外部，不能通过其类对象调用私有结构
}
//反射操作可以做的事情
public void test2() throws Exception {
    Class cla = Person.class;
    //1.通过反射创建Person对象
    Constructor cons = cla.getConstructor(String.class, int.class);
    Object obj = cons.newInstance("Tom",12); //可转为Person对象
    System.out.println(obj.toString());
    //2.通过反射，调用指定属性、方法
    Field age = cla.getDeclaredField("age");//属性
    age.set(obj,10);
    Method show = cla.getDeclaredMethod("show");//方法
    show.invoke(obj); //调用操作
    //通过反射，可以调用Person类(运行时类)的私有结构
    //调用私有构造器
    Constructor cons1 = cla.getDeclaredConstructor(String.class);
    cons1.setAccessible(true);
    Person p1 = (Person) cons1.newInstance("Jerry");
    System.out.println(p1); //name = Jerry, age = 0
    //调用私有属性
    Field name = cla.getDeclaredField("name");
    name.setAccessible(true);
    name.set(p1, "Tony");
    //调用私有方法
    Method showNation = cla.getDeclaredMethod("showNation", String.class);
    showNation.setAccessible(true);
    String nation = (String) showNation.invoke(p1,"China"); //获取返回值
}

注：

一般情况下，new的方式和反射方式应该使用哪个？
- 主要采用new方式
反射使用的场景？
- 当编译时不确定需要new哪个类时，可以采用反射的方式。（比如服务器运行时，注册和登录的操作不确定，需要采用反射）
反射与面向对象的封装性是否矛盾？
- 封装性解决了是否建议调用相关结构的问题，反射解决的是是否能够调用相应结构的问题。

2 Class类介绍

类的加载过程：经过javac .exe命令以后，会生成一个或多个字节码文件(.class)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程称为类的加载。加载到内存中的类，就称为运行时类，此运行时类作为Class的一个实例。

加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类（唯一存在）。

获取Class类的四种方式：

前提：若已知具体的类，通过运行时类的 class属性获取，该方法最为安全可靠，程序性能最高
- 实例：Class clazz = String .class;
前提：已知某个类的实例，调用该实例的 getClass()方法获取Class对象
- 实例：Class clazz = "abc".getClass();
前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException（使用频率高）
- 实例：Class clazz = Class.forName(“java.lang.String”);
其他方式（了解）
- ClassLoader cl = this.getClass().getClassLoader();
- Class clazz4 = cl.loadClass(“类的全类名”);

哪些类型可以有Class对象？

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

Class类的常用方法：

15.3 类的加载与ClassLoader的理解

1 类的加载

2 类的加载器

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

补充：采用类加载器读取配置文件

public void test3() throws IOException {
        Properties pros = new Properties();
        //方式一：此时文件默认路径在module下
//        FileInputStream fis = new FileInputStream("src\\com\\java\\test\\jdbc.properties");
//        pros.load(fis);
        //方式二：采用ClassLoader   此时文件默认路径在module的src目录下
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("com/java/test/jdbc.properties");
        pros.load(is);
        String name = pros.getProperty("name");
        String password = pros.getProperty("password");
        System.out.println(name + " " + password);
    }

15.4 创建运行时类的对象

创建运行时类的对象：调用Class对象的newInstance()方法

要求：

类必须有一个无参数的构造器。
类的构造器的访问权限需要足够。

public void test1() throws Exception {
    Class<Person> clazz = Person.class;
    Person person = clazz.newInstance(); //newInstance内部调用了空参构造器
    System.out.println(person);
}

注：没有无参的构造器也能创建运行时类对象，只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。

通过一个实例体会反射的动态性

public void test2(){
    int num = new Random().nextInt(3);
    String classPath = "";
    switch (num){
        case 0:
            classPath = "java.util.Date";
            break;
        case 1:
            classPath = "java.lang.Object";
            break;
        case 2:
            classPath = "com.java.clas.Person";
            break;
    }
    try{
        Class clazz = Class.forName(classPath);
        Object obj = clazz.newInstance();
        System.out.println(obj);
    }catch (Exception e){
        e.getMessage();
    }
}

15.5 获取运行时类的完整结构（了解）

1 实现的全部接口

public Class<?>[] getInterfaces()---> 确定此对象所表示的类或接口实现的接口。

2 所继承的父类

public Class<? Super T> getSuperclass()---> 返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的 Class。

3 全部的构造器

public Constructor<T>[] getConstructors()---> 返回此 Class 对象所表示的类的所有public构造方法。
public Constructor<T>[] getDeclaredConstructors()---> 返回此 Class 对象表示的类声明的所有构造方法。
Constructor类中：
- public int getModifiers() --->取得修饰符
- public String getName()--->取得方法名称
- public Class<?>[] getParameterTypes()--->取得参数的类型

4 全部的方法

public Method[] getDeclaredMethods()---> 返回此Class对象所表示的类或接口的全部方法
public Method[] getMethods()---> 返回此Class对象所表示的类或接口的public的方法
Method类中：
- public Class<?> getReturnType()--->取得全部的返回值
- public Class<?>[] getParameterTypes()--->取得全部的参数
- public int getModifiers()--->取得修饰符
- public Class<?>[] getExceptionTypes()--->取得异常信息

5 全部的Field

public Field[] getFields()---> 返回此Class对象所表示的类或接口的public的Field。
public Field[] getDeclaredFields()---> 返回此Class对象所表示的类或接口的全部Field。
Field方法中：
- public int getModifiers() --->以整数形式返回此Field的修饰符
- public Class<?> getType()---> 得到Field的属性类型
- public String getName() --->返回Field的名称。

6 Annotation相关

get Annotation(Class<T> annotationClass)
getDeclaredAnnotations()

7 泛型相关

Type getGenericSuperclass()--->获取父类泛型类型
ParameterizedType--->泛型类型
getActualTypeArguments()--->获取实际的泛型类型参数数组

8 类所在的包

Package getPackage()

15.6 调用运行时类的指定结构

1 调用指定属性

//调用运行时类的指定结构--->属性
public void test() throws Exception {
    Class<Person> clazz = Person.class;
    //创建运行时类对象
    Person p = clazz.newInstance();
    //获取指定属性
    Field age = clazz.getDeclaredField("age");
    //保证当前属性是可访问的
    age.setAccessible(true);
    //设置当前属性值
    age.set(p,10); //set(哪个对象的属性, 设置值)
    //获取当前属性值
    int ageValue = (int)age.get(p);
    System.out.println(ageValue);
}

2 调用指定方法

//调用运行时类的指定结构--->方法
public void test5() throws Exception {
    Class<Person> clazz = Person.class;
    //创建运行时类对象
    Person p = clazz.newInstance();
    //获取指定方法
    Method showNation = clazz.getDeclaredMethod("showNation", String.class);
    //保证当前属性是可访问的
    showNation.setAccessible(true);
    //调用invoke()执行方法
    Object nation = showNation.invoke(p, "China");
    //调用静态方法
    Method show = clazz.getDeclaredMethod("show");
    show.setAccessible(true);
    show.invoke(null);  //参数可以直接写null,不需要指定对象
}

3 调用指定构造器（了解）

//调用运行时类的指定结构--->构造器
public void test6() throws Exception {
    Class<Person> clazz = Person.class;
    //获取指定构造器
    Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class,int.class);
    //保证构造器是可访问的
    constructor.setAccessible(true);
    //调用构造器创建运行时类的对象
    Person p = constructor.newInstance("Tom", 10);
    System.out.println(p);
}

15.7 反射的应用：动态代理

1 代理设计模式的原理

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
动态代理使用场合：调试、远程方法调用
动态代理相比于静态代理的优点：抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

例子：

静态代理：代理类和被代理类在编译期间就确定下来了

interface  ClothFactory{
    void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{
    private ClothFactory factory; //用被代理类对象进行实例化
    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }
    public void produceCloth() {
        System.out.println("代理一些准备工作");
        factory.produceCloth();
    }
}
//被代理类
class nikeClothFactory implements ClothFactory{
    public void produceCloth() {
        System.out.println("生产Nike衣服");
    }
}
public class StaticProxy {
    public static void main(String[] args) {
        //创建被代理类对象
        nikeClothFactory nike = new nikeClothFactory();
        //创建代理类对象
        ProxyClothFactory p = new ProxyClothFactory(nike);
        p.produceCloth();
    }
}

动态代理

//被代理类：nikeClothFactory
//代理工厂:专门生产代理类
class ProxyFactory {
    //调用此方法，返回一个代理类对象
    public static Object getProxyInstance(Object obj){//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;
    }
    //当通过代理类对象调用方法时，会自动调用此方法
    //proxy：代理类对象 method:调用的方法 args：方法参数
    //将被代理类要执行的方法的功能，声明在invoke()中
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method:代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        Object returnValue = method.invoke(obj, args);
        return returnValue;
    }
}
public class ProxyTest {
    public static void main(String[] args) {
        //创建被代理类对象
        nikeClothFactory nike = new nikeClothFactory();
        //创建代理类对象
        ClothFactory proxyInstance = (ClothFactory) ProxyFactory.getProxyInstance(nike);
        //当通过代理类对象调用方法时，会自动调用被代理类中同名的方法
        proxyInstance.produceCloth();
    }
}

2 AOP

AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理

举例：在上述动态代理基础上做改进

class Util{ //加入一些通用方法
    public void method1(){
        System.out.println("=====通用方法一=====");
    }
    public void method2(){
        System.out.println("=====通用方法二=====");
    }
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    Util u = new Util();
    u.method1();
    //method:代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
    Object returnValue = method.invoke(obj, args);
    u.method2();
    return returnValue;
}