真的懂反射了吗？

引言

new 和反射 都可以创建对象，那么为什么要？什么区别？
那么在什么时候会用反射，那么就要思考反射的特性：动态性（也就是在编译的时候，确定不下来要用哪一个对象）

反射的定义

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

反射的原理

要想理解反射的原理，首先要明白正常的类加载的过程

正常的加载和反射
new: 静态编译，在编译期就将模块编译进来，执行该字节码文件，所有的模块都被加载；

反射：动态编译，编译期没有加载，等到模块被调用时才加载；

而 反编译：.class —> .java

Class 类对象获取方式

• Class 类是用来描述类的
  比如说有一个Person类，一个Order类，一个Book类，这些都是不同的类，现在需要一个类，用来描述类，这就是Class，它应该有类名，属性，方法，构造器等。
• Class 对象只能由系统建立对象，一个类（而不是一个对象）在 JVM 中只会有一个Class实例

既然已经知道了，对于任意一个类来说，都有一个唯一的Class 类实例，这个对象里面包含了对应类的名称
、方法、属性、构造器等类的信息，那么如何可以获取到一个类的class 对象

获取class对象的三种方式
通过new对象实现反射机制 获取class类对象
通过类名.Class 获取class 类对象
通过全限定名获取 包名+类名获取

//通过new对象实现反射机制  获取class类对象
        Person person = new Person();
        Class<?> clazz = person.getClass();

        //通过类名获取class 类对象
        Class<?> clazz2 = Person.class;

        //通过全限定名获取 包名+类名获取
        Class<?> clazz3 = Class.forName("Person");

观察反射以及class 类

构造一个Person类

import java.util.Date;

public class Person {
    private String username;

    private int age;

    private Date birthDay;

    public String nick;

    public String sex;
    public Person(String username){
        this.username = username;
    }
    public Person(){
    }
    public Person(String username, int age){
        this.username = username;
        this.age = age;
    }

    public String getNick() {
        return nick;
    }

    public void setNick(String nick) {
        this.nick = nick;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Date getBirthDay() {
        return birthDay;
    }

    public void setBirthDay(Date birthDay) {
        this.birthDay = birthDay;
    }


    private void sayHello(){
        System.out.println("person sayHello ---");
    }

    public void workIng(){
        System.out.println("person work ing ---");
    }

    @Override
    public String toString() {
        return "Person{" +
                "username='" + username + '\'' +
                ", age=" + age +
                ", birthDay=" + birthDay +
                ", nick='" + nick + '\'' +
                '}';
    }



}

通过反射获取的class对象来调用对应的class 方法

• getFields()：获得类的public类型的属性

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class reflect {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        Person person = new Person();
        Class<?> clazz = person.getClass();
        //获取类的名字
        System.out.println(clazz.getName());

        //获取类的所有属性 不论是否是public 修饰
        Field[] declaredFields = clazz.getDeclaredFields();
        //获取类中的public属性
        Field[] fields = clazz.getFields();

        System.out.println("=============");

        //获取类的所有方法
        Method[] declaredMethods = clazz.getDeclaredMethods();
       //获取类的public方法
        Method[] methods = clazz.getMethods();
        //获取指定名字的方法，指定的名字的方法可能会抛出NoSuchMethodException
        Method method = clazz.getMethod("setUsername", String.class);




        //获取类的 所有public 构造器
        Constructor<?>[] constructors = clazz.getConstructors();
        //获取类的特定构造器 需要定义构造器的参数列表
        Class[] cl = {String.class};
        Constructor<?> constructor1 = clazz.getConstructor(cl);

        //通过class 类的构造方法创建一个类对象 默认是Object类型的
        Person personNew = (Person) clazz.newInstance();
        //也可以同时使用构造器的方式
        Person person2 =(Person) constructors[0].newInstance("pine",1);

    }
}

class 常用的一些方法

getName()：获得类的完整名字。

getFields()：获得类的public类型的属性。

getDeclaredFields()：获得类的所有属性。包括private 声明的和继承类

getMethods()：获得类的public类型的方法。

getDeclaredMethods()：获得类的所有方法。包括private 声明的和继承类

getMethod(String name, Class[]
parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。

getConstructors()：获得类的public类型的构造方法。

getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes
参数指定构造方法的参数类型。

newInstance()：通过类的构造方法创建这个类的一个对象。

反射的优缺点

• 优点： 运行期类型的判断，动态加载类，提高代码灵活度。
• 缺点： 性能瓶颈：反射相当于一系列解释操作，通知 JVM 要做的事情，性能比直接的java代码要慢很多。

反射的场景使用

反射是框架设计的灵魂。
例如模块化的开发，通过反射去调用对应的字节码；
动态代理设计模式也采用了反射机制，还有我们日常使用的 Spring／Hibernate 等框架也大量使用到了反射机制。

• Spring 动态代理
  举例：
  ①我们在使用JDBC连接数据库时使用Class.forName()通过反射加载数据库的驱动程序；

  ②Spring框架也用到很多反射机制，最经典的就是xml的配置模式。
  Spring 通过 XML 配置模式装载 Bean 的过程：
  1) 将程序内所有 XML 或 Properties 配置文件加载入内存中;
  2)Java类里面解析xml或properties里面的内容，得到对应实体类的字节码字符串以及相关的属性信息;
  3)使用反射机制，根据这个字符串获得某个类的Class实例; 4)动态配置实例的属性

• 还有例如前后端的交互的时候，服务器跑起来，代码运行起来。
  前端如果去请求访问login 的时候才创建对象，请求访问rigister，才去造对应的对象。这就用到了反射。