什么是“反射”和“内省”？

已于 2023-04-04 16:37:34 修改
阅读量431 收藏 1
点赞数
文章标签： java 反射 内省
于 2021-07-27 16:57:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44778023/article/details/119148084
版权

目录

反射和内省

Property属性、Method方法、Field字段

反射

反射操作构造方法

    /**
     * 反射操作构造方法
     */
    @Test
    public void testReflectConstruct() throws Exception {
        // 1、创建反射对象
        Class<User> userClass = User.class;
        // 2、获得参数为String和Integer的公有构造器
        Constructor<User> constructor = userClass.getConstructor(String.class, int.class);
        // 3、通过获得的构造器创建对象和为参数赋值
        User user1 = constructor.newInstance("王政为2", 33);
        System.out.println("user1 = " + user1);

        /

        // 1、获取私有无参构造器
        Constructor<User> declaredConstructor = userClass.getDeclaredConstructor();
        // 2、允许访问（即无视private）
        declaredConstructor.setAccessible(true);
        // 3、通过获取到的无参构造器创建对象
        User user2 = declaredConstructor.newInstance();
        System.out.println("user2 = " + user2);
    }

通过反射操作无参、有参、私有、公有的方法

/**
 * 通过反射操作无参、有参、私有、公有的方法
 */
@Test
public void testMethod() throws Exception {
    // 1、创建反射对象
    Class<User> userClass = User.class;
    // 2、获得参数为String和Integer的公有构造器
    Constructor<User> constructor = userClass.getConstructor(String.class, int.class);
    // 3、通过获得的构造器创建对象和为参数赋值
    User user = constructor.newInstance("王政为2", 33);

    ///操作有参方法///
    
    // 1、通过反射的Class对象userClass获取到参数为String的方法eat
    Method method = userClass.getMethod("eat", String.class);
    // 2、指定调用对象并传入参数，调用方法
    method.invoke(user, "麻瓜");

    ///操作无参方法 & 操作私有方法///
    // 1、通过反射对象获取到无参的方法say
    Method declaredMethod = userClass.getDeclaredMethod("say");
    // 2、因为say是私有的，将其设置为允许访问（即无视private）
    declaredMethod.setAccessible(true);
    // 3、调用方法
    declaredMethod.invoke(user);

    ///获得所有方法///
    // 获得所有属于当前类的公有私有方法
    Method[] declaredMethods = userClass.getDeclaredMethods();
    for (Method dm : declaredMethods) {
        System.out.println("dm.getName() = " + dm.getName());
    }
    // 获得当前类及其父类的所有的公有方法
    Method[] methods = userClass.getMethods();
    for (Method m : methods) {
        System.out.println("m.getName() = " + m.getName());
    }
}

反射操作字段

    /**
     * 反射操作字段
     */
    @Test
public void testField() throws Exception {
        // 获取User.class对象
        Class<User> userClass = User.class;
        // 获得公有的参数依次为String和int的
        Constructor<User> constructor = userClass.getConstructor(String.class, int.class);
        // 获得实例对象
        User user = constructor.newInstance("王政象信息",22);
        System.out.println(user);

        获得字段
        // 1、获取私有字段name
        Field field = userClass.getDeclaredField("name");
        // 2、将私有设置为允许访问
        field.setAccessible(true);
        // 3、获取user中的name值，并打印
        System.out.println("field.get(user) = " + field.get(user));

        修改字段
        // 1、获取私有字段name
        Field name = userClass.getDeclaredField("name");
        // 2、将私有设置为允许访问
        name.setAccessible(true);
        // 3、修改user对象中的name值
        name.set(user,"象信息王政");
        // 打印
        System.out.println("field.get(user) = " + field.get(user));
    }
}

记忆要点

  1. 获取当前类的所有方法、属性、构造器（包括私有），一般是getDeclaredXXX()，不加Declared一般就是获取当前类及其父类的所有公有方法。
  2. 一般需要构建某个东西，如：构造器、JavaBean描述对象BeanInfo等是传入.class或者getClass()对象，因为其是独一无二的。
  3. 一般需要指定获得某个字段或者方法，一般需要指定或数据来自哪个对象，此时就不再是class对象，而是实例化对象。

内省

实体类

@Data
public class User {

    private String name = "王政";
    private int age = 21;

    private void say() {
        System.out.println("哈哈哈");
    }

    public void eat(String food) {
        System.out.println(food);
    }

    public User() {
    }

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

Map和JavaBean之间的相互转化

public class BeanUtils<T> {

