• Java反射


    https://www.liaoxuefeng.com/wiki/1252599548343744/1255945147512512

    反射是为了解决在运行期,对某个实例一无所知的情况下,如何调用其方法。

    除了int等基本类型外,Java的其他类型全部都是class(包括interface)。例如:

    • String
    • Object
    • Runnable
    • Exception
    • ...

    仔细思考,我们可以得出结论:class(包括interface)的本质是数据类型(Type。无继承关系的数据类型无法赋值:

    Number n = new Double(123.456); // OK
    String s = new Double(123.456); // compile error!

    class是由JVM在执行过程中动态加载的。JVM在第一次读取到一种class类型时,将其加载进内存。

    每加载一种class,JVM就为其创建一个Class类型的实例,并关联起来。同一个Class在一次程序运行过程中只会加载一次。注意:这里的Class类型是一个名叫Classclass。它长这样:

    public final class Class {
        private Class() {}
    }

    String类为例,当JVM加载String类时,它首先读取String.class文件到内存,然后,为String类创建一个Class实例并关联起来:

    Class cls = new Class(String);
    

    这个Class实例是JVM内部创建的,如果我们查看JDK源码,可以发现Class类的构造方法是private,只有JVM能创建Class实例,我们自己的Java程序是无法创建Class实例的。

    所以,JVM持有的每个Class实例都指向一个数据类型(classinterface):

    ┌───────────────────────────┐
    │      Class Instance       │──────> String
    ├───────────────────────────┤
    │name = "java.lang.String"  │
    └───────────────────────────┘
    ┌───────────────────────────┐
    │      Class Instance       │──────> Random
    ├───────────────────────────┤
    │name = "java.util.Random"  │
    └───────────────────────────┘
    ┌───────────────────────────┐
    │      Class Instance       │──────> Runnable
    ├───────────────────────────┤
    │name = "java.lang.Runnable"│
    └───────────────────────────┘
    

    一个Class实例包含了该class的所有完整信息:

    ┌───────────────────────────┐
    │      Class Instance       │──────> String
    ├───────────────────────────┤
    │name = "java.lang.String"  │
    ├───────────────────────────┤
    │package = "java.lang"      │
    ├───────────────────────────┤
    │super = "java.lang.Object" │
    ├───────────────────────────┤
    │interface = CharSequence...│
    ├───────────────────────────┤
    │field = value[],hash,...   │
    ├───────────────────────────┤
    │method = indexOf()...      │
    └───────────────────────────┘
    

    由于JVM为每个加载的class创建了对应的Class实例,并在实例中保存了该class的所有信息,包括类名、包名、父类、实现的接口、所有方法、字段等,因此,如果获取了某个Class实例,我们就可以通过这个Class实例获取到该实例对应的class的所有信息。

    这种通过Class实例获取class信息的方法称为反射(Reflection)。

    如何获取一个classClass实例?有三个方法:

    方法一:直接通过一个class的静态变量class获取:

    Class cls = String.class;

    方法二:如果我们有一个实例变量,可以通过该实例变量提供的getClass()方法获取:

    
    
    String s = "Hello";
    Class cls = s.getClass();

    方法三:如果知道一个class的完整类名,可以通过静态方法Class.forName()获取:

    
    
    Class cls = Class.forName("java.lang.String");

    因为Class实例在JVM中是唯一的,所以,上述方法获取的Class实例是同一个实例。可以用==比较两个Class实例:

    Class cls1 = String.class;
    
    String s = "Hello";
    Class cls2 = s.getClass();
    
    boolean sameClass = cls1 == cls2; // true
    注意一下Class实例比较和instanceof的差别:
    
    Integer n = new Integer(123);
    
    boolean b1 = n instanceof Integer; // true,因为n是Integer类型
    boolean b2 = n instanceof Number; // true,因为n是Number类型的子类
    
    boolean b3 = n.getClass() == Integer.class; // true,因为n.getClass()返回Integer.class
    boolean b4 = n.getClass() == Number.class; // false,因为Integer.class!=Number.class

    instanceof不但匹配指定类型,还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型,但不能作子类型比较。

    通常情况下,我们应该用instanceof判断数据类型,因为面向抽象编程的时候,我们不关心具体的子类型。只有在需要精确判断一个类型是不是某个class的时候,我们才使用==判断class实例。

    因为反射的目的是为了获得某个实例的信息。因此,当我们拿到某个Object实例时,我们可以通过反射获取该Objectclass信息:

    void printObjectInfo(Object obj) {
        Class cls = obj.getClass();
    }

    注意到数组(例如String[])也是一种Class,而且不同于String.class,它的类名是[Ljava.lang.String。此外,JVM为每一种基本类型如int也创建了Class,通过int.class访问。

    如果获取到了一个Class实例,我们就可以通过该Class实例来创建对应类型的实例:

    // 获取String的Class实例:
    Class cls = String.class;
    // 创建一个String实例:
    String s = (String) cls.newInstance();
    

    上述代码相当于new String()。通过Class.newInstance()可以创建类实例,它的局限是:只能调用public的无参数构造方法。带参数的构造方法,或者非public的构造方法都无法通过Class.newInstance()被调用。

    动态加载

    JVM在执行Java程序的时候,并不是一次性把所有用到的class全部加载到内存,而是第一次需要用到class时才加载。例如:

    // Main.java
    public class Main {
        public static void main(String[] args) {
            if (args.length > 0) {
                create(args[0]);
            }
        }
    
        static void create(String name) {
            Person p = new Person(name);
        }
    }
    

    当执行Main.java时,由于用到了Main,因此,JVM首先会把Main.class加载到内存。然而,并不会加载Person.class,除非程序执行到create()方法,JVM发现需要加载Person类时,才会首次加载Person.class。如果没有执行create()方法,那么Person.class根本就不会被加载。

    这就是JVM动态加载class的特性。

    动态加载class的特性对于Java程序非常重要。利用JVM动态加载class的特性,我们才能在运行期根据条件加载不同的实现类。例如,Commons Logging总是优先使用Log4j,只有当Log4j不存在时,才使用JDK的logging。利用JVM动态加载特性,大致的实现代码如下:

    // Commons Logging优先使用Log4j:
    LogFactory factory = null;
    if (isClassPresent("org.apache.logging.log4j.Logger")) {
        factory = createLog4j();
    } else {
        factory = createJdkLog();
    }
    
    boolean isClassPresent(String name) {
        try {
            Class.forName(name);
            return true;
        } catch (Exception e) {
            return false;
        }
    }
    

    有了Class实例之后,就能获取它父类的Class和它实现的接口了

    public class Main {
        public static void main(String[] args) throws Exception {
            Class i = Integer.class;
            Class n = i.getSuperclass();
            System.out.println(n);
            Class o = n.getSuperclass();
            System.out.println(o);
            System.out.println(o.getSuperclass());
        }
    }
    //运行上述代码,可以看到,Integer的父类类型是Number,Number的父类是Object。//Object的父类是null。除Object外,其他任何非interface的Class都必定存在一个父类类型。
    
    
    public class Main {
        public static void main(String[] args) throws Exception {
            Class s = Integer.class;
            Class[] is = s.getInterfaces();
            for (Class i : is) {
                System.out.println(i);
            }
        }
    }
    
    运行上述代码可知,Integer实现的接口有:
    java.lang.Comparable
    java.lang.constant.Constable
    java.lang.constant.ConstantDesc
    
    要特别注意:getInterfaces()只返回当前类直接实现的接口类型,并不包括其父类实现的接口类型。若想知道父类的接口,就再结合getSuperclass。
    public class Main {
        public static void main(String[] args) throws Exception {
            Class s = Integer.class.getSuperclass();
            Class[] is = s.getInterfaces();
            for (Class i : is) {
                System.out.println(i);
            }
        }
    }
    //Integer的父类是Number,Number实现的接口是java.io.Serializable。
    
    
    此外,对所有interface的Class调用getSuperclass()返回的是null,获取接口的父接口要用getInterfaces():
    
    System.out.println(java.io.DataInputStream.class.getSuperclass()); // java.io.FilterInputStream,因为DataInputStream继承自FilterInputStream
    System.out.println(java.io.Closeable.class.getSuperclass()); // null,对接口调用getSuperclass()总是返回null,获取接口的父接口要用getInterfaces()
    如果一个类没有实现任何interface,那么getInterfaces()返回空数组。
    继承关系
    当我们判断一个实例是否是某个类型时,正常情况下,使用instanceof操作符:
    
    Object n = Integer.valueOf(123);
    boolean isDouble = n instanceof Double; // false
    boolean isInteger = n instanceof Integer; // true
    boolean isNumber = n instanceof Number; // true
    boolean isSerializable = n instanceof java.io.Serializable; // true
    如果是两个Class实例,要判断一个向上转型是否成立,可以调用isAssignableFrom():
    // Integer i = ?
    Integer.class.isAssignableFrom(Integer.class); // true,因为Integer可以赋值给Integer
    // Number n = ?
    Number.class.isAssignableFrom(Integer.class); // true,因为Integer可以赋值给Number
    // Object o = ?
    Object.class.isAssignableFrom(Integer.class); // true,因为Integer可以赋值给Object
    // Integer i = ?
    Integer.class.isAssignableFrom(Number.class); // false,因为Number不能赋值给Integer

    小结1

    JVM为每个加载的classinterface创建了对应的Class实例来保存classinterface的所有信息;

    获取一个class对应的Class实例后,就可以获取该class的所有信息;

    通过Class实例获取class信息的方法称为反射(Reflection);

    JVM总是动态加载class,可以在运行期根据条件来控制加载class。

    使用反射 

    利用反射访问字段

    对任意的一个Object实例,只要我们获取了它的Class,就可以获取它的一切信息。

    我们先看看如何通过Class实例获取字段信息。Class类提供了以下几个方法来获取字段:

    • Field getField(name):根据字段名获取某个public的field(包括父类)
    • Field getDeclaredField(name):根据字段名获取当前类的某个field(不包括父类)
    • Field[] getFields():获取所有public的field包括父类
    • Field[] getDeclaredFields():获取当前类的所有field(不包括父类)
    class Student extends Person {
        public int score;
        private int grade;
    }
    
    class Person {
        public String name;
    }
    
    public class Main {
        public static void main(String[] args) throws Exception {
            Class stdClass = Student.class;
            // 获取public字段"score":
            System.out.println(stdClass.getField("score"));
            // 获取继承的public字段"name":
            System.out.println(stdClass.getField("name"));
            // 获取private字段"grade":
            System.out.println(stdClass.getDeclaredField("grade"));
        }
    }
    
    上述代码首先获取Student的Class实例,然后,分别获取public字段、继承的public字段以及private字段,打印出的Field类似:
    
    public int Student.score
    public java.lang.String Person.name
    private int Student.grade

    一个Field对象包含了一个字段的所有信息:

    • getName():返回字段名称,例如,"name"
    • getType():返回字段类型,也是一个Class实例,例如,String.class
    • getModifiers():返回字段的修饰符,它是一个int,不同的bit表示不同的含义。 
    以String类的value字段为例,它的定义是:
    
    public final class String {
        private final byte[] value;
    }
    我们用反射获取该字段的信息,代码如下:
    
    Field f = String.class.getDeclaredField("value");
    f.getName(); // "value"
    f.getType(); // class [B 表示byte[]类型
    int m = f.getModifiers();
    Modifier.isFinal(m); // true
    Modifier.isPublic(m); // false
    Modifier.isProtected(m); // false
    Modifier.isPrivate(m); // true
    Modifier.isStatic(m); // false

    拿到一个实例的某个字段对应的Field之后,自然也能得到Field里字段的值。

    先获取Class实例,再获取Field实例,然后,用Field.get(Object)获取指定实例的指定字段的值。
    
    public class Main {
    
        public static void main(String[] args) throws Exception {
            Object p = new Person("Xiao Ming");
            Class c = p.getClass();
            Field f = c.getDeclaredField("name");
            Object value = f.get(p);
            System.out.println(value); // "Xiao Ming"
        }
    }
    
    class Person {
        private String name;
    
        public Person(String name) {
            this.name = name;
        }
    }

    但以上代码会报错,因为name是private的。要想访问private的field,需要这样:

    f.setAccessible(true);

    因此反射也是可以访问private修饰的字段的。此外,setAccessible(true)可能会失败。如果JVM运行期存在SecurityManager,那么它会根据规则进行检查,有可能阻止setAccessible(true)。例如,某个SecurityManager可能不允许对javajavax开头的package的类调用setAccessible(true),这样可以保证JVM核心库的安全。

    既然能得到字段值,自然也是可以改变字段值的。

    设置字段值是通过Field.set(Object, Object)实现的,其中第一个Object参数是指定的实例,第二个Object参数是待修改的值。示例代码如下:
    
    public class Main {
    
        public static void main(String[] args) throws Exception {
            Person p = new Person("Xiao Ming");
            System.out.println(p.getName()); // "Xiao Ming"
            Class c = p.getClass();
            Field f = c.getDeclaredField("name");
            f.setAccessible(true);
            f.set(p, "Xiao Hong");
            System.out.println(p.getName()); // "Xiao Hong"
        }
    }
    
    class Person {
        private String name;
    
        public Person(String name) {
            this.name = name;
        }
    
        public String getName() {
            return this.name;
        }
    }

    利用反射调用方法/构造方法

    类似获取Class实例的Field对象,也可以获取它的Method信息:

    Method getMethod(name, Class...):获取某个public的Method(包括父类)
    Method getDeclaredMethod(name, Class...):获取当前类的某个Method(不包括父类)
    Method[] getMethods():获取所有public的Method(包括父类)
    Method[] getDeclaredMethods():获取当前类的所有Method(不包括父类)
    
    
    示例:
    public class Main {
        public static void main(String[] args) throws Exception {
            Class stdClass = Student.class;
            // 获取public方法getScore,参数为String:
            System.out.println(stdClass.getMethod("getScore", String.class));
            // 获取继承的public方法getName,无参数:
            System.out.println(stdClass.getMethod("getName"));
            // 获取private方法getGrade,参数为int:
            System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));
        }
    }
    class Student extends Person {
        public int getScore(String type) {
            return 99;
        }
        private int getGrade(int year) {
            return 1;
        }
    }
    class Person {
        public String getName() {
            return "Person";
        }
    }
    
    输出
    public int Student.getScore(java.lang.String)
    public java.lang.String Person.getName()
    private int Student.getGrade(int)

    类似的,一个Method对象也包含着一个方法的所有信息。

    • getName():返回方法名称,例如:"getScore"
    • getReturnType():返回方法返回值类型,也是一个Class实例,例如:String.class
    • getParameterTypes():返回方法的参数类型,是一个Class数组,例如:{String.class, int.class}
    • getModifiers():返回方法的修饰符,它是一个int,不同的bit表示不同的含义。

    获取到Method对象之后,自然就可以调用它了。

    1. 调用方法
    public class Main {
        public static void main(String[] args) throws Exception {
            // String对象:
            String s = "Hello world";
            // 获取String substring(int)方法,参数为int:
            Method m = String.class.getMethod("substring", int.class);
            // 在s对象上调用该方法并获取结果:
            String r = (String) m.invoke(s, 6);
            // 打印调用结果:
            System.out.println(r);
        }
    }
    对Method实例调用invoke就相当于调用该方法,invoke的第一个参数是对象实例,即在哪个实例上调用该方法,后面的可变参数要与方法参数一致,否则将报错。
    
    2.调用静态方法
    调用静态方法时,由于无需指定实例对象,所以invoke方法传入的第一个参数永远为null。
    public class Main {
        public static void main(String[] args) throws Exception {
            // 获取Integer.parseInt(String)方法,参数为String:
            Method m = Integer.class.getMethod("parseInt", String.class);
            // 调用该静态方法并获取结果:
            Integer n = (Integer) m.invoke(null, "12345");
            // 打印调用结果:
            System.out.println(n);
        }
    }
    
    3.调用非public方法
    和Field类似,调用非public方法,要通过Method.setAccessible(true)允许其调用。(setAccessible也可能会失败)
    public class Main {
        public static void main(String[] args) throws Exception {
            Person p = new Person();
            Method m = p.getClass().getDeclaredMethod("setName", String.class);
            m.setAccessible(true);
            m.invoke(p, "Bob");
            System.out.println(p.name);
        }
    }
    
    class Person {
        String name;
        private void setName(String name) {
            this.name = name;
        }
    }
    
    4.多态问题
    这个例子中,继承Person的Student类复写了hello方法。使用反射调用方法时,仍然遵循多态原则:即总是调用实际类型的覆写方法(如果存在)。
    
    public class Main {
        public static void main(String[] args) throws Exception {
            // 获取Person的hello方法:
            Method h = Person.class.getMethod("hello");
            // 对Student实例调用hello方法:
            h.invoke(new Student());
            // 输出 Student:hello
        }
    }
    
    class Person {
        public void hello() {
            System.out.println("Person:hello");
        }
    }
    
    class Student extends Person {
        public void hello() {
            System.out.println("Student:hello");
        }
    }

    通过反射来创建新的实例,可以调用Class提供的newInstance()方法

    Person p = Person.class.newInstance();
    //它只能调用该类的public无参数构造方法。
    //如果构造方法带有参数,或者不是public,就无法直接通过Class.newInstance()来调用。

    为了调用任意的构造方法,Java的反射API提供了Constructor对象,它包含一个构造方法的所有信息,可以创建一个实例。Constructor对象和Method非常类似,不同之处仅在于它是一个构造方法,并且,调用结果总是返回实例:

    public class Main {
        public static void main(String[] args) throws Exception {
            // 获取构造方法Integer(int):
            Constructor cons1 = Integer.class.getConstructor(int.class);
            // 调用构造方法:
            Integer n1 = (Integer) cons1.newInstance(123);
            System.out.println(n1);
    
            // 获取构造方法Integer(String)
            Constructor cons2 = Integer.class.getConstructor(String.class);
            Integer n2 = (Integer) cons2.newInstance("456");
            System.out.println(n2);
        }
    }

    通过Class实例获取Constructor的方法如下:

    • getConstructor(Class...):获取某个publicConstructor
    • getDeclaredConstructor(Class...):获取某个Constructor
    • getConstructors():获取所有publicConstructor
    • getDeclaredConstructors():获取所有Constructor

    注意Constructor总是当前类定义的构造方法,和父类无关,因此不存在多态的问题。

    调用非publicConstructor时,必须首先通过setAccessible(true)设置允许访问。setAccessible(true)可能会失败。

    动态代理

    众所周知,class是可以实例化(非抽象类)而interface是不能实例化的。但有没有可能不编写实现类,直接在运行期创建某个interface的实例呢?这就要通过动态代理实现。

    首先复习一下静态创建:

    定义接口:
    
    public interface Hello {
        void morning(String name);
    }
    编写实现类:
    
    public class HelloWorld implements Hello {
        public void morning(String name) {
            System.out.println("Good morning, " + name);
        }
    }
    创建实例,转型为接口并调用:
    
    Hello hello = new HelloWorld();
    hello.morning("Bob");

    还有一种方式是动态代码,我们仍然先定义了接口Hello,但是我们并不去编写实现类,而是直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个Hello接口对象。这种没有实现类但是在运行期动态创建了一个接口对象的方式,我们称为动态代码。JDK提供的动态创建接口对象的方式,就叫动态代理。

    一个最简单的动态代理实现如下:

    public class Main {
        public static void main(String[] args) {
            InvocationHandler handler = new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println(method);
                    if (method.getName().equals("morning")) {
                        System.out.println("Good morning, " + args[0]);
                    }
                    return null;
                }
            };
            Hello hello = (Hello) Proxy.newProxyInstance(
                Hello.class.getClassLoader(), // 传入ClassLoader
                new Class[] { Hello.class }, // 传入要实现的接口
                handler); // 传入处理调用方法的InvocationHandler
            hello.morning("Bob");
        }
    }
    
    interface Hello {
        void morning(String name);
    }

    在运行期动态创建一个interface实例的方法如下:

    1. 定义一个InvocationHandler实例,它负责实现接口的方法调用;
    2. 通过Proxy.newProxyInstance()创建interface实例,它需要3个参数:
      1. 使用的ClassLoader,通常就是接口类的ClassLoader
      2. 需要实现的接口数组,至少需要传入一个接口进去;
      3. 用来处理接口方法调用的InvocationHandler实例。
    3. 将返回的Object强制转型为接口。

     动态代理实际上是JDK在运行期动态创建class字节码并加载的过程,它并没有什么黑魔法,把上面的动态代理改写为静态实现类大概长这样:

    public class HelloDynamicProxy implements Hello {
        InvocationHandler handler;
        public HelloDynamicProxy(InvocationHandler handler) {
            this.handler = handler;
        }
        public void morning(String name) {
            handler.invoke(
               this,
               Hello.class.getMethod("morning"),
               new Object[] { name });
        }
    }
    其实就是JDK帮我们自动编写了一个上述类(不需要源码,可以直接生成字节码),并不存在可以直接实例化接口的黑魔法
  • 相关阅读:
    构造方法
    封装 private
    局部变量和成员变量区别
    IOC
    Linux端口占用查询命令
    Nginx小白入门实战
    SQL left join right join inner join之间的区别
    IDEA导入maven工程时,不会自动识别怎么办
    Spring中Controller层中的method显示为灰色并且提示method is never used的原因
    查看服务器公网IP
  • 原文地址:https://www.cnblogs.com/Nullc/p/12695312.html
Copyright © 2020-2023  润新知