（十二）反射与内省

最新推荐文章于 2022-03-23 20:27:36 发布

Yanko24

最新推荐文章于 2022-03-23 20:27:36 发布

阅读量127

点赞数

分类专栏：编程语言

本文链接：https://blog.csdn.net/weixin_43495317/article/details/100710803

版权

编程语言专栏收录该内容

33 篇文章 0 订阅

订阅专栏

什么是反射（Reflection）
- 通过对象去获取类信息

Class类

Class类是一切的反射根源类
Class类表示什么？
- 很多的人——可以定义一个Person类
很多的车——可以定义一个Car类
- 很多的类——Class类
得到Class类的对象有三种方式
- Object类中的getClass()方法
- 类.class
- 通过Class的forName()方法

使用Class类进行对象的实例化操作

// 调用无参数的构造方法进行实例化
public T newInstance() throws InstantiationException, IllegalAccessException

// 调用有参数的构造方法进行实例化
public Constructor<?>[] getConstructors() throws SecurityException

示例

/**
 * 获取Class对象的三种形式
 */
@Test
public void test1() {
    // 通过对象的getClass()方法
    Dog dog = new Dog("二哈", 5, "白色");
    Class dogClass = dog.getClass();

    // 通过类.class
    Class aClass = Dog.class;

    // 通过Class.forName()方法
    try {
        Class forName = Class.forName("day11_反射与内省.reflection.Dog");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

通过Class类取得类信息

通过反射来实例化对象

/**
 * 通过反射来实例化对象
 */
@Test
public void test2() {
    Class<Dog> dogClass = Dog.class;
    try {
        // 通过Class对象实例化类对象，调用了默认无参的构造方法
        Dog dog = (Dog) dogClass.newInstance();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

获取所有的构造方法

/**
 * 获取所有的构造方法
 */
@Test
public void test3() {
    Class<Dog> dogClass = Dog.class;
    Constructor<?>[] constructors = dogClass.getConstructors();
    for (int i = 0; i < constructors.length; i++) {
        System.out.println(constructors[i].getName());
        System.out.println(constructors[i].getParameterCount());
    }
    try {
        // 获取一个指定的构造方法
        Constructor<Dog> constructor = dogClass.getConstructor(String.class, int.class, String.class);
        // 调用有参数的构造方法来实例化对象
        Dog dog = constructor.newInstance("哈士奇", 4, "黑色");
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    }
}

获取属性

/**
 * 获取的所有属性
 */
@Test
public void test4() {
    Class<Dog> dogClass = Dog.class;
    // 获取非私有的属性
    Field[] fields = dogClass.getFields();
    System.out.println(fields.length);
    System.out.println("------------------");
    // 获取所有属性（包括私有属性）
    Field[] declaredFields = dogClass.getDeclaredFields();
    System.out.println(declaredFields.length);
    System.out.println("-------------------");
    for (int i = 0; i < declaredFields.length; i++) {
        int modifiers = declaredFields[i].getModifiers();
        Class<?> type = declaredFields[i].getType();
        String name = declaredFields[i].getName();
        System.out.println(Modifier.toString(modifiers) + " " + type + " " + name);
    }
}

获取包名

@Test
public void test5() {
    Dog dog = new Dog("拉布拉多", 5, "黄色");
    Class<Dog> dogClass = Dog.class;
    // 获取类的包名
    Package aPackage = dogClass.getPackage();
    System.out.println(aPackage.getName());
}

通过Class类调用属性或方法

调用类中的方法

@Test
public void test5() {
    Dog dog = new Dog("拉布拉多", 5, "黄色");
    Class<Dog> dogClass = Dog.class;
    // 获取公共的方法，包括继承的公有方法
    Method[] methods = dogClass.getMethods();
    for (int i = 0; i < methods.length; i++) {
        System.out.println(methods[i]);
        if (methods[i].getName().equals("toString")) {
            try {
                String s = (String) methods[i].invoke(dog);
                System.out.println(s);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    System.out.println("-------------------");
    // 访问私有方法，获取到本类中定义的所有方法（不包括父类）
    Method[] declaredMethods = dogClass.getDeclaredMethods();
    for (int i = 0; i < declaredMethods.length; i++) {
        System.out.println(declaredMethods[i]);
        if (declaredMethods[i].getName().equals("set")) {
            // 设置方法可以被访问（去除访问修饰符的检查）
            declaredMethods[i].setAccessible(true);
            try {
                declaredMethods[i].invoke(dog);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
}

调用类中的属性

@Test
public void test6() {
    Dog dog = new Dog("拉布拉多", 4, "灰色");
    Class<Dog> dogClass = Dog.class;
    try {
        Field name = dogClass.getDeclaredField("name");
        name.setAccessible(true);
        name.set(dog, "二哈");
        System.out.println("修改后的名字为：" + dog.getName());
    } catch (NoSuchFieldException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
}

动态代理设计模式

所谓动态代理，即通过运行代理类：Proxy的代理，接口和实现类之间可以不直接发生联系，而可以在运行期（Runtime）实现动态关联
Java动态代理主要是使用java.lang.reflect包中的两个类

InvocationHandler类

public Object invoke(Object obj, Method method, Object[] obs)
// 其中第一个参数obj指的是代理类，method是被代理的方法，obs是指被代理的方法的参数组。此方法由代理类来实现

Proxy类

protected Proxy(InvocationHandler h);
static Class getProxy(ClassLoader loader, Class[] interface);
static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h);
// 动态代理其实是在运行时生成class，所以，我们必须提供一组interface，然后告诉他class已经实现了这些interface，而且在生成Proxy的时候，我们必须给他提供一个handler，让他来接管实际的工作

类加载器原理分析
- 类加载的过程
  - JVM将类加载过程分为三个步骤：装载（Load）、链接（Link）和初始化（Initialize）。链接又分为三个步骤：验证、准备和解析
  - 装载：查找并加载类的二进制数据
  - 链接：
    - 验证：确保被加载类的正确性
    - 准备：为类的静态变量分配内存，并将其初始化为默认值
    - 解析：把类中的符号引用转换为直接引用
  - 初始化：为类的静态变量赋予正确的初始值
- 类的初始化，类什么时候被初始化
  - 创建类的实例，也就是new一个对象
  - 访问某个类或者接口的静态变量，或者对该静态变量赋值
  - 调用类的静态方法
  - 反射（Class.forName(“com.reflect.Dog”)）
  - 初始化一个类的子类（会首先初始化子类的父类）
  - JVM启动时标明的启动类，即文件名和类名相同的那个类
- 类的加载
  - 指的是将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个这个类的Java.lang.Class对象，用来封装在方法区类的对象
JavaBean的概念
- 什么是JavaBean？
  - Bean理解为组件意思，JavaBean就是Java组件，在广泛的理解就是一个类，对于组件来说，关键在于要具有“能够被IDE构建工具侦测其属性和事件”的能力，通常在Java中
- JavaBean的命名规则
  - 对于一个名称为xxx的属性，通常要写两个方法：getXxx()和setXxx()。任何浏览这些方法的工具，都会把get或set后面的第一个字母自动转换为小写
  - 对于布尔属性，可以使用以上get和set方式，不过也可以把get替换成is
  - Bean的普通方法不必遵循以上的命名规则，不过他们必须是public的
  - 对于事件，要使用Swing中处理监听器的方式。如addWindowListener，reemoveWindowListener
- BeanUtils工具类：http://apache.org/
内省基本概念
- 概念：内省（Introspector）是Java语言对Bean类属性、事件的一种缺省处理方法。例如类A中有属性name，那我们可以通过getName，setName来得到其值或者设置新的值
- 通过getName/setName来访问name属性，这就是默认的规则
- Java中提供了一套API用来访问某个属性的getter/setter方法，通过这些API可以使你不需要了解这个规则，这些API存放于包java.beans中，一般的做法是通过类Introspector的getBeanInfo方法来获取某个对象的BeanInfo信息，然后通过BeanInfo来获取属性的描述器（PropertyDescriptor），通过这个属性描述器就可以获取某个对应属性的getter/setter方法，然后我们就可以通过反射机制来调用这些方法

Introspector相关API

Introspector类
- Introspector类为通过工具学习有关受目标JavaBean支持的属性、事件和方法的只是提供了一个标准方法t
```
// 在JavaBean上进行内省，了解其所有属性、公开的方法和事件
static BeanInfo getBeanInfo(Class<?> beanClass);
```

BeanInfo类

该类实现此BeanInfo接口并提供有关其bean的方法、属性、事件等显式信息

// 获得beans MethodDescriptor
MethodDescriptor[] getMethodDescriptors();

// 获得 beans PropertyDescriptor
PropertyDescriptor[] getPropertyDescriptors();

PropertyDescriptor类

PropertyDescriptor描述JavaBean通过一对存储器方法导出的一个属性

// 获取应该用于读取属性值的方法
Method getReadMethod();

// 获取应该用于写入属性值得方法
Method getWriteMethod();

MethodDescriptor类
- MethodDescriptor描述了一种特殊的方法，即JavaBean支持从其他组件对其进行外部访问
```
// 获得此MethodDescriptor封装的方法
Method getMethod();
```

理解可配置的AOP框架
- 补充知识
  - AOP的概念：Aspect Oriented Programming（面向切面编程）
  - 可理解AOP框架实现
  - AOP用来封装横切关注点，具体可以在以下场景使用：
    - 权限
    - 缓存
    - 错误处理
    - 调试
    - 记录跟踪
    - 持久化
    - 同步
    - 事务

单例模式优化

保证同步保证线程安全synchronized
使用volatile关键字
- volatile提醒编译器它后面定义的变量随时都有可能改变，因此编译后的程序每次需要存储或读取这个变量的时候，都会直接从变量地址中读取数据。如果没有volatile关键字，则编译器可能优化调用和存储，可能暂时使用寄存器中的值，如果这个变量由别的程序更新了的话，将出现不一致的情况
防止反射调用私有构造方法

让单例类序列化安全

import java.io.Serializable;

/**
 * @author xiao儿
 * @date 2019/9/10 20:10
 * @Description SingleTon
 * 单例模式
 * 1.多线程访问的安全问题
 * 2.加上volatile关键字，保证变量的一致性
 * 3.防止反射私有化构造方法
 * 4.让单例类序列化安全
 */
public class Singleton implements Serializable {
    private volatile static Singleton singleton = null;

    private Singleton() {
        if (singleton != null) {
            throw new RuntimeException("此类对象为单例模式，已经被实例化");
        }
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

Yanko24

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
（十二）反射与内省

什么是反射（Reflection）通过对象去获取类信息Class类Class类是一切的反射根源类Class类表示什么？很多的人——可以定义一个Person类很多的车——可以定义一个Car类很多的类——Class类得到Class类的对象有三种方式Object类中的getClass()方法类.class通过Class的forName()方法...
复制链接

扫一扫