    /**
     * 将JavaBean对象转换为Map
     */
    public static Map<String, Object> getMapByJavabean(Object bean) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
        Map<String, Object> maps = new HashMap<>();
        // Object.class 是指断点，Object.class中的所有方法都被忽略
        BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass(), Object.class);
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
            String name = propertyDescriptor.getName();
            Object value = propertyDescriptor.getReadMethod().invoke(bean);
            maps.put(name, value);
        }
        return maps;
    }

    /**
     * 将Map转换为JavaBean对象
     */
    public static<T> T getJavaBeanByMap(Map<String, Object> maps ,Class<?> clazz) throws IntrospectionException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        BeanInfo beanInfo = Introspector.getBeanInfo(clazz,Object.class);
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        Constructor<?> constructor = clazz.getConstructor();
        Object o = constructor.newInstance();
        T jBean = (T) o;
        for (PropertyDescriptor pd : propertyDescriptors) {
            String name = pd.getName();
            pd.getWriteMethod().invoke(jBean,maps.get(name));
        }
        return jBean;
    }

}
class Test{
    
    /**
     * 将JavaBean对象转换为Map集合
     */
    @Test
    public void testGetMapByJavaBean() throws IllegalAccessException, IntrospectionException, InvocationTargetException {
        Map<String, Object> maps = BeanUtils.getMapByJavabean(new User("王政", 22));
        System.out.println("maps.toString() = " + maps.toString());
    }

    /**
     * 将Map集合转换为JavaBean对象
     */
    @Test
    public void testGetJavaBeanByMap() throws InvocationTargetException, NoSuchMethodException, IntrospectionException, InstantiationException, IllegalAccessException {
        Map<String,Object> maps = new HashMap<>();
        maps.put("name","王政哈哈");
        maps.put("age",22);
        User javaBeanByMap = new BeanUtils<User>().getJavaBeanByMap(maps, User.class);
        System.out.println("javaBeanByMap = " + javaBeanByMap);
    }
}

通过内省操作JavaBean内容

public class UserTest {

    /**
     * 内省获取JavaBean对象中的方法
     */
    @Test
    public void testIntroMethod() throws Exception {
        User user = User.class.newInstance();
        // 1、通过字节码对象,获取到JavaBean的描述对象。
        BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
        // 2、通过JavaBean描述对象获取 方法描述器，返回方法描述器数组
        MethodDescriptor[] md = beanInfo.getMethodDescriptors();
        // 3、遍历方法描述器数组
        for (MethodDescriptor methodDescriptor : md) {
            // 打印方法名
            System.out.println("methodDescriptor.getName() = " + methodDescriptor.getName());
        }
    }

    /**
     * 内省获取JavaBean对象中的属性
     */
    @Test
    public void testIntroPro2() throws Exception {
        // 通过反射获取到User对象
        // 1、获取类对象
        Class<User> userClass = User.class;
        // 2、获取类中构造器
        Constructor<User> constructor = userClass.getConstructor();
        // 3、通过构造器创建User对象
        User user = constructor.newInstance();
        // 4、通过User.class对象获取到JavaBean描述对象BeanInfo
        BeanInfo beanInfo = Introspector.getBeanInfo(User.class);
        // 5、通过JavaBean描述对象获取到 属性描述器，返回属性描述器数组。
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        // 6、遍历属性描述器数组中的元素，获取单独的属性并操作
        for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
            if ("name".equals(propertyDescriptor.getName())) {
                // 获取name的设置器（Setter）并调用（修改的对象，数据）
                propertyDescriptor.getWriteMethod().invoke(user, "王政");
            } else if ("age".equals(propertyDescriptor.getName())) {
                // 获取age的设置器（Setter）并调用（修改的对象，数据）
                propertyDescriptor.getWriteMethod().invoke(user, 11);
            }
            // 获取每个属性描述器数组元素的获得器（Getter），并调用
            System.out.println("propertyDescriptor.getReadMethod() = " + propertyDescriptor.getReadMethod().invoke(user));
        }
    }
}

内省的定义就是通过反射和Introspector类获取到JavaBean的描述对象BeanInfo，通过描述对象获得传入的Class类对象类中满足JavaBean规范的属性和方法

反射和内省的区别

反射：反射操作任何类中的所有成员。

内省：内省只能操作符合JavaBean规则的类的成员。

使用反射打破单例

/**
 * @projectName: 10_reflect
 * @package: cn.wolfcode.test_single
 * @className: SayUtilsSingle
 * @author: 王政
 * @description: TODO 单例类
 * @date: 21/7/27 16:06
 * @version: 1.0
 */
