AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java中的反射使用

2022-05-27 126
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java中的反射使用

Java反射

说到Java中的反射使用，大家肯定不陌生，但是在真正使用的时候却犯了难。因为不经常使用的关系，当真正需要使用反射的时候却经常忘记该怎么写了，真的是非常尴尬…


为此，我特地分类整理了一些常用的反射使用方法，以方便大家使用。点击查看项目源码


反射设置属性


反射设置某个对象的成员属性


/**
 * 反射设置某个对象的成员属性
 *
 * @param owner     对象
 * @param fieldName 属性名
 * @param value     属性值
 * @return
 * @throws Exception
 */
public static void setField(Object owner, String fieldName, Object value)
        throws Exception {
    Class<?> ownerClass = owner.getClass();
    Field field = ownerClass.getDeclaredField(fieldName);
    field.setAccessible(true);
    field.set(owner, value);
}


反射设置某个类的静态属性


/**
 * 反射设置某个类的静态属性
 *
 * @param className 类名
 * @param fieldName 属性名
 * @param value     属性值
 * @return
 * @throws Exception
 */
public static void setStaticField(String className, String fieldName, Object value)
        throws Exception {
    Class<?> ownerClass = Class.forName(className);
    Field field = ownerClass.getDeclaredField(fieldName);
    field.setAccessible(true);
    field.set(null, value);
}
/**
 * 反射设置某个类的静态属性
 *
 * @param clazz     类
 * @param fieldName 属性名
 * @param value     属性值
 * @return
 * @throws Exception
 */
public static void setStaticField(Class<?> clazz, String fieldName, Object value)
        throws Exception {
    Field field = clazz.getDeclaredField(fieldName);
    field.setAccessible(true);
    field.set(null, value);
}


反射获取属性


反射获取某个对象的成员属性


/**
 * 反射获取某个对象的成员属性
 *
 * @param owner     对象
 * @param fieldName 属性名
 * @return
 * @throws Exception
 */
public static Object getField(Object owner, String fieldName)
        throws Exception {
    Class<?> ownerClass = owner.getClass();
    Field field = ownerClass.getDeclaredField(fieldName);
    field.setAccessible(true);
    return field.get(owner);
}


反射获取某个类的静态属性


/**
 * 反射获取某个类的静态属性
 *
 * @param className 类名
 * @param fieldName 属性名
 * @return
 * @throws Exception
 */
public static Object getStaticField(String className, String fieldName)
        throws Exception {
    Class<?> ownerClass = Class.forName(className);
    Field field = ownerClass.getDeclaredField(fieldName);
    field.setAccessible(true);
    return field.get(ownerClass);
}
/**
 * 反射获取某个类的静态属性
 *
 * @param clazz     类
 * @param fieldName 属性名
 * @return
 * @throws Exception
 */
public static Object getStaticField(Class<?> clazz, String fieldName)
        throws Exception {
    Field field = clazz.getDeclaredField(fieldName);
    field.setAccessible(true);
    return field.get(clazz);
}


反射执行方法


注意点


对于我们封装的方法来说，当方法的参数类型是int、boolean、short等基础类型时，使用getClass()方法获取到的类型将是Integer、Boolean、Short等包装类，在调用getDeclaredMethod获取方法对象的时候就会抛异常NoSuchMethodException;


如果调用的方法属于该对象的父类,那getDeclaredMethod就会抛异常NoSuchMethodException;


获取参数的类集合方法


/**
 * 获取参数的类集合
 *
 * @param args
 * @return
 */
private static Class<?>[] getClasses(Object... args) {
    Class<?>[] argsClass;
    if (args != null && args.length > 0) {
        argsClass = new Class[args.length];
        for (int i = 0, j = args.length; i < j; i++) {
            argsClass[i] = args[i].getClass();
        }
    } else {
        argsClass = new Class[0];
    }
    return argsClass;
}


反射执行某对象的成员方法


/**
 * 反射执行某对象的成员方法
 *
 * @param owner      对象
 * @param methodName 方法名
 * @param args       参数集合
 * @return
 * @throws Exception
 */
public static Object invokeMethod(Object owner, String methodName,
                                  Object... args) throws Exception {
    Class<?> ownerClass = owner.getClass();
    Class<?>[] argsClass = getClasses(args);
    Method method = ownerClass.getDeclaredMethod(methodName, argsClass);
    method.setAccessible(true);
    return method.invoke(owner, args);
}
/**
 * 反射执行某对象的成员方法（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
 *
 * @param owner      对象
 * @param methodName 方法名
 * @param args       参数集合
 * @return
 * @throws Exception
 */
