反射和动态代理之Java学习总结

反射和动态代理

类型信息
运行时类型信息使得你可以在程序运行时发现和使用类型信息，它在运行时是通过Class对象表示的，为了生成这个类对象，JVM将使用“类加载器”子系统，当程序创建第一个对类的静态成员的引用时，就会加载这个类。类加载器首先会检查这个类的Class对象是否已经加载。如果尚未加载，默认的类加载器就会根据类名查找.class文件。

获取Class对象的方式
1，根据带包名的类名获取Class对象的引用：Class.forName("className")
2，获取已有对象的Class对象的引用：对象.getClass()
3，使用类字面常量获取Class对象的引用：类字面常量.class，类字面常量可以应用于类、接口、数组

类型检查
1，instanceof关键字
2，动态类型的Class.isInstance()
代码示例如下:

class Base {
}

class Derived extends Base {
}

public class FamilyVsExactType {
    public static void main(String[] args) {
        Base base = new Base();
        Base derived = new Derived();
        System.out.println("base instanceof Base: " + (base instanceof Base));
        System.out.println("derived instanceof Base: "  + (derived instanceof Base));
        System.out.println("Base.class.isInstance(base): " + Base.class.isInstance(base));
        System.out.println("Base.class.isInstance(derived): " + Base.class.isInstance(derived));
    }
}

反射
Class类与java.lang.reflect类库一起对反射的概念进行了支持，该类库包含了Field、Method以及Constructor类。在使用反射之前必须先加载该类的Class对象

RTTI和反射的区别
RTTI：编译器在编译时打开和检查.class文件
反射：在运行时打开和检查.class文件

动态代理
代理：它是你为了提供额外的或不同的操作，而插入的用来代替“实际”对象的对象。这些操作通常涉及与“实际”对象的通信，因此代理通常充当着中间人的角色。
Java动态代理：它可以动态地创建代理并动态地处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上，它的工作是提示调用的类型并确定相应的对策。
动态代理示例如下：

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

interface Interface {
    void doSomething();

    void somethingElse(String arg);
}

class RealObject implements Interface {
    public void doSomething() {
        System.out.println("doSomething");
    }

    public void somethingElse(String arg) {
        System.out.println("somethingElse " + arg);
    }
}

class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;

    public DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("*** proxy: " + proxy.getClass() + ", method: "
                + method + ", args: " + args);
        if (args != null) {
            for (Object arg : args) {
                System.out.println("  " + arg);
            }
        }
        return method.invoke(proxied, args);
    }
}

public class SimpleDynamicProxy {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }

    public static void main(String[] args) {
        RealObject real = new RealObject();
        consumer(real);

        // 创建代理
        Interface proxy = (Interface) Proxy.newProxyInstance(
                Interface.class.getClassLoader(),
                new Class[] { Interface.class }, new DynamicProxyHandler(real));
        
        // 调用
        consumer(proxy);
    }
}

通过调用静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要得到一个类加载器，一个你希望该代理实现的接口列表(不是类或抽象类)，以及IvocationHandler接口的一个实现。动态代理可以将所有调用重定向到调用处理器，因此通常会向调用处理器的构造器传递给一个“实际”对象的引用，从而使用调用处理器在执行其中介任务时，可以将请求转发。