java 反射

1、什么是反射

​ Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

2、反射的应用场景

• 运行时动态根据配置动态创建对象，实现解耦（spring中比较多）
• 动态代理
• 动态修复一些三方jar的实现。（javassist asm）
• jdbc数据库连接

3、反射中的关键对象

4、class类

4.1、获得类相关的方法

4.2、获取类属性的方法

4.3、获得类中注解相关的方法

4.4、获得类中构造器相关的方法

4.5、获得类中方法相关的方法

4. 6、其它重要方法

5、Field类

成员变量（属性）操作相关的类

6、Method类

方法操作相关的类

7、Constructor类

8、代码示例

8.1、示例操作类

package com.whw.domain;

public class Customer {
    private Integer num;
    private String name;
    private String sex;
    private Integer age;
    private String addr;
    private Integer tel;

    public Customer(){

    }

    public Customer(Integer num, String name) {
        this.num = num;
        this.name = name;
    }

    public Customer(Integer num, String name, String sex, Integer age) {
        this.num = num;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public Customer(Integer num, String name, String sex, Integer age, String addr, Integer tel) {
        this.num = num;
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.addr = addr;
        this.tel = tel;
    }

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public Integer getTel() {
        return tel;
    }

    public void setTel(Integer tel) {
        this.tel = tel;
    }
}

8.2、class类的创建

Class类的创建方式常用的有三种：

private static void operationClass() {
    //方式一：通过全类名的形式
    Class c1 = Customer.class;

    //方式一：通过全类名的形式
    Class c2= null;
    try {
        c2 = Class.forName("com.whw.domain.Customer");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }

    //方式三：对象.getClass()
    Class c2=new Customer().getClass();
}

8.3、类相关操作方法

private static void operationClass2() {
        Class c1 = JButton.class;

        //获取类的完整路径名字
        String name = c1.getName();
        System.out.println(name);//javax.swing.JButton

        //获得类的包
        //Package aPackage = c1.getPackage();
        //System.out.println(aPackage);//package javax.swing, Java Platform API Specification, version 1.8
        //获取类的包名
        //System.out.println(aPackage.getName());//javax.swing

        //获取类的名字
        //String simpleName = c1.getSimpleName();
        //System.out.println(simpleName);//JButton

        //获得当前类继承的父类的名字
        //Class superclass = c1.getSuperclass();
        //System.out.println(superclass);//class javax.swing.AbstractButton
    }
3、获取类的所有构造方法
private static void operationClass3() 
    throws IllegalAccessException, InvocationTargetException, InstantiationException {
        /*Class c1 = Customer.class;
        Constructor[] constructors = c1.getConstructors();
        for (Constructor constructor : constructors) {
            int count = constructor.getParameterCount();
            System.out.println("构造函数：" + constructor.getName() + "，参数个数：" + count);
        }*/
        //构造函数：com.whw.domain.Customer，参数个数：6
    //构造函数：com.whw.domain.Customer，参数个数：4
    //构造函数：com.whw.domain.Customer，参数个数：2
    //构造函数：com.whw.domain.Customer，参数个数：0


        //直接创建对象
        //Class c1 = Customer.class;
        //Customer customer = (Customer)c1.newInstance();
        //customer.setName("王伟");
        //System.out.println(customer.getName());//王伟


        //通过构造器构造对象
        //Class c1 = Customer.class;
        //Customer customer = (Customer)c1.getConstructors()[2].newInstance(1,"王伟");
        //System.out.println(customer.getName());//王伟
    }

8.4、操作Filed

private static void operationClass4() 
    throws NoSuchFieldException, IllegalAccessException, InstantiationException {
        Class c1 = Customer.class;
        //获取所有公有public属性
        /*Field[] fields = c1.getFields();
        for (Field field:fields){
            System.out.println(field.getName());
        }*/

        //获取所有属性
        /*Field[] fields = c1.getDeclaredFields();
        for (Field field:fields){
            System.out.println("字段名："+field.getName()+",访问修饰符："+ Modifier.toString(field.getModifiers()));
        }*/
        //num
        //name
        //sex
        //age
        //addr
        //tel

        //获取指定属性,并设置值
        Customer customer= (Customer) c1.newInstance();
        Field field=c1.getDeclaredField("name");//获取姓名属性
        field.setAccessible(true);//设置可操作私有字段属性
        field.set(customer,"王伟");
        System.out.println(customer.getName());
}

8.5、操作方法

private static void operationClass5() {
        Class c1 = Customer.class;
        Method[] methods = c1.getMethods();
        for (Method method : methods) {
            System.out.println(
                "方法名：" + method.getName() + 
                ",参数个数：" + method.getParameterCount()+
                "，返回值类型："+method.getGenericReturnType());
            Class<?>[] parameterTypes = method.getParameterTypes();
            for (Class parameterType : parameterTypes) {
                System.out.println(parameterType.getName());//获取参数类型
         }
     }
}

9、反射的优劣势

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