public class SayUtilsSingle {
    private static final SayUtilsSingle SAY_UTILS_SINGLE = new SayUtilsSingle();

    private static int num = 1;

    public static SayUtilsSingle getInstance(){
        return SAY_UTILS_SINGLE;
    }

    public void say(){
        System.out.println("哈哈哈哈" + num);
    }

    private SayUtilsSingle() {
        num++;
    }
}

通过反射打破单例

/**
 * @projectName: 10_reflect
 * @package: cn.wolfcode.test_single
 * @className: BrokenSingle
 * @author: 王政
 * @description: TODO
 * @date: 21/7/27 16:10
 * @version: 1.0
 */
public class BrokenSingle {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        // 正常操作
        SayUtilsSingle single = SayUtilsSingle.getInstance();
        single.say();
        // 打破
        // 获取单例类的类对象
        Class<SayUtilsSingle> susc = SayUtilsSingle.class;
        // 获取类对象的无参构造方法（不管是否是private修饰都能获取到）
        Constructor<SayUtilsSingle> declaredConstructor = susc.getDeclaredConstructor();
        // 允许访问私有
        declaredConstructor.setAccessible(true);
        // 通过构造器创建对象，成功打破单例
        SayUtilsSingle single1 = declaredConstructor.newInstance();
        single1.say();
    }
}

建议：需要使用单例模式的时候通过枚举类创建单例，枚举的单例是无法被反射打破的。

注意事项

  1. 在使用反射时候，我们通过.class或者getClass()获取到的反射对象，通过反射对象调用getDeclaredFields()方法获取到的包含本类所有的字段的数组，其中的元素是按照类中书写的顺序存储的。
  2. 在使用内省时候，我们通过Introspector对象调用getPropertyDescriptors()方法获取到的包含本类所有的字段的数组，其中的元素是按照元素名称的顺序从小到大排序存储的。

**重要：**在传输基本数据的时候以Object类型接收，此时使用接收来的数据获取到的类对象是基本数据类型的包装类，解决方法就是尽量在传输数据和设计实体类的时候变量均设置为包装数据类型。

