Java反射详解

一，类的加载概述和加载时机　

1.1.1，类的加载概述:

　　 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。　

• 加载
  • 　就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
• 连接
  • 　验证 是否有正确的内部结构，并和其他类协调一致
  • 　准备 负责为类的静态成员分配内存，并设置默认初始化值
  • 　解析 将类的二进制数据中的符号引用替换为直接引用
• 初始化
  • 　就是我们以前讲过的初始化步骤　

1.1.2，加载时机:

• 创建类的实例
  • 访问类的静态变量，或者为静态变量赋值
  • 调用类的静态方法
  • 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
  • 初始化某个类的子类
  • 直接使用java.exe命令来运行某个主类

1.2.1，类加载器的概述和分类:

• A.类加载器的概述:
  • 　　负责将.class文件加载到内存中，并为之生成对应的Class对象。虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。　
• B.类加载器的分类:
  • 　　Bootstrap ClassLoader 根类加载器
  • 　　Extension ClassLoader 扩展类加载器
  • 　　Sysetm ClassLoader 系统类加载器
• C.类加载器的作用:
  • 　　Bootstrap ClassLoader 根类加载器
  • 　　也被称为引导类加载器，负责Java核心类的加载
  • 　　比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
  • 　　Extension ClassLoader 扩展类加载器
  • 　　负责JRE的扩展目录中jar包的加载。
  • 　　在JDK中JRE的lib目录下ext目录
  • 　　Sysetm ClassLoader 系统类加载器
  • 　　负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

二，什么是反射?

1.3.1，反射的概述：

　　 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
　　 对于任意一个对象，都能够调用它的任意一个方法和属性；
　　 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
　　 要想解剖一个类,必须先要获取到该类的字节码文件对象。
　　 而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

1.3.2，解剖获取字节码对象的三种方式：

1. Object类的getClass()方法,判断两个对象是否是同一个字节码文件
2. 静态属性class,锁对象
3. Class类中静态方法forName(),读取配置文件

package com.bgs.reflect;
import com.bgs.pojo.Person;
public class ExampleReflect_day01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //第一种方式通过Class类中静态方法forName(),读取配置文件
        Class<?> clazz1 = Class.forName("com.bgs.pojo.Person");
        //静态属性class,锁对象
        Class clazz2 = Person.class;
        //第三种方式直接new对象通过对象.class来获取对象
        Person person = new Person();
        Class class3 = person.getClass();
        //对比三个字节码对象是否一样
        System.out.println(clazz1 == clazz2);
        System.out.println(class3 == clazz2);
    }
}

执行结果:true，true（说明这三种获取字节码对象的方式获取的都是同一个字节码对象，所以我们可以选择其中一个使用.forName比较常用）

三，反射各种函数的使用：

1.4.1，通过反射获取带参构造方法并使用:

　　Class类的newInstance()方法是使用该类无参的构造函数创建对象, 如果一个类没有无参的构造函数, 就不能这样创建了,可以调用Class类的getConstructor(String.class,int.class)方法获取一个指定的构造函数然后再调用Constructor类的newInstance("张三",20)方法创建对象

先创建一个实体类Person

package com.bgs.pojo;

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

    public Person(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())    //判断调用对象和传入对象的字节码文件是否是同一个字节码文件
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }
    public void eat() {
        System.out.println("Suppose one day you're gone");
    }
    public void eat(int num) {
        System.out.println("So does this world still have the meaning that I exist?"+num);
        
    }
}

然后在创建一个测试类，去或者实体类中的私有属性，并且为其赋值(没有通过封装的get，set方法就为其加上了属性是不是很好奇)

package com.bgs.reflect;

import java.lang.reflect.Constructor;

import com.bgs.pojo.Person;

public class ExampleReflect_day03 {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.bgs.pojo.Person的字节码对象
//        Person p = (Person) clazz.newInstance(); //通过无参构造创建对象(调用newInstance的方笔必须要有默认参数)假如没有则会报异常
//        System.out.println(p);
        Constructor<?> constructor = clazz.getConstructor(int.class,String.class);//获取有参构造
        Person person = (Person) constructor.newInstance(23,"张三");    //通过有参构造创建对象
        System.out.println(person);    //执行结果为:Person [age=23, name=张三]
    }　　　　　　
}

1.4.2，通过反射获取成员变量并使用：

ackage com.bgs.reflect;

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

import com.bgs.pojo.Person;

/**
 * @author Administrator Field 
 *             Class.getField(String)方法可以获取类中的指定字段(可见的),
 *         如果是私有的可以用getDeclaedField("name")方法获取,通过set(obj,
 *         "李四")方法可以设置指定对象上该字段的值,
 *         如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)
 *         可以获取指定对象中该字段的值
 * 
 */