public static Object invokeMethod(Object owner, String methodName,
                                  Class<?>[] argsClass, Object... args) throws Exception {
    Class<?> ownerClass = owner.getClass();
    Method method = ownerClass.getDeclaredMethod(methodName, argsClass);
    method.setAccessible(true);
    return method.invoke(owner, args);
}


反射执行某个类的静态方法


/**
 * 反射执行某个类的静态方法
 *
 * @param className  类名
 * @param methodName 方法名
 * @param args       参数集合
 * @return
 * @throws Exception
 */
public static Object invokeStaticMethod(String className,
                                        String methodName, Object... args) throws Exception {
    Class<?> ownerClass = Class.forName(className);
    Class<?>[] argsClass = getClasses(args);
    Method method = ownerClass.getDeclaredMethod(methodName, argsClass);
    method.setAccessible(true);
    return method.invoke(null, args);
}
/**
 * 反射执行某个类的静态方法
 *
 * @param clazz      类
 * @param methodName 方法名
 * @param args       参数集合
 * @return
 * @throws Exception
 */
public static Object invokeStaticMethod(Class<?> clazz,
                                        String methodName, Object... args) throws Exception {
    Class<?>[] argsClass = getClasses(args);
    Method method = clazz.getDeclaredMethod(methodName, argsClass);
    method.setAccessible(true);
    return method.invoke(null, args);
}
/**
 * 反射执行某个类的静态方法（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
 *
 * @param className  类名
 * @param methodName 方法名
 * @param argsClass  参数类型的集合
 * @param args       参数集合
 * @return
 * @throws Exception
 */
public static Object invokeStaticMethod(String className,
                                        String methodName, Class<?>[] argsClass, Object... args) throws Exception {
    Class<?> ownerClass = Class.forName(className);
    Method method = ownerClass.getDeclaredMethod(methodName, argsClass);
    method.setAccessible(true);
    return method.invoke(null, args);
}
/**
 * 反射执行某个类的静态方法（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
 *
 * @param clazz      类
 * @param methodName 方法名
 * @param argsClass  参数类型的集合
 * @param args       参数集合
 * @return
 * @throws Exception
 */
public static Object invokeStaticMethod(Class<?> clazz,
                                        String methodName, Class<?>[] argsClass, Object... args) throws Exception {
    Method method = clazz.getDeclaredMethod(methodName, argsClass);
    method.setAccessible(true);
    return method.invoke(null, args);
}


反射构建实例


/**
 * 反射构建实例
 *
 * @param className 类名
 * @param args      构造函数的参数集合
 * @return
 * @throws Exception
 */
public static Object newInstance(String className, Object... args)
        throws Exception {
    Class<?> newOneClass = Class.forName(className);
    Class<?>[] argsClass = getClasses(args);
    Constructor<?> cons = newOneClass.getDeclaredConstructor(argsClass);
    cons.setAccessible(true);
    return cons.newInstance(args);
}
/**
 * 反射构建实例
 *
 * @param clazz 类
 * @param args  构造函数的参数集合
 * @return
 * @throws Exception
 */
public static <T> T newInstance(Class<T> clazz, Object... args)
        throws Exception {
    Class<?>[] argsClass = getClasses(args);
    Constructor<?> cons = clazz.getDeclaredConstructor(argsClass);
    cons.setAccessible(true);
    return (T) cons.newInstance(args);
}
/**
 * 反射构建实例（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
 *
 * @param className 类名
 * @param argsClass 参数类型的集合
 * @param args      构造函数的参数集合
 * @return
 * @throws Exception
 */
public static Object newInstance(String className, Class<?>[] argsClass, Object... args)
        throws Exception {
    Class<?> newOneClass = Class.forName(className);
    Constructor<?> cons = newOneClass.getDeclaredConstructor(argsClass);
    cons.setAccessible(true);
    return cons.newInstance(args);
}
/**
 * 反射构建实例（对于参数是基础类型的方法，反射时用getClass获取的是包装类型，会出错）
 *
 * @param clazz     类
 * @param argsClass 参数类型的集合
 * @param args      构造函数的参数集合
 * @return
 * @throws Exception
 */
public static <T> T newInstance(Class<T> clazz, Class<?>[] argsClass, Object... args)
        throws Exception {
    Constructor<?> cons = clazz.getDeclaredConstructor(argsClass);
    cons.setAccessible(true);
    return (T) cons.newInstance(args);
}


测试


测试所需的类


/**
 * 学生类
 *
 * @author xuexiang
 * @since 2019/3/4 下午8:36
 */
