Java高级特性-反射

2019独角兽企业重金招聘Python工程师标准>>>

 

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

转载于:https://my.oschina.net/u/1041012/blog/916098