反射(Reflection)

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

反射机制提供的功能

  • 在运行时访问任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时访问任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时处理注解
  • 生成动态代理
/**
 * @author Xie Chenxi
 * @date 2020-03-20 13:39
 */
public class ReflectTest {


    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {

        Class<Person> clazz = Person.class;

        // 1.通过反射,创建类的对象
        Constructor<Person> constructor = clazz.getConstructor(int.class, String.class);
        Person p = constructor.newInstance(18, "CHANGEX");
        System.out.println(p);

        // 2.通过反射调用对象指定的属性和方法
        Field age = clazz.getDeclaredField("age");
        // 访问私有属性和方法
        age.setAccessible(true);
        age.set(p, 20);
        System.out.println(p.getAge());

        // 3.通过反射调用对象的指定方法
        Method eat = clazz.getDeclaredMethod("eat", String.class);
        // 调用私有方法
        eat.setAccessible(true);
        eat.invoke(p, "APPLE");
    }
}

@Data
@AllArgsConstructor
@ToString
class Person {

    private int age;
    private String name;

    public void eat(String food) {
        System.out.println(name + "在吃" + food);
    }
}

反射机制与面向对象中的封装性是不是矛盾的?如何看待两个技术?

  • 不矛盾。封装强调的是一种规范和建议。反射强调的是动态性

关于java.lang.Class类的理解

  • 类的加载过程
    • 程序经过javac.exe命令以后,会生成一个或多个字节码文件(.class结尾),接着使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程称为类的加载。加载到内存中的类,我们就成为运行时类,此运行时类,就作为Class的一个实例。
  • 换句话说,Class的实例就对应着一个运行时类。
  • 加载到内存中的运行时类,会缓存一定的时间。再次时间之内,我们可以通过不同的方式来获取此运行时类。
  • 获取Class实例的4种方式
    • 	public void test() {
      
      		// 方式一:调用运行时类的属性
      		Class<Person> clazz = Person.class;
      		System.out.println(clazz);
      
      		// 方式二:通过运行时类的对象
      		Person p1 = new Person();
      		Class clazz1 = p1.getClass();
      		System.out.println(clazz1);
      
      		//方式三:通过Class的静态方法
      		Class clazz3 = Class.forName("java.lang.String");
      		System.out.println(clazz3);
      
      		//方式四:使用类的加载器 ClassLoader
      		ClassLoader classLoader = Person.class.getClassLoder();
      		Class clazz4 = classLoader.loadClass("java.lang.String");
      		System.out.println(clazz4);
      
      	}
      
    
    

### 哪些类型可以有Class对象?

  • 所有class
  • interface
  • 数组
  • 枚举
  • annotation
  • primitive type:基本数据类型
  • void

类的加载过程

  • 当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过如下三个步骤来对该类进行初始化
  • 类的加载(Load)
    • 将类的class文件读入内存,并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器的参与
  • 类的链接(Link)
    • 验证:确保加载的类信息符合JVM规范,例如:以cafe开头,没有安全方面的问题
    • 准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段,这些内存都将在方法区中进行分配
    • 解析:虚拟机常量池内的符号引用替换为直接引用的过程
  • 类的初始化(Initialize)
    • 执行类构造器()方法的过程。类构造器()方法是由编译器自动手机类中所有变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的,不是构造该类对象的构造器)
    • 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化
    • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步

类加载器的作用

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

类加载器的类型

  • 引导类加载器,用于加载Java核心类库,无法直接获取
  • 扩展类加载器,加载拓展类库
  • 系统类加载器,自定义类使用该加载器进行加载,通过调用该加载器的父类,可以获得扩展类加载器
    动态代理

代理设计模式的原理

  • 使用一个代理对象将对象包装起来,然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及合适将方法调用转到原始对象上。
  • 静态代理特征是代理类和目标对象的类都是在编译期间确定下来,不利于程序的扩展,同时每一个代理类只能为一个接口服务,这样依赖程序开发中必然产生过多的代理类。最好可以通过一个代理类完成全部的代理功能。
  • 动态代理可以在程序运行是创建代理类,扩展性更好。
/**
 * @author Xie Chenxi
 * @date 2020-03-20 15:24
 */
public class ProxyTest {
}

/**
 * 代理类与被代理类的公共接口
 */
interface Human {

    void eat();

    String sleep();
}

/**
 * 被代理类
 */
class SuperMan implements Human {

    @Override
    public void eat() {
        System.out.println("~~吃饭");
    }

    @Override
    public String sleep() {

        return "~~~~~~睡觉";
    }
}

/**
 * 增强类
 */
class CustomerInvokeHandler implements InvocationHandler {

    /**
     * 增强类需要持有被代理类对象
     */
    private Object obj;

    public CustomerInvokeHandler(Object obj) {

        this.obj = obj;
    }

    /**
     * 增强方法
     *
     * @param proxy  代理对象
     * @param method 执行方法
     * @param args   方法参数
     * @return 返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 前置增强
        System.out.println("前置增强~");
        // 调用被代理类的方法,获取返回值
        Object returnValue = method.invoke(obj, args);

        // 后置增强
        System.out.println("后置增强~");

        return returnValue;
    }
}

class HumanFactory {

    /**
     * @param obj 被代理对象
     * @return
     */
    public static Object getProxyInstance(Object obj) {

        CustomerInvokeHandler handler = new CustomerInvokeHandler(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
    }
}

class Test {
    public static void main(String[] args) {

        Human human = (Human) HumanFactory.getProxyInstance(new SuperMan());
        human.eat();
        System.out.println(human.sleep());
    }
}