public class Student {
    /**
     * 用于测试反射获取静态属性
     */
    private static long TotalNumber = 28;
    public int ID;
    /**
     * 用于测试反射获取成员属性
     */
    private String Name;
    private int Age = 20;
    private int Sex;
    private int Score;
    private Student() {
    }
    /**
     * 用于测试反射构建实例
     */
    private Student(int ID, String name) {
        this.ID = ID;
        Name = name;
    }
    public Student(int ID, String name, int age) {
        this.ID = ID;
        Name = name;
        Age = age;
    }
    public Student(int ID, String name, int age, int sex, int score) {
        this.ID = ID;
        Name = name;
        Age = age;
        Sex = sex;
        Score = score;
    }
    /**
     * 用于测试反射调用成员方法
     * @return
     */
    private String getName(Integer param) {
        return Name;
    }
    /**
     * 用于测试反射调用成员方法
     * @return
     */
    private Student setName(String name) {
        Name = name;
        return this;
    }
    /**
     * 用于测试反射调用静态方法
     * @return
     */
    private static long incrementTotalNumber(int number) {
        return TotalNumber + number;
    }
    @Override
    public String toString() {
        return "Student{" +
                "ID=" + ID +
                ", Name='" + Name + '\'' +
                ", Age=" + Age +
                ", Sex=" + Sex +
                ", Score=" + Score +
                "}, TotalNumber=" + TotalNumber;
    }
}
/**
 * 继承了Student，用于测试"如果调用的方法属于该对象的父类,那getDeclaredMethod就会抛异常NoSuchMethodException"的问题
 *
 * @author xuexiang
 * @since 2019/3/4 下午10:12
 */
public class GoodStudent extends Student {
    private int AchievementCount = 3;
    public GoodStudent(int ID, String name, int age, int sex, int score) {
        super(ID, name, age, sex, score);
    }
    public GoodStudent(Student student) {
        super(student.ID + 1, "xxxx", 22);
    }
    public int getAchievementCount() {
        return AchievementCount;
    }
    public GoodStudent setAchievementCount(int achievementCount) {
        AchievementCount = achievementCount;
        return this;
    }
}


测试方法


/**
 * 测试
 *
 * @param args
 */
