Java高级特性-反射

 

Roadmap

1. 基本概念

1.1 什么是反射

反射机制是在运行状态中，对于任意一个类，都可以知道这个类的全部属性和方法；对于任意一个对象，都可以调用它的任意一个方法和属性。

 

1.2 反射的做用

在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具备的成员变量和方法
在运行时调用任意一个对象的方法
生成动态代理
反向工程 .class -> .java

前提是在运行时，不是编译时，也就是在运行前并不知道调用哪个类，经过反射就能够作到这些 

1.3 反射中的类

java.lang.Class
java.lang.reflect.Constructor
java.lang.reflect.Field
java.lang.reflect.Method
java.lang.reflect.Modifier

2 反射的使用

2.1 反射机制获取类

public class MyReflection {

   // 属性方法省略

    public static void main(String[] arg) throws ClassNotFoundException {
        //第一种方式：  
        Class c1 = Class.forName("refelection.MyReflection");
        //第二种方式：每一个类都有 .class  
        Class c2 = MyReflection.class;
        //第三种方式：
        Class c3 = new MyReflection().getClass();
   ｝
｝

2.2 获取全部属性

public static void main(String[] arg) throws ClassNotFoundException {
       
       
        Class c1 = Class.forName("refelection.MyReflection");
        Class c2 = MyReflection.class;
        Class c3 = new MyReflection().getClass();


        Field[] fs1 = c1.getDeclaredFields();
        Field[] fs2 = c2.getFields();


        Method[] method1 = c1.getDeclaredMethods();
        Method[] method2 = c2.getMethods();

        Constructor[] cts1 = c1.getDeclaredConstructors();
        Constructor[] cts12 =c2.getDeclaredConstructors();

        for(Field field:fs1){
            System.out.println("** get declaredFields **");
            System.out.println(Modifier.toString(field.getModifiers()));
            System.out.println( field.getType().getSimpleName());
            System.out.println( field.getName());
        }

        for(Field field:fs2){
            System.out.println("** get getFields **");
            System.out.println(Modifier.toString(field.getModifiers()));
            System.out.println( field.getType().getSimpleName());
            System.out.println( field.getName());
        }

        for(Method method:method1){
            System.out.println("** get getDeclaredMethods **");
            System.out.println(Modifier.toString(method.getModifiers()));
            System.out.println( method.getName());
        }

        for(Method method:method2){
            System.out.println("** get getMethods **");
            System.out.println(Modifier.toString(method.getModifiers()));
            System.out.println( method.getName());
        }

        for(Constructor constructor:cts1){
            System.out.println("** get getDeclaredConstructors **");
            System.out.println(Modifier.toString(constructor.getModifiers()));
            System.out.println( constructor.getName());
        }

        for(Constructor constructor:cts12){
            System.out.println("** get getConstructors **");
            System.out.println(Modifier.toString(constructor.getModifiers()));
            System.out.println( constructor.getName());
        }

    }

* getFields()与getDeclaredFields()区别:getFields()只能访问类中声明为公有的字段,私有的字段它没法访问，能访问从其它类继承来的公有方法.getDeclaredFields()能访问类中全部的字段,与public,private,protect无关，不能访问从其它类继承来的方法  

* getMethods()与getDeclaredMethods()区别:getMethods()只能访问类中声明为公有的方法,私有的方法它没法访问,能访问从其它类继承来的公有方法.getDeclaredFields()能访问类中全部的字段,与public,private,protect无关,不能访问从其它类继承来的方法  

* getConstructors()与getDeclaredConstructors()区别:getConstructors()只能访问类中声明为public的构造函数.getDeclaredConstructors()能访问类中全部的构造函数,与public,private,protect无关  

 

2.3 获取指定属性

获取指定属性与获取所有属性的方法相似 而且一一对应，方法名没有S之外，返回的对象是具体对象而不是数组了。

//获取类  
    Class c = Class.forName("User");  
    //获取id属性  
    Field idF = c.getDeclaredField("id");

 

2.4 打破封装

 类方法有一些是私有的，反射机制提供了setAccessiable(true)方法，打破封装性，这样能够经过反射解析一些私有方法，如读取，赋值等。 显然这是一个不安全的操做。

//获取类  
    Class c = Class.forName("User");  
    //获取id属性  
    Field idF = c.getDeclaredField("id");  
    //实例化这个类赋给o  
    Object o = c.newInstance();  
    //打破封装  
    idF.setAccessible(true); //使用反射机制能够打破封装性，致使了java对象的属性不安全。  
    idF.set(o, "110"); //set

    另外，在框架满天飞的时代下面，有的时候在运行程序的时候 会遇到 java.lang.IllegalAccessException:   

       多数状况下是在用反射机制下，访问了私有属性的缘故

3 动态代理

3.1 InvocationHandler

        每个动态代理类都必需要实现InvocationHandler这个接口，而且每一个代理类的实例都关联到了一个handler，当咱们经过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。咱们来看看InvocationHandler这个接口的惟一一个方法 invoke 方法：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

 

proxy:　　指代咱们所代理的那个真实对象

method:　指代的是咱们所要调用真实对象的某个方法的Method对象

args:　　指代的是调用真实对象某个方法时接受的参数

3.2 Proxy    

    Proxy这个类的做用就是用来动态建立一个代理对象的类，它提供了许多的方法，可是咱们用的最多的就是 newProxyInstance 这个方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)  throws IllegalArgumentException

 

这个方法的做用就是获得一个动态的代理对象，其接收三个参数，

loader:一个ClassLoader对象，定义了由哪一个ClassLoader对象来对生成的代理对象进行加载

interfaces:一个Interface对象的数组，表示的是我将要给我须要代理的对象提供一组什么接口，若是我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

h:一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪个InvocationHandler对象上

3.3 开始动态代理

 

3.3.1 构建真实对象

public interface Subject {

    void call(String content);
}


public class RealSubject implements Subject{

    public void call(String content){
        System.out.println(content);
    }
}

3.3.2 构建动态代理类

public class DynamicProxy implements InvocationHandler {


    private Object subject;

    //    构造方法，给咱们要代理的真实对象赋初值
    public DynamicProxy(Object subject)
    {
        this.subject = subject;
    }


    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //　　在代理真实对象前咱们能够添加一些本身的操做
        System.out.println("before call");

        System.out.println("Method:" + method);

        //    当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
        method.invoke(subject, args);

        //　　在代理真实对象后咱们也能够添加一些本身的操做
        System.out.println("after call");

        return null;
    }
}

3.3.3 客户端调用

public static void main(String[] arg){

        //    咱们要代理的真实对象
        Subject realSubject = new RealSubject();

        //    咱们要代理哪一个真实对象，就将该对象传进去，最后是经过该真实对象来调用其方法的
        InvocationHandler handler = new DynamicProxy(realSubject);

        /*
         * 经过Proxy的newProxyInstance方法来建立咱们的代理对象，咱们来看看其三个参数
         * 第一个参数 handler.getClass().getClassLoader() ，咱们这里使用handler这个类的ClassLoader对象来加载咱们的代理对象
         * 第二个参数realSubject.getClass().getInterfaces()，咱们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
         * 第三个参数handler， 咱们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
         */
        Subject subject = (Subject)Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject
                .getClass().getInterfaces(), handler);

        System.out.println(subject.getClass().getName());
        subject.call("test");
    }

输出：

com.sun.proxy.$Proxy0 before call Method:public abstract void refelection.proxy.Subject.call(java.lang.String) test after call