Java反射机制

在运行状态中，对于任意一个类，都能够获取到这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性(包括私有的方法和属性)，这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。通俗点讲，通过反射，该类对我们来说是完全透明的，想要获取任何东西都可以。

想要使用反射机制，就必须要先获取到该类的字节码文件对象(.class)，通过字节码文件对象，就能够通过该类中的方法获取到我们想要的所有信息(方法，属性，类名，父类名，实现的所有接口等等)，每一个类对应着一个字节码文件也就对应着一个Class类型的对象，也就是字节码文件对象。

反射机制能获取的信息

获取字节码文件对象

1. 第一种方式–>Class.forName(“类名字符串”)。

通过Class类中的静态方法forName，直接获取到一个类的字节码文件对象，此时该类还是源文件阶段，并没有变为字节码文件。

Class c1=Class.forName("csdn.Student");

2. 第二种方式–>先创建对象,再用对象调用getClass()方法，即实例对象.getClass().返回运行时类。

通过类的实例获取该类的字节码文件对象，该类处于创建对象阶段,任何一个java对象都有getClass()方法

Student s=new Student();
Class c2 = s.getClass();

3. 第三种方式–>类名.class。返回Class的对象。(每个类都有class属性)

当类被加载成.class文件时，此时Person类变成了.class，在获取该字节码文件对象，也就是获取自己， 该类处于字节码阶段。

Class c3=Student.class;

有了字节码文件对象才能获得类中所有的信息，我们在使用反射获取信息时，也要考虑使用上面哪种方式获取字节码对象合理，视不同情况而定。下面介绍Class类的功能。

获取简单/完整类名

• 获取简单类名

public class Demo02 {
    public static void main(String[] args) throws Exception {
        //获得字符串的Class对象
        Class c = Class.forName("java.lang.String");
        //获得简单类名
        String name = c.getSimpleName();
        //打印输入: name = String
        System.out.println("name = " + name);
    }
}

• 获取完整类名

public class Demo02 {
    public static void main(String[] args) throws Exception {
        //获得字符串的Class对象
        Class c = Class.forName("java.lang.String");
        //获得完整类名(包含包名和类名)
        String name = c.getName();
        //打印输入: name = java. lang.String
        System.out.println("name = " + name);
    }
}

通过字节码对象创建实例对象

//注:类名字符串是"包名+类名" 返回Class的对象。(这种是最常用的方法)
Class c1=Class.forName("csdn.Student");
// 创建student实例，通过student的无参构造方法
Student stu = (Student)c1.newInstance();

获取构造器方法

constructor 如果没有无参构造，只有有参构造如何创建实例呢？看下面

方法声明	返回值类型	功能描述
getConstructors()	Constructor型数组	获得所有权限为public的构造方法
getConstructor(Class <?>.. paramsTypes)	Constructor对象	获得权限为public的指定构造方法
getDeclaredConstructors()	Constructor型数组	返回此Class对象表示的类声明的所有构造方法。
getDeclaredConstructor(Class<?>.. paramsTypes)	Constructor对象	返回此Class对象所表示的类的指定构造方法。

• 获取指定构造方法

1 //获取字节码文件
2 Class clazz1=Class.forName("csdn.Student");
3 //先获取有参构造器，parameterTypes;表示参数列表，有多少写多少，也可以不写，不写就是调用无参构造器
4 Constructor constructor = clazz1.getConstructor(int.class,String.class);
5 //通过构造器来实例化对象，将实际的参数传进去
6 Student student = (Student)constructor.newInstance("小明"，12);

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

• 获取全部构造方法

Class clazz1 = Class.forName("Reflect.Student");
//获取所有的构造方法
Constructor[] constructors = clazz1.getConstructors();
//遍历所有的构造方法
for(int i= 0;i<constructors.length;i++) {
    //获取每个构造函数中的参数类型字节码
    Class[] parameterTypes = constructors[i].getParameterTypes();
    //获取构造函数中参数类型
    System.out.println("第"+i+"个构造函数");
    for(int j=0;j<parameterTypes.length;j++) {
        //获取构造函数中参数类型
        System.out.println(parameterTypes[j].getName()+",");
    }
}