public static void main(String[] args) {
    Student student = new Student(123, "xxxxxx", 25, 0, 100);
    System.out.println(student);
    System.out.println("--------测试反射属性设置------------");
    //反射设置某个对象的成员属性
    try {
        ReflectionUtils.setField(student, "Name", "xuexiang");
    } catch (Exception e) {
        e.printStackTrace();
    }
    //反射设置某个对象的静态属性
    try {
        ReflectionUtils.setStaticField(Student.class, "TotalNumber", 1111);
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("--------测试反射属性获取------------");
    //反射获取某个对象的成员属性
    try {
        System.out.println("Name:" + ReflectionUtils.getField(student, "Name"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    //反射获取某个对象的静态属性
    try {
        System.out.println("TotalNumber:" + ReflectionUtils.getStaticField(Student.class, "TotalNumber"));
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("--------测试反射方法执行------------");
    //反射执行某对象的成员方法
    try {
        System.out.println("getName():" + ReflectionUtils.invokeMethod(student, "getName", 23));
    } catch (Exception e) {
        e.printStackTrace();
    }
//        //反射执行某对象父类的成员方法（将会出错）
//        try {
//            GoodStudent goodStudent = new GoodStudent(student);
//            System.out.println("getName():" + ReflectionUtils.invokeMethod(goodStudent, "getName", 23));
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    //反射执行某个类的静态方法
    try {
        //对于参数是基础类型的方法，反射时用getClass获取的是包装类型，所以需要传入参数的类数组
        System.out.println("incrementTotalNumber():" + ReflectionUtils.invokeStaticMethod(Student.class, "incrementTotalNumber", new Class[]{int.class}, 2));
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("--------测试反射构建实例------------");
    //反射构建实例
    try {
        Student student1 = ReflectionUtils.newInstance(Student.class, new Class[]{int.class, String.class}, 22334455, "xuexiangjys");
        System.out.println(student1);
    } catch (Exception e) {
        e.printStackTrace();
    }
//        //反射父类的构造方法构建实例（将会出错）
//        try {
//            GoodStudent student2 = ReflectionUtils.newInstance(GoodStudent.class, new Class[]{int.class, String.class}, 22334455, "xuexiangjys");
//            System.out.println(student2);
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
}




文章标签：
Java
关键词：
Java反射
xuexiangjyss
目录
相关文章
三三是该溜子
|
2天前
|
Java 数据库连接 Spring
反射-----浅解析（Java）
在java中，我们可以通过反射机制，知道任何一个类的成员变量（成员属性）和成员方法，也可以堆任何一个对象，调用这个对象的任何属性和方法，更进一步我们还可以修改部分信息和。
三三是该溜子
15 3
智物科技库
|
1月前
|
监控 Java
Java基础——反射
本文介绍了Java反射机制的基本概念和使用方法，包括`Class`类的使用、动态加载类、获取方法和成员变量信息、方法反射操作、以及通过反射了解集合泛型的本质。同时，文章还探讨了动态代理的概念及其应用，通过实例展示了如何利用动态代理实现面向切面编程（AOP），例如为方法执行添加性能监控。
智物科技库
33 5
兴化
|
1月前
|
Java
Java的反射
Java的反射。
兴化
32 2
进步`于辰
|
2月前
|
存储 Java
[Java]反射
本文详细介绍了Java反射机制的基本概念、使用方法及其注意事项。首先解释了反射的定义和类加载过程，接着通过具体示例展示了如何使用反射获取和操作类的构造方法、方法和变量。文章还讨论了反射在类加载、内部类、父类成员访问等方面的特殊行为，并提供了通过反射跳过泛型检查的示例。最后，简要介绍了字面量和符号引用的概念。全文旨在帮助读者深入理解反射机制及其应用场景。
进步`于辰
39 0
[Java]反射
2的n次方_
|
3月前
|
安全 Java 索引
Java——反射&枚举
本文介绍了Java反射机制及其应用，包括获取Class对象、构造方法、成员变量和成员方法。反射允许在运行时动态操作类和对象，例如创建对象、调用方法和访问字段。文章详细解释了不同方法的使用方式及其注意事项，并展示了如何通过反射获取类的各种信息。此外，还介绍了枚举类型的特点和使用方法，包括枚举的构造方法及其在反射中的特殊处理。
2的n次方_
78 9
Java——反射&枚举
bug菌
|
2月前
|
安全 Java 测试技术
🌟Java零基础-反射：从入门到精通
【10月更文挑战第4天】本文收录于「滚雪球学Java」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
bug菌
32 2
程序员小海绵
|
3月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射（2023版）
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
程序员小海绵
67 3
LKIDTI数据
|
2月前
|
IDE Java 编译器
java的反射与注解
java的反射与注解
LKIDTI数据
25 0
游客xldroq4hd2x5q
|
3月前
|
Java 程序员 编译器
Java的反射技术reflect
Java的反射技术允许程序在运行时动态加载和操作类，基于字节码文件构建中间语言代码，进而生成机器码在JVM上执行，实现了“一次编译，到处运行”。此技术虽需更多运行时间，但广泛应用于Spring框架的持续集成、动态配置及三大特性（IOC、DI、AOP）中，支持企业级应用的迭代升级和灵活配置管理，适用于集群部署与数据同步场景。
游客xldroq4hd2x5q
49 7
1176112968452250
|
3月前
|
存储 安全 Java
扫盲java基础-反射(一)
扫盲java基础-反射(一)
1176112968452250
51 0

热门文章

最新文章

  • 1
    Java volatile关键字：你真的懂了吗？
  • 2
    java小工具util系列2：字符串工具
  • 3
    Java爬虫：数据采集的强大工具
  • 4
    Java多线程并发编程：同步机制与实践应用
  • 5
    Java中的异常处理：从基础到高级
  • 6
    深入理解Java异常处理机制
  • 7
    Liunx部署java项目Tomcat、Redis、Mysql教程
  • 8
    Java爬虫：深入解析商品详情的利器
  • 9
    java实现从HDFS上下载文件及文件夹的功能，以流形式输出，便于用户自定义保存任何路径下
  • 10
    Java 异常处理：机制、策略与最佳实践
  • 1
    【Java开发指南 | 第三十一篇】Java 包(package)
    83
  • 2
    【Java开发指南 | 第二十九篇】Java接口
    49
  • 3
    【Java开发指南 | 第二十八篇】Java封装
    59
  • 4
    【Java开发指南 | 第二十六篇】Java多态
    40
  • 5
    【Java开发指南 | 第二十四篇】Java继承
    61
  • 6
    【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
    58
  • 7
    【Java开发指南 | 第八篇】Java变量、构造方法、创建对象
    93
  • 8
    Java Stream API详解与使用
    99
  • 9
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    82
  • 10
    《手把手教你》系列技巧篇（四十三）-java+ selenium自动化测试-处理https 安全问题或者非信任站点-上篇（详解教程）
    134

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    手把手教你白嫖阿里云服务器(免费领服务器)