java 反射

通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。一般程序中对象的类型都是在编译期就确定下来的，而 Java 反射机制可以动态地创建对象并调用其属性，这样的对象的类型是编译期未知的。

作用

• 创建一个类的对象
• 判断一个对象所属的类
• 判断一个类所具有的成员变量和方法
• 调用一个对象的任意方法

反射最重要的用途就是开发各种通用框架。很多框架（比如 Spring）都是配置化的（比如通过 XML 文件配置 Bean），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射，运行时动态加载需要加载的对象。

获取class类型

Class.forName静态方法

public final class Class<T> .... {
	@CallerSensitive
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }
    ....
}

比如在JDBC开发中常用此方法加载数据库驱动：Class.forName(driver);

使用类对象的getClass()方法

`StringBuilder str = new StringBuilder("123");Class<?> klass = str.getClass();`

直接获取某一个对象的 class

Class<?> klass = int.class;
Class<?> classInt = Integer.TYPE;

创建对象

Class对象的newInstance()方法

Class<?> c = String.class;
Object str = c.newInstance();

通过类对象的getConstructor()或getDeclaredConstructor()方法获得构造器对象，然后调用其newInstance()方法创建对象。

//获取String所对应的Class对象
Class<?> c = String.class;
//获取String类带一个String参数的构造器
Constructor constructor = c.getConstructor(String.class);
//根据构造器创建实例
Object obj = constructor.newInstance("23333");
System.out.println(obj);

这种方法可以用指定的构造器构造类的实例。

判断对象实例类型

instanceof

isInstance

public native boolean isInstance(Object obj);

获取方法

• getDeclaredMethods 方法返回类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

public Method[] getDeclaredMethods() throws SecurityException

• getMethods 方法返回某个类的所有公用（public）方法，包括其继承类的公用方法。

public Method[] getMethods() throws SecurityException

• getMethod 方法返回一个特定的方法，其中第一个参数为方法名称，后面的参数为方法的参数对应Class的对象。

public Method getMethod(String name, Class<?>... parameterTypes)

获取类的成员变量（字段）信息

• getFiled：访问公有的成员变量
• getDeclaredField：所有已声明的成员变量，但不能得到其父类的成员变量

getFileds 和 getDeclaredFields 方法用法同上（参照 Method）。

调用方法

当我们从类中获取了一个方法后，我们就可以用 invoke() 方法来调用这个方法。invoke 方法的原型为:

public Object invoke(Object obj, Object... args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException

利用反射创建数组

Class<?> cls = Class.forName("java.lang.String");
Object array = Array.newInstance(cls,25);
//往数组里添加内容
Array.set(array,0,"hello");
Array.set(array,1,"Java");
Array.set(array,2,"fuck");
Array.set(array,3,"Scala");
//获取某一项的内容
System.out.println(Array.get(array,2));

Class.forName与ClassLoader区别

ClassLoader是将.class文件加载到jvm中，不会执行static代码块，只有在newInstance才会去执行static块。

Class.forName不仅将.class文件加载到jvm中，还会执行static代码块

ClassLoader类加载器

• 启动类加载器：加载Java的核心库
• 扩展类加载器：加载Java的扩展库
• 应用程序类加载器：加载Java应用的类

反射机制的动态代理

// 获取类加载器的方法
TestReflect testReflect = new TestReflect();
        System.out.println("类加载器  " + testReflect.getClass().getClassLoader().getClass().getName());

// 定义项目接口，代理目标
interface Subject {
    public String say(String name, int age);
}

// 定义真实项目，实现代理目标的接口
class RealSubject implements Subject {
    public String say(String name, int age) {
        return name + "  " + age;
    }
}

class MyInvocationHandler implements InvocationHandler {
    private Object obj = null;
    public Object bind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object temp = method.invoke(this.obj, args);
        return temp;
    }
}

public class TestReflect {
    public static void main(String[] args) throws Exception {
        MyInvocationHandler demo = new MyInvocationHandler();
        Subject sub = (Subject) demo.bind(new RealSubject());
        String info = sub.say("Rollen", 20);
        System.out.println(info);
    }
}

在泛型为Integer的ArrayList中存放一个String类型的对象

        ArrayList<Integer> list = new ArrayList<Integer>();
        System.out.println(list.getClass());
        Method method = list.getClass().getMethod("add", Object.class);
        method.invoke(list, "Java反射机制实例。");
        System.out.println(list.get(0));

将反射机制应用于工厂模式

对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。 当我们添加很多的子类的时候，会很麻烦。

利用反射机制实现工厂模式，可以在不修改工厂类的情况下添加任意多个子类。

// 例如对于Apple这个子类的添加
Fruit f = Factory.getInstance("net.xsoftlab.baike.Apple");

参考：

https://www.sczyh30.com/posts/Java/java-reflection-1/#

https://blog.csdn.net/wangjun_818/article/details/73839498