获取成员变量并使用Field对象

方法声明	返回值类型	功能描述
getFields()	Field型数组	获得所有权限为public的成员变量
getField(String name)	Field对象	获得权限为public的指定成员变量
getDeclaredFields()	Field型数组	返回此Class对象所表示的实体的所有成员变量，但不包括继承的属性
getDeclaredField(String name)	Field对象	它返回此Class对象所表示的类或接口的指定已声明成员变量

• 获取指定成员变量

Class clazz1 = Class.forName("Reflect.Student");
//获取其实例对象
Student student = (Student)clazz1.newInstance();
//获取成员变量clazz1.getField(name);通过name来获取指定成员变量，如果该成员变量是私有的，则应该使用getDeclaredField(name);
Field field = clazz1.getDeclaredField("id");
//对其成员变量进行操作
//赋值操作
field.setInt(student, 1);
//获取成员变量的值，field.get(obj);obj为所表示字段的值的对象，也就是该属性对应诶的实例对象。
System.out.println(field.getInt(student));

Class.getField(String)方法可以获取类中的指定字段(可见的), 如果是私有的可以用getDeclaedField("name")方法获取,通过set(obj, "李四")方法可以设置指定对象上该字段的值, 如果是私有的需要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)可以获取指定对象中该字段的值.

• 获取全部成员变量

// 通过反射获得字节码文件对象
Class clazz1 = Class.forName("Reflect.Student");
// 实例化
Student student = (Student) clazz1.newInstance();
// 赋值操作
student.setId(3);
student.setName("zhangsan");
// 将私有的属性一并获取
Field[] fields = clazz1.getDeclaredFields();
for (int i = 0; i < fields.length; i++) {
    // 打开操作权限
    fields[i].setAccessible(true);
    // 获取成员变量的值
    System.out.println(fields[i].get(student));
}

获得方法并使用Method

方法声明	返回值类型	功能描述
getMethodsQ)	Method型数组	获得所有权限为public的方法
getMethod(String name,Class Class<?>.. paramsTypes)	Method对象	获得权限为public的指定方法
getDeclaredMethodsQ	Method型数组	返回此Class 对象表示的实体的所有方法， 但不包括继承的方法。
getDeclaredMethod(String name,Class Class<?>.. paramsTypes)	Method对象	返回此Class对象所表示的实体的指定公共成员方法，name指定方法名称，parameterTypes指定方 法参数类型。

• 获取指定方法

// 通过反射获得字节码文件对象
Class clazz1 = Class.forName("Reflect.Student");
// 实例化
Student student = (Student) clazz1.newInstance();

/**
* clazz1.clazz1.getMethod(name, parameterTypes)
*   name 方法的名字
*   parameterTypes：方法的参数类型为Class类型，没有则不填写，比如参数为String，则填写为String.Class
*/
//eat为不带参数的public方法
Method method = clazz1.getMethod("eat");
Method method1 = clazz1.getMethod("sing", String.class);

/**
* method.invoke(obj, args)
*   obj:方法的对象
*   args:是的参数值，没有则不填
*/
//调用方法
method.invoke(student);
method1.invoke(student, "呵呵");

//获取私有的方法，和获取属性一样，say为私有的方法
Method method2 = clazz1.getDeclaredMethod("say");
method2.setAccessible(true);
method2.invoke(student);

Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String, Class...)方法可以获取类中的指定方法,如果为私有方法，则需要打开一个权限。setAccessible(true);用invoke(Object, Object...)可以调用该方法，

• 获取全部方法