public class ExampleReflect_day04 {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.bgs.pojo.Person的字节码对象
        Constructor<?> constructor = clazz.getConstructor(int.class,String.class);//获取有参构造
        Person person = (Person) constructor.newInstance(23,"张三");    //通过有参构造创建对象
//        Field f = clazz.getField("name");    //反射获取姓名字段
//        f.set(person, "姜煜");//对姓名字段进行修改    //异常: Class com.example.reflect.ExampleReflect_day04 can not access a member of class com.example.reflect.Person with modifiers "private"
        Field f = clazz.getDeclaredField("name");    //暴力反射获取姓名字段
        f.setAccessible(true);    //去除私有权限
        f.set(person, "姜煜");
        System.out.println(person);　　
    }
}

执行结果为:Person [age=23, name=姜煜]　　原本用反射给这个对象的私有属性赋值赋的是23，张三，然后用暴力反射去给对象把name的属性李四换成姜煜

1.4.3，通过反射获取方法并使用

　　Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String, Class...)方法可以获取类中的指定方法,调用invoke(Object, Object...)可以调用该方法,Class.getMethod("eat") invoke(obj) 　　　　　　　　Class.getMethod("eat",int.class) invoke(obj,10)

package com.bgs.reflect;

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

import com.bgs.pojo.Person;

public class ExampleReflect_day05 {
    public static void main(String[] args) throws Exception {
        Class<?> clazz = Class.forName("com.bgs.pojo.Person");//获取包为com.example.reflect.Person的字节码对象
        Constructor<?> constructor = clazz.getConstructor(int.class, String.class);// 获取有参构造
        Person person = (Person) constructor.newInstance(23, "张三"); // 通过有参构造创建对象
        
        Method m = clazz.getMethod("eat"); //获取etc方法
        m.invoke(person);
        
        Method m2 = clazz.getMethod("eat", int.class);//获取有参的eat方法
        m2.invoke(person, 10);
    }
}

执行结果:Suppose one day you're gone　　So does this world still have the meaning that I exist?10 ，可能有的小白不知道为什么执行这个，因为我再实体类中添加的有这个eat方法

1.4.4，通过反射越过泛型检查:

　　案例演示：
　　　　ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据，如何实现呢？

package com.bgs.reflect;

import java.lang.reflect.Method;
import java.sql.Array;
import java.util.ArrayList;

/**
 *         泛型只在编译器有效,在运行期会被擦除掉
 */
public class ExampleReflect_day06 {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(111);
        list.add(222);
        Class<?> clazz = Class.forName("java.util.ArrayList");    //获取到字节码对象
        Method m = clazz.getMethod("add", Object.class);    //获取add方法
        m.invoke(list, "abc");
        System.out.println(list);
    }
}

执行结果：[111, 222, abc] 是不是感觉反射特别神奇，竟然连集合的泛型都能无视

1.4.5，动态代理的概述和实现:

　　动态代理概述
　　　　代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。
　　　　举例：春节回家买票让人代买
　　　　动态代理：在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

　　通过代理的过程:
　　　　在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。
　　　　我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象
　　　　public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
　　　　最终会调用InvocationHandler的方法
　　　　InvocationHandler Object invoke(Object proxy,Method method,Object[] args)

　　代码实现:

　　　　1.先创建一个接口类Student　

package com.bgs.动态代理;

public interface Student {
    public void login();
    
    public void submit();
}

　　　　2.再创建一个类去实现Student接口

package com.bgs.动态代理;

public class StudentImp implements Student{

    @Override
    public void login() {
    //    System.out.println("校验管理功能");
        System.out.println("登陆");
    //    System.out.println("日志管理功能");
        
    }

    @Override
    public void submit() {
    //    System.out.println("校验管理功能");
        System.out.println("提交");
    //    System.out.println("日志管理功能");
    }
    
}

 假如实现类中我们要加一个校验信息功能，和日志管理功能，我们要在每个实现功能的上面去添加校验管理功能，那个的下面添加日志管理功能，现在才两个功能还好，假如以后代码功能多了我们这样会造成代码耦合度高，代码复用性低，会造成程序执行缓慢，因为都是重复代码（这就是我们为什么要用动态代理的原因）

　　　　3.再创建一个动态代理类，去实现InvocationHandler接口实现invoke方法

package com.bgs.动态代理;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
    private Object target;
    
    public  MyInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("校验管理功能");
        method.invoke(target, args);    //执行被代理target对象的方法
        System.out.println("日志管理功能");
        return null;
    }
}

　　　　4.创建一个测试类,

package com.bgs.动态代理;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;



public class Test {
    public static void main(String[] args) {
        UserImp uImp = new UserImp();
        uImp.add();
        uImp.delete();
        System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        MyInvocationHandler m = new MyInvocationHandler(uImp);
        ////参数第一个是传的固定的 第二个参数也是固定的 第三个参数传的事MyInvocationHandler的子类对象
        User user = (User) Proxy.newProxyInstance(uImp.getClass().getClassLoader(), uImp.getClass().getInterfaces(), m);
        user.add();
        user.delete();
    }
}

执行结果:

　　　

四，反射总结:

　　灵活使用反射能让我们代码更加灵活，这里比如JDBC原生代码注册驱动，hibernate 的实体类，Spring 的 AOP等等都有反射的实现。但是凡事都有两面性，反射也会消耗系统的性能，增加复杂性等，合理使用才是真！