JAVA反射笔记

JAVA反射机制

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

获取Class 类的实例( 四种方法)

1） 前提：若已知具体的类，通过类的class属性获取，该方法最为安全可靠，
程序性能最高
实例：Class clazz = String.class;
2） 前提：已知某个类的实例，调用该实例的getClass()方法获取Class对象
实例：Class clazz = “www.atguigu.com”.getClass();
3） 前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方
法forName()获取，可能抛出 ClassNotFoundException
实例：Class clazz = Class.forName(“java.lang.String”);
此种方法比较常见
4）其他方式(不做要求)
ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”);*
注：获取方式不同，但获取的运行时类都是同一个

反射的应用举例

• String str = “test4.Person”;
• Class clazz = Class.forName(str);
• Object obj = clazz.newInstance();
• Field field = clazz.getField(“name”);
• field.set(obj, “Peter”);
• Object name = field.get(obj);
• System.out.println(name);
注：test4.Person是test4包下的Person类

java.lang.Class类的理解

1.加载过程
程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class)，再使用java.exe命令对某个字节码文件进行解释运行 相当于将某个字节码文件加载到内存中，此过程就称为类的加载。加载到内存中的类称为运行时类，此运行时类就作为Class的一个实例
可以通过类造对象，而类本身也是Class的对象

类的加载与ClassLoaderd的理解

类的加载过程：
1.类的加载(Load)：将类的class字节码文件通过java.exe读入内存，并为之创建一个java.lang.Class对象。此过程由类加载
器完成
2.类的链接(Link)：将类的二进制数据合并到JRE中
3.类的初始化(Initialize)：JVM负责对类进行初始化

类加载器的作用：

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

创建运行时类的对象

创建 类的对象：调用Class对象的newInstance()方法
要求：
1）类必须有一个无参数的构造器。
2）类的构造器的访问权限需要足够(大于private)。

在javabean中要求调用一个空参构造器，原因：
1.便于通过反射，创建运行时类的对象
2.便于子类继承此运行时类时，默认调用super()时保证父类有此构造器

获取运行时类的完整结构

以获取全部属性Field为例：
Class clazz = Person.class;

• public Field[] getFields()
  返回此Class对象所表示的类或接口及其所有父类的public的Field。
• public Field[] getDeclaredFields()
  返回此Class对象所表示的类或接口的全部Field，不包含父类的Field。

调用运行时类的属性结构

Class clazz = Person.class;
Person p = clazz.newInstance();
Field Fieldname = clazz.getDeclaredField(“Fieldname”);
//如果属性是private的
Fieldname.setAccessable(true);
Fieldname.invoke(p,args…);

反射的应用：动态代理

静态代理，特征是代理类和目标
对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代
理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。 最
好可以通过一个代理类完成全部的代理功能。

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时
根据需要动态创建目标类的代理对象。
动态代理相比于静态代理的优点：
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中
处理，这样，我们可以更加灵活和统一的处理众多的方法。

动态代理步骤

/**
 * 动态代理举例：
 *
 *
 * @author yellowfish
 * @create 2020-12-07-14:49
 */
interface Human{
    String getBelief();
    void eat(String food);

}
//被代理类
class SuperMan implements Human{
    @Override
    public String getBelief() {
        return "I believe I can fly";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃"+food);
    }
}
/*
要想实现动态代理所需解决的问题：
问题一：如何根据加载到内存的被代理类，动态的创建一个代理类及其对象
问题二：当通过代理类的对象调用方法时，如何动态的调用被代理类的同名方法
 */

//代理工厂：为被代理类提供普适的代理方式
class ProxyFactory {
    //调用此方法返回一个代理类的对象,解决问题一
    public static Object getProxyInstance(Object obj) {//obj:被代理类的对象
        MyInvocationHandler handler = new MyInvocationHandler();
        handler.bind(obj);
        //Proxy.newProxyInstance()：三个参数：被代理类的类加载器 被代理类实现的接口
        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;
    }
        //当我们通过代理类的对象，调用方法a时，就会自动调用如下方法：invoke()
    //将被代理类a方法要执行的功能声明在invoke中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //method即为代理类对象调用的方法，此方法也就作为了被代理类对象调用的方法
        Object invoke = method.invoke(obj,args);
        return invoke;
    }
}


public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //proxyInstance:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        String belief = proxyInstance.getBelief();
        System.out.println(belief);
        proxyInstance.eat("快餐");