Java ABCs (8): Java反射机制

HαLlus

于 2021-05-18 16:38:49 发布

阅读量158

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/Astartia/article/details/116888278

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章目录

08 Java反射机制

08 Java反射机制

8-1 反射机制概述

反射(Reflection)是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象地称之为：反射。

正常方式：

反射方式：

补充：动态语言 vs 静态语言

动态语言是一类在运行时可以改变其结构的语言，例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗而言就是在运行时代码可以根据某些条件改变自身结构。如Object-C, C#, avaScript, PHP, Python, Erlang。
静态语言与动态语言相对，运行时结构不可变。如Java, C, C++。

Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。

8-2 反射相关的主要API

java.lang.Class - 代表一个类.
java.lang.reflect.Method - 代表类的方法.
java.lang.reflect.Field - 代表类的成员变量.
java.lang.reflect.Constructor - 代表类的构造器.

8-3 反射的应用

类的加载过程：

第一步：程序经过javac.exe命令后，会生成一个或多个字节码文件(.class)
第二步：使用java.exe命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中。

1. 获取运行时类的对象

加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例；换句话说，Class的实例对应着一个运行时类。

加载到内存中的运行时类，会缓存一定的时间。在此间之内，我们可以通过不同的方式来获取此运行时类。

获取Class实例的方式：

调用运行时类的属性.class
通过运行时类的对象调用getClass()方法
调用Class的静态方法forName(String classPath)
使用类的加载器ClassLoader

public class ReflectionTest {
    @Test
    public void test() throws ClassNotFoundException {
        //方式一：调用运行时类的属性.class
        Class<Person> clazz = Person.class;
        System.out.println(clazz);

        //方式二：通过运行时类的对象调用getClass()方法
        Person p = new Person();
        Class<? extends Person> clazz1 = p.getClass();
        System.out.println(clazz1);

        //方式三：调用Class的静态方法forName(String classPath)
        Class<?> clazz2 = Class.forName("Person");
        System.out.println(clazz2);

        System.out.println(clazz == clazz1);//true
        System.out.println(clazz == clazz2);//true
        System.out.println(clazz1 == clazz2);//true
        
        //方式四：使用类的加载器ClassLoader
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class<?> clazz3 = classLoader.loadClass("Person");
        System.out.println(clazz3);
        System.out.println(clazz == clazz3);//true

    }
}

不仅类具有Class对象，以下的类型都可以获取运行时的Class实例：

class - 外部类，成员（成员内部类，静态内部类），局部内部类，匿名内部类
interface - 接口
[] - 数组
enum - 枚举
annotation - 注解
primitive type - 基本数据类型
void

public class ReflectionTest() {
    @Test
    public void test() {
        Class<Object> c1 = Object.class;
        Class<Comparable> c2 = Comparable.class;//interface java.lang.Comparable
        Class<String[]> c3 = String[].class;//class [Ljava.lang.String;
        Class<int[][]> c4 = int[][].class;//class [[I
        Class<ElementType> c5 = ElementType.class;//class java.lang.annotation.ElementType
        Class<Override> c6 = Override.class;//interface java.lang.Override
        Class<Integer> c7 = int.class;
        Class<Void> c8 = void.class;
        Class<Class> c9 = Class.class;

        int[] a = new int[10];
        int[] b = new int[100];
        Class<? extends int[]> c10 = a.getClass();
        Class<? extends int[]> c11 = b.getClass();
        System.out.println(c10 == c11);//true, 只要元素类型与维度一样，就是同一个Class
    }
}

关于类加载器的说明（了解）

Java的类加载器包括引导类加载器、系统类加载器和扩展类加载器。

ClassLoader的使用示例:

public class ClassLoaderTest {

    @Test
    public void test1(){
        //系统类加载器（调用类加载器）
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2

        //扩展类加载器（调用系统类加载器getParent()方法）
        ClassLoader parent = classLoader.getParent();
        System.out.println(parent);//sun.misc.Launcher$ExtClassLoader@28a418fc

        //无法直接用getParent()获取引导类加载器
        //引导类加载器主要负责加载java的核心类库，无法加载自定义类
        ClassLoader parent1 = parent.getParent();
        System.out.println(parent1);//null
    }