// 通过反射获得字节码文件对象
Class clazz1 = Class.forName("Reflect.Student");
Method[] methods = clazz1.getDeclaredMethods();
// 实例化
Student student = (Student) clazz1.newInstance();
for(Method method :methods) {
    method.setAccessible(true);
    System.out.println(method.getName());
    //获得方法的参数，又回到了之前的代码
    Class<?>[] parameterTypes = method.getParameterTypes();
    for(int i=0;i<parameterTypes.length;i++) {
        //获取构造函数中参数类型
        System.out.println(parameterTypes[i].getName()+",");
    }
}

获得该类的所有接口

Class[]　getInterfaces()：确定此对象所表示的类或接口实现的接口

返回值：接口的字节码文件对象的数组

获取指定资源的输入流

InputStream getResourceAsStream(String name)

return：一个 InputStream 对象；如果找不到带有该名称的资源，则返回 null

参数：所需资源的名称，如果以”/“开始，则绝对资源名为”/“后面的一部分。

动态代理的概述和实现

动态代理：一种设计模式，其非常简单，很容易理解，你自己可以做这件事，但是觉得自己做非常麻烦或者不方便，所以就叫一个另一个人(代理)来帮你做这个事情，而你就不用管了，这就是动态代理。举个例子，买火车票叫人代买。

在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理

在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象分三步，但是注意JDK提供的代理正能针对接口做代理，也就是下面的第二步返回的必须要是一个接口。

1. new出代理对象，通过实现InvacationHandler接口，然后new出代理对象来。
2. 通过Proxy类中的静态方法newProxyInstance，来将代理对象假装成那个被代理的对象，也就是如果叫人帮我们代买火车票一样，那个代理就假装成我们自己本人
3. 执行方法，代理成功

将代理对象中的内容进行实现

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( "权限校验");
        //执行被代理 target对象的方法
        method.invoke(target, args);
        System.out.println("日志记录");
        return null;
    }
}

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

public class StudentImp implements Student {
    @Override
    public void login() {
        System.out.println("登录");
    }

    @Override
    public void submit() {
        System.out.println("提交");
    }
}

MyInvocationHandler m = new MyInvocationHandler(si);
Student s = (Student)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), m);
s.login();
s.submit();

注意：newProxyInstance的三个参数，第一个类加载器，第二个被代理对象的接口，第三个代理对象。

其他方法

还有很多方法，比如获得类加载器，等等。具体还需要别的，就通过查看API文档来解决。

方法声明	返回值类型	功能描述
getName()	String对象	返回此Class对象所表示的实体全限定名称
newInstance()	类对象	创建Class对象所表示的类的一个新实例
getInterfaces()	Class型数组	获得该类实现的所有接口
getPackage0)	Package对象	获得此类的包

反射机制的应用实例

1. 利用反射，在泛型为int的arryaList集合中存放一个String类型的对象

原理：集合中的泛型只在编译器有效，而到了运行期，泛型则会失效，

1. 利用反射，简化编写Servlet的个数。

什么意思呢？每当我们写一个功能时，就需要写一个对应的Servlet，导致最后Servlet有很多，自己都看不过来，所以对其进行了优化，两种方式，

• 每次从页面传过来一个参数，method=”xxx”; 然后编写一个Servlet，获得其参数method的值，进行判断，如果是add，则调用add方法，如果是delete，则调用delete方法，这样就可以写在一个servlet中实现所有的功能了。

• 利用反射编写一个BaseServlet继承HttpServlet，这是一个通用的BaseServlet。需要明白servlet的生命周期

编写具体实现的方法servlet类。
MySerlvet001 extends BaseServlet

解释：需要明白servlet的生命周期，也就是service方法，因为是servlet，所以在访问的时候，会经过service方法，而子类MyServlet001中并没有，所以就到父类BaseServlet中找,发现有，然后获取参数即知道了需要调用什么方法，因为方法的编写都在子类中，所以通过反射，获取到子类中对应的方法并运行，其中需要注意的是this这个参数在BaseServlet中的用法。需要理解它。才能理解我们这个程序。