君去何方
关注
反射与内省
Saul_M的博客
07-29 296
github 示例代码：参考Demo 1、什么是反射 类信息 ---> 对象 对象 ---> 类信息 2、Class类 Class类是一切的反射根源。 Class类表示什么？ 很多的人——可以定义一个Person类（有年龄，性别，姓名等） 很多的车——可以定义一个Car类（有发动机，颜色，车轮等） 很多的类——Class类（类名，构造方法，属性，方法...
反射内省作业
weixin_45701868的博客
04-26 2021
目录 1、单选题 2、编程题 反射基本方法的使用 使用反射输出学生name和age 演示内省 1、单选题 1、下面程序的输出结果是什么? （C） public class Example extends Date { public static void main(String[] args) { new Example().test(); } public void test() { System.out.println(super.getClass().get...
反射和内省
梦不遥远的专栏
01-26 515
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 1.反射：一个类有多个组成部分，比如成员方法，成员变量，构造函数。反射就是加载类，并且去解剖出类的各个组成部分。 2.加载类：java中有一个Class类用于代表某一个类的代码。 3.Class类既然代表某个类的字节码，那么必然提供了加载某个字节码的方法，例如： forName(),
反射机制和内省机制的区别
Forever212121的博客
05-14 551
1.什么是反射 反射就是在运行状态把 Java 类中的各种成分映射成相应相应的 Java 类，可以动态得获取所有的属性以及动态调用任意一个方法。 1).一段java代码在程序的运行期间会经历三个阶段：source-->class-->runtime 2).Class对象 在java中用一个Class对象来表示一个java类的class阶段 Class对象封装了一个java类定义的成员变量
用反射和内省技术实现简单SpringIOC
05-25
首先，我们来理解什么是反射和内省。 反射是Java提供的一种强大的动态类型机制，它允许程序在运行时检查类的信息，如类名、属性、方法等，并能够创建和操作对象。Java.lang.reflect包提供了Class、Constructor、...
java反射全解（反射原理+反射API详解+反射与数组+反射与泛型+反射源码与性能开销+反射优缺点+反射与内省）
06-21
java 反射机制全解 java 反射机制是 Java 语言中的一种动态获取信息和调用对象方法的技术核心。它允许在程序运行时加载、探索以及使用编译期间完全未知的 ....反射机制可以动态地获取内省的信息和调用内省的方法。
minimalcode-reflect:JavaBean 的简约反射和内省功能
05-30
在Java编程语言中，反射和内省是两个强大的特性，它们允许程序在运行时检查类、接口、字段和方法的信息，甚至动态地调用方法和访问属性。"minimalcode-reflect"项目提供了一个简约的框架，专注于JavaBean的反射和...
Java反射与内省-PPT
最新发布
11-20
Java反射与内省是Java编程语言中的核心特性，它们为开发者提供了强大的能力，可以在运行时检查和操作类、接口、对象及其属性。本PPT深入探讨了这些概念，旨在帮助开发者充分利用Java平台的灵活性。 首先，Java反射...
不学无数——反射和内省的区别
weixin_33682719的博客
09-03 151
反射和内省的区别 内省是基于反射实现的，主要用来操作JavaBean，通过内省可以很方便的动态获得bean的set/get方法，属性，方法名，他相当于是反射的工具类一样 1. 反射 反射其实简单来说就是通过类的名字获得对于这个类的描述，这种描述包括方法、构造器、属性的描述。举个例子来说就是通过类名可以进行实例化对象、对类中的方法的调用、对类中属性的赋值。在许多的框架中反射是经常被应用到的技术，...
深入理解Java的内省与反射
weixin_34138521的博客
04-26 213
很多朋友在深入的接触Java语言后就会发现这样两个词：反射和内省，之前我们已经通过实例解析了Java的反射机制，在什么场合下应用以及如何使用？今天把这二者放在一起介绍，因为它们二者是相辅相成的。 反射 相对而言，反射比内省更容易理解一点。用一句比较白的话来概括，反射就是让你可以通过名称来得到对象(类，属性，方法)的技术。例如我们可以通过类名来生成一个类的实例；知道了方法名，就可以调用这个方...
反射与内省（简单易懂版）
Strine的博客
03-24 157
因此我们可以使用反射，可以通过一个对象的字节码文件，获取到它的真实类型以及调用该对象中的方法；动态性：反射和new都能创建对象并且调用里面的方法，但是反射是针对字符串编程，而new是针对实体类编程，反射可以深入到类的内部结构去进行一些操作；当我们在传入对象进行一些操作的时候，大部分需要强转，但是我们不知道调用者带了什么对象的时候无法强转（有风险）；1.突破一些sdk的API接口限制（访问一个类的私有字段，私有方法等等）2.获取属性对应的读写方法，操作属性的值等操作方式；4.公共的无参构造器；
关于反射与内省
qq_41366408的博客
08-14 166
@反射和内省 反射 在程序运行过程中，通过字节码对象，去获取类中的成员信息（构造器，方法，字段） 为什么使用反射：可以通过一个对象，获取到它的真实类型以及调用该对象中的方法 获取字节码对象的方式 // 通过Class类的forName(String className)方法来获取字节码对象 className：类的全限定名 Class clz = Class.forName("cn.wolfcode._01_reflect.Person"); // 通过对象的getClass()方法来获取字节码对象 Cla
反射(Reflection)和内省(Introspector)
GZL的博客
09-15 288
反射可以通过类名获取到对应的Class,可以通过方法名获取到Method并通过invoke方法调用获取到的方法. 应用场景:这样一个应用程序，它支持动态的功能扩展，也就是说程序不重新启动但是可以自动加载新的功能，这个功能使用一个具体类来表示。首先我们必须为这些功能定义一个接口类，然后我们要求所有扩展的功能类必须实现我指定的接口，这个规定了应用程序和可扩展功能之间的接口规则，但是怎么动态加载呢？我
内省和反射
语言观止
12-05 1816
内省和反射的英文名称分别为：introspector和reflection 内省：从字面上理解，凡是查看（类、函数等）内部情况的函数叫做内省函数。Lua把debug.getinfo称为内省函数，它可以查看函数或者协程里面的情况。 反射：通过函数（类等）的字符串名访问对应的函数，成为反射。Lua中的反射为： function func(a) print(a, "fun
反射与内省.md
LEIQINGQI的博客
10-09 295
文章目录1、 什么是反射2、 Class 类3、 通过Class 类获取类信息4、 通过Class 类调用属性或方法5、 动态代理InvocationHandler 类Proxy 类接口接口实现测试5、类加载器原理分析1、类的加载过程类的初始化，类什么时候才被初始化 ? ( 6 种情况 )3 类的加载6、 JavaBean 概念什么是JavaBeanJavaBean 命名规则7、 内省基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

君去何方

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值