java中的反射（二）

2022-09-03 15:02:04

java中的反射（一）：https://www.cnblogs.com/KeleLLXin/p/14060555.html

目录

一、反射

1、class类

2、访问字段

3、调用方法

4、调用构造方法

5、获取继承对象

6、动态代理

二、sping中的反射

本篇内容,参考https://www.liaoxuefeng.com/wiki/1252599548343744/1255945147512512

本篇包括：

4、调用构造方法

5、获取继承对象

6、动态代理

调用构造方法

我们通常使用new操作符创建新的实例：Person p = new Person();

如果通过反射来创建新的实例，可以调用Class提供的newInstance()方法：Person p = Person.class.newInstance();

调用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);

    }

}

运行结果

123

456

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

getConstructor(Class...)：获取某个public的Constructor；

getDeclaredConstructor(Class...)：获取某个Constructor；

getConstructors()：获取所有public的Constructor；

getDeclaredConstructors()：获取所有Constructor。

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

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

小结

Constructor对象封装了构造方法的所有信息；

通过Class实例的方法可以获取Constructor实例：getConstructor()，getConstructors()，getDeclaredConstructor()，getDeclaredConstructors()；

通过Constructor实例可以创建一个实例对象：newInstance(Object... parameters)；通过设置setAccessible(true)来访问非public构造方法。

获取继承关系

当我们获取到某个Class对象时，实际上就获取到了一个类的类型：

Class cls = String.class; // 获取到String的Class

还可以用实例的getClass()方法获取：

String s = "";

Class cls = s.getClass(); // s是String，因此获取到String的Class

最后一种获取Class的方法是通过Class.forName("")，传入Class的完整类名获取：

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

这三种方式获取的Class实例都是同一个实例，因为JVM对每个加载的Class只创建一个Class实例来表示它的类型。

获取父类的Class

有了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());

    }

}

运行结果

class java.lang.Number

class java.lang.Object

null

运行上述代码，可以看到，Integer的父类类型是Number，Number的父类是Object，Object的父类是null。除Object外，其他任何非interface的Class都必定存在一个父类类型。

获取interface

由于一个类可能实现一个或多个接口，通过Class我们就可以查询到实现的接口类型。例如，查询Integer实现的接口：

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);

        }

    }

}

运行结果

interface java.lang.Comparable

interface java.lang.constant.Constable

interface java.lang.constant.ConstantDesc

运行上述代码可知，Integer实现的接口有如上。

要特别注意：getInterfaces()只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型：

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);

        }

    }

}

运行结果

interface java.io.Serializable

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

小结

通过Class对象可以获取继承关系：

Class getSuperclass()：获取父类类型；

Class[] getInterfaces()：获取当前类实现的所有接口。

通过Class对象的isAssignableFrom()方法可以判断一个向上转型是否可以实现。

动态代理

我们来比较Java的class和interface的区别：

可以实例化class（非abstract）；

不能实例化interface。

所有interface类型的变量总是通过向上转型并指向某个实例的：

CharSequence cs = new StringBuilder();

有没有可能不编写实现类，直接在运行期创建某个interface的实例呢？

这是可能的，因为Java标准库提供了一种动态代理（Dynamic Proxy）的机制：可以在运行期动态创建某个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);

}

运行结果

public abstract void Hello.morning(java.lang.String)

Good morning, Bob

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

定义一个InvocationHandler实例，它负责实现接口的方法调用；

通过Proxy.newProxyInstance()创建interface实例，它需要3个参数：

使用的ClassLoader，通常就是接口类的ClassLoader；

需要实现的接口数组，至少需要传入一个接口进去；

用来处理接口方法调用的InvocationHandler实例。

将返回的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", String.class),

           new Object[] { name });

    }

}

其实就是JDK帮我们自动编写了一个上述类（不需要源码，可以直接生成字节码），并不存在可以直接实例化接口的黑魔法。

小结

Java标准库提供了动态代理功能，允许在运行期动态创建一个接口的实例；

动态代理是通过Proxy创建代理对象，然后将接口方法“代理”给InvocationHandler完成的。

下一篇，spring中的反射：https://www.cnblogs.com/KeleLLXin/p/14068083.html

码农公寓

调用构造方法

获取继承关系

动态代理

相关文章