    @Test
    public void test2() throws IOException {
        Properties pros = new Properties();
//        //读取配置文件方式一：直接指定资源路径
//        FileInputStream fis = new FileInputStream("jdbc.properties");
//        pros.load(fis);

        //读取配置文件方式二：通过当前类定位路径获取资源
        ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("jdbc.properties");
        pros.load(is);

        String user = pros.getProperty("user");
        String password = pros.getProperty("password");
        System.out.println("user: " + user + ", password: " + password);//user: Tom, password: abc123

    }
}

2. 创建运行时类的对象

newInstance(): 调用此方法，创建对应的运行时类对象
- 调用条件：
  - 运行时类必须提供空参构造器
  - 要求空参构造器访问权限必须给够，通常设置为public
- 在javabean中要求提供一个public的空参构造器，原因如下：
  - 便于通过反射，创建运行时类的对象
  - 便于子类继承此运行时类时，默认调用super()的情况下，保证父类有此构造器
.class.getConstructor() -> constructor.newInstance()

public class NewInstanceTest {

    @Test
    public void test() throws Exception {
        Class<Person> clazz = Person.class;
        //方式一：调用class的newInstance()方法
        //要求运行时类必须有空参构造器且其访问权足够
        Person p = clazz.newInstance();
        System.out.println(p);

        //方式二：先调用class的getConstructor()方法，指定构造器
        // 再使用构造器的newInstance()方法创建对象
        Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
        Person person = constructor.newInstance("Tom", 12);
        System.out.println(person);
    }
}

3. 获取运行时类的指定结构

首先，我们自定义一个Person类及相关接口和注解。

注解:


@Target({ElementType.PARAMETER, ElementType.METHOD, ElementType.CONSTRUCTOR,
        ElementType.LOCAL_VARIABLE, ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value() default "hello";
}

接口:


public interface MyInterface {
    void info();
}

父类Creature:


public class Creature<T> implements Serializable {
    private char gender;
    public double weight;

    private void breathe() {
        System.out.println("Creatures breathe air to live.");
    }

    public void eat() {
        System.out.println("Creatures eat for energy.");
    }
}

Person类:


@MyAnnotation(value = "hi")
public class Person extends Creature<String> implements Comparable<String>, MyInterface {

    private String name;
    int age;
    public int id;

    public Person() {

    }

    @MyAnnotation(value = "abc")
    private Person(String name) {
        this.name = name;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @MyAnnotation
    private String show(String nation) {
        System.out.println("name:\t" + this.name + "\nnationality:\t" + nation);
        return nation;
    }

    public String display(String interest, int years) throws ClassCastException, NullPointerException {
        return interest + "[" + years + "]";
    }

    @Override
    public void info() {
        System.out.println("This is a creature of Homo Sapiens.");
    }

    @Override
    public int compareTo(String o) {
        return 0;
    }
}

(1) 获取成员变量：

getFields() - 获取当前运行时类及其父类中声明为public访问权限的属性
getDeclaredFields() - 获取当前运行时类及其父类中声明的所有属性，不包含父类
Field作为成员变量类：
- field.getModifiers() - 权限修饰符
- field.getType() - 数据类型
- field.getName() - 获取变量名

public class FieldTest {

    @Test
    public void test1() {
        Class<Person> clazz = Person.class;

        //getFields() - 获取当前运行时类及其父类中声明为public访问权限的属性
        Field[] fields = clazz.getFields();
        for (Field f: fields) {
            System.out.println(f);
        }

        System.out.println();
        //getDeclaredFields() - 获取当前运行时类及其父类中声明的所有属性，不包含父类
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field f: declaredFields) {
            System.out.println(f);
        }
    }

    //权限修饰符 数据类型 变量名
    @Test
    public void test2() {
        Class<Person> clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();

        for (Field f: declaredFields) {
            //1. 权限修饰符
            int modifiers = f.getModifiers();
            System.out.print(Modifier.toString(modifiers) + "\t");
            //2. 数据类型
            Class<?> type = f.getType();
            System.out.print(type.getName() + "\t");
            //3. 变量名
            String name = f.getName();
            System.out.println(name);
        }
    }
}

(2) 获取类方法:

getMethods() - 获取运行时类及其父类所有声明为public的方法
getDeclaredMethods() - 获取Person中所有方法（包括接口重写的方法），不包含父类方法
Method作为方法类：
- method.getAnnotations() - 获取方法声明的注解(注解必须声明为Runtime)
- method.getModifiers() - 获取权限修饰符
- method.getReturnType() - 获取返回值类型
- method.getName() - 获取方法名
- method.getParameterTypes() - 获取形参列表
- method.getExceptionTypes() - 获取异常列表

public class MethodTest {

    @Test
    public void test1() {
        Class<Person> clazz = Person.class;

        //getMethods() - 获取运行时类及其父类所有声明为public的方法
        Method[] methods = clazz.getMethods();
        for (Method m: methods) {
            System.out.println(m);
        }

        System.out.println();
        //getDeclaredMethods() - 获取Person中所有方法（包括接口重写的方法），不包含父类方法
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m: declaredMethods) {
            System.out.println(m);
        }
    }

    //@Xxx
    //权限修饰符 返回值类型 方法名(参数类型1 形参名1,...) throws XxxException{}
    @Test
    public void test2() {
        Class<Person> clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method m: declaredMethods) {
            //1.获取方法声明的注解(注解必须声明为Runtime)
            Annotation[] annotations = m.getAnnotations();
            for (Annotation a: annotations) {
                System.out.println(a);
            }
            //2. 权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + "\t");
            //3. 返回值类型
            Class<?> returnType = m.getReturnType();
            System.out.print(returnType.getName() + "\t");
            //4. 方法名
            System.out.print(m.getName() + "(");
            //5. 形参列表
            Class<?>[] parameterTypes = m.getParameterTypes();

            if (parameterTypes != null && parameterTypes.length != 0) {
                for (int i = 0; i < parameterTypes.length; i++) {
                    if (i == parameterTypes.length - 1) {
                        System.out.print(parameterTypes[i].getName() + " args_" + i + ")");
                    } else {
                        System.out.print(parameterTypes[i].getName() + " args_" + i + ", ");
                    }
                }
            } else {
                System.out.print(")");
            }
            //6. 获取异常
            Class<?>[] exceptionTypes = m.getExceptionTypes();
            if (exceptionTypes != null && exceptionTypes.length != 0) {
                System.out.print(" throws ");
                for (int i = 0; i < exceptionTypes.length; i++) {
                    if (i == exceptionTypes.length - 1) {
                        System.out.print(exceptionTypes[i].getName());
                    } else {
                        System.out.print(exceptionTypes[i].getName() + ", ");
                    }
                }
            }
            System.out.println();
            System.out.println();
        }
    }

(3) 获取其他指定结构

getConstructors() - 获取当前运行时类中的public构造器
getDeclaredConstructors() - 获取当前运行时类中所有的构造器
getSuperclass() - 获取父类
getGenericSuperclass() - 获取带泛型的父类
getInterfaces() - 获取运行时类所实现的接口
getPackage() - 获取运行时类所在的包
getAnnotations() - 获取运行时类的注解
…

public class OtherTest {

    @Test
    public void testConstructor() {
        Class<Person> clazz = Person.class;

        //getConstructors() - 获取当前运行时类中的public构造器
        Constructor<?>[] cons = clazz.getConstructors();
        for (Constructor c: cons) {
            System.out.println(c);
        }
        System.out.println();

        //getDeclaredConstructors() - 获取当前运行时类中所有的构造器
        Constructor<?>[] cons1 = clazz.getDeclaredConstructors();
        for (Constructor c: cons1) {
            System.out.println(c);
        }
    }

    @Test
    public void testSuper() {
        Class<Person> clazz = Person.class;
        //获取父类
        Class<? super Person> superclass = clazz.getSuperclass();
        System.out.println(superclass);

        //获取带泛型的父类
        Type genericSuperclass = clazz.getGenericSuperclass();
        System.out.println(genericSuperclass);

        //获取运行时类的父类的泛型
        ParameterizedType paramType = (ParameterizedType) genericSuperclass;
        System.out.println(paramType);

        //获取泛型类型
        Type[] actualTypeArguments = paramType.getActualTypeArguments();
        System.out.println(Arrays.toString(actualTypeArguments));

    }

    @Test
    public void testInterface() {
        Class<Person> clazz = Person.class;

        //获取运行时类的接口
        Class<?>[] interfaces = clazz.getInterfaces();
        for (Class c: interfaces) {
            System.out.println(c);
        }

        //获取运行时类父类的接口
        Class<?>[] interfaces1 = clazz.getSuperclass().getInterfaces();
        for (Class c: interfaces1) {
            System.out.println(c);
        }
    }

    @Test
    public void testPackage() {
        Class<Person> clazz = Person.class;
        System.out.println(clazz.getPackage());
    }

    @Test
    public void testAnnotation() {
        Class<Person> clazz = Person.class;
        //获取运行时类的注解
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation a: annotations) {
            System.out.println(a);
        }
    }
}

8-4 动态代理

代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象。

任何对原始对象的调用都要通过代理。
代理对象决定是否以及何时将方法调用转到原始对象上。

动态代理是指通过代理类来调用其他对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。动态代理相比于静态代理的优点在于，抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样我们可以更加灵活和统一的处理众多的方法。

动态代理使用场合：

调试
远程方法调用

应用举例:

(1) 使用静态代理

public class StaticProxyTest {

    public static void main(String[] args) {
        //创建被代理类的对象
        NikeClothFactory realFactory = new NikeClothFactory();
        //创建代理类对象
        ProxyClothFactory proxyFactory = new ProxyClothFactory(realFactory);

        proxyFactory.produceCloth();
    }
}

//接口
interface ClothFactory {
    void produceCloth();
}

//代理类
class ProxyClothFactory implements ClothFactory {

    private ClothFactory factory;//用被代理对象进行实例化

    public ProxyClothFactory(ClothFactory factory) {
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("Proxy factory is preparing for production...");
        factory.produceCloth();
        System.out.println("Proxy factory has got all other things done");
    }
}

//被代理类
class NikeClothFactory implements ClothFactory {

    @Override
    public void produceCloth() {
        System.out.println("Nike is producing sneakers...");
    }
}

(2) 使用动态代理的情形：

首先明确实现动态代理需要解决的问题：

问题1: 如何根据加载到内存中的被代理类，动态地创建一个代理类及其对象？
问题2: 当通过代理类对象调用方法时，如何动态地去调用被代理类中的同名方法？

public class DynamicProxyTest {

    public static void main(String[] args) {
        //1. 创建被代理类对象
        NikeClothFactory nikeClothFactory = new NikeClothFactory();
        //2. 调用ProxyFactory类的静态方法getProxyInstance，动态地创建一个代理类对象
        ClothFactory proxyInstance1 = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        //3. 通过代理类对象调用相关方法
        proxyInstance1.produceCloth();
    }
}


class ProxyFactory {
    /**
     * 通过此静态方法返回一个代理类对象，解决问题1
     * @param obj 被代理对象
     * @return 代理类对象
     */
    public static Object getProxyInstance(Object obj) {
        MyInvocationHandler h = new MyInvocationHandler();
        h.bind(obj);
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), h);
    }
}


class MyInvocationHandler implements InvocationHandler {

    private Object obj;//用于存储被代理类对象

    public void bind(Object obj) {
        this.obj = obj;
    }

    /**
     * 问题2的解决：
     * 当我们通过代理类对象调用方法a时，就会调用如下的invoke()方法
     * 将被代理类要执行的方法a的功能声明在invoke()中
     * @param proxy 代理类对象
     * @param method 需要让代理类对象去调用的方法
     * @param args method方法的形参列表
     * @return method方法的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnValue = method.invoke(obj, args);//obj: 被代理类对象
        return returnValue